Reshare keys to the updated reconstruction threshold

Changing a domain's reconstruction threshold via a resharing proposal had no
cryptographic effect. The resharing key event was built from the old domain
registry, so the node reshared at the old threshold, and per_domain_thresholds
was only folded into the registry on completion. Lowering t left an unusable
(higher-degree) key; raising t left the advertised threshold unenforced.

Build the resharing key events from the effective (threshold-updated) domains
via a new DomainRegistry::effective_domain_by_index, so the reshare targets the
new degree. The old-side threshold still comes from the previous registry, so
reshare(old_t, .., new_t) receives the correct pair.

Author: SimonRastikian

crates/contract/src/primitives/domain.rs

@@ -147,6 +147,26 @@ impl DomainRegistry {
         self.domains.get(index)
     }
 
+    /// Like [`Self::get_domain_by_index`], but with `reconstruction_threshold` overridden
+    /// by `threshold_updates` when present, so a resharing key event reshares to the new
+    /// degree. Matches the update [`Self::with_threshold_updates`] folds in on completion.
+    pub fn effective_domain_by_index(
+        &self,
+        index: usize,
+        threshold_updates: &BTreeMap<DomainId, ReconstructionThreshold>,
+    ) -> Option<DomainConfig> {
+        self.get_domain_by_index(index).map(|domain| {
+            let reconstruction_threshold = threshold_updates
+                .get(&domain.id)
+                .copied()
+                .unwrap_or(domain.reconstruction_threshold);
+            DomainConfig {
+                reconstruction_threshold,
+                ..domain.clone()
+            }
+        })
+    }
+
     /// Returns the given domain by the DomainId.
     pub fn get_domain_by_domain_id(&self, id: DomainId) -> Option<&DomainConfig> {
         self.domains.iter().find(|domain| domain.id == id)
@@ -771,4 +791,33 @@ pub mod tests {
             ReconstructionThreshold::new(2)
         );
     }
+
+    #[test]
+    fn effective_domain_by_index__should_override_only_the_targeted_domains_threshold() {
+        // Given a registry with two domains and an update targeting the second.
+        let registry = registry_of(vec![
+            DomainConfig {
+                id: DomainId(0),
+                protocol: Protocol::CaitSith,
+                reconstruction_threshold: ReconstructionThreshold::new(2),
+                purpose: DomainPurpose::Sign,
+            },
+            DomainConfig {
+                id: DomainId(1),
+                protocol: Protocol::CaitSith,
+                reconstruction_threshold: ReconstructionThreshold::new(2),
+                purpose: DomainPurpose::Sign,
+            },
+        ]);
+        let updates = BTreeMap::from([(DomainId(1), ReconstructionThreshold::new(4))]);
+
+        // When reading each domain's effective config.
+        let d0 = registry.effective_domain_by_index(0, &updates).unwrap();
+        let d1 = registry.effective_domain_by_index(1, &updates).unwrap();
+
+        // Then only the targeted domain reports the new threshold.
+        assert_eq!(d0.reconstruction_threshold, ReconstructionThreshold::new(2));
+        assert_eq!(d1.reconstruction_threshold, ReconstructionThreshold::new(4));
+        assert!(registry.effective_domain_by_index(2, &updates).is_none());
+    }
 }

crates/contract/src/state/resharing.rs

@@ -82,9 +82,8 @@ impl ResharingContractState {
                     self.prospective_epoch_id().next(),
                     self.previous_running_state
                         .domains
-                        .get_domain_by_index(0)
-                        .unwrap()
-                        .clone(),
+                        .effective_domain_by_index(0, proposal.per_domain_thresholds())
+                        .unwrap(),
                     proposal.parameters().clone(),
                 ),
                 cancellation_requests: HashSet::new(),
@@ -136,11 +135,11 @@ impl ResharingContractState {
             if let Some(next_domain) = self
                 .previous_running_state
                 .domains
-                .get_domain_by_index(self.reshared_keys.len())
+                .effective_domain_by_index(self.reshared_keys.len(), &self.per_domain_thresholds)
             {
                 self.resharing_key = KeyEvent::new(
                     self.prospective_epoch_id(),
-                    next_domain.clone(),
+                    next_domain,
                     self.resharing_key.proposed_parameters().clone(),
                 );
             } else {

crates/contract/src/state/running.rs

@@ -67,7 +67,10 @@ impl RunningContractState {
         &mut self,
         proposal: &ProposedThresholdParameters,
     ) -> Option<ResharingContractState> {
-        if let Some(first_domain) = self.domains.get_domain_by_index(0) {
+        if let Some(first_domain) = self
+            .domains
+            .effective_domain_by_index(0, proposal.per_domain_thresholds())
+        {
             let epoch_id = self.prospective_epoch_id();
 
             Some(ResharingContractState {
@@ -78,11 +81,7 @@ impl RunningContractState {
                     self.add_domains_votes.clone(),
                 ),
                 reshared_keys: Vec::new(),
-                resharing_key: KeyEvent::new(
-                    epoch_id,
-                    first_domain.clone(),
-                    proposal.parameters().clone(),
-                ),
+                resharing_key: KeyEvent::new(epoch_id, first_domain, proposal.parameters().clone()),
                 cancellation_requests: HashSet::new(),
                 per_domain_thresholds: proposal.per_domain_thresholds().clone(),
             })
@@ -641,6 +640,28 @@ pub mod running_tests {
         );
     }
 
+    #[test]
+    fn transition_to_resharing__should_carry_threshold_update_into_the_resharing_key_event() {
+        // Given a running state with one domain and a proposal changing its threshold.
+        let mut state = gen_running_state_with_params(1, 5, 5);
+        let domain_id = state.domains.get_domain_by_index(0).unwrap().id;
+        let proposal = gen_valid_params_proposal(&state.parameters).with_per_domain_thresholds(
+            BTreeMap::from([(domain_id, ReconstructionThreshold::new(3))]),
+        );
+
+        // When transitioning into resharing.
+        let resharing = state
+            .transition_to_resharing_no_checks(&proposal)
+            .expect("state has a domain, so it transitions into resharing");
+
+        // Then the resharing key event carries the updated threshold, so the node
+        // reshares to the new degree rather than the stale one.
+        assert_eq!(
+            resharing.resharing_key.domain().reconstruction_threshold,
+            ReconstructionThreshold::new(3),
+        );
+    }
+
     /// Builds a `DomainConfig` for the next domain id with the given protocol,
     /// purpose, and reconstruction threshold.
     fn single_domain_proposal(