@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/contracts/workers/dvn/src/tests/dvn.rs

@@ -0,0 +1,349 @@
+use crate::tests::setup::TestSetup;
+use crate::{dvn::Dvn, DVNClient, DstConfig, DstConfigParam, IDVN};
+use endpoint_v2::FeeRecipient;
+use message_lib_common::interfaces::ILayerZeroDVN;
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{Address as _, AuthorizedFunction},
+    vec, Address, Bytes, BytesN, Env, IntoVal, Symbol,
+};
+use worker::{DvnFeeParams, IDvnFeeLib, Worker};
+
+fn with_contract<F, R>(setup: &TestSetup, f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    setup.env.as_contract(&setup.contract_id, f)
+}
+
+fn new_addr(env: &Env) -> Address {
+    Address::generate(env)
+}
+
+fn grant_allowlist(setup: &TestSetup, oapp: &Address) {
+    with_contract(setup, || {
+        Dvn::set_allowlist(&setup.env, oapp, true);
+    });
+}
+
+fn configure_dst_config(setup: &TestSetup, dst_eid: u32, config: DstConfig) {
+    let admin = setup.admins.get(0).unwrap();
+    let params = vec![&setup.env, DstConfigParam { dst_eid, config }];
+    with_contract(setup, || {
+        Dvn::set_dst_config(&setup.env, &admin, &params);
+    });
+}
+
+fn configure_fee_lib(setup: &TestSetup, fee_lib: &Address, default_multiplier: u32) {
+    let admin = setup.admins.get(0).unwrap();
+    with_contract(setup, || {
+        Dvn::set_worker_fee_lib(&setup.env, &admin, fee_lib);
+    });
+    with_contract(setup, || {
+        Dvn::set_default_multiplier_bps(&setup.env, &admin, default_multiplier);
+    });
+}
+
+#[test]
+fn test_vid_returns_configured_value() {
+    let setup = TestSetup::new(1);
+    let client = DVNClient::new(&setup.env, &setup.contract_id);
+    assert_eq!(client.vid(), crate::tests::setup::VID);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #5)")] // DvnError::EidNotSupported
+fn test_dst_config_not_set_panics() {
+    let setup = TestSetup::new(1);
+    let client = DVNClient::new(&setup.env, &setup.contract_id);
+    client.dst_config(&999);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #5)")] // DvnError::EidNotSupported
+fn test_get_fee_missing_dst_config_panics() {
+    let setup = TestSetup::new(1);
+    let send_lib = new_addr(&setup.env);
+    let sender = new_addr(&setup.env);
+    let packet_header = Bytes::new(&setup.env);
+    let payload_hash = BytesN::from_array(&setup.env, &[0u8; 32]);
+    let options = Bytes::new(&setup.env);
+
+    with_contract(&setup, || {
+        Dvn::get_fee(&setup.env, &send_lib, &sender, 999, &packet_header, &payload_hash, 1, &options);
+    });
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1209)")] // WorkerError::NotAllowed
+fn test_get_fee_not_allowed_due_to_allowlist() {
+    let setup = TestSetup::new(1);
+    let allowed = new_addr(&setup.env);
+    grant_allowlist(&setup, &allowed);
+
+    let send_lib = new_addr(&setup.env);
+    let sender = new_addr(&setup.env);
+    let packet_header = Bytes::new(&setup.env);
+    let payload_hash = BytesN::from_array(&setup.env, &[0u8; 32]);
+    let options = Bytes::new(&setup.env);
+
+    with_contract(&setup, || {
+        Dvn::get_fee(&setup.env, &send_lib, &sender, 1, &packet_header, &payload_hash, 1, &options);
+    });
+}
+
+#[test]
+fn test_get_fee_uses_default_multiplier_when_dst_multiplier_zero() {
+    let setup = TestSetup::new(1);
+    let fee_lib = setup.env.register(MockFeeLib, ());
+    configure_fee_lib(&setup, &fee_lib, 15_000);
+    configure_dst_config(&setup, 42, DstConfig { gas: 1, multiplier_bps: 0, floor_margin_usd: 0 });
+
+    let fee = with_contract(&setup, || {
+        Dvn::get_fee(
+            &setup.env,
+            &new_addr(&setup.env),
+            &new_addr(&setup.env),
+            42,
+            &Bytes::new(&setup.env),
+            &BytesN::from_array(&setup.env, &[0; 32]),
+            1,
+            &Bytes::new(&setup.env),
+        )
+    });
+
+    assert_eq!(fee, 15_000);
+}
+
+#[test]
+fn test_get_fee_prefers_dst_multiplier_when_nonzero() {
+    let setup = TestSetup::new(1);
+    let fee_lib = setup.env.register(MockFeeLib, ());
+    configure_fee_lib(&setup, &fee_lib, 15_000);
+    configure_dst_config(&setup, 43, DstConfig { gas: 1, multiplier_bps: 9_000, floor_margin_usd: 0 });
+
+    let fee = with_contract(&setup, || {
+        Dvn::get_fee(
+            &setup.env,
+            &new_addr(&setup.env),
+            &new_addr(&setup.env),
+            43,
+            &Bytes::new(&setup.env),
+            &BytesN::from_array(&setup.env, &[0; 32]),
+            1,
+            &Bytes::new(&setup.env),
+        )
+    });
+
+    assert_eq!(fee, 9_000);
+}
+
+#[test]
+fn test_pause_and_setters_happy_paths() {
+    let setup = TestSetup::new(1);
+    let admin = setup.admins.get(0).unwrap();
+    let other = new_addr(&setup.env);
+
+    with_contract(&setup, || {
+        Dvn::set_paused(&setup.env, true);
+    });
+    with_contract(&setup, || {
+        assert!(Dvn::paused(&setup.env));
+    });
+    with_contract(&setup, || {
+        Dvn::set_paused(&setup.env, false);
+    });
+    with_contract(&setup, || {
+        assert!(!Dvn::paused(&setup.env));
+    });
+
+    with_contract(&setup, || {
+        Dvn::set_default_multiplier_bps(&setup.env, &admin, 1234);
+    });
+    with_contract(&setup, || {
+        assert_eq!(Dvn::default_multiplier_bps(&setup.env), 1234);
+    });
+
+    with_contract(&setup, || {
+        Dvn::set_deposit_address(&setup.env, &admin, &other);
+    });
+    with_contract(&setup, || {
+        assert_eq!(Dvn::deposit_address(&setup.env), other);
+    });
+
+    let pf = new_addr(&setup.env);
+    with_contract(&setup, || {
+        Dvn::set_price_feed(&setup.env, &admin, &pf);
+    });
+    with_contract(&setup, || {
+        assert_eq!(Dvn::price_feed(&setup.env), pf);
+    });
+
+    let opts = Bytes::from_array(&setup.env, &[1, 2, 3]);
+    with_contract(&setup, || {
+        Dvn::set_supported_option_types(&setup.env, &admin, 77, opts.clone());
+    });
+    with_contract(&setup, || {
+        assert_eq!(Dvn::get_supported_option_types(&setup.env, 77), Some(opts));
+    });
+
+    let fee_lib = new_addr(&setup.env);
+    with_contract(&setup, || {
+        Dvn::set_worker_fee_lib(&setup.env, &admin, &fee_lib);
+    });
+    with_contract(&setup, || {
+        assert_eq!(Dvn::worker_fee_lib(&setup.env), fee_lib);
+    });
+}
+
+#[test]
+fn test_acl_and_allowlist_size_reads() {
+    let setup = TestSetup::new(1);
+    let addr = setup.admins.get(0).unwrap();
+
+    let has_acl = with_contract(&setup, || Dvn::has_acl(&setup.env, &addr));
+    assert!(has_acl);
+    let allowlist_size = with_contract(&setup, || Dvn::allowlist_size(&setup.env));
+    assert_eq!(allowlist_size, 0);
+}
+
+#[test]
+fn test_set_dst_config_auth_verification() {
+    let setup = TestSetup::new(1);
+    let admin = setup.admins.get(0).unwrap();
+    let dst_eid = 100u32;
+    let client = DVNClient::new(&setup.env, &setup.contract_id);
+    let params = vec![
+        &setup.env,
+        DstConfigParam { dst_eid, config: DstConfig { gas: 1000, multiplier_bps: 10000, floor_margin_usd: 0 } },
+    ];
+
+    client.set_dst_config(&admin, &params);
+
+    let auths = setup.env.auths();
+    assert_eq!(auths.len(), 1);
+    let (auth_addr, auth_invocation) = &auths[0];
+    assert_eq!(auth_addr, &admin);
+    match &auth_invocation.function {
+        AuthorizedFunction::Contract((contract_id, fn_name, args)) => {
+            assert_eq!(contract_id, &setup.contract_id);
+            assert_eq!(fn_name, &Symbol::new(&setup.env, "set_dst_config"));
+            assert_eq!(args, &(admin.clone(), params.clone()).into_val(&setup.env));
+        }
+        _ => panic!("Expected Contract auth"),
+    }
+}
+
+#[test]
+fn test_assign_job_auth_verification() {
+    let setup = TestSetup::new(1);
+    let admin = setup.admins.get(0).unwrap();
+    let fee_lib = setup.env.register(MockFeeLib, ());
+    let dst_eid = 50u32;
+    let deposit_addr = new_addr(&setup.env);
+    let send_lib = new_addr(&setup.env);
+    let sender = new_addr(&setup.env);
+    let packet_header = Bytes::new(&setup.env);
+    let payload_hash = BytesN::from_array(&setup.env, &[0u8; 32]);
+    let options = Bytes::new(&setup.env);
+
+    configure_fee_lib(&setup, &fee_lib, 10_000);
+    configure_dst_config(&setup, dst_eid, DstConfig { gas: 1, multiplier_bps: 10_000, floor_margin_usd: 0 });
+
+    with_contract(&setup, || {
+        Dvn::set_deposit_address(&setup.env, &admin, &deposit_addr);
+    });
+    with_contract(&setup, || {
+        Dvn::set_supported_message_lib(&setup.env, &send_lib, true);
+    });
+
+    let result = setup.env.as_contract(&setup.contract_id, || {
+        Dvn::assign_job(&setup.env, &send_lib, &sender, dst_eid, &packet_header, &payload_hash, 1, &options)
+    });
+
+    assert_eq!(result, FeeRecipient { amount: 10_000, to: deposit_addr.clone() });
+
+    let auths = setup.env.auths();
+    // send_lib auth + admin auths from previous configuration steps
+    assert!(auths.iter().any(|(addr, _)| addr == &send_lib));
+}
+
+#[test]
+fn test_set_admin_add() {
+    let setup = TestSetup::new(1);
+    let existing_admin = setup.admins.get(0).unwrap();
+    let new_admin = new_addr(&setup.env);
+
+    // Verify new_admin is not an admin initially
+    let is_admin = with_contract(&setup, || Dvn::is_admin(&setup.env, &new_admin));
+    assert!(!is_admin);
+
+    // Add new admin by existing admin
+    with_contract(&setup, || {
+        Dvn::set_admin(&setup.env, &existing_admin, &new_admin, true);
+    });
+
+    // Verify new_admin is now an admin
+    let is_admin = with_contract(&setup, || Dvn::is_admin(&setup.env, &new_admin));
+    assert!(is_admin);
+}
+
+#[test]
+fn test_set_admin_remove() {
+    let setup = TestSetup::new(1);
+    let existing_admin = setup.admins.get(0).unwrap();
+    let new_admin = new_addr(&setup.env);
+
+    // Add new admin first
+    with_contract(&setup, || {
+        Dvn::set_admin(&setup.env, &existing_admin, &new_admin, true);
+    });
+
+    // Remove the new admin
+    with_contract(&setup, || {
+        Dvn::set_admin(&setup.env, &existing_admin, &new_admin, false);
+    });
+
+    // Verify new_admin is no longer an admin
+    let is_admin = with_contract(&setup, || Dvn::is_admin(&setup.env, &new_admin));
+    assert!(!is_admin);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::Unauthorized
+fn test_set_admin_unauthorized() {
+    let setup = TestSetup::new(1);
+    let non_admin = new_addr(&setup.env);
+    let new_admin = new_addr(&setup.env);
+
+    // Attempt to add admin by non-admin should fail
+    with_contract(&setup, || {
+        Dvn::set_admin(&setup.env, &non_admin, &new_admin, true);
+    });
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1204)")] // WorkerError::AttemptingToRemoveOnlyAdmin
+fn test_set_admin_cannot_remove_last_admin() {
+    let setup = TestSetup::new(1);
+    let existing_admin = setup.admins.get(0).unwrap();
+
+    // Attempt to remove the only admin should fail
+    with_contract(&setup, || {
+        Dvn::set_admin(&setup.env, &existing_admin, &existing_admin, false);
+    });
+}
+
+#[contract]
+struct MockFeeLib;
+
+#[contractimpl]
+impl IDvnFeeLib for MockFeeLib {
+    fn get_fee(_env: &Env, params: &DvnFeeParams) -> i128 {
+        if params.multiplier_bps == 0 {
+            params.default_multiplier_bps as i128
+        } else {
+            params.multiplier_bps as i128
+        }
+    }
+}

package/contracts/workers/dvn/src/tests/key_pair.rs

@@ -0,0 +1,66 @@
+//! Test utilities for DVN multisig testing
+//!
+//! Provides key pair generation and signing for secp256k1 ECDSA signatures.
+
+extern crate std;
+
+use k256::ecdsa::{SigningKey, VerifyingKey};
+use sha3::{Digest, Keccak256};
+use soroban_sdk::{BytesN, Env};
+
+/// A secp256k1 key pair with private key and derived Ethereum-style address
+#[derive(Clone)]
+pub struct KeyPair {
+    /// The secp256k1 signing key (private key)
+    signing_key: SigningKey,
+    /// The derived Ethereum-style address (last 20 bytes of keccak256(pubkey))
+    pub eth_address: [u8; 20],
+}
+
+impl KeyPair {
+    pub fn generate() -> Self {
+        let signing_key = SigningKey::random(&mut rand::thread_rng());
+        let eth_address = Self::derive_eth_address(&signing_key);
+        Self { signing_key, eth_address }
+    }
+
+    fn derive_eth_address(signing_key: &SigningKey) -> [u8; 20] {
+        let verifying_key: &VerifyingKey = signing_key.verifying_key();
+        let pubkey_bytes = verifying_key.to_encoded_point(false);
+        let pubkey_uncompressed = pubkey_bytes.as_bytes();
+
+        let mut hasher = Keccak256::new();
+        hasher.update(&pubkey_uncompressed[1..65]);
+        let hash = hasher.finalize();
+
+        let mut eth_address = [0u8; 20];
+        eth_address.copy_from_slice(&hash[12..32]);
+        eth_address
+    }
+
+    pub fn signer(&self, env: &Env) -> BytesN<20> {
+        BytesN::from_array(env, &self.eth_address)
+    }
+
+    /// Sign a 32-byte digest and return a 65-byte signature (r || s || v)
+    pub fn sign(&self, digest: &[u8; 32]) -> [u8; 65] {
+        let (signature, recovery_id) = self.signing_key.sign_prehash_recoverable(digest).expect("Signing failed");
+
+        let r = signature.r().to_bytes();
+        let s = signature.s().to_bytes();
+        let v = 27 + recovery_id.to_byte();
+
+        let mut result = [0u8; 65];
+        result[0..32].copy_from_slice(&r);
+        result[32..64].copy_from_slice(&s);
+        result[64] = v;
+
+        result
+    }
+
+    /// Sign a digest and return as BytesN<65> for use in Soroban
+    pub fn sign_bytes(&self, env: &Env, digest: &BytesN<32>) -> BytesN<65> {
+        let signature = self.sign(&digest.to_array());
+        BytesN::from_array(env, &signature)
+    }
+}

package/contracts/workers/dvn/src/tests/mod.rs

@@ -0,0 +1,5 @@
+pub mod auth;
+pub mod dvn;
+pub mod key_pair;
+pub mod multisig;
+pub mod setup;

package/contracts/workers/dvn/src/tests/multisig/mod.rs

@@ -0,0 +1,3 @@
+pub mod set_signer;
+pub mod set_threshold;
+pub mod verify_signatures;

package/contracts/workers/dvn/src/tests/multisig/set_signer.rs

@@ -0,0 +1,133 @@
+use crate::errors::MultisigError;
+use crate::storage::MultisigStorage;
+use crate::tests::setup::TestSetup;
+use soroban_sdk::{
+    testutils::{AuthorizedFunction, BytesN as _},
+    BytesN, Env, IntoVal, Symbol,
+};
+
+fn random_signer(env: &Env) -> BytesN<20> {
+    BytesN::random(env)
+}
+
+fn clear_signers(setup: &TestSetup) {
+    setup.env.as_contract(&setup.contract_id, || {
+        MultisigStorage::remove_signers(&setup.env);
+    });
+}
+
+#[test]
+fn test_set_signer() {
+    let setup = TestSetup::new(1);
+    let new_signer = random_signer(&setup.env);
+
+    setup.multisig_client.set_signer(&new_signer, &true);
+
+    let auths = setup.env.auths();
+    assert_eq!(auths.len(), 1);
+    let (auth_addr, auth_invocation) = &auths[0];
+    assert_eq!(auth_addr, &setup.contract_id);
+    match &auth_invocation.function {
+        AuthorizedFunction::Contract((contract_id, fn_name, args)) => {
+            assert_eq!(contract_id, &setup.contract_id);
+            assert_eq!(fn_name, &Symbol::new(&setup.env, "set_signer"));
+            assert_eq!(args, &(new_signer.clone(), true).into_val(&setup.env));
+        }
+        _ => panic!("Expected Contract auth"),
+    }
+
+    assert!(setup.multisig_client.is_signer(&new_signer));
+    assert_eq!(setup.multisig_client.get_signers().len(), 2);
+}
+
+#[test]
+fn test_set_signer_duplicate_fails() {
+    let setup = TestSetup::new(1);
+    let signer = random_signer(&setup.env);
+
+    setup.multisig_client.set_signer(&signer, &true);
+    let res = setup.multisig_client.try_set_signer(&signer, &true);
+
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerAlreadyExists.into());
+}
+
+#[test]
+fn test_set_signer_remove_success() {
+    let setup = TestSetup::new(1);
+    let signer = random_signer(&setup.env);
+
+    setup.multisig_client.set_signer(&signer, &true);
+    assert!(setup.multisig_client.is_signer(&signer));
+
+    setup.multisig_client.set_signer(&signer, &false);
+    assert!(!setup.multisig_client.is_signer(&signer));
+}
+
+#[test]
+fn test_set_signer_remove_not_found() {
+    let setup = TestSetup::new(1);
+    let signer = random_signer(&setup.env);
+
+    let res = setup.multisig_client.try_set_signer(&signer, &false);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
+}
+
+#[test]
+fn test_set_signer_invalid_signer_zero_address() {
+    let setup = TestSetup::new(1);
+    let zero = BytesN::from_array(&setup.env, &[0u8; 20]);
+
+    let res = setup.multisig_client.try_set_signer(&zero, &true);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::InvalidSigner.into());
+}
+
+#[test]
+fn test_get_signers_empty_map() {
+    let setup = TestSetup::new(1);
+
+    clear_signers(&setup);
+
+    let signers = setup.multisig_client.get_signers();
+    assert_eq!(signers.len(), 0);
+    let non_signer = random_signer(&setup.env);
+    assert!(!setup.multisig_client.is_signer(&non_signer));
+}
+
+#[test]
+fn test_total_signers() {
+    let setup = TestSetup::new(2);
+
+    assert_eq!(setup.multisig_client.total_signers(), 2);
+
+    let new_signer = random_signer(&setup.env);
+    setup.multisig_client.set_signer(&new_signer, &true);
+    assert_eq!(setup.multisig_client.total_signers(), 3);
+
+    setup.multisig_client.set_signer(&new_signer, &false);
+    assert_eq!(setup.multisig_client.total_signers(), 2);
+}
+
+#[test]
+fn test_remove_signer_when_no_signers() {
+    let setup = TestSetup::new(1);
+
+    clear_signers(&setup);
+
+    let signer = random_signer(&setup.env);
+    let res = setup.multisig_client.try_set_signer(&signer, &false);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
+}
+
+#[test]
+fn test_remove_signer_violates_threshold() {
+    // Create DVN with 2 signers and threshold 2
+    let setup = TestSetup::new(2);
+
+    // Get one of the existing signers
+    let signers = setup.multisig_client.get_signers();
+    let signer_to_remove = signers.get(0).unwrap();
+
+    // Removing a signer should fail because it would leave only 1 signer with threshold 2
+    let res = setup.multisig_client.try_set_signer(&signer_to_remove, &false);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
+}

package/contracts/workers/dvn/src/tests/multisig/set_threshold.rs

@@ -0,0 +1,108 @@
+use crate::tests::setup::{TestSetup, DEFAULT_MULTIPLIER_BPS, VID};
+use crate::{dvn::Dvn, errors::MultisigError, storage::MultisigStorage};
+use soroban_sdk::{
+    testutils::{Address as _, AuthorizedFunction, BytesN as _},
+    vec, Address, BytesN, Env, IntoVal, Symbol, Vec,
+};
+
+fn random_signer(env: &Env) -> BytesN<20> {
+    BytesN::random(env)
+}
+
+fn register_dvn(env: &Env, signer_count: usize, threshold: u32) {
+    let signers: Vec<BytesN<20>> = (0..signer_count).map(|_| random_signer(env)).fold(vec![env], |mut acc, s| {
+        acc.push_back(s);
+        acc
+    });
+    let admins: Vec<Address> = vec![env, Address::generate(env)];
+    let supported_msglibs: Vec<Address> = vec![env, Address::generate(env)];
+    let price_feed: Address = Address::generate(env);
+    let worker_fee_lib: Address = Address::generate(env);
+    let deposit_address: Address = Address::generate(env);
+
+    let _ = env.register(
+        Dvn,
+        (
+            &VID,
+            &signers,
+            &threshold,
+            &admins,
+            &supported_msglibs,
+            &price_feed,
+            &worker_fee_lib,
+            &DEFAULT_MULTIPLIER_BPS,
+            &deposit_address,
+        ),
+    );
+}
+
+#[test]
+fn test_set_threshold_success() {
+    let setup = TestSetup::new(2);
+
+    setup.multisig_client.set_threshold(&2);
+
+    let auths = setup.env.auths();
+    assert_eq!(auths.len(), 1);
+    let (auth_addr, auth_invocation) = &auths[0];
+    assert_eq!(auth_addr, &setup.contract_id);
+    match &auth_invocation.function {
+        AuthorizedFunction::Contract((contract_id, fn_name, args)) => {
+            assert_eq!(contract_id, &setup.contract_id);
+            assert_eq!(fn_name, &Symbol::new(&setup.env, "set_threshold"));
+            assert_eq!(args, &(2u32,).into_val(&setup.env));
+        }
+        _ => panic!("Expected Contract auth"),
+    }
+
+    assert_eq!(setup.multisig_client.threshold(), 2);
+
+    setup.multisig_client.set_threshold(&1);
+    assert_eq!(setup.multisig_client.threshold(), 1);
+}
+
+#[test]
+fn test_set_threshold_zero_fails() {
+    let setup = TestSetup::new(1);
+
+    let res = setup.multisig_client.try_set_threshold(&0);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::ZeroThreshold.into());
+}
+
+#[test]
+fn test_set_threshold_above_signers_fails() {
+    let setup = TestSetup::new(2);
+
+    let res = setup.multisig_client.try_set_threshold(&3);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
+}
+
+#[test]
+fn test_set_threshold_with_no_signers_fails() {
+    let setup = TestSetup::new(1);
+
+    setup.env.as_contract(&setup.contract_id, || {
+        MultisigStorage::remove_signers(&setup.env);
+    });
+
+    let res = setup.multisig_client.try_set_threshold(&1);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1)")] // MultisigError::ZeroThreshold
+fn test_constructor_threshold_zero_panics() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    register_dvn(&env, 1, 0);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #2)")] // MultisigError::TotalSignersLessThanThreshold
+fn test_constructor_signers_less_than_threshold_panics() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    register_dvn(&env, 1, 2);
+}