@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

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);
 }
 

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

@@ -1,5 +1,5 @@
-use crate::testing_utils::{assert_event, assert_events, ExpectedEvent, IntoExpectedEvent};
-use soroban_sdk::{contract, contractevent, contractimpl, testutils::Address as _, Address, Env, IntoVal, Val, Vec};
+use crate::testing_utils::{assert_contains_event, assert_contains_events, assert_eq_event, assert_eq_events};
+use soroban_sdk::{contract, contractevent, contractimpl, testutils::Address as _, Address, Env};
 
 // ============================================
 // Test Fixtures
@@ -78,7 +78,7 @@ impl TestingUtilsContract {
 }
 
 // ============================================
-// assert_event
+// assert_eq_event
 // ============================================
 
 // Basic functionality
@@ -91,7 +91,7 @@ fn test_assert_event_found() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+    assert_eq_event(&env, &contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
@@ -102,7 +102,7 @@ fn test_assert_event_with_multiple_fields() {
 
     client.emit_event2(&123, &456);
 
-    assert_event(&env, &contract_id, TestEvent2 { name: 123, count: 456 });
+    assert_eq_event(&env, &contract_id, TestEvent2 { name: 123, count: 456 });
 }
 
 #[test]
@@ -114,7 +114,7 @@ fn test_assert_event_with_address() {
     let addr = Address::generate(&env);
     client.emit_event3(&addr);
 
-    assert_event(&env, &contract_id, TestEvent3 { address: addr });
+    assert_eq_event(&env, &contract_id, TestEvent3 { address: addr });
 }
 
 #[test]
@@ -125,8 +125,8 @@ fn test_assert_event_among_multiple() {
 
     client.emit_multiple_events(&10, &20);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 10 });
-    assert_event(&env, &contract_id, TestEvent1 { value: 20 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 10 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 20 });
 }
 
 // Edge cases
@@ -139,7 +139,7 @@ fn test_assert_event_finds_first_matching_event() {
 
     client.emit_multiple_events(&42, &42);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
@@ -151,23 +151,23 @@ fn test_assert_event_finds_correct_event_among_many() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_mixed_four_events(&1, &100, &200, &2, &3);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 2 });
-    assert_event(&env, &contract_id, TestEvent2 { name: 100, count: 200 });
+    assert_contains_event(&env, &contract_id, TestEvent1 { value: 2 });
+    assert_contains_event(&env, &contract_id, TestEvent2 { name: 100, count: 200 });
 }
 
 // Error cases
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_no_events_emitted() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 42 });
+    assert_eq_event(&env, &contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -175,11 +175,11 @@ fn test_assert_event_not_found() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &contract_id, TestEvent1 { value: 100 });
+    assert_eq_event(&env, &contract_id, TestEvent1 { value: 100 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_wrong_contract() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -188,11 +188,11 @@ fn test_assert_event_wrong_contract() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &other_contract_id, TestEvent1 { value: 42 });
+    assert_eq_event(&env, &other_contract_id, TestEvent1 { value: 42 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_topics_length_mismatch() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -200,11 +200,11 @@ fn test_assert_event_topics_length_mismatch() {
 
     client.emit_event1(&42);
 
-    assert_event(&env, &contract_id, TestEvent2 { name: 42, count: 0 });
+    assert_eq_event(&env, &contract_id, TestEvent2 { name: 42, count: 0 });
 }
 
 #[test]
-#[should_panic(expected = "Expected event not found")]
+#[should_panic(expected = "Expected exactly one event")]
 fn test_assert_event_data_mismatch() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -212,11 +212,11 @@ fn test_assert_event_data_mismatch() {
 
     client.emit_event2(&123, &456);
 
-    assert_event(&env, &contract_id, TestEvent2 { name: 123, count: 789 });
+    assert_eq_event(&env, &contract_id, TestEvent2 { name: 123, count: 789 });
 }
 
 // ============================================
-// assert_events
+// assert_eq_events
 // ============================================
 
 // Basic functionality
@@ -229,7 +229,7 @@ fn test_assert_events_single() {
 
     client.emit_event1(&42);
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 42 }.expected(&env)]);
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }]);
 }
 
 #[test]
@@ -240,11 +240,7 @@ fn test_assert_events_multiple_same_type() {
 
     client.emit_multiple_events(&10, &20);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 10 }.expected(&env), TestEvent1 { value: 20 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 10 }, &TestEvent1 { value: 20 }]);
 }
 
 #[test]
@@ -255,11 +251,7 @@ fn test_assert_events_multiple_different_types() {
 
     client.emit_both_events(&42, &123, &456);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent2 { name: 123, count: 456 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent2 { name: 123, count: 456 }]);
 }
 
 #[test]
@@ -270,11 +262,7 @@ fn test_assert_events_order_independent() {
 
     client.emit_both_events(&42, &123, &456);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent2 { name: 123, count: 456 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent2 { name: 123, count: 456 }]);
 }
 
 #[test]
@@ -282,7 +270,7 @@ fn test_assert_events_empty_list() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
 
-    assert_events(&env, &contract_id, &[]);
+    assert_eq_events(&env, &contract_id, &[]);
 }
 
 #[test]
@@ -293,11 +281,7 @@ fn test_assert_events_with_duplicates() {
 
     client.emit_multiple_events(&42, &42);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 42 }]);
 }
 
 // Edge cases
@@ -311,7 +295,7 @@ fn test_assert_events_partial_match() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_two_plus_event2(&10, &20, &100, &200);
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 10 }.expected(&env)]);
+    assert_contains_events(&env, &contract_id, &[&TestEvent1 { value: 10 }]);
 }
 
 #[test]
@@ -323,14 +307,10 @@ fn test_assert_events_three_events() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_three_events(&1, &2, &3);
 
-    assert_events(
+    assert_eq_events(
         &env,
         &contract_id,
-        &[
-            TestEvent1 { value: 1 }.expected(&env),
-            TestEvent1 { value: 2 }.expected(&env),
-            TestEvent1 { value: 3 }.expected(&env),
-        ],
+        &[&TestEvent1 { value: 1 }, &TestEvent1 { value: 2 }, &TestEvent1 { value: 3 }],
     );
 }
 
@@ -345,14 +325,10 @@ fn test_assert_events_mixed_event_types_three() {
     // Use single contract call that emits all events (events don't accumulate across calls)
     client.emit_mixed_three_types(&42, &100, &200, &addr);
 
-    assert_events(
+    assert_eq_events(
         &env,
         &contract_id,
-        &[
-            TestEvent3 { address: addr.clone() }.expected(&env),
-            TestEvent1 { value: 42 }.expected(&env),
-            TestEvent2 { name: 100, count: 200 }.expected(&env),
-        ],
+        &[&TestEvent1 { value: 42 }, &TestEvent2 { name: 100, count: 200 }, &TestEvent3 { address: addr.clone() }],
     );
 }
 
@@ -368,21 +344,17 @@ fn test_assert_events_from_specific_contract_ignores_others() {
     client1.emit_multiple_events(&10, &30);
 
     // Assert events from contract1 are found when using contract1's address
-    assert_events(
-        &env,
-        &contract_id1,
-        &[TestEvent1 { value: 10 }.expected(&env), TestEvent1 { value: 30 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id1, &[&TestEvent1 { value: 10 }, &TestEvent1 { value: 30 }]);
 
     // Verify that using contract2's address doesn't match contract1's events
     // (this tests the filtering logic - events should not be found for wrong contract)
-    assert_events(&env, &contract_id2, &[]);
+    assert_contains_events(&env, &contract_id2, &[]);
 }
 
 // Error cases
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_first_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -390,11 +362,11 @@ fn test_assert_events_first_not_found() {
 
     client.emit_event1(&42);
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 100 }.expected(&env)]);
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 100 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #1 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_second_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -402,15 +374,11 @@ fn test_assert_events_second_not_found() {
 
     client.emit_event1(&42);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 100 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 100 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #2 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_third_not_found() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -418,19 +386,15 @@ fn test_assert_events_third_not_found() {
 
     client.emit_multiple_events(&10, &20);
 
-    assert_events(
+    assert_eq_events(
         &env,
         &contract_id,
-        &[
-            TestEvent1 { value: 10 }.expected(&env),
-            TestEvent1 { value: 20 }.expected(&env),
-            TestEvent1 { value: 30 }.expected(&env),
-        ],
+        &[&TestEvent1 { value: 10 }, &TestEvent1 { value: 20 }, &TestEvent1 { value: 30 }],
     );
 }
 
 #[test]
-#[should_panic(expected = "Expected event #1 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_duplicate_expected_but_not_emitted() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -438,24 +402,20 @@ fn test_assert_events_duplicate_expected_but_not_emitted() {
 
     client.emit_event1(&42);
 
-    assert_events(
-        &env,
-        &contract_id,
-        &[TestEvent1 { value: 42 }.expected(&env), TestEvent1 { value: 42 }.expected(&env)],
-    );
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }, &TestEvent1 { value: 42 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_no_events_emitted() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
 
-    assert_events(&env, &contract_id, &[TestEvent1 { value: 42 }.expected(&env)]);
+    assert_eq_events(&env, &contract_id, &[&TestEvent1 { value: 42 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_wrong_contract() {
     let env = Env::default();
     let contract_id1 = env.register(TestingUtilsContract, ());
@@ -464,27 +424,11 @@ fn test_assert_events_wrong_contract() {
 
     client1.emit_event1(&42);
 
-    assert_events(&env, &contract_id2, &[TestEvent1 { value: 42 }.expected(&env)]);
-}
-
-#[test]
-#[should_panic(expected = "Expected event #0 not found")]
-fn test_assert_events_topics_length_mismatch() {
-    let env = Env::default();
-    let contract_id = env.register(TestingUtilsContract, ());
-    let client = TestingUtilsContractClient::new(&env, &contract_id);
-
-    client.emit_event1(&42);
-
-    let empty_topics: Vec<Val> = Vec::new(&env);
-    let data: Val = 42u32.into_val(&env);
-    let expected_with_empty_topics = ExpectedEvent { topics: empty_topics, data };
-
-    assert_events(&env, &contract_id, &[expected_with_empty_topics]);
+    assert_eq_events(&env, &contract_id2, &[&TestEvent1 { value: 42 }]);
 }
 
 #[test]
-#[should_panic(expected = "Expected event #0 not found")]
+#[should_panic(expected = "Expected events to match exactly")]
 fn test_assert_events_data_mismatch() {
     let env = Env::default();
     let contract_id = env.register(TestingUtilsContract, ());
@@ -492,66 +436,5 @@ fn test_assert_events_data_mismatch() {
 
     client.emit_event2(&100, &200);
 
-    assert_events(&env, &contract_id, &[TestEvent2 { name: 100, count: 999 }.expected(&env)]);
-}
-
-// ============================================
-// ExpectedEvent & IntoExpectedEvent
-// ============================================
-
-#[test]
-fn test_into_expected_event() {
-    let env = Env::default();
-
-    let event = TestEvent1 { value: 42 };
-    let expected = event.expected(&env);
-
-    assert!(!expected.topics.is_empty());
-}
-
-#[test]
-fn test_into_expected_event_with_multiple_fields() {
-    let env = Env::default();
-
-    let event = TestEvent2 { name: 123, count: 456 };
-    let expected = event.expected(&env);
-
-    assert!(!expected.topics.is_empty());
-}
-
-#[test]
-fn test_into_expected_event_with_address() {
-    let env = Env::default();
-
-    let addr = Address::generate(&env);
-    let event = TestEvent3 { address: addr };
-    let expected = event.expected(&env);
-
-    assert!(!expected.topics.is_empty());
-}
-
-#[test]
-fn test_expected_event_struct() {
-    let env = Env::default();
-
-    let topics: Vec<Val> = Vec::new(&env);
-    let data: Val = 42u32.into_val(&env);
-
-    let expected = ExpectedEvent { topics, data };
-
-    assert_eq!(expected.topics.len(), 0);
-}
-
-#[test]
-fn test_expected_event_with_topics() {
-    let env = Env::default();
-
-    let mut topics: Vec<Val> = Vec::new(&env);
-    topics.push_back(42u32.into_val(&env));
-    topics.push_back(100u64.into_val(&env));
-    let data: Val = 999u32.into_val(&env);
-
-    let expected = ExpectedEvent { topics, data };
-
-    assert_eq!(expected.topics.len(), 2);
+    assert_eq_events(&env, &contract_id, &[&TestEvent2 { name: 100, count: 999 }]);
 }

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

@@ -5,7 +5,7 @@ use crate::{
     errors::{OwnableError, TtlConfigurableError},
     option_ext::OptionExt,
     ownable::{Ownable, OwnableInitializer},
-    testing_utils::assert_event,
+    testing_utils::assert_eq_event,
     ttl_configurable::{
         TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable, LEDGERS_PER_DAY, MAX_TTL,
     },
@@ -314,7 +314,7 @@ fn test_default_ttl_configurable_set_all() {
     let persistent = Some(persistent_cfg);
     owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
 
-    assert_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
 
     let (instance, persistent) = client.configurable_ttl_configs();
     assert_eq!(instance, Some(instance_cfg));
@@ -331,7 +331,7 @@ fn test_default_ttl_configurable_set_partial() {
     let instance = Some(instance_cfg);
     let persistent = None;
     owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
-    assert_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
 
     let (instance, persistent) = client.configurable_ttl_configs();
     assert_eq!(instance, Some(instance_cfg));
@@ -375,7 +375,7 @@ fn test_default_ttl_configurable_freeze() {
 
     assert!(!client.is_ttl_configs_frozen());
     owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
-    assert_event(&env, &contract_id, TtlConfigsFrozen {});
+    assert_eq_event(&env, &contract_id, TtlConfigsFrozen {});
     assert!(client.is_ttl_configs_frozen());
 }
 
@@ -398,7 +398,7 @@ fn test_default_ttl_configurable_freeze_when_already_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
     owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
-    assert_event(&env, &contract_id, TtlConfigsFrozen {});
+    assert_eq_event(&env, &contract_id, TtlConfigsFrozen {});
     owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
 }