fix(mint): replace mint keys with key sets; fixed size BLS indices

src/dbc.rs

@@ -156,16 +156,15 @@ mod tests {
         let genesis_key = genesis_owner.public_key_set.public_key();
 
         let mut genesis_node = Mint::new(KeyManager::new(
-            genesis_key,
+            genesis_owner.public_key_set.clone(),
             (0, genesis_owner.secret_key_share.clone()),
             genesis_key,
         ));
 
-        let (gen_dbc_content, gen_dbc_trans, (_gen_key, gen_node_sig)) =
+        let (gen_dbc_content, gen_dbc_trans, (gen_key_set, gen_node_sig)) =
             genesis_node.issue_genesis_dbc(amount).unwrap();
 
-        let genesis_sig = genesis_owner
-            .public_key_set
+        let genesis_sig = gen_key_set
             .combine_signatures(vec![gen_node_sig.threshold_crypto()])
             .unwrap();
 
@@ -197,14 +196,9 @@ mod tests {
 
         assert_eq!(split_transaction, mint_request.transaction.blinded());
 
-        let mint_sig = genesis_owner
-            .public_key_set
-            .combine_signatures(vec![split_transaction_sigs
-                .values()
-                .next()
-                .unwrap()
-                .1
-                .threshold_crypto()])
+        let (mint_key_set, mint_sig_share) = split_transaction_sigs.values().next().unwrap();
+        let mint_sig = mint_key_set
+            .combine_signatures(vec![mint_sig_share.threshold_crypto()])
             .unwrap();
 
         let inputs =
@@ -257,14 +251,9 @@ mod tests {
             .unwrap();
         assert_eq!(mint_request.transaction.blinded(), transaction);
 
-        let mint_sig = genesis_owner
-            .public_key_set
-            .combine_signatures(vec![transaction_sigs
-                .values()
-                .next()
-                .unwrap()
-                .1
-                .threshold_crypto()])
+        let (mint_key_set, mint_sig_share) = transaction_sigs.values().next().unwrap();
+        let mint_sig = mint_key_set
+            .combine_signatures(vec![mint_sig_share.threshold_crypto()])
             .unwrap();
 
         let fuzzed_parents = BTreeSet::from_iter(
@@ -308,7 +297,7 @@ mod tests {
             if let Some(input) = repeating_inputs.next() {
                 let id = crate::bls_dkg_id();
                 let key_mgr = KeyManager::new(
-                    id.public_key_set.public_key(),
+                    id.public_key_set.clone(),
                     (0, id.secret_key_share),
                     genesis_key,
                 );
@@ -326,8 +315,9 @@ mod tests {
         for _ in 0..n_wrong_msg_sigs.coerce() {
             if let Some(input) = repeating_inputs.next() {
                 let wrong_msg_sig = genesis_node.key_mgr.sign(&Hash([0u8; 32]));
-                let wrong_msg_mint_sig = genesis_owner
-                    .public_key_set
+                let wrong_msg_mint_sig = genesis_node
+                    .key_mgr
+                    .public_key_set()
                     .combine_signatures(vec![wrong_msg_sig.threshold_crypto()])
                     .unwrap();
 

src/error.rs

@@ -41,7 +41,8 @@ pub enum Error {
     #[error("DBC already spent in transaction: {transaction:?}")]
     DbcAlreadySpent {
         transaction: crate::DbcTransaction,
-        transaction_sigs: BTreeMap<crate::DbcContentHash, (crate::PublicKey, crate::NodeSignature)>,
+        transaction_sigs:
+            BTreeMap<crate::DbcContentHash, (crate::PublicKeySet, crate::NodeSignature)>,
     },
     #[error("Genesis Input has already been spent in a different transaction")]
     GenesisInputAlreadySpent,

src/key_manager.rs

@@ -4,12 +4,13 @@ use threshold_crypto::{SecretKeyShare, SignatureShare};
 
 use crate::{Error, Hash, Result};
 
-pub use threshold_crypto::{PublicKey, Signature};
+pub use threshold_crypto::{PublicKey, PublicKeySet, Signature};
+
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct NodeSignature(usize, SignatureShare);
+pub struct NodeSignature(u64, SignatureShare);
 
 impl NodeSignature {
-    pub fn threshold_crypto(&self) -> (usize, &SignatureShare) {
+    pub fn threshold_crypto(&self) -> (u64, &SignatureShare) {
         (self.0, &self.1)
     }
 }
@@ -48,31 +49,31 @@ impl From<Vec<PublicKey>> for KeyCache {
 
 #[derive(Debug)]
 pub struct KeyManager {
-    public_key: PublicKey,
-    node_secret_key_share: (usize, SecretKeyShare),
-    genesis: PublicKey,
+    public_key_set: PublicKeySet,
+    secret_key_share: (u64, SecretKeyShare),
+    genesis_key: PublicKey,
     cache: KeyCache,
 }
 
 impl KeyManager {
     pub fn new(
-        public_key: PublicKey,
-        node_secret_key_share: (usize, SecretKeyShare),
-        genesis: PublicKey,
+        public_key_set: PublicKeySet,
+        secret_key_share: (u64, SecretKeyShare),
+        genesis_key: PublicKey,
     ) -> Self {
         let mut cache = KeyCache::default();
-        cache.add_known_key(genesis);
-        cache.add_known_key(public_key);
+        cache.add_known_key(genesis_key);
+        cache.add_known_key(public_key_set.public_key());
         Self {
-            public_key,
-            node_secret_key_share,
-            genesis,
+            public_key_set,
+            secret_key_share,
+            genesis_key,
             cache,
         }
     }
 
     pub fn verify_we_are_a_genesis_node(&self) -> Result<()> {
-        if self.public_key == self.genesis {
+        if self.public_key_set.public_key() == self.genesis_key {
             Ok(())
         } else {
             Err(Error::NotGenesisNode)
@@ -83,14 +84,14 @@ impl KeyManager {
         &self.cache
     }
 
-    pub fn public_key(&self) -> PublicKey {
-        self.public_key
+    pub fn public_key_set(&self) -> PublicKeySet {
+        self.public_key_set.clone()
     }
 
     pub fn sign(&self, msg_hash: &Hash) -> NodeSignature {
         NodeSignature(
-            self.node_secret_key_share.0,
-            self.node_secret_key_share.1.sign(msg_hash),
+            self.secret_key_share.0,
+            self.secret_key_share.1.sign(msg_hash),
         )
     }
 

src/lib.rs

@@ -27,7 +27,7 @@ pub use crate::{
     dbc_content::{BlindedOwner, DbcContent},
     dbc_transaction::DbcTransaction,
     error::{Error, Result},
-    key_manager::{KeyCache, KeyManager, NodeSignature, PublicKey, Signature},
+    key_manager::{KeyCache, KeyManager, NodeSignature, PublicKey, PublicKeySet, Signature},
     mint::{Mint, MintRequest, MintTransaction},
 };