wip secmod

src/http_management.ml

@@ -3,93 +3,12 @@ open Api
 open Hash
 
 module Keys_get = struct
-  let mk_future_denom (module Sm : Secmod.S) ~section_name
-      ({
-         pub;
-         value;
-         stamp_start;
-         stamp_expire_withdraw;
-         stamp_expire_deposit;
-         stamp_expire_legal;
-         fee_withdraw;
-         fee_deposit;
-         fee_refresh;
-         fee_refund;
-         age_mask;
-         h_pub;
-         master_sig= _;
-         revoked_sig= _;
-       } :
-        Denom_data.t) =
-    let denom_pub =
-      DenominationKey.of_rsa RsaDenominationKey.{ age_mask; rsa_pub= pub }
-    in
-    let denom_secmod_sig =
-      let open Signatures.DenominationKeyAnnouncement in
-      let h_denom_pub = h_pub in
-      let h_section_name = Hash.Cstring.H64.hash section_name in
-      let anchor_time = stamp_start in
-      let duration_withdraw =
-        Timestamp.diff stamp_start stamp_expire_withdraw
-      in
-      sign_f ~f:Sm.sign_with_sm_key
-        { h_denom_pub; h_section_name; anchor_time; duration_withdraw }
-    in
-    FutureDenom.
-      {
-        section_name;
-        value;
-        stamp_start;
-        stamp_expire_withdraw;
-        stamp_expire_deposit;
-        stamp_expire_legal;
-        denom_pub;
-        fee_withdraw;
-        fee_deposit;
-        fee_refresh;
-        fee_refund;
-        denom_secmod_sig;
-      }
-
-  let mk_future_signkey (module Sm : Secmod.S)
-      ({
-         pub;
-         stamp_start;
-         stamp_expire;
-         stamp_end;
-         master_sig= _;
-         revoked_sig= _;
-       } :
-        Signkey_data.t) =
-    let signkey_secmod_sig =
-      let open Signatures.SigningKeyAnnouncement in
-      let exchange_pub = pub in
-      let anchor_time = stamp_start in
-      let duration = Timestamp.diff stamp_start stamp_expire in
-      sign_f ~f:Sm.sign_with_sm_key { exchange_pub; anchor_time; duration }
-    in
-    FutureSignKey.
-      { key= pub; stamp_start; stamp_expire; stamp_end; signkey_secmod_sig }
-
   let mk_future_keys_response (module Sm : Secmod.S) =
-    let future_signkeys =
-      Sm.get_signkeys_data ()
-      |> List.filter (fun k -> Option.is_none k.Signkey_data.master_sig)
-      |> List.map (fun signkey -> mk_future_signkey (module Sm) signkey)
-    in
-    let future_denoms =
-      Sm.get_denoms_data ()
-      |> List.filter (fun k -> Option.is_none k.Denom_data.master_sig)
-      |> List.map (fun dn_data ->
-          let opt = Sm.find_denom_section_name dn_data.Denom_data.h_pub in
-          match opt with
-          | None -> Fmt.failwith "section_name not found."
-          | Some section_name ->
-              mk_future_denom (module Sm) ~section_name dn_data)
-    in
+    let future_signkeys = Sm.get_future_signkeys () in
+    let future_denoms = Sm.get_future_denominations () in
     let master_pub = Config.Exchange.master_public_key in
-    let denom_secmod_public_key = Sm.get_sm_key_pub () in
-    let signkey_secmod_public_key = Sm.get_sm_key_pub () in
+    let denom_secmod_public_key = Sm.sm_pubkey in
+    let signkey_secmod_public_key = Sm.sm_pubkey in
     FutureKeysResponse.
       {
         future_denoms;
@@ -113,15 +32,15 @@ module Keys_get = struct
 end
 
 module Keys_post = struct
+  let error_key_unknown =
+    "404 not found, One of the keys for which a signature was provided is \
+     unknown to the exchange."
+
   let verify_denom_signature (module Sm : Secmod.S)
       DenomSignature.{ h_denom_pub; master_sig } =
     let* denom =
-      match Sm.find_denom_data h_denom_pub with
-      | None ->
-          Fmt.error
-            "404 not found, One of the keys for which a signature was provided \
-             is unknown to the exchange."
-      | Some denom -> Ok denom
+      Sm.find_future_denomination h_denom_pub
+      |> Option.to_result ~none:error_key_unknown
     in
     let open Signatures.DenominationKeyValidity in
     let r : r =
@@ -144,12 +63,7 @@ module Keys_post = struct
   let verify_signkey_signature (module Sm : Secmod.S)
       SignKeySignature.{ key; master_sig } =
     let* signkey =
-      match Sm.find_signkey_data key with
-      | None ->
-          Fmt.error
-            "404 not found, One of the keys for which a signature was provided \
-             is unknown to the exchange."
-      | Some signkey -> Ok signkey
+      Sm.find_future_signkey key |> Option.to_result ~none:error_key_unknown
     in
     let open Signatures.ExchangeSigningKeyValidity in
     let r : r =
@@ -157,7 +71,7 @@ module Keys_post = struct
         start= signkey.stamp_start;
         expire= signkey.stamp_expire;
         end_= signkey.stamp_end;
-        signkey_pub= signkey.pub;
+        signkey_pub= signkey.key;
       }
     in
     verify_f ~f:Sm.verify_with_master_key master_sig r
@@ -170,18 +84,18 @@ module Keys_post = struct
   let do_ ~db_conn:_ (module Sm : Secmod.S)
       MasterSignatures.{ denom_sigs; signkey_sigs } =
     let* () =
-      signkey_sigs
-      |> List.map (fun SignKeySignature.{ key; master_sig } ->
-          (key, master_sig))
-      |> Sm.add_signkey_master_signatures
+      list_iter
+        (fun SignKeySignature.{ key; master_sig } ->
+          Sm.certify_future_signkey key ~master_sig)
+        signkey_sigs
     in
     let* () =
-      denom_sigs
-      |> List.map (fun DenomSignature.{ h_denom_pub; master_sig } ->
-          (h_denom_pub, master_sig))
-      |> Sm.add_denom_master_signatures
+      list_iter
+        (fun DenomSignature.{ h_denom_pub; master_sig } ->
+          Sm.certify_future_denomination h_denom_pub ~master_sig)
+        denom_sigs
     in
-    let* () = Sm.store () in
+    let* () = Sm.save () in
     Ok ()
 
   let jsont = MasterSignatures.jsont