JJ: Description from the destination commit:

~~~ almost ok

JJ: Description from source commit:
.

src/api.ml

@@ -922,6 +922,19 @@ module SignKey = struct
     master_sig: ExchangeSigningKeyValidity.t;
   }
 
+  (* TODO rm one of them *)
+  let of_signkey
+      Signkey.
+        {
+          pub;
+          stamp_start;
+          stamp_expire;
+          stamp_end;
+          master_sig;
+          revoked_sig= _;
+        } =
+    { key= pub; stamp_start; stamp_expire; stamp_end; master_sig }
+
   let jsont =
     let make key stamp_start stamp_expire stamp_end master_sig =
       { key; stamp_start; stamp_expire; stamp_end; master_sig }

src/crypto.ml

@@ -269,7 +269,7 @@ type eddsa_sig = EddsaSignature.t
 type rsa_priv = RsaPrivateKey.t
 type rsa_pub = RsaPublicKey.t
 type rsa_sig = RsaSignature.t
-type denomination_hash = Hash.DenominationHash.t
+type denom_hash = Hash.DenominationHash.t
 
 (* WIP *)
 module FDH_RSA = struct

src/denomination.ml

@@ -12,7 +12,7 @@ type t = {
   fee_refresh: Amount.t;
   fee_refund: Amount.t;
   age_mask: int;
-  h_pub: denomination_hash;
+  h_pub: denom_hash;
   master_sig: Signatures.DenominationKeyValidity.t;
   revoked_sig: Signatures.MasterDenominationKeyRevocation.t option;
 }

src/http_information.ml

@@ -41,7 +41,6 @@ let denomgroup_of_denomdata
         master_sig;
         revoked_sig= _;
       } =
-  let master_sig = match master_sig with None -> assert false | Some v -> v in
   let denoms =
     [
       RsaDenom.
@@ -112,92 +111,66 @@ let mk_keys ~db_conn (module Sm : Secmod.S) ~last_issue_date =
   let wallet_balance_limit_without_kyc = None in
   let hard_limits = [] in
   let zero_limits = [] in
-  let denom_data_l =
+  let dn_l =
-    (* TODO sm-db *)
     (*Pg.get_denominations db_conn |> unwrap_err_caqti *)
-    Sm.get_denoms_data ()
+    Sm.get_denominations ()
-  in
+    |>
-  let denom_data_l =
     (* reverse chronological order *)
-    List.sort
+    List.sort (fun a b ->
-      (fun a b -> Stdlib.compare b.Denomination.stamp_start a.stamp_start)
+        Stdlib.compare b.Denomination.stamp_start a.stamp_start)
-      denom_data_l
   in
   let list_issue_date =
-    match denom_data_l with
+    match dn_l with
-    | [] -> Time.Timestamp.never
+    | [] -> Timestamp.never
-    | v :: _ -> v.Denomination.stamp_start
+    | dn :: _ -> dn.Denomination.stamp_start
   in
   let denominations =
-    let open Denomination in
     (* if `?last_issue_date` query param does not exactly match the `stamp_start`
        of one of the denomination keys, all keys are returned *)
+    let open Denomination in
     let l =
       match last_issue_date with
-      | None -> denom_data_l
+      | None -> dn_l
       | Some last_issue_date -> (
           match
             List.find_opt
-              (fun v ->
+              (fun v -> Timestamp.compare v.stamp_start last_issue_date = 0)
-                Time.Timestamp.compare v.stamp_start last_issue_date = 0)
+              dn_l
-              denom_data_l
           with
-          | None -> denom_data_l
+          | None -> dn_l
           | Some _ ->
               List.filter
                 (fun v ->
                   Time.Timestamp.compare v.stamp_start last_issue_date >= 0)
-                denom_data_l)
+                dn_l)
     in
     List.map denomgroup_of_denomdata l
   in
 
   let signkeys =
-    (* TODO sm-db
-       use database signkey data / verify secmod and database are in sync *)
     (*
     let now = Ptime_clock.now () |> Option.some in
     let+ signkey_data_l = Pg.get_active_signkeys db_conn ~now |> unwrap_err_caqti in*)
-    let signkey_data_l = Sm.get_signkeys_data () in
+    Sm.get_signkeys ()
-    let signkey_data_l =
+    |> List.sort (fun a b ->
-      List.sort
-        (fun a b ->
         let open Signkey in
         Stdlib.compare b.stamp_start a.stamp_start)
-        signkey_data_l
+    |> List.map Api.SignKey.of_signkey
-    in
-    List.filter_map
-      (fun Signkey.
-             {
-               pub;
-               stamp_start;
-               stamp_expire;
-               stamp_end;
-               master_sig;
-               revoked_sig= _;
-             } ->
-        match master_sig with
-        | None -> None
-        | Some master_sig ->
-            Some
-              SignKey.
-                { key= pub; stamp_start; stamp_expire; stamp_end; master_sig })
-      signkey_data_l
   in
 
   let exchange_pub =
     (* the eddsa pub key used to sign exchange_sig *)
     match signkeys with
     | [] -> Fmt.failwith "exchange has no active signkey"
-    | v :: _ -> v.SignKey.key
+    | sk :: _ -> sk.SignKey.key
   in
   let exchange_sig =
     (* Compact EdDSA signature (binary-only) over the
        contatentation of all of the master_sigs (in reverse
        chronological order by group) in the arrays under "denominations". *)
     let hc =
-      denom_data_l
+      dn_l
-      |> List.filter_map (fun v -> v.Denomination.master_sig)
+      |> List.map (fun dn -> dn.Denomination.master_sig)
       |> List.map Signatures.DenominationKeyValidity.to_octets
       |> String.concat ""
       |> Hash.H64.hash

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= _;
-       } :
-        Denomination.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.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 =
+    let future_signkeys = Sm.get_future_signkeys () in
-      Sm.get_signkeys_data ()
+    let future_denoms = Sm.get_future_denominations () in
-      |> List.filter (fun k -> Option.is_none k.Signkey.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.Denomination.master_sig)
-      |> List.map (fun dn_data ->
-          let opt = Sm.find_denom_section_name dn_data.Denomination.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 master_pub = Config.Exchange.master_public_key in
-    let denom_secmod_public_key = Sm.get_sm_key_pub () in
+    let denom_secmod_public_key = Sm.sm_pubkey in
-    let signkey_secmod_public_key = Sm.get_sm_key_pub () in
+    let signkey_secmod_public_key = Sm.sm_pubkey in
     FutureKeysResponse.
       {
         future_denoms;
@@ -144,7 +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
+      match Sm.find_signkey key with
       | None ->
           Fmt.error
             "404 not found, One of the keys for which a signature was provided \
@@ -170,18 +89,18 @@ module Keys_post = struct
   let do_ ~db_conn:_ (module Sm : Secmod.S)
       MasterSignatures.{ denom_sigs; signkey_sigs } =
     let* () =
+      list_iter
+        (fun SignKeySignature.{ key; master_sig } ->
+          Sm.certify_future_signkey key master_sig)
         signkey_sigs
-      |> List.map (fun SignKeySignature.{ key; master_sig } ->
-          (key, master_sig))
-      |> Sm.add_signkey_master_signatures
     in
     let* () =
+      list_iter
+        (fun DenomSignature.{ h_denom_pub; master_sig } ->
+          Sm.certify_future_denomination h_denom_pub master_sig)
         denom_sigs
-      |> List.map (fun DenomSignature.{ h_denom_pub; master_sig } ->
-          (h_denom_pub, master_sig))
-      |> Sm.add_denom_master_signatures
     in
-    let* () = Sm.store () in
+    let* () = Sm.save () in
     Ok ()
 
   let jsont = MasterSignatures.jsont

src/pg.ml

@@ -67,7 +67,7 @@ let insert_signkey =
 
 let find_denom =
   let find_denom =
-    Caqti_type.(denomination_hash ->? denom_data)
+    Caqti_type.(denom_hash ->? denom_data)
       "SELECT dn.denom_pub, (dn.coin).*, dn.valid_from, dn.expire_withdraw, \
        dn.expire_deposit, dn.expire_legal, (dn.fee_withdraw).*, \
        (dn.fee_deposit).*, (dn.fee_refresh).*, (dn.fee_refund).*, dn.age_mask, \
@@ -104,7 +104,7 @@ let insert_denom =
 let insert_denomination_revocation =
   let denomination_revocation_insert =
     let master_sig = Signatures.MasterDenominationKeyRevocation.caqti in
-    Caqti_type.(t2 denomination_hash master_sig ->. unit)
+    Caqti_type.(t2 denom_hash master_sig ->. unit)
       "INSERT INTO denomination_revocations (denominations_serial, master_sig) \
        SELECT denominations_serial, $2 FROM denominations WHERE \
        denom_pub_hash=$1"
@@ -168,7 +168,7 @@ let disable_auditor =
 let insert_auditor_denom_sig =
   let insert_auditor_denom_sig =
     let auditor_sig = Signatures.ExchangeKeyValidity.caqti in
-    Caqti_type.(t3 eddsa_pub denomination_hash auditor_sig ->. unit)
+    Caqti_type.(t3 eddsa_pub denom_hash auditor_sig ->. unit)
       "WITH ax AS (SELECT auditor_uuid FROM auditors WHERE auditor_pub=$1) \
        INSERT INTO auditor_denom_sigs (auditor_uuid, denominations_serial, \
        auditor_sig) SELECT ax.auditor_uuid, denominations_serial, $3 FROM \
@@ -185,8 +185,7 @@ let insert_auditor_denom_sig =
 let get_auditor_keys =
   let get_auditor_keys =
     let auditor_sig = Signatures.ExchangeKeyValidity.caqti in
-    Caqti_type.(
+    Caqti_type.(unit ->* t5 eddsa_pub string string denom_hash auditor_sig)
-      unit ->* t5 eddsa_pub string string denomination_hash auditor_sig)
       "SELECT a.auditor_pub, a.auditor_url, a.auditor_name, dn.denom_pub_hash, \
        ads.auditor_sig FROM auditor_denom_sigs AS ads JOIN auditors AS a USING \
        (auditor_uuid) JOIN denominations AS dn USING (denominations_serial) \

src/pg_type.ml

@@ -32,7 +32,7 @@ include struct
 
   let fullpayto_hash = FullPaytoHash.caqti
   let nomalizaedpayto_hash = NormalizedPaytoHash.caqti
-  let denomination_hash = DenominationHash.caqti
+  let denom_hash = DenominationHash.caqti
   let privatecontract_hash = PrivateContractHash.caqti
   let extensionspolicy_hash = ExtensionsPolicyHash.caqti
   let merchantwire_hash = MerchantWireHash.caqti
@@ -51,21 +51,10 @@ let signkey_data =
         Signkey.
           { pub; stamp_start; stamp_expire; stamp_end; master_sig; revoked_sig }
       ->
-      match master_sig with
-      | None -> Error "signkey_data master_sig is none"
-      | Some master_sig ->
       Ok (pub, stamp_start, stamp_expire, stamp_end, master_sig, revoked_sig))
     ~decode:(fun
         (pub, stamp_start, stamp_expire, stamp_end, master_sig, revoked_sig) ->
-      Ok
+      Ok { pub; stamp_start; stamp_expire; stamp_end; master_sig; revoked_sig })
-        {
-          pub;
-          stamp_start;
-          stamp_expire;
-          stamp_end;
-          master_sig= Some master_sig;
-          revoked_sig;
-        })
     (t6 eddsa_pub time time time master_sig revoked_sig)
 
 let denom_data =
@@ -91,9 +80,6 @@ let denom_data =
             revoked_sig;
           }
       ->
-      match master_sig with
-      | None -> Error "denom_data master_sig is none"
-      | Some master_sig ->
       Ok
         ( pub,
           value,
@@ -135,11 +121,11 @@ let denom_data =
           fee_refund;
           age_mask;
           h_pub;
-          master_sig= Some master_sig;
+          master_sig;
           revoked_sig;
         })
     (t12 rsa_pub amount time time time time amount amount amount amount int
-       (t3 denomination_hash master_sig revoked_sig))
+       (t3 denom_hash master_sig revoked_sig))
 
 let account_restrictions =
   custom

src/secmod.ml

@@ -1,6 +1,7 @@
 module type S = sig
   open Crypto
 
+  val sm_pubkey : eddsa_pub
   val sign_with_sm_key : string -> eddsa_sig
   val sign_with_signkey : pub:eddsa_pub -> string -> eddsa_sig
   val verify_with_master_key : eddsa_sig -> msg:string -> (unit, string) result
@@ -9,26 +10,20 @@ module type S = sig
   val verify_with_signkey :
     pub:eddsa_pub -> eddsa_sig -> msg:string -> (unit, string) result
 
-  (* TODO query database instead? *)
+  val get_signkeys : unit -> Signkey.t list
-  val get_sm_key_pub : unit -> eddsa_pub
+  val get_denominations : unit -> Denomination.t list
-  val get_signkeys_data : unit -> Signkey.t list
+  val get_future_signkeys : unit -> Api.FutureSignKey.t list
-  val get_denoms_data : unit -> Denomination.t list
+  val get_future_denominations : unit -> Api.FutureDenom.t list
-  val find_signkey_data : eddsa_pub -> Signkey.t option
+  val find_signkey : eddsa_pub -> Signkey.t option
-  val find_denomination : denomination_hash -> Denomination.t option
+  val find_denomination : denom_hash -> Denomination.t option
-  val find_denom_section_name : denomination_hash -> string option
 
-  (* - management operations - *)
+  val certify_future_signkey :
-  (* TODO
+    eddsa_pub ->
-   problem of keeping db and secmod state syncronized
+    Signatures.ExchangeSigningKeyValidity.t ->
-   do db interaction from secmod? *)
-
-  val add_signkey_master_signatures :
-    (eddsa_pub * Signatures.ExchangeSigningKeyValidity.t) list ->
     (unit, string) result
 
-  val add_denom_master_signatures :
+  val certify_future_denomination :
-    (denomination_hash * Signatures.DenominationKeyValidity.t) list ->
+    denom_hash -> Signatures.DenominationKeyValidity.t -> (unit, string) result
-    (unit, string) result
 
   val revoke_signkey :
     eddsa_pub ->
@@ -36,55 +31,58 @@ module type S = sig
     (unit, string) result
 
   val revoke_denomination :
-    denomination_hash ->
+    denom_hash ->
     Signatures.MasterDenominationKeyRevocation.t ->
     (unit, string) result
 
-  val store : unit -> (unit, string) result
+  val save : unit -> (unit, string) result
 end
 
 module Make (Conn : Pg.CONN) = struct
   open Syntax
   open Crypto
+  module DenominationHash = Hash.DenominationHash
 
   type sk = Signkey.t
   type future_sk = Api.FutureSignKey.t
   type dn = Denomination.t
   type future_dn = Api.FutureDenom.t
 
-  (* TODO use lock *)
+  (* TODO ! use lock *)
+  (* not sure what to do with coin section_name, rm if possible *)
   type t = {
     sm_key: eddsa_priv;
     sm_pubkey: eddsa_pub;
     sk_ht: (eddsa_pub, sk) Hashtbl.t;
-    dn_ht: (rsa_pub, dn) Hashtbl.t;
+    dn_ht: (denom_hash, dn) Hashtbl.t;
     sk_key_ht: (eddsa_pub, eddsa_priv) Hashtbl.t;
-    dn_key_ht: (rsa_pub, rsa_priv) Hashtbl.t;
+    dn_key_ht: (denom_hash, rsa_priv) Hashtbl.t;
     future_sk_ht: (eddsa_pub, future_sk) Hashtbl.t;
-    future_dn_ht: (rsa_pub, future_dn) Hashtbl.t;
+    future_dn_ht: (denom_hash, future_dn) Hashtbl.t;
     future_sk_key_ht: (eddsa_pub, eddsa_priv) Hashtbl.t;
-    future_dn_key_ht: (rsa_pub, rsa_priv) Hashtbl.t;
+    future_dn_key_ht: (denom_hash, rsa_priv) Hashtbl.t;
+    dn_section_name_ht: (denom_hash, string) Hashtbl.t;
   }
 
-  let database_find_sk conn fname pub =
+  let sm_key_fname = Fpath.(Config.secrets_dir / "sm_key")
+  let sk_key_fname i = Fpath.(Config.secrets_dir / Fmt.str "sk_%d" i)
+
+  let dn_key_fname section_name =
+    Fpath.(Config.secrets_dir / Fmt.str "dn_%s" section_name)
+
+  let database_find_sk conn pub =
     let* opt = Pg.find_signkey conn pub |> unwrap_err_caqti in
     match opt with
     | None ->
-        Fmt.error
+        Fmt.error "secmod failure: a signkey could not be found in database"
-          "load_signkey error, no associated data found in database for \
-           signkey `%s`."
-          (Fpath.to_string fname)
     | Some sk_data -> Ok sk_data
 
-  let database_find_dn conn ~section_name pub =
+  let database_find_dn conn h_pub =
-    let h_pub = Hash.DenominationHash.hash (RsaPublicKey.to_octets pub) in
     let* opt = Pg.find_denom conn h_pub |> unwrap_err_caqti in
     match opt with
     | None ->
         Fmt.error
-          "load_denom error no associated metadata found in database for \
+          "secmod failure: a denomination could not be found in database"
-           denomination `%s`."
-          section_name
     | Some dn_data -> Ok dn_data
 
   (* TODO clean up *)
@@ -92,18 +90,10 @@ module Make (Conn : Pg.CONN) = struct
     let error_invalid_state =
       Fmt.error "secmod load error: invalid store state."
     in
-    let* sm_key = Data_file.read_eddsa Fpath.(Config.secrets_dir / "sk_sm") in
+    let* sm_key = Data_file.read_eddsa sm_key_fname in
     let* sk_keys =
-      let l =
+      let l = List.init 1 sk_key_fname in
-        List.init 1 (fun i -> Fpath.(Config.secrets_dir / Fmt.str "sk_%d" i))
+      let* l = list_map (fun fname -> Data_file.read_eddsa fname) l in
-      in
-      let* l =
-        list_map
-          (fun fname ->
-            let+ opt = Data_file.read_eddsa fname in
-            Option.map (fun priv -> (fname, priv)) opt)
-          l
-      in
       match opt_list l with Error () -> error_invalid_state | Ok opt -> Ok opt
     in
     let* dn_keys =
@@ -112,8 +102,7 @@ module Make (Conn : Pg.CONN) = struct
         list_map
           (fun coin ->
             let section_name = coin.section_name in
-            let fname = Fpath.(Config.secrets_dir / section_name) in
+            let+ opt = Data_file.read_rsa (dn_key_fname section_name) in
-            let+ opt = Data_file.read_rsa fname in
             Option.map (fun priv -> (section_name, priv)) opt)
           all_coins
       in
@@ -129,9 +118,9 @@ module Make (Conn : Pg.CONN) = struct
         (* sk *)
         let* l =
           list_map
-            (fun (fname, priv) ->
+            (fun priv ->
               let pub = EddsaPrivateKey.pub_of_priv priv in
-              let+ sk = database_find_sk conn fname pub in
+              let+ sk = database_find_sk conn pub in
               ((pub, sk), (pub, priv)))
             sk_keys
         in
@@ -140,19 +129,28 @@ module Make (Conn : Pg.CONN) = struct
           (list_to_ht sk_l, list_to_ht priv_l)
         in
         (* dn *)
+        let dn_section_name_ht = Hashtbl.create 0xff in
         let* l =
           list_map
             (fun (section_name, priv) ->
-              let pub = RsaPrivateKey.pub_of_priv priv in
+              let h_pub =
-              let+ dn = database_find_dn conn ~section_name pub in
+                priv
-              ((pub, dn), (pub, priv)))
+                |> RsaPrivateKey.pub_of_priv
+                |> RsaPublicKey.to_octets
+                |> DenominationHash.hash
+              in
+
+              (* fill dn_section_name_ht *)
+              Hashtbl.replace dn_section_name_ht h_pub section_name;
+
+              let+ dn = database_find_dn conn h_pub in
+              ((h_pub, dn), (h_pub, priv)))
             dn_keys
         in
         let dn_ht, dn_key_ht =
-          let dn_l, priv_l = List.split l in
+          match List.split l with l1, l2 -> (list_to_ht l1, list_to_ht l2)
-          (list_to_ht dn_l, list_to_ht priv_l)
         in
-        (* future keys are not stored (until they are signed)
+        (* future keys are not stored anywhere until they are certified with a master_sig
            so we don't have any future key to load *)
         let t =
           {
@@ -166,6 +164,7 @@ module Make (Conn : Pg.CONN) = struct
             future_dn_ht= Hashtbl.create 0xff;
             future_sk_key_ht= Hashtbl.create 0xff;
             future_dn_key_ht= Hashtbl.create 0xff;
+            dn_section_name_ht;
           }
         in
         Ok (Some t)
@@ -214,17 +213,16 @@ module Make (Conn : Pg.CONN) = struct
           age_restricted= _;
         } =
     assert (cipher = `RSA);
-    let open Time in
+    let start = Time.Absolute.of_ptime (Ptime_clock.now ()) in
-    let start = Absolute.of_ptime (Ptime_clock.now ()) in
     let stamp_start = Timestamp.of_absolute start in
     let stamp_expire_withdraw =
-      Timestamp.of_absolute @@ Absolute.add start duration_withdraw
+      Timestamp.of_absolute @@ Time.Absolute.add start duration_withdraw
     in
     let stamp_expire_deposit =
-      Timestamp.of_absolute @@ Absolute.add start duration_spend
+      Timestamp.of_absolute @@ Time.Absolute.add start duration_spend
     in
     let stamp_expire_legal =
-      Timestamp.of_absolute @@ Absolute.add start duration_legal
+      Timestamp.of_absolute @@ Time.Absolute.add start duration_legal
     in
     let priv, pub = RsaPrivateKey.generate ~bits:rsa_keysize () in
     let open Api in
@@ -232,11 +230,10 @@ module Make (Conn : Pg.CONN) = struct
       RsaDenominationKey.{ age_mask= 0; rsa_pub= pub }
     in
     let denom_pub = DenominationKey.Rsa rsa_denomination_key in
+    let h_pub = DenominationHash.hash (RsaPublicKey.to_octets pub) in
     let denom_secmod_sig =
       let open Signatures.DenominationKeyAnnouncement in
-      let h_denom_pub =
+      let h_denom_pub = h_pub in
-        Hash.DenominationHash.hash (RsaPublicKey.to_octets pub)
-      in
       let h_section_name = Hash.Cstring.H64.hash section_name in
       let anchor_time = stamp_start in
       let duration_withdraw =
@@ -262,8 +259,8 @@ module Make (Conn : Pg.CONN) = struct
           denom_secmod_sig;
         }
     in
-    Hashtbl.replace t.future_dn_ht pub future_dn;
+    Hashtbl.replace t.future_dn_ht h_pub future_dn;
-    Hashtbl.replace t.future_dn_key_ht pub priv;
+    Hashtbl.replace t.future_dn_key_ht h_pub priv;
     ()
 
   let make_new () =
@@ -280,6 +277,7 @@ module Make (Conn : Pg.CONN) = struct
         future_dn_ht= Hashtbl.create 0xff;
         future_sk_key_ht= Hashtbl.create 0xff;
         future_dn_key_ht= Hashtbl.create 0xff;
+        dn_section_name_ht= Hashtbl.create 0xff;
       }
     in
     make_future_sk t;
@@ -297,24 +295,25 @@ module Make (Conn : Pg.CONN) = struct
         t
     | Error e -> Fmt.failwith "secmod init failure: %s." e
 
+  let sm_pubkey = t.sm_pubkey
   let sign_with_sm_key s = sign_with_sm_key t s
-  let verify_with_sm_key s ~msg = EddsaSignature.verify ~key:t.sm_pubkey s ~msg
 
   let sign_with_signkey ~pub s =
     match Hashtbl.find_opt t.sk_key_ht pub with
     | None -> Fmt.failwith "secmod failure: signkey not found."
     | Some priv -> EddsaSignature.sign ~key:priv s
 
+  let verify_with_sm_key s ~msg = EddsaSignature.verify ~key:t.sm_pubkey s ~msg
+
   let verify_with_master_key =
     EddsaSignature.verify ~key:Config.master_public_key
 
   let verify_with_signkey ~pub s ~msg =
-    (* check that the key we are verifying with is one of our own *)
+    (* check that [pub] is one of our own keys *)
     match Hashtbl.find_opt t.sk_ht pub with
     | None -> Fmt.failwith "secmod failure: signkey not found."
     | Some _priv -> EddsaSignature.verify ~key:pub s ~msg
 
-  let sm_pubkey = t.sm_pubkey
   let get_signkeys () = t.sk_ht |> Hashtbl.to_seq_values |> List.of_seq
   let get_denominations () = t.dn_ht |> Hashtbl.to_seq_values |> List.of_seq
 
@@ -367,88 +366,107 @@ module Make (Conn : Pg.CONN) = struct
             let* () = Pg.insert_signkey (module Conn) sk |> unwrap_err_caqti in
             Ok ())
 
-  let add_signkey_master_signatures l =
+  let certify_future_denomination h_pub master_sig =
-    Miou.Mutex.protect t.lock @@ fun () ->
+    match
-    list_iter
+      ( Hashtbl.find_opt t.future_dn_ht h_pub,
-      (fun (pub, master_sig) ->
+        Hashtbl.find_opt t.future_dn_key_ht h_pub )
+    with
+    | None, _ | _, None ->
+        Error "secmod failure: future denomination not found."
+    | Some future_dn, Some priv -> (
+        match Hashtbl.find_opt t.dn_ht h_pub with
+        | Some _dn ->
+            Error
+              "secmod failure: this denomination already has a master signature"
+        | None ->
+            let Api.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= _;
+                  } =
+              future_dn
+            in
+            let rsa_pub =
+              match denom_pub with
+              | Rsa Api.RsaDenominationKey.{ age_mask= _; rsa_pub } -> rsa_pub
+            in
+            let dn =
+              Denomination.
+                {
+                  pub= rsa_pub;
+                  value;
+                  stamp_start;
+                  stamp_expire_withdraw;
+                  stamp_expire_deposit;
+                  stamp_expire_legal;
+                  fee_withdraw;
+                  fee_deposit;
+                  fee_refresh;
+                  fee_refund;
+                  age_mask= 0;
+                  h_pub;
+                  master_sig;
+                  revoked_sig= None;
+                }
+            in
+            Hashtbl.replace t.dn_ht h_pub dn;
+            Hashtbl.replace t.dn_key_ht h_pub priv;
+            Hashtbl.replace t.dn_section_name_ht h_pub section_name;
+            Hashtbl.remove t.future_dn_ht h_pub;
+            Hashtbl.remove t.future_dn_key_ht h_pub;
+
+            let* () = Pg.insert_denom (module Conn) dn |> unwrap_err_caqti in
+            Ok ())
+
+  let revoke_signkey pub revoked_sig =
     match Hashtbl.find_opt t.sk_ht pub with
-        | None -> Error "secmod failure: public key not found."
+    | None -> Error "secmod failure: signkey not found."
-        | Some signkey ->
+    | Some sk ->
-            let sk_data =
+        let sk = { sk with revoked_sig= Some revoked_sig } in
-              { signkey.sk_data with master_sig= Some master_sig }
+        Hashtbl.replace t.sk_ht pub sk;
-            in
-            let signkey = { signkey with sk_data } in
-            let* () =
-              Pg.insert_signkey (module Conn) sk_data |> unwrap_err_caqti
-            in
-            Hashtbl.replace t.sk_ht pub signkey;
-            Ok ())
-      l
 
-  let add_denom_master_signatures l =
+        (* TODO revoke, apply to database *)
-    Miou.Mutex.protect t.lock @@ fun () ->
-    list_iter
-      (fun (h_denom_pub, master_sig) ->
-        match Hashtbl.find_opt t.dn_ht h_denom_pub with
-        | None -> Error "secmod failure: denomination hash not found."
-        | Some denom ->
-            let dn_data = { denom.dn_data with master_sig= Some master_sig } in
-            let denom = { denom with dn_data } in
-            let* () =
-              Pg.insert_denom (module Conn) dn_data |> unwrap_err_caqti
-            in
-            Hashtbl.replace t.dn_ht h_denom_pub denom;
-            Ok ())
-      l
-
-  let revoke_signkey exchange_pub revoked_sig =
-    Miou.Mutex.protect t.lock @@ fun () ->
-    match Hashtbl.find_opt t.sk_ht exchange_pub with
-    | None -> Error "secmod failure: denomination hash not found."
-    | Some signkey ->
-        let sk_data = { signkey.sk_data with revoked_sig= Some revoked_sig } in
-        let signkey = { signkey with sk_data } in
-        Hashtbl.replace t.sk_ht exchange_pub signkey;
         Ok ()
 
-  let revoke_denomination h_denom_pub revoked_sig =
+  let revoke_denomination pub revoked_sig =
-    Miou.Mutex.protect t.lock @@ fun () ->
+    match Hashtbl.find_opt t.dn_ht pub with
-    match Hashtbl.find_opt t.dn_ht h_denom_pub with
+    | None -> Error "secmod failure: denomination not found."
-    | None -> Error "secmod failure: denomination hash not found."
+    | Some dn ->
-    | Some denom ->
+        let dn = { dn with revoked_sig= Some revoked_sig } in
-        let dn_data = { denom.dn_data with revoked_sig= Some revoked_sig } in
+        Hashtbl.replace t.dn_ht pub dn;
-        let denom = { denom with dn_data } in
+
-        Hashtbl.replace t.dn_ht h_denom_pub denom;
+        (* TODO revoke, apply to database *)
         Ok ()
 
-  let store () =
+  let save () =
-    Miou.Mutex.protect t.lock @@ fun () ->
+    let* () = Data_file.write_eddsa sm_key_fname t.sm_key in
     let* () =
-      Data_file.write_eddsa Fpath.(Config.secrets_dir / "sk_sm") t.sm_key_priv
+      Hashtbl.to_seq_values t.sk_key_ht
+      |> List.of_seq
+      |> List.mapi (fun i priv -> Data_file.write_eddsa (sk_key_fname i) priv)
+      |> list_iter Fun.id
     in
     let* () =
-      Hashtbl.to_seq_values t.sk_ht
+      Hashtbl.to_seq t.dn_key_ht
       |> List.of_seq
-      |> List.mapi (fun i (key : signkey) ->
+      |> list_iter (fun (pub, priv) ->
-          let fname = Fpath.(Config.secrets_dir / Fmt.str "sk_%d" i) in
+          let* section_name =
-          (fname, key.priv))
+            match Hashtbl.find_opt t.dn_section_name_ht pub with
-      |> list_iter (fun (fname, key) -> Data_file.write_eddsa fname key)
-    in
-    let* () =
-      let* l =
-        Hashtbl.to_seq_values t.dn_ht
-        |> List.of_seq
-        |> Syntax.list_map (fun (key : denom) ->
-            let+ section_name =
-              match Hashtbl.find_opt t.dn_section_name_ht key.dn_data.h_pub with
             | None -> Error "invalid state, section_name not found"
             | Some s -> Ok s
           in
-            let fname = Fpath.(Config.secrets_dir / section_name) in
+          Data_file.write_rsa (dn_key_fname section_name) priv)
-            (fname, key.priv))
     in
-      list_iter (fun (fname, key) -> Data_file.write_rsa fname key) l
+    Logs.info (fun m -> m "saved secmod private keys data");
-    in
-    Logs.info (fun m -> m "stored secmod data to file");
     Ok ()
 end

src/secmod.mli

@@ -1,6 +1,7 @@
 module type S = sig
   open Crypto
 
+  val sm_pubkey : eddsa_pub
   val sign_with_sm_key : string -> eddsa_sig
   val sign_with_signkey : pub:eddsa_pub -> string -> eddsa_sig
   val verify_with_master_key : eddsa_sig -> msg:string -> (unit, string) result
@@ -9,26 +10,20 @@ module type S = sig
   val verify_with_signkey :
     pub:eddsa_pub -> eddsa_sig -> msg:string -> (unit, string) result
 
-  (* TODO query database instead? *)
+  val get_signkeys : unit -> Signkey.t list
-  val get_sm_key_pub : unit -> eddsa_pub
+  val get_denominations : unit -> Denomination.t list
-  val get_signkeys_data : unit -> Signkey.t list
+  val get_future_signkeys : unit -> Api.FutureSignKey.t list
-  val get_denoms_data : unit -> Denomination.t list
+  val get_future_denominations : unit -> Api.FutureDenom.t list
-  val find_signkey_data : eddsa_pub -> Signkey.t option
+  val find_signkey : eddsa_pub -> Signkey.t option
-  val find_denomination : denomination_hash -> Denomination.t option
+  val find_denomination : denom_hash -> Denomination.t option
-  val find_denom_section_name : denomination_hash -> string option
 
-  (* - management operations - *)
+  val certify_future_signkey :
-  (* TODO
+    eddsa_pub ->
-     problem of keeping db and secmod state syncronized
+    Signatures.ExchangeSigningKeyValidity.t ->
-     do db interaction from secmod? *)
-
-  val add_signkey_master_signatures :
-    (eddsa_pub * Signatures.ExchangeSigningKeyValidity.t) list ->
     (unit, string) result
 
-  val add_denom_master_signatures :
+  val certify_future_denomination :
-    (denomination_hash * Signatures.DenominationKeyValidity.t) list ->
+    denom_hash -> Signatures.DenominationKeyValidity.t -> (unit, string) result
-    (unit, string) result
 
   val revoke_signkey :
     eddsa_pub ->
@@ -36,11 +31,11 @@ module type S = sig
     (unit, string) result
 
   val revoke_denomination :
-    denomination_hash ->
+    denom_hash ->
     Signatures.MasterDenominationKeyRevocation.t ->
     (unit, string) result
 
-  val store : unit -> (unit, string) result
+  val save : unit -> (unit, string) result
 end
 
 module Make (_ : Pg.CONN) : S

src/signkey.ml

@@ -1,5 +1,6 @@
 open Crypto
 
+(* TODO replace by Api.SignKey.t instead? (no revoked_sig) *)
 type t = {
   pub: eddsa_pub;
   stamp_start: Timestamp.t;