@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.21

package/contracts/utils/src/testing_utils.rs

@@ -1,26 +1,76 @@
-use soroban_sdk::{testutils::Events, xdr::ToXdr, Address, Env, Event, Val, Vec};
+use soroban_sdk::{testutils::Events, xdr, Address, Env, Event, TryFromVal, Val, Vec};
 
-fn topics_eq(env: &Env, a: &Vec<Val>, b: &Vec<Val>) -> bool {
-    if a.len() != b.len() {
-        return false;
-    }
-    for i in 0..a.len() {
-        let av = a.get(i).unwrap();
-        let bv = b.get(i).unwrap();
-        // Compare XDR serialization for deep value equality
-        if av.to_xdr(env) != bv.to_xdr(env) {
-            return false;
-        }
+/// Decodes a raw emitted contract event (XDR) into `(topics, data)`.
+///
+/// Soroban testutils exposes events as [`ContractEvents`](soroban_sdk::testutils::ContractEvents),
+/// which internally stores XDR [`ContractEvent`](soroban_sdk::xdr::ContractEvent) values.
+/// This helper converts the XDR topics/data into `soroban_sdk::Val` so tests can inspect
+/// topics and data using normal Soroban conversions (`TryFromVal` / `IntoVal`).
+///
+/// Returns `None` if any topic or the data payload can't be converted into `Val` for the
+/// provided `Env`.
+///
+/// # Example
+/// ```ignore
+/// let events = env.events().all().filter_by_contract(&contract);
+/// for ev in events.events().iter() {
+///     let (topics, data) = utils::testing_utils::decode_event_topics_data(&env, ev).unwrap();
+///     // ... inspect topics/data ...
+/// }
+/// ```
+pub fn decode_event_topics_data(env: &Env, event: &xdr::ContractEvent) -> Option<(Vec<Val>, Val)> {
+    // In the current Soroban SDK version this is always `V0`.
+    // Using a single-variant match avoids "irrefutable let-else" warnings.
+    let v0 = match &event.body {
+        xdr::ContractEventBody::V0(v0) => v0,
+    };
+
+    let mut topics = Vec::<Val>::new(env);
+    for t in v0.topics.iter() {
+        topics.push_back(Val::try_from_val(env, t).ok()?);
     }
-    true
+    let data = Val::try_from_val(env, &v0.data).ok()?;
+    Some((topics, data))
 }
 
-fn data_eq(env: &Env, a: &Val, b: &Val) -> bool {
-    // Compare XDR serialization for deep value equality
-    a.to_xdr(env) == b.to_xdr(env)
+/// Asserts that the environment emitted exactly one event: `expected`.
+///
+/// This is a **strict equality** assertion over `env.events().all()`:
+/// the full event list must be exactly `[expected]` (no extra events).
+///
+/// Uses the event struct's `.topics()` and `.data()` methods (generated by `#[contractevent]`)
+/// to compare against emitted events. No more hardcoding topic names or field keys!
+///
+/// # Example
+/// ```ignore
+/// use crate::events::OwnershipTransferred;
+///
+/// let expected = OwnershipTransferred {
+///     previous_owner: owner.clone(),
+///     new_owner: new_owner.clone(),
+/// };
+/// assert_eq_event(&env, &contract, expected);
+/// ```
+pub fn assert_eq_event<E: Event>(env: &Env, contract: &Address, expected: E) {
+    // Compare against the emitted `xdr::ContractEvent` directly. This avoids the
+    // `xdr -> Val` roundtrip and ensures we match exactly what was emitted.
+    //
+    // IMPORTANT: This asserts *equality* (not "contains").
+    extern crate std;
+
+    assert_eq!(
+        env.events().all(),
+        std::vec![expected.to_xdr(env, contract)],
+        "Expected exactly one event. Expected topics: {:?}, data: {:?}",
+        expected.topics(env),
+        expected.data(env),
+    );
 }
 
-/// Asserts that an event matching the expected event was emitted from the contract.
+/// Asserts that the contract emitted an event equal to `expected`.
+///
+/// This is a **contains** assertion: after filtering events by `contract`,
+/// `expected` must appear at least once (order doesn't matter; extra events allowed).
 ///
 /// Uses the event struct's `.topics()` and `.data()` methods (generated by `#[contractevent]`)
 /// to compare against emitted events. No more hardcoding topic names or field keys!
@@ -33,68 +83,86 @@ fn data_eq(env: &Env, a: &Val, b: &Val) -> bool {
 ///     previous_owner: owner.clone(),
 ///     new_owner: new_owner.clone(),
 /// };
-/// assert_event(&env, &contract, expected);
+/// assert_eq_event(&env, &contract, expected);
 /// ```
-pub fn assert_event<E: Event>(env: &Env, contract: &Address, expected: E) {
-    let events = env.events().all();
-    let expected_topics: Vec<Val> = expected.topics(env);
-    let expected_data: Val = expected.data(env);
+pub fn assert_contains_event<E: Event>(env: &Env, contract: &Address, expected: E) {
+    // Compare against the emitted `xdr::ContractEvent` directly. This avoids the
+    // `xdr -> Val` roundtrip and ensures we match exactly what was emitted.
+    let expected_xdr = expected.to_xdr(env, contract);
 
+    let events = env.events().all().filter_by_contract(contract);
     let mut found = false;
-    for (address, topics, data) in events.iter() {
-        if &address == contract && topics_eq(env, &topics, &expected_topics) && data_eq(env, &data, &expected_data) {
+    for event in events.events().iter() {
+        if *event == expected_xdr {
             found = true;
             break;
         }
     }
 
-    assert!(found, "Expected event not found. Expected topics: {:?}, data: {:?}", expected_topics, expected_data);
+    assert!(
+        found,
+        "Expected event not found. Expected topics: {:?}, data: {:?}",
+        expected.topics(env),
+        expected.data(env)
+    );
 }
 
-/// A helper struct to hold event topics and data for batch assertion with mixed event types.
-pub struct ExpectedEvent {
-    pub topics: Vec<Val>,
-    pub data: Val,
-}
+/// Asserts that the environment emitted events that match `expected_events` exactly.
+///
+/// This is a **strict equality** assertion over `env.events().all()`:
+/// the full event list must match `expected_events` **in order** and **count**
+/// (no missing/extra events).
+///
+/// # Example
+/// ```ignore
+/// assert_eq_events(env, &contract, &[
+///     &Event1 { ... },
+///     &Event2 { ... },
+/// ]);
+/// ```
 
-pub trait IntoExpectedEvent: Event + Sized {
-    fn expected(self, env: &Env) -> ExpectedEvent {
-        ExpectedEvent { topics: self.topics(env), data: self.data(env) }
-    }
-}
+pub fn assert_eq_events(env: &Env, contract: &Address, expected_events: &[&dyn Event]) {
+    // Note: this module is only compiled for tests / testutils usage, where `std` is available.
+    extern crate std;
+    let expected_xdrs: std::vec::Vec<xdr::ContractEvent> =
+        expected_events.iter().map(|e| e.to_xdr(env, contract)).collect();
 
-// Blanket implementation for all Event types
-impl<E: Event> IntoExpectedEvent for E {}
+    assert_eq!(env.events().all(), expected_xdrs, "Expected events to match exactly");
+}
 
-/// Asserts that all expected events were emitted from the contract (in any order).
-/// Use this when asserting multiple events of different types.
+/// Asserts that all `expected_events` were emitted by the contract (in any order).
+///
+/// This is a **contains** assertion with multiset semantics: after filtering events by
+/// `contract`, every expected event must be present, and duplicates in `expected_events`
+/// require duplicate emissions. Extra emitted events are allowed.
 ///
 /// # Example
 /// ```ignore
-/// use utils::testing_utils::IntoExpectedEvent;
-///
-/// assert_events(env, &contract, &[
-///     Event1 { ... }.expected(env),
-///     Event2 { ... }.expected(env),
+/// assert_eq_events(env, &contract, &[
+///     &Event1 { ... },
+///     &Event2 { ... },
 /// ]);
 /// ```
-pub fn assert_events(env: &Env, contract: &Address, expected_events: &[ExpectedEvent]) {
-    let events = env.events().all();
-    // Track which emitted events have already been matched so that duplicate expectations
-    // require duplicate emissions (multiset semantics).
-    //
+
+pub fn assert_contains_events(env: &Env, contract: &Address, expected_events: &[&dyn Event]) {
     // Note: this module is only compiled for tests / testutils usage, where `std` is available.
     extern crate std;
-    let mut used: std::vec::Vec<bool> = std::vec![false; events.len() as usize];
+    let events = env.events().all().filter_by_contract(contract);
+    let raw_events = events.events();
+    // Track which emitted events have already been matched so that duplicate expectations
+    // require duplicate emissions (multiset semantics).
+    // We use a `std::vec::Vec<bool>` as a "used" mask to implement multiset matching.
+    let mut used: std::vec::Vec<bool> = std::vec![false; raw_events.len()];
 
     for (i, expected) in expected_events.iter().enumerate() {
+        let expected_xdr = expected.to_xdr(env, contract);
+
         let mut found = false;
-        for (idx, (address, topics, data)) in events.iter().enumerate() {
+        for (idx, event) in raw_events.iter().enumerate() {
             if used[idx] {
                 continue;
             }
-            if &address == contract && topics_eq(env, &topics, &expected.topics) && data_eq(env, &data, &expected.data)
-            {
+            if *event == expected_xdr {
                 used[idx] = true;
                 found = true;
                 break;
@@ -104,7 +172,9 @@ pub fn assert_events(env: &Env, contract: &Address, expected_events: &[ExpectedE
         assert!(
             found,
             "Expected event #{} not found. Expected topics: {:?}, data: {:?}",
-            i, expected.topics, expected.data
+            i,
+            expected.topics(env),
+            expected.data(env)
         );
     }
 }

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

@@ -9,6 +9,8 @@ use soroban_sdk::{
     vec, Address, BytesN, Env, IntoVal, Symbol, TryIntoVal, Val, Vec,
 };
 
+use crate::testing_utils::decode_event_topics_data;
+
 // Test contract implementing Multisig + Auth (self-owning)
 #[contract]
 pub struct TestContract;
@@ -60,14 +62,13 @@ 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();
+    let events = env.events().all().filter_by_contract(contract);
     // Find the signer_set event for this contract (snake_case event name)
-    let found = events.iter().any(|event| {
-        if &event.0 != contract {
+    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]
-        let topics = &event.1;
         if topics.len() != 2 {
             return false;
         }
@@ -77,7 +78,7 @@ fn assert_signer_set_event(env: &Env, contract: &Address, signer: &BytesN<20>, a
             return false;
         }
         // Check data is a map with "active" field
-        let data_map: Map<Symbol, bool> = event.2.try_into_val(env).unwrap();
+        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");
@@ -85,14 +86,13 @@ fn assert_signer_set_event(env: &Env, contract: &Address, signer: &BytesN<20>, a
 
 fn assert_threshold_set_event(env: &Env, contract: &Address, threshold: u32) {
     use soroban_sdk::Map;
-    let events = env.events().all();
+    let events = env.events().all().filter_by_contract(contract);
     // Find the threshold_set event for this contract (snake_case event name)
-    let found = events.iter().any(|event| {
-        if &event.0 != contract {
+    let found = events.events().iter().any(|event| {
+        let Some((topics, data)) = decode_event_topics_data(env, event) else {
             return false;
-        }
+        };
         // Check topics: ["threshold_set"]
-        let topics = &event.1;
         if topics.len() != 1 {
             return false;
         }
@@ -101,7 +101,7 @@ fn assert_threshold_set_event(env: &Env, contract: &Address, threshold: u32) {
             return false;
         }
         // Check data is a map with "threshold" field
-        let data_map: Map<Symbol, u32> = event.2.try_into_val(env).unwrap();
+        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");

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

@@ -6,7 +6,7 @@ use crate::{
         self, Ownable, OwnableInitializer, OwnableStorage, OwnershipRenounced, OwnershipTransferred,
         OwnershipTransferring,
     },
-    testing_utils::assert_event,
+    testing_utils::assert_eq_event,
 };
 use soroban_sdk::{
     contract, contractimpl,
@@ -137,7 +137,7 @@ fn transfer_ownership_with_event() {
     }]);
     client.transfer_ownership(&new_owner);
 
-    assert_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
+    assert_eq_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
     assert_eq!(client.owner(), Some(new_owner));
 }
 
@@ -163,7 +163,7 @@ fn transfer_ownership_to_same_owner() {
     client.transfer_ownership(&owner);
 
     // Should still emit event and update (even if same owner)
-    assert_event(&env, &contract, OwnershipTransferred { old_owner: owner.clone(), new_owner: owner.clone() });
+    assert_eq_event(&env, &contract, OwnershipTransferred { old_owner: owner.clone(), new_owner: owner.clone() });
     assert_eq!(client.owner(), Some(owner));
 }
 
@@ -270,7 +270,7 @@ fn propose_ownership_transfer_initiate_and_accept() {
     }]);
     client.propose_ownership_transfer(&new_owner, &ttl);
 
-    assert_event(
+    assert_eq_event(
         &env,
         &contract,
         OwnershipTransferring { old_owner: owner.clone(), new_owner: new_owner.clone(), ttl },
@@ -290,7 +290,7 @@ fn propose_ownership_transfer_initiate_and_accept() {
     }]);
     client.accept_ownership();
 
-    assert_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
+    assert_eq_event(&env, &contract, OwnershipTransferred { old_owner: owner, new_owner: new_owner.clone() });
     assert_eq!(client.owner(), Some(new_owner)); // Now new owner
     assert_eq!(client.pending_owner(), None);
 }
@@ -564,7 +564,7 @@ fn renounce_ownership_with_event() {
     }]);
     client.renounce_ownership();
 
-    assert_event(&env, &contract, OwnershipRenounced { old_owner: owner });
+    assert_eq_event(&env, &contract, OwnershipRenounced { old_owner: owner });
     assert_eq!(client.owner(), None);
 }