@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/utils/src/tests/multisig.rs

@@ -1,17 +1,14 @@
 use crate::{
     auth::Auth,
-    errors::MultisigError,
-    multisig::{init_multisig, recover_signer, Multisig},
+    errors::MultiSigError,
+    multisig::{init_multisig, recover_signer, MultiSig, SignerSet, ThresholdSet},
+    testing_utils::{assert_eq_event, assert_eq_events},
 };
 use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{AuthorizedFunction, Events},
-    vec, Address, BytesN, Env, IntoVal, Symbol, TryIntoVal, Val, Vec,
+    contract, contractimpl, testutils::AuthorizedFunction, vec, Address, BytesN, Env, IntoVal, Symbol, Val, Vec,
 };
 
-use crate::testing_utils::decode_event_topics_data;
-
-// Test contract implementing Multisig + Auth (self-owning)
+// Test contract implementing MultiSig + Auth (self-owning)
 #[contract]
 pub struct TestContract;
 
@@ -32,7 +29,7 @@ impl Auth for TestContract {
 }
 
 #[contractimpl(contracttrait)]
-impl Multisig for TestContract {}
+impl MultiSig for TestContract {}
 
 fn signer(env: &Env, seed: u8) -> BytesN<20> {
     let mut bytes = [0u8; 20];
@@ -60,53 +57,6 @@ fn assert_auth(env: &Env, contract: &Address, func: &str, expected_args: Vec<Val
     }
 }
 
-fn assert_signer_set_event(env: &Env, contract: &Address, signer: &BytesN<20>, active: bool) {
-    use soroban_sdk::Map;
-    let events = env.events().all().filter_by_contract(contract);
-    // Find the signer_set event for this contract (snake_case event name)
-    let found = events.events().iter().any(|event| {
-        let Some((topics, data)) = decode_event_topics_data(env, event) else {
-            return false;
-        };
-        // Check topics: ["signer_set", signer]
-        if topics.len() != 2 {
-            return false;
-        }
-        let topic_symbol: Symbol = topics.get(0).unwrap().try_into_val(env).unwrap();
-        let topic_signer: BytesN<20> = topics.get(1).unwrap().try_into_val(env).unwrap();
-        if topic_symbol != Symbol::new(env, "signer_set") || &topic_signer != signer {
-            return false;
-        }
-        // Check data is a map with "active" field
-        let data_map: Map<Symbol, bool> = data.try_into_val(env).unwrap();
-        data_map.get(Symbol::new(env, "active")) == Some(active)
-    });
-    assert!(found, "signer_set event not found");
-}
-
-fn assert_threshold_set_event(env: &Env, contract: &Address, threshold: u32) {
-    use soroban_sdk::Map;
-    let events = env.events().all().filter_by_contract(contract);
-    // Find the threshold_set event for this contract (snake_case event name)
-    let found = events.events().iter().any(|event| {
-        let Some((topics, data)) = decode_event_topics_data(env, event) else {
-            return false;
-        };
-        // Check topics: ["threshold_set"]
-        if topics.len() != 1 {
-            return false;
-        }
-        let topic_symbol: Symbol = topics.get(0).unwrap().try_into_val(env).unwrap();
-        if topic_symbol != Symbol::new(env, "threshold_set") {
-            return false;
-        }
-        // Check data is a map with "threshold" field
-        let data_map: Map<Symbol, u32> = data.try_into_val(env).unwrap();
-        data_map.get(Symbol::new(env, "threshold")) == Some(threshold)
-    });
-    assert!(found, "threshold_set event not found");
-}
-
 // ============================================
 // init: Initialization tests
 // ============================================
@@ -114,7 +64,6 @@ fn assert_threshold_set_event(env: &Env, contract: &Address, threshold: u32) {
 #[test]
 fn init_sets_signers_and_threshold() {
     let env = Env::default();
-    env.mock_all_auths();
 
     let s1 = signer(&env, 1);
     let s2 = signer(&env, 2);
@@ -130,7 +79,7 @@ fn init_sets_signers_and_threshold() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1067)")] // ZeroThreshold
+#[should_panic(expected = "Error(Contract, #1068)")] // ZeroThreshold
 fn init_zero_threshold_fails() {
     let env = Env::default();
     let s1 = signer(&env, 1);
@@ -140,7 +89,7 @@ fn init_zero_threshold_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1065)")] // TotalSignersLessThanThreshold
+#[should_panic(expected = "Error(Contract, #1066)")] // TotalSignersLessThanThreshold
 fn init_threshold_exceeds_signers_fails() {
     let env = Env::default();
     let s1 = signer(&env, 1);
@@ -164,6 +113,46 @@ fn init_already_initialized_fails() {
     });
 }
 
+#[test]
+fn init_emits_signer_and_threshold_events() {
+    let env = Env::default();
+
+    let s1 = signer(&env, 1);
+    let s2 = signer(&env, 2);
+    let signers = vec![&env, s1.clone(), s2.clone()];
+
+    let contract = env.register(TestContract, (&signers, 2u32));
+
+    assert_eq_events(
+        &env,
+        &contract,
+        &[
+            &SignerSet { signer: s1, active: true },
+            &SignerSet { signer: s2, active: true },
+            &ThresholdSet { threshold: 2 },
+        ],
+    );
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1062)")] // InvalidSigner
+fn init_zero_signer_fails() {
+    let env = Env::default();
+    let signers = vec![&env, zero_signer(&env)];
+
+    env.register(TestContract, (&signers, 1u32));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1064)")] // SignerAlreadyExists
+fn init_duplicate_signers_fails() {
+    let env = Env::default();
+    let s1 = signer(&env, 1);
+    let signers = vec![&env, s1.clone(), s1];
+
+    env.register(TestContract, (&signers, 1u32));
+}
+
 // ============================================
 // set_signer: Add/remove signer tests
 // ============================================
@@ -186,13 +175,29 @@ fn set_signer_add() {
     assert_auth(&env, &contract, "set_signer", (s2.clone(), true).into_val(&env));
 
     // Verify SignerSet event was emitted
-    assert_signer_set_event(&env, &contract, &s2, true);
+    assert_eq_event(&env, &contract, SignerSet { signer: s2.clone(), active: true });
 
     assert_eq!(client.total_signers(), 2);
     assert!(client.is_signer(&s1));
     assert!(client.is_signer(&s2));
 }
 
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn set_signer_requires_auth() {
+    let env = Env::default();
+
+    let s1 = signer(&env, 1);
+    let s2 = signer(&env, 2);
+    let signers = vec![&env, s1];
+
+    let contract = env.register(TestContract, (&signers, 1u32));
+    let client = TestContractClient::new(&env, &contract);
+
+    // No `mock_*auth*` provided -> contract.require_auth() must fail.
+    client.set_signer(&s2, &true);
+}
+
 #[test]
 fn set_signer_remove() {
     let env = Env::default();
@@ -211,7 +216,7 @@ fn set_signer_remove() {
     assert_auth(&env, &contract, "set_signer", (s1.clone(), false).into_val(&env));
 
     // Verify SignerSet event was emitted
-    assert_signer_set_event(&env, &contract, &s1, false);
+    assert_eq_event(&env, &contract, SignerSet { signer: s1.clone(), active: false });
 
     assert_eq!(client.total_signers(), 1);
     assert!(!client.is_signer(&s1));
@@ -230,7 +235,7 @@ fn set_signer_zero_address_fails() {
     let client = TestContractClient::new(&env, &contract);
 
     let res = client.try_set_signer(&zero_signer(&env), &true);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::InvalidSigner.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::InvalidSigner.into());
 }
 
 #[test]
@@ -245,7 +250,7 @@ fn set_signer_duplicate_fails() {
     let client = TestContractClient::new(&env, &contract);
 
     let res = client.try_set_signer(&s1, &true);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerAlreadyExists.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::SignerAlreadyExists.into());
 }
 
 #[test]
@@ -261,7 +266,7 @@ fn set_signer_remove_not_found_fails() {
     let client = TestContractClient::new(&env, &contract);
 
     let res = client.try_set_signer(&s2, &false);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::SignerNotFound.into());
 }
 
 #[test]
@@ -277,7 +282,7 @@ fn set_signer_remove_violates_threshold_fails() {
     let client = TestContractClient::new(&env, &contract);
 
     let res = client.try_set_signer(&s1, &false);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::TotalSignersLessThanThreshold.into());
 }
 
 // ============================================
@@ -302,11 +307,27 @@ fn set_threshold_success() {
     assert_auth(&env, &contract, "set_threshold", (2u32,).into_val(&env));
 
     // Verify ThresholdSet event was emitted
-    assert_threshold_set_event(&env, &contract, 2);
+    assert_eq_event(&env, &contract, ThresholdSet { threshold: 2 });
 
     assert_eq!(client.threshold(), 2);
 }
 
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn set_threshold_requires_auth() {
+    let env = Env::default();
+
+    let s1 = signer(&env, 1);
+    let s2 = signer(&env, 2);
+    let signers = vec![&env, s1, s2];
+
+    let contract = env.register(TestContract, (&signers, 1u32));
+    let client = TestContractClient::new(&env, &contract);
+
+    // No `mock_*auth*` provided -> contract.require_auth() must fail.
+    client.set_threshold(&2);
+}
+
 #[test]
 fn set_threshold_zero_fails() {
     let env = Env::default();
@@ -319,7 +340,7 @@ fn set_threshold_zero_fails() {
     let client = TestContractClient::new(&env, &contract);
 
     let res = client.try_set_threshold(&0);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::ZeroThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::ZeroThreshold.into());
 }
 
 #[test]
@@ -334,7 +355,7 @@ fn set_threshold_exceeds_signers_fails() {
     let client = TestContractClient::new(&env, &contract);
 
     let res = client.try_set_threshold(&2);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::TotalSignersLessThanThreshold.into());
 }
 
 // ============================================
@@ -344,7 +365,6 @@ fn set_threshold_exceeds_signers_fails() {
 #[test]
 fn get_signers_returns_all() {
     let env = Env::default();
-    env.mock_all_auths();
 
     let s1 = signer(&env, 1);
     let s2 = signer(&env, 2);
@@ -429,7 +449,6 @@ fn test_sig2(env: &Env) -> BytesN<65> {
 #[test]
 fn verify_signatures_success() {
     let env = Env::default();
-    env.mock_all_auths();
 
     let s1 = test_signer1(&env);
     let s2 = test_signer2(&env);
@@ -449,7 +468,6 @@ fn verify_signatures_success() {
 #[test]
 fn verify_n_signatures_success() {
     let env = Env::default();
-    env.mock_all_auths();
 
     let s1 = test_signer1(&env);
     let s2 = test_signer2(&env);
@@ -468,7 +486,6 @@ fn verify_n_signatures_success() {
 #[test]
 fn verify_n_signatures_zero_threshold_fails() {
     let env = Env::default();
-    env.mock_all_auths();
 
     let s1 = test_signer1(&env);
     let signers = vec![&env, s1];
@@ -480,13 +497,12 @@ fn verify_n_signatures_zero_threshold_fails() {
     let signatures: Vec<BytesN<65>> = vec![&env];
 
     let res = client.try_verify_n_signatures(&digest, &signatures, &0);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::ZeroThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::ZeroThreshold.into());
 }
 
 #[test]
 fn verify_n_signatures_insufficient_signatures_fails() {
     let env = Env::default();
-    env.mock_all_auths();
 
     let s1 = test_signer1(&env);
     let signers = vec![&env, s1];
@@ -498,13 +514,12 @@ fn verify_n_signatures_insufficient_signatures_fails() {
     let signatures: Vec<BytesN<65>> = vec![&env]; // Empty
 
     let res = client.try_verify_n_signatures(&digest, &signatures, &1);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignatureError.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::SignatureError.into());
 }
 
 #[test]
 fn verify_n_signatures_signer_not_found_fails() {
     let env = Env::default();
-    env.mock_all_auths();
 
     // Register with only signer2, but provide sig1 (from signer1)
     let s2 = test_signer2(&env);
@@ -517,13 +532,12 @@ fn verify_n_signatures_signer_not_found_fails() {
     let signatures = vec![&env, test_sig1(&env)]; // sig1 is from signer1, not registered
 
     let res = client.try_verify_n_signatures(&digest, &signatures, &1);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::SignerNotFound.into());
 }
 
 #[test]
 fn verify_n_signatures_unsorted_signers_fails() {
     let env = Env::default();
-    env.mock_all_auths();
 
     let s1 = test_signer1(&env);
     let s2 = test_signer2(&env);
@@ -537,7 +551,84 @@ fn verify_n_signatures_unsorted_signers_fails() {
     let signatures = vec![&env, test_sig2(&env), test_sig1(&env)];
 
     let res = client.try_verify_n_signatures(&digest, &signatures, &2);
-    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::UnsortedSigners.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::UnsortedSigners.into());
+}
+
+#[test]
+fn verify_n_signatures_duplicate_signers_fails() {
+    let env = Env::default();
+
+    let s1 = test_signer1(&env);
+    let s2 = test_signer2(&env);
+    let signers = vec![&env, s1, s2];
+
+    let contract = env.register(TestContract, (&signers, 2u32));
+    let client = TestContractClient::new(&env, &contract);
+
+    let digest = test_digest(&env);
+    // Duplicate signer (sig1 twice) must fail the strict ordering check (not strictly increasing).
+    let signatures = vec![&env, test_sig1(&env), test_sig1(&env)];
+
+    let res = client.try_verify_n_signatures(&digest, &signatures, &2);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::UnsortedSigners.into());
+}
+
+#[test]
+fn verify_n_signatures_threshold_one_still_requires_sorted_if_multiple_provided() {
+    let env = Env::default();
+
+    let s1 = test_signer1(&env);
+    let s2 = test_signer2(&env);
+    let signers = vec![&env, s1, s2];
+
+    let contract = env.register(TestContract, (&signers, 2u32));
+    let client = TestContractClient::new(&env, &contract);
+
+    let digest = test_digest(&env);
+    // Even though threshold=1, passing multiple signatures still requires them to be strictly sorted.
+    let signatures = vec![&env, test_sig2(&env), test_sig1(&env)];
+
+    let res = client.try_verify_n_signatures(&digest, &signatures, &1);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::UnsortedSigners.into());
+}
+
+#[test]
+fn verify_n_signatures_threshold_met_but_extra_invalid_signature_fails() {
+    let env = Env::default();
+
+    // Register only signer1 with threshold=1 (so sig1 alone would be sufficient).
+    let s1 = test_signer1(&env);
+    let signers = vec![&env, s1];
+
+    let contract = env.register(TestContract, (&signers, 1u32));
+    let client = TestContractClient::new(&env, &contract);
+
+    let digest = test_digest(&env);
+    // Provide an extra signature from signer2 (not registered). Even though threshold is met,
+    // verification checks *all provided signatures* and must fail.
+    let signatures = vec![&env, test_sig1(&env), test_sig2(&env)];
+
+    let res = client.try_verify_n_signatures(&digest, &signatures, &1);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::SignerNotFound.into());
+}
+
+#[test]
+fn verify_signatures_enforces_configured_threshold() {
+    let env = Env::default();
+
+    let s1 = test_signer1(&env);
+    let s2 = test_signer2(&env);
+    let signers = vec![&env, s1, s2];
+
+    // Configured threshold = 2
+    let contract = env.register(TestContract, (&signers, 2u32));
+    let client = TestContractClient::new(&env, &contract);
+
+    let digest = test_digest(&env);
+    // Only one signature -> must fail because `verify_signatures` uses configured threshold.
+    let signatures = vec![&env, test_sig1(&env)];
+    let res = client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultiSigError::SignatureError.into());
 }
 
 // ============================================
@@ -667,65 +758,3 @@ fn recover_signer_invalid_v_fails() {
     // Should panic - recovery_id must be 0 or 1
     recover_signer(&env, &digest, &signature);
 }
-
-#[test]
-#[should_panic(expected = "Error(Crypto, InvalidInput)")]
-fn verify_signatures_invalid_r_zero_fails() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let s1 = signer(&env, 1);
-    let signers = vec![&env, s1];
-
-    let contract = env.register(TestContract, (&signers, 1u32));
-    let client = TestContractClient::new(&env, &contract);
-
-    let digest = BytesN::from_array(&env, &[0u8; 32]);
-
-    // Create signature with r=0 (invalid)
-    // Soroban's secp256k1_recover validates signatures and rejects r=0 at the crypto level
-    let mut invalid_sig_bytes = [0u8; 65];
-    // r = 0 (bytes 0-31 are already 0)
-    // s = some value (bytes 32-63)
-    for i in 32..64 {
-        invalid_sig_bytes[i] = 1;
-    }
-    // v = 27 (byte 64)
-    invalid_sig_bytes[64] = 27;
-    let invalid_sig = BytesN::from_array(&env, &invalid_sig_bytes);
-    let signatures = vec![&env, invalid_sig];
-
-    // Soroban's crypto API rejects invalid signatures with HostError
-    client.verify_signatures(&digest, &signatures);
-}
-
-#[test]
-#[should_panic(expected = "Error(Crypto, InvalidInput)")]
-fn verify_signatures_invalid_s_zero_fails() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let s1 = signer(&env, 1);
-    let signers = vec![&env, s1];
-
-    let contract = env.register(TestContract, (&signers, 1u32));
-    let client = TestContractClient::new(&env, &contract);
-
-    let digest = BytesN::from_array(&env, &[0u8; 32]);
-
-    // Create signature with s=0 (invalid)
-    // Soroban's secp256k1_recover validates signatures and rejects s=0 at the crypto level
-    let mut invalid_sig_bytes = [0u8; 65];
-    // r = some value (bytes 0-31)
-    for i in 0..32 {
-        invalid_sig_bytes[i] = 1;
-    }
-    // s = 0 (bytes 32-63 are already 0)
-    // v = 27 (byte 64)
-    invalid_sig_bytes[64] = 27;
-    let invalid_sig = BytesN::from_array(&env, &invalid_sig_bytes);
-    let signatures = vec![&env, invalid_sig];
-
-    // Soroban's crypto API rejects invalid signatures with HostError
-    client.verify_signatures(&digest, &signatures);
-}

package/contracts/utils/src/tests/option_ext.rs

@@ -10,7 +10,7 @@ fn unwrap_or_panic_some_returns_value() {
 
 #[test]
 fn unwrap_or_panic_none_panics_with_error() {
-    const EXPECTED: &str = "Error(Contract, #1034)"; // OwnerNotSet
+    const EXPECTED: &str = "Error(Contract, #1035)"; // OwnerNotSet
     assert_panics_contains("none unwrap_or_panic", EXPECTED, || {
         let env = Env::default();
         let _got: u32 = None::<u32>.unwrap_or_panic(&env, OwnableError::OwnerNotSet);