feat: adding reconstruction threshold in node

crates/contract/src/primitives/thresholds.rs

@@ -16,10 +16,8 @@ pub(crate) fn governance_threshold_lower_relative_bound(n: u64) -> u64 {
     3_u64.saturating_mul(n).div_ceil(5)
 }
 
-/// Upper bound on the GovernanceThreshold for `n` participants:
-/// Currently set to 100% of participants but would be a discussion subject
-/// to drop this upper bound down not to have problems with smart contract
-/// being locked if t = n and if an operator stops voting
+/// Upper bound on the GovernanceThreshold for `n` participants: currently 100%.
+/// Whether to lower it is open (see `docs/design/domain-separation.md` §7).
 pub(crate) fn governance_threshold_upper_relative_bound(n: u64) -> u64 {
     n
 }

crates/e2e-tests/tests/ckd_verification.rs

@@ -1,4 +1,7 @@
-use crate::common;
+use crate::common::{
+    CKD_PV_VERIFICATION_PORT_SEED, CKD_VERIFICATION_PORT_SEED, must_get_bls_public_key,
+    must_get_domain, must_setup_cluster,
+};
 
 use anyhow::Context;
 use blstrs::{G1Projective, G2Projective, Scalar};
@@ -7,8 +10,7 @@ use group::ff::Field as _;
 use near_account_id::AccountId;
 use near_mpc_contract_interface::types::kdf::derive_app_id;
 use near_mpc_contract_interface::types::{
-    Bls12381G1PublicKey, Bls12381G2PublicKey, CKDAppPublicKey, CKDAppPublicKeyPV, Curve,
-    DomainPurpose,
+    Bls12381G1PublicKey, Bls12381G2PublicKey, CKDAppPublicKey, CKDAppPublicKeyPV, Protocol,
 };
 use rand::SeedableRng;
 use threshold_signatures::confidential_key_derivation::{
@@ -42,20 +44,11 @@ fn verify_ckd(
 #[expect(non_snake_case)]
 async fn ckd_response__passes_cryptographic_verification() {
     // given
-    let (cluster, running) =
-        common::must_setup_cluster(common::CKD_VERIFICATION_PORT_SEED, |_| {}).await;
-
-    let bls_domain = running
-        .domains
-        .domains
-        .iter()
-        .find(|d| {
-            Curve::from(d.protocol) == Curve::Bls12381 && matches!(d.purpose, DomainPurpose::CKD)
-        })
-        .expect("no Bls12381 CKD domain found")
-        .clone();
-
-    let mpc_pk = common::must_get_bls_public_key(&running, bls_domain.id);
+    let (cluster, running) = must_setup_cluster(CKD_VERIFICATION_PORT_SEED, |_| {}).await;
+
+    let bls_domain = must_get_domain(&running, Protocol::ConfidentialKeyDerivation);
+
+    let mpc_pk = must_get_bls_public_key(&running, bls_domain.id);
     let user = cluster.default_user_account().clone();
 
     let mut rng = rand::rngs::StdRng::seed_from_u64(1);
@@ -95,20 +88,11 @@ async fn ckd_response__passes_cryptographic_verification() {
 #[expect(non_snake_case)]
 async fn ckd_pv_response__passes_cryptographic_verification() {
     // given
-    let (cluster, running) =
-        common::must_setup_cluster(common::CKD_PV_VERIFICATION_PORT_SEED, |_| {}).await;
-
-    let bls_domain = running
-        .domains
-        .domains
-        .iter()
-        .find(|d| {
-            Curve::from(d.protocol) == Curve::Bls12381 && matches!(d.purpose, DomainPurpose::CKD)
-        })
-        .expect("no Bls12381 CKD domain found")
-        .clone();
-
-    let mpc_pk = common::must_get_bls_public_key(&running, bls_domain.id);
+    let (cluster, running) = must_setup_cluster(CKD_PV_VERIFICATION_PORT_SEED, |_| {}).await;
+
+    let bls_domain = must_get_domain(&running, Protocol::ConfidentialKeyDerivation);
+
+    let mpc_pk = must_get_bls_public_key(&running, bls_domain.id);
     let user = cluster.default_user_account().clone();
 
     let mut rng = rand::rngs::StdRng::seed_from_u64(2);

crates/e2e-tests/tests/common.rs

@@ -7,8 +7,9 @@ use blstrs::{G1Projective, Scalar};
 use e2e_tests::{CLUSTER_WAIT_TIMEOUT, MpcCluster, MpcClusterConfig, metrics};
 use group::Group;
 use near_mpc_contract_interface::types::{
-    Bls12381G2PublicKey, CKDAppPublicKey, Curve, DomainId, DomainPurpose, ProtocolContractState,
-    PublicKey, PublicKeyExtended, RunningContractState,
+    Bls12381G2PublicKey, CKDAppPublicKey, Curve, DomainConfig, DomainId, DomainPurpose, Protocol,
+    ProtocolContractState, PublicKey, PublicKeyExtended, ReconstructionThreshold,
+    RunningContractState,
 };
 use near_mpc_crypto_types::Bls12381G1PublicKey;
 use serde_json::json;
@@ -36,6 +37,7 @@ pub const CONTRACT_UPGRADE_COMPATIBILITY_TESTNET_PORT_SEED: u16 = 19;
 pub const TIMEOUT_METRIC_PORT_SEED: u16 = 20;
 pub const MIGRATION_BACK_PORT_SEED: u16 = 21;
 pub const SIGTERM_HANDLER_PORT_SEED: u16 = 22;
+pub const DISTINCT_RECONSTRUCTION_THRESHOLDS_PORT_SEED: u16 = 23;
 
 /// Start a cluster, wait for Running state and presignatures to buffer.
 ///
@@ -376,6 +378,28 @@ pub fn must_get_bls_public_key(
     }
 }
 
+/// Builds a `DamgardEtAl` signing domain with reconstruction threshold `t`, which needs `2t - 1` signers.
+pub fn damgard_etal_domain(id: u64, t: u64) -> DomainConfig {
+    DomainConfig {
+        id: DomainId(id),
+        protocol: Protocol::DamgardEtAl,
+        reconstruction_threshold: ReconstructionThreshold::new(t),
+        purpose: DomainPurpose::Sign,
+    }
+}
+
+/// Returns the domain running `protocol_type`, panicking if absent. Each
+/// protocol appears at most once per registry, so it identifies a unique domain.
+pub fn must_get_domain(running: &RunningContractState, protocol_type: Protocol) -> DomainConfig {
+    running
+        .domains
+        .domains
+        .iter()
+        .find(|d| d.protocol == protocol_type)
+        .unwrap_or_else(|| panic!("no domain with protocol {protocol_type:?}"))
+        .clone()
+}
+
 /// Send a sign request and assert the network produced a successful response.
 ///
 /// Panics if the request can't be submitted to the contract — the test cannot
@@ -406,6 +430,34 @@ pub async fn send_sign_request(
     Ok(())
 }
 
+/// Sign with every scheme in `running`, asserting each request succeeds.
+pub async fn sign_all_schemes(
+    cluster: &MpcCluster,
+    running: &RunningContractState,
+    rng: &mut impl rand::Rng,
+) {
+    for (label, protocol) in [
+        ("ECDSA", Protocol::CaitSith),
+        ("Damgard et al", Protocol::DamgardEtAl),
+        ("EdDSA", Protocol::Frost),
+    ] {
+        let domain = must_get_domain(running, protocol);
+        let payload = match Curve::from(protocol) {
+            Curve::Edwards25519 => generate_eddsa_payload(rng),
+            _ => generate_ecdsa_payload(rng),
+        };
+        let outcome = cluster
+            .send_sign_request(domain.id, payload, cluster.default_user_account())
+            .await
+            .expect("sign request failed");
+        assert!(
+            outcome.is_success(),
+            "{label} sign request failed: {:?}",
+            outcome.failure_message()
+        );
+    }
+}
+
 /// Send a CKD request and assert the network produced a successful response.
 ///
 /// Panics if the request can't be submitted to the contract — the test cannot

crates/e2e-tests/tests/distinct_reconstruction_thresholds.rs

@@ -0,0 +1,50 @@
+use crate::common::{
+    DISTINCT_RECONSTRUCTION_THRESHOLDS_PORT_SEED, damgard_etal_domain, generate_ckd_app_public_key,
+    must_get_domain, must_setup_cluster, sign_all_schemes,
+};
+
+use near_mpc_contract_interface::types::Protocol;
+use rand::SeedableRng;
+
+/// Each domain signs using its own reconstruction threshold rather than the
+/// governance threshold. The governance threshold is 4 with a total of 6 nodes.
+/// The signing procedure succeeds despite Damgard et al. requiring at least 7
+/// participants under a governance-threshold signing model.
+/// Therefore, signing is performed using the reconstruction threshold,
+/// not the governance threshold.
+#[tokio::test]
+#[expect(non_snake_case)]
+async fn distinct_reconstruction_thresholds__should_sign_for_every_scheme() {
+    // Given
+    let (cluster, contract_state) =
+        must_setup_cluster(DISTINCT_RECONSTRUCTION_THRESHOLDS_PORT_SEED, |c| {
+            c.num_nodes = 6;
+            c.initial_participant_indices = (0..6).collect();
+            c.threshold = 4;
+            c.triples_to_buffer = 2;
+            c.presignatures_to_buffer = 2;
+            c.domains
+                .push(damgard_etal_domain(c.domains.len() as u64, 3));
+        })
+        .await;
+
+    let ckd_domain = must_get_domain(&contract_state, Protocol::ConfidentialKeyDerivation);
+
+    // When / Then
+    let mut rng = rand::rngs::StdRng::seed_from_u64(0);
+    sign_all_schemes(&cluster, &contract_state, &mut rng).await;
+
+    let outcome = cluster
+        .send_ckd_request(
+            ckd_domain.id,
+            generate_ckd_app_public_key(&mut rng),
+            cluster.default_user_account(),
+        )
+        .await
+        .expect("ckd request failed");
+    assert!(
+        outcome.is_success(),
+        "ckd request failed: {:?}",
+        outcome.failure_message()
+    );
+}

crates/e2e-tests/tests/e2e.rs

@@ -3,6 +3,7 @@ mod ckd_verification;
 mod cleanup_lagging_node;
 mod common;
 mod contract_upgrade_compatibility;
+mod distinct_reconstruction_thresholds;
 mod foreign_chain_configuration;
 mod foreign_chain_tx_validation;
 mod key_resharing;

crates/e2e-tests/tests/parallel_sign_calls.rs

@@ -7,7 +7,7 @@ use near_mpc_contract_interface::types::{
 };
 use serde_json::json;
 
-/// 9 parallel calls (3 robust ECDSA + 2 ECDSA + 2 EdDSA + 2 CKD) via the test parallel
+/// 9 parallel calls (3 DamgardEtAl + 2 ECDSA + 2 EdDSA + 2 CKD) via the test parallel
 /// contract, against a 6-node / threshold-5 cluster that carries all four signing-scheme
 /// domains. Verifies all calls succeed and both the signature and CKD queues drain.
 #[tokio::test]
@@ -25,12 +25,7 @@ async fn mpc_cluster_should_successfully_process_parallel_requests() {
             c.initial_participant_indices = (0..6).collect();
             c.threshold = 5;
             c.domains = vec![
-                DomainConfig {
-                    id: DomainId(0),
-                    protocol: Protocol::DamgardEtAl,
-                    reconstruction_threshold: ReconstructionThreshold::new(3),
-                    purpose: DomainPurpose::Sign,
-                },
+                common::damgard_etal_domain(0, 3),
                 DomainConfig {
                     id: DomainId(1),
                     protocol: Protocol::CaitSith,

crates/e2e-tests/tests/request_during_resharing.rs

@@ -1,37 +1,33 @@
-use crate::common;
-
-use mpc_primitives::domain::{Curve, DomainId};
-use near_mpc_contract_interface::types::{
-    DomainConfig, DomainPurpose, Protocol, ProtocolContractState, ReconstructionThreshold,
+use crate::common::{
+    REQUEST_DURING_RESHARING_PORT_SEED, damgard_etal_domain, generate_ckd_app_public_key,
+    must_get_domain, must_setup_cluster, sign_all_schemes,
 };
+
+use near_mpc_contract_interface::types::{Protocol, ProtocolContractState};
 use rand::SeedableRng;
 
 /// Tests that signature and CKD requests are processed using the previous
 /// running state's threshold while resharing is in progress.
 ///
 /// Setup: 6 nodes, 5 initial participants (threshold 5). Domains cover
-/// classic ECDSA (CaitSith), robust ECDSA (DamgardEtAl), EdDSA (Frost) and
-/// CKD (ConfidentialKeyDerivation). Threshold is 5 because robust ECDSA
-/// requires ≥ 5 signers (see `robust_ecdsa::translate_threshold`). Begin
-/// resharing to all 6 with threshold 6, then kill node 5 so resharing can't
-/// complete. Requests should still succeed using the old threshold of 5
-/// across all signing schemes.
+/// classic ECDSA (CaitSith), DamgardEtAl, EdDSA (Frost) and
+/// CKD (ConfidentialKeyDerivation). The DamgardEtAl domain uses a
+/// reconstruction threshold of `t = 3`, which requires `2t - 1 = 5` signers,
+/// so we need at least 5 participants. Begin resharing to all 6 with threshold
+/// 6, then kill node 5 so resharing can't complete. Requests should still
+/// succeed using the previous running state across all signing schemes.
 #[tokio::test]
 async fn test_request_during_resharing() {
     // given
     let (mut cluster, contract_state) =
-        common::must_setup_cluster(common::REQUEST_DURING_RESHARING_PORT_SEED, |c| {
+        must_setup_cluster(REQUEST_DURING_RESHARING_PORT_SEED, |c| {
             c.num_nodes = 6;
             c.initial_participant_indices = (0..5).collect();
             c.threshold = 5;
             c.triples_to_buffer = 2;
             c.presignatures_to_buffer = 2;
-            c.domains.push(DomainConfig {
-                id: DomainId(c.domains.len() as u64),
-                protocol: Protocol::DamgardEtAl,
-                reconstruction_threshold: ReconstructionThreshold::new(3),
-                purpose: DomainPurpose::Sign,
-            });
+            c.domains
+                .push(damgard_etal_domain(c.domains.len() as u64, 3));
         })
         .await;
 
@@ -46,66 +42,18 @@ async fn test_request_during_resharing() {
     cluster.kill_nodes(&[5]).expect("failed to kill node 5");
 
     // then
-    let ecdsa_domain = contract_state
-        .domains
-        .domains
-        .iter()
-        .find(|d| {
-            Curve::from(d.protocol) == Curve::Secp256k1
-                && d.protocol == Protocol::CaitSith
-                && d.purpose == DomainPurpose::Sign
-        })
-        .expect("no CaitSith Sign domain");
-    let robust_ecdsa_domain = contract_state
-        .domains
-        .domains
-        .iter()
-        .find(|d| d.protocol == Protocol::DamgardEtAl && d.purpose == DomainPurpose::Sign)
-        .expect("no DamgardEtAl Sign domain");
-    let eddsa_domain = contract_state
-        .domains
-        .domains
-        .iter()
-        .find(|d| {
-            Curve::from(d.protocol) == Curve::Edwards25519 && d.purpose == DomainPurpose::Sign
-        })
-        .expect("no Edwards25519 Sign domain");
-    let ckd_domain = contract_state
-        .domains
-        .domains
-        .iter()
-        .find(|d| d.purpose == DomainPurpose::CKD)
-        .expect("no CKD domain");
+    let ckd_domain = must_get_domain(&contract_state, Protocol::ConfidentialKeyDerivation);
 
     let mut rng = rand::rngs::StdRng::seed_from_u64(0);
     for i in 0..3 {
-        for (label, domain_id, is_eddsa) in [
-            ("ECDSA", ecdsa_domain.id, false),
-            ("robust ECDSA", robust_ecdsa_domain.id, false),
-            ("EdDSA", eddsa_domain.id, true),
-        ] {
-            let payload = if is_eddsa {
-                common::generate_eddsa_payload(&mut rng)
-            } else {
-                common::generate_ecdsa_payload(&mut rng)
-            };
-            tracing::info!(i, label, "sending sign request during resharing");
-            let outcome = cluster
-                .send_sign_request(domain_id, payload, cluster.default_user_account())
-                .await
-                .expect("sign request failed");
-            assert!(
-                outcome.is_success(),
-                "{label} sign request {i} failed: {:?}",
-                outcome.failure_message()
-            );
-        }
+        tracing::info!(i, "sending sign requests during resharing");
+        sign_all_schemes(&cluster, &contract_state, &mut rng).await;
 
         tracing::info!(i, "sending CKD request during resharing");
         let outcome = cluster
             .send_ckd_request(
                 ckd_domain.id,
-                common::generate_ckd_app_public_key(&mut rng),
+                generate_ckd_app_public_key(&mut rng),
                 cluster.default_user_account(),
             )
             .await