mte/src/json.ml

open Types

let encode_exn jsont v = Jsont_bytesrw.encode_string jsont v |> Result.get_ok
let encode jsont v = Jsont_bytesrw.encode_string jsont v
let decode jsont v = Jsont_bytesrw.decode_string jsont v

module ErrorDetail = struct
  open ErrorDetail

  let jsont =
    let make code hint = { code; hint } in
    let enc_code v = v.code in
    let enc_hint v = v.hint in
    Jsont.Object.map ~kind:"ErrorDetail" make
    |> Jsont.Object.mem "code" Jsont.int ~enc:enc_code
    |> Jsont.Object.opt_mem "hint" Jsont.(string) ~enc:enc_hint
    |> Jsont.Object.finish
end

module Timestamp = struct
  open Timestamp

  let number_or_never_jsont =
    let never =
      let dec s =
        match s with
        | "never" -> Never
        | _ -> Jsont.Error.msg Jsont.Meta.none "unexpected string value"
      in
      let enc = function Never -> "never" | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.string
    in
    let number =
      let dec n = Seconds n in
      let enc = function Seconds n -> n | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.number
    in
    let enc = function Never -> never | Seconds _ -> number in
    Jsont.any ~dec_string:never ~dec_number:number ~enc ()

  let jsont =
    let make t_s = t_s in
    Jsont.Object.map ~kind:"Timestamp" make
    |> Jsont.Object.mem "t_s" number_or_never_jsont ~enc:Fun.id
    |> Jsont.Object.finish
end

module RelativeTime = struct
  open RelativeTime

  let number_or_forever_jsont =
    let forever =
      let dec s =
        match s with
        | "forever" -> Forever
        | _ -> Jsont.Error.msg Jsont.Meta.none "unexpected string value"
      in
      let enc = function Forever -> "forever" | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.string
    in
    let number =
      let dec n = Microseconds n in
      let enc = function Microseconds n -> n | _ -> assert false in
      Jsont.map ~dec ~enc Jsont.number
    in
    let enc = function Forever -> forever | Microseconds _ -> number in
    Jsont.any ~dec_string:forever ~dec_number:number ~enc ()

  let jsont =
    let make t_s = t_s in
    Jsont.Object.map ~kind:"RelativeTime" make
    |> Jsont.Object.mem "t_s" number_or_forever_jsont ~enc:Fun.id
    |> Jsont.Object.finish
end

let amount_jsont =
  Jsont.of_of_string ~kind:"Amount" Amount.of_string ~enc:Amount.to_string

module EddsaPublicKey = struct
  open EddsaPublicKey

  let jsont =
    let dec = Jsont.Base.dec_result of_string in
    let enc = Jsont.Base.enc to_string in
    Jsont.Base.string (Jsont.Base.map ~kind:"EddsaPublicKey" ~dec ~enc ())
end

module EddsaSignature = struct
  let jsont = Jsont.string
end

module RsaDenominationKey = struct
  open RsaDenominationKey

  let jsont =
    let make age_mask rsa_pub = { age_mask; rsa_pub } in
    let age_mask v = v.age_mask in
    let rsa_pub v = v.rsa_pub in
    Jsont.Object.map ~kind:"RsaDenominationKey" make
    |> Jsont.Object.mem "age_mask" Jsont.int ~enc:age_mask
    |> Jsont.Object.mem "rsa_pub" Jsont.string ~enc:rsa_pub
    |> Jsont.Object.finish
end

module CSDenominationKey = struct
  open CSDenominationKey

  let jsont =
    let make age_mask cs_pub = { age_mask; cs_pub } in
    let age_mask v = v.age_mask in
    let cs_pub v = v.cs_pub in
    Jsont.Object.map ~kind:"CSDenominationKey" make
    |> Jsont.Object.mem "age_mask" Jsont.int ~enc:age_mask
    |> Jsont.Object.mem "cs_pub" Jsont.string ~enc:cs_pub
    |> Jsont.Object.finish
end

module DenominationKey = struct
  open DenominationKey

  let rsa v = Rsa v
  let cs v = CS v

  let jsont =
    let open Jsont.Object in
    let rsa = Case.map "RSA" RsaDenominationKey.jsont ~dec:rsa in
    let cs = Case.map "CS" CSDenominationKey.jsont ~dec:cs in
    let enc_case = function
      | Rsa v -> Case.value rsa v
      | CS v -> Case.value cs v
    in
    let cases = Case.[ make rsa; make cs ] in
    map ~kind:"DenominationKey" Fun.id
    |> case_mem "cipher" Jsont.string ~enc:Fun.id ~enc_case cases
    |> finish
end

module FutureSignKey = struct
  open FutureSignKey

  let jsont =
    (* TODO ppx? *)
    let make key stamp_start stamp_expire stamp_end signkey_secmod_sig =
      { key; stamp_start; stamp_expire; stamp_end; signkey_secmod_sig }
    in
    let key v = v.key in
    let stamp_start v = v.stamp_start in
    let stamp_expire v = v.stamp_expire in
    let stamp_end v = v.stamp_end in
    let signkey_secmod_sig v = v.signkey_secmod_sig in
    let open Jsont.Object in
    map ~kind:"FutureSignKey" make
    |> mem "key" EddsaPublicKey.jsont ~enc:key
    |> mem "stamp_start" Timestamp.jsont ~enc:stamp_start
    |> mem "stamp_expire" Timestamp.jsont ~enc:stamp_expire
    |> mem "stamp_end" Timestamp.jsont ~enc:stamp_end
    |> mem "signkey_secmod_sig" EddsaSignature.jsont ~enc:signkey_secmod_sig
    |> finish
end