feat(ecdsa): [CON-1053] populate key_id in QuadrupleId for newly …

…crated Quadruples

rs/consensus/src/ecdsa.rs

@@ -601,6 +601,7 @@ fn compute_priority(
 
 #[cfg(test)]
 mod tests {
+    use super::test_utils::fake_ecdsa_key_id;
     use super::*;
     use ic_types::consensus::ecdsa::EcdsaUIDGenerator;
     use ic_types::crypto::canister_threshold_sig::idkg::IDkgTranscriptId;
@@ -689,22 +690,22 @@ mod tests {
         let subnet_id = SubnetId::from(PrincipalId::new_subnet_test_id(2));
         let mut uid_generator = EcdsaUIDGenerator::new(subnet_id, Height::new(0));
         let request_id_fetch_1 = RequestId {
-            quadruple_id: uid_generator.next_quadruple_id(),
+            quadruple_id: uid_generator.next_quadruple_id(fake_ecdsa_key_id()),
             pseudo_random_id: [1; 32],
             height: Height::from(80),
         };
         let request_id_drop = RequestId {
-            quadruple_id: uid_generator.next_quadruple_id(),
+            quadruple_id: uid_generator.next_quadruple_id(fake_ecdsa_key_id()),
             pseudo_random_id: [2; 32],
             height: Height::from(70),
         };
         let request_id_fetch_2 = RequestId {
-            quadruple_id: uid_generator.next_quadruple_id(),
+            quadruple_id: uid_generator.next_quadruple_id(fake_ecdsa_key_id()),
             pseudo_random_id: [3; 32],
             height: Height::from(102),
         };
         let request_id_stash = RequestId {
-            quadruple_id: uid_generator.next_quadruple_id(),
+            quadruple_id: uid_generator.next_quadruple_id(fake_ecdsa_key_id()),
             pseudo_random_id: [4; 32],
             height: Height::from(200),
         };

rs/consensus/src/ecdsa/payload_builder.rs

@@ -1244,20 +1244,22 @@ mod tests {
         assert!(signing_requets.is_empty());
 
         // Add two quadruples in creation
-        let quadruple_id_0 = ecdsa_payload.peek_next_quadruple_id();
+        let quadruple_id_0 = ecdsa_payload.peek_next_quadruple_id(key_id.clone());
         let (_kappa_config_ref, _lambda_config_ref) =
             quadruples::test_utils::create_new_quadruple_in_creation(
                 &subnet_nodes,
                 registry_version,
                 &mut ecdsa_payload.uid_generator,
+                key_id.clone(),
                 &mut ecdsa_payload.quadruples_in_creation,
             );
-        let quadruple_id_1 = ecdsa_payload.peek_next_quadruple_id();
+        let quadruple_id_1 = ecdsa_payload.peek_next_quadruple_id(key_id.clone());
         let (_kappa_config_ref, _lambda_config_ref) =
             quadruples::test_utils::create_new_quadruple_in_creation(
                 &subnet_nodes,
                 registry_version,
                 &mut ecdsa_payload.uid_generator,
+                key_id.clone(),
                 &mut ecdsa_payload.quadruples_in_creation,
             );
         let new_requests = get_signing_requests(
@@ -1350,8 +1352,10 @@ mod tests {
                 (key_id.clone(), [1; 32], non_expired_time),
             ]);
         // Add quadruples
-        let _discarded_quadruple_id = create_available_quadruple(&mut ecdsa_payload, 10);
-        let matched_quadruple_id = create_available_quadruple(&mut ecdsa_payload, 11);
+        let _discarded_quadruple_id =
+            create_available_quadruple(&mut ecdsa_payload, key_id.clone(), 10);
+        let matched_quadruple_id =
+            create_available_quadruple(&mut ecdsa_payload, key_id.clone(), 11);
 
         let result = get_signing_requests(
             Height::from(1),
@@ -1390,8 +1394,8 @@ mod tests {
         assert!(result.is_empty());
 
         // Add quadruples
-        create_available_quadruple(&mut ecdsa_payload, 10);
-        create_available_quadruple(&mut ecdsa_payload, 11);
+        create_available_quadruple(&mut ecdsa_payload, valid_key_id.clone(), 10);
+        create_available_quadruple(&mut ecdsa_payload, valid_key_id.clone(), 11);
 
         let result = get_signing_requests(
             height,
@@ -1830,7 +1834,7 @@ mod tests {
         let transcript_builder = TestEcdsaTranscriptBuilder::new();
         let max_ongoing_signatures = 1;
 
-        create_available_quadruple(&mut ecdsa_payload, 13);
+        create_available_quadruple(&mut ecdsa_payload, key_id.clone(), 13);
 
         let all_requests = get_signing_requests(
             Height::from(0),
@@ -2009,10 +2013,15 @@ mod tests {
 
             // Create a payload block with references to these past blocks
             let mut ecdsa_payload = empty_ecdsa_payload(subnet_id);
+            let key_id = ecdsa_payload.key_transcript.key_id.clone();
             ecdsa_payload.key_transcript.current = Some(current_key_transcript.clone());
             let (quadruple_id_1, quadruple_id_2) = (
-                ecdsa_payload.uid_generator.next_quadruple_id(),
-                ecdsa_payload.uid_generator.next_quadruple_id(),
+                ecdsa_payload
+                    .uid_generator
+                    .next_quadruple_id(key_id.clone()),
+                ecdsa_payload
+                    .uid_generator
+                    .next_quadruple_id(key_id.clone()),
             );
             let req_id_1 = ecdsa::RequestId {
                 quadruple_id: quadruple_id_1.clone(),
@@ -2050,13 +2059,13 @@ mod tests {
             add_expected_transcripts(reshare_params_1.as_ref().get_refs());
 
             // Add some quadruples in creation
-            // let next_quadruple_id = ecdsa_payload.uid_generator.next_quadruple_id();
             let block_reader = TestEcdsaBlockReader::new();
             let (kappa_config_ref, _lambda_config_ref) =
                 quadruples::test_utils::create_new_quadruple_in_creation(
                     &subnet_nodes,
                     env.newest_registry_version,
                     &mut ecdsa_payload.uid_generator,
+                    key_id.clone(),
                     &mut ecdsa_payload.quadruples_in_creation,
                 );
             let kappa_transcript = {
@@ -2297,8 +2306,9 @@ mod tests {
             // Create a payload block with references to these past blocks
             let mut ecdsa_payload = empty_ecdsa_payload(subnet_id);
             let uid_generator = &mut ecdsa_payload.uid_generator;
-            let quadruple_id_1 = uid_generator.next_quadruple_id();
-            let quadruple_id_2 = uid_generator.next_quadruple_id();
+            let key_id = ecdsa_payload.key_transcript.key_id.clone();
+            let quadruple_id_1 = uid_generator.next_quadruple_id(key_id.clone());
+            let quadruple_id_2 = uid_generator.next_quadruple_id(key_id.clone());
             ecdsa_payload.key_transcript.current = Some(current_key_transcript.clone());
             let req_id_1 = ecdsa::RequestId {
                 quadruple_id: quadruple_id_1.clone(),
@@ -2336,6 +2346,7 @@ mod tests {
                     &subnet_nodes,
                     env.newest_registry_version,
                     &mut ecdsa_payload.uid_generator,
+                    key_id.clone(),
                     &mut ecdsa_payload.quadruples_in_creation,
                 );
             let kappa_transcript = {
@@ -2748,7 +2759,7 @@ mod tests {
             );
             let test_inputs = TestSigInputs::from(&sig_inputs);
             payload_0.available_quadruples.insert(
-                payload_0.uid_generator.next_quadruple_id(),
+                payload_0.uid_generator.next_quadruple_id(key_id.clone()),
                 test_inputs.sig_inputs_ref.presig_quadruple_ref.clone(),
             );
             for (transcript_ref, transcript) in test_inputs.idkg_transcripts {
@@ -2758,6 +2769,7 @@ mod tests {
                 &env.nodes.ids::<Vec<_>>(),
                 env.newest_registry_version,
                 &mut payload_0.uid_generator,
+                key_id.clone(),
                 &mut payload_0.quadruples_in_creation,
             );
             payload_0.ongoing_xnet_reshares.insert(

rs/consensus/src/ecdsa/payload_builder/quadruples.rs

@@ -274,7 +274,7 @@ fn make_new_quadruples_if_needed_helper(
             let kappa_config = new_random_config(subnet_nodes, registry_version, uid_generator);
             let lambda_config = new_random_config(subnet_nodes, registry_version, uid_generator);
             quadruples_in_creation.insert(
-                uid_generator.next_quadruple_id(),
+                uid_generator.next_quadruple_id(ecdsa_payload.key_transcript.key_id.clone()),
                 ecdsa::QuadrupleInCreation::new(kappa_config, lambda_config),
             );
         }
@@ -309,6 +309,7 @@ pub(super) mod test_utils {
 
     use std::collections::BTreeMap;
 
+    use ic_ic00_types::EcdsaKeyId;
     use ic_types::{
         consensus::ecdsa::{self, EcdsaPayload, QuadrupleId, UnmaskedTranscript},
         NodeId, RegistryVersion,
@@ -318,28 +319,39 @@ pub(super) mod test_utils {
         subnet_nodes: &[NodeId],
         registry_version: RegistryVersion,
         uid_generator: &mut ecdsa::EcdsaUIDGenerator,
+        key_id: EcdsaKeyId,
         quadruples_in_creation: &mut BTreeMap<ecdsa::QuadrupleId, ecdsa::QuadrupleInCreation>,
     ) -> (ecdsa::RandomTranscriptParams, ecdsa::RandomTranscriptParams) {
         let kappa_config_ref = new_random_config(subnet_nodes, registry_version, uid_generator);
         let lambda_config_ref = new_random_config(subnet_nodes, registry_version, uid_generator);
         quadruples_in_creation.insert(
-            uid_generator.next_quadruple_id(),
+            uid_generator.next_quadruple_id(key_id),
             ecdsa::QuadrupleInCreation::new(kappa_config_ref.clone(), lambda_config_ref.clone()),
         );
         (kappa_config_ref, lambda_config_ref)
     }
 
-    pub fn create_available_quadruple(ecdsa_payload: &mut EcdsaPayload, caller: u8) -> QuadrupleId {
-        create_available_quadruple_with_key_transcript(ecdsa_payload, caller, None)
+    pub fn create_available_quadruple(
+        ecdsa_payload: &mut EcdsaPayload,
+        key_id: EcdsaKeyId,
+        caller: u8,
+    ) -> QuadrupleId {
+        create_available_quadruple_with_key_transcript(
+            ecdsa_payload,
+            caller,
+            key_id,
+            /*key_transcript=*/ None,
+        )
     }
 
     pub fn create_available_quadruple_with_key_transcript(
         ecdsa_payload: &mut EcdsaPayload,
         caller: u8,
+        key_id: EcdsaKeyId,
         key_transcript: Option<UnmaskedTranscript>,
     ) -> QuadrupleId {
         let sig_inputs = create_sig_inputs(caller);
-        let quadruple_id = ecdsa_payload.uid_generator.next_quadruple_id();
+        let quadruple_id = ecdsa_payload.uid_generator.next_quadruple_id(key_id);
         let mut quadruple_ref = sig_inputs.sig_inputs_ref.presig_quadruple_ref.clone();
         quadruple_ref.key_unmasked_ref = key_transcript;
         ecdsa_payload
@@ -403,6 +415,7 @@ pub(super) mod tests {
         let subnet_id = subnet_test_id(1);
         let height = Height::new(10);
         let (mut ecdsa_payload, env, _block_reader) = set_up(&mut rng, subnet_id, height);
+        let key_id = ecdsa_payload.key_transcript.key_id.clone();
 
         // 4 Quadruples should be created in advance (in creation + unmatched available = 4)
         let quadruples_to_create_in_advance = 4;
@@ -413,7 +426,7 @@ pub(super) mod tests {
 
         // Add 3 available quadruples
         for i in 0..3 {
-            create_available_quadruple(&mut ecdsa_payload, i);
+            create_available_quadruple(&mut ecdsa_payload, key_id.clone(), i);
         }
 
         // 2 available quadruples are already matched
@@ -473,6 +486,7 @@ pub(super) mod tests {
             &env.nodes.ids::<Vec<_>>(),
             env.newest_registry_version,
             &mut payload.uid_generator,
+            payload.key_transcript.key_id.clone(),
             &mut payload.quadruples_in_creation,
         );
 
@@ -677,9 +691,19 @@ pub(super) mod tests {
 
         // Create three quadruples, with the current, a different, no key transcript.
         let quadruple_ids = vec![
-            create_available_quadruple_with_key_transcript(&mut payload, 1, Some(key_transcript)),
-            create_available_quadruple_with_key_transcript(&mut payload, 2, Some(key_transcript2)),
-            create_available_quadruple_with_key_transcript(&mut payload, 3, None),
+            create_available_quadruple_with_key_transcript(
+                &mut payload,
+                1,
+                key_id.clone(),
+                Some(key_transcript),
+            ),
+            create_available_quadruple_with_key_transcript(
+                &mut payload,
+                2,
+                key_id.clone(),
+                Some(key_transcript2),
+            ),
+            create_available_quadruple_with_key_transcript(&mut payload, 3, key_id.clone(), None),
         ];
 
         // All three quadruples are matched with a context
@@ -702,7 +726,12 @@ pub(super) mod tests {
 
         // Create three quadruples of the current key transcript
         for i in 0..3 {
-            create_available_quadruple_with_key_transcript(&mut payload, i, Some(key_transcript));
+            create_available_quadruple_with_key_transcript(
+                &mut payload,
+                i,
+                key_id.clone(),
+                Some(key_transcript),
+            );
         }
 
         // None of them are matched to a context
@@ -726,7 +755,7 @@ pub(super) mod tests {
 
         // Create three quadruples without key transcript
         for i in 0..3 {
-            create_available_quadruple_with_key_transcript(&mut payload, i, None);
+            create_available_quadruple_with_key_transcript(&mut payload, i, key_id.clone(), None);
         }
 
         // None of them are matched to a context
@@ -768,6 +797,7 @@ pub(super) mod tests {
                 create_available_quadruple_with_key_transcript(
                     &mut payload,
                     i,
+                    key_id.clone(),
                     Some(other_key_transcript),
                 )
             })

rs/consensus/src/ecdsa/payload_builder/signatures.rs

@@ -138,6 +138,7 @@ mod tests {
     use std::collections::BTreeSet;
 
     use ic_crypto_test_utils_reproducible_rng::reproducible_rng;
+    use ic_ic00_types::EcdsaKeyId;
     use ic_logger::replica_logger::no_op_logger;
     use ic_test_utilities::types::ids::subnet_test_id;
     use ic_types::{consensus::ecdsa::EcdsaPayload, Height};
@@ -182,9 +183,10 @@ mod tests {
 
     fn create_request_id_with_available_quadruple(
         ecdsa_payload: &mut EcdsaPayload,
+        key_id: EcdsaKeyId,
         pseudo_random_id: [u8; 32],
     ) -> ecdsa::RequestId {
-        let quadruple_id = create_available_quadruple(ecdsa_payload, pseudo_random_id[0]);
+        let quadruple_id = create_available_quadruple(ecdsa_payload, key_id, pseudo_random_id[0]);
 
         ecdsa::RequestId {
             quadruple_id,
@@ -228,8 +230,9 @@ mod tests {
         let valid_key_id = ecdsa_payload.key_transcript.key_id.clone();
         let valid_key_ids = BTreeSet::from([valid_key_id.clone()]);
         // Add a quadruple
-        let quadruple_id = create_available_quadruple(&mut ecdsa_payload, 10);
-        let _quadruple_id_2 = create_available_quadruple(&mut ecdsa_payload, 11);
+        let quadruple_id = create_available_quadruple(&mut ecdsa_payload, valid_key_id.clone(), 10);
+        let _quadruple_id_2 =
+            create_available_quadruple(&mut ecdsa_payload, valid_key_id.clone(), 11);
 
         let signing_requests = get_signing_requests(
             height,
@@ -258,10 +261,12 @@ mod tests {
             /*should_create_key_transcript=*/ false,
             /*pseudo_random_ids=*/ vec![pseudo_random_id(0), pseudo_random_id(1)],
         );
+        let key_id = ecdsa_payload.key_transcript.key_id.clone();
         let mut requests = BTreeMap::new();
         for context in contexts.values() {
             let request_id = create_request_id_with_available_quadruple(
                 &mut ecdsa_payload,
+                key_id.clone(),
                 context.pseudo_random_id,
             );
 
@@ -291,10 +296,12 @@ mod tests {
                 .map(|i| pseudo_random_id(i as u8))
                 .collect(),
         );
+        let key_id = ecdsa_payload.key_transcript.key_id.clone();
         let mut requests = BTreeMap::new();
         for context in contexts.values() {
             let request_id = create_request_id_with_available_quadruple(
                 &mut ecdsa_payload,
+                key_id.clone(),
                 context.pseudo_random_id,
             );