@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__auth__snapshot_generated_multisig_code.snap

@@ -1,20 +1,14 @@
 ---
 source: contracts/common-macros/src/tests/auth.rs
-assertion_line: 33
 expression: formatted
 ---
 pub struct MyContract;
 use utils::{auth::Auth as _, multisig::Multisig as _};
-#[doc(hidden)]
-mod __multisig_impl_my_contract {
-    use super::*;
-    use utils::{auth::Auth, multisig::Multisig};
-    #[common_macros::contract_impl]
-    impl Auth for MyContract {
-        fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
-            env.current_contract_address()
-        }
+#[common_macros::contract_impl]
+impl utils::auth::Auth for MyContract {
+    fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+        env.current_contract_address()
     }
-    #[common_macros::contract_impl(contracttrait)]
-    impl Multisig for MyContract {}
 }
+#[common_macros::contract_impl(contracttrait)]
+impl utils::multisig::Multisig for MyContract {}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__auth__snapshot_generated_ownable_code.snap

@@ -1,24 +1,19 @@
 ---
 source: contracts/common-macros/src/tests/auth.rs
-assertion_line: 18
 expression: formatted
 ---
 pub struct MyContract;
-use utils::{auth::Auth as _, ownable::{Ownable as _, OwnableInitializer as _}};
-#[doc(hidden)]
-mod __ownable_impl_my_contract {
-    use super::*;
-    use utils::{
-        auth::Auth, errors::OwnableError, option_ext::OptionExt as _,
-        ownable::{Ownable, OwnableInitializer},
-    };
-    impl OwnableInitializer for MyContract {}
-    #[common_macros::contract_impl]
-    impl Auth for MyContract {
-        fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
-            <Self as Ownable>::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet)
-        }
+use utils::{
+    auth::Auth as _, option_ext::OptionExt as _,
+    ownable::{Ownable as _, OwnableInitializer as _},
+};
+impl utils::ownable::OwnableInitializer for MyContract {}
+#[common_macros::contract_impl]
+impl utils::auth::Auth for MyContract {
+    fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+        <Self as utils::ownable::Ownable>::owner(env)
+            .unwrap_or_panic(env, utils::errors::OwnableError::OwnerNotSet)
     }
-    #[common_macros::contract_impl(contracttrait)]
-    impl Ownable for MyContract {}
 }
+#[common_macros::contract_impl(contracttrait)]
+impl utils::ownable::Ownable for MyContract {}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__contract_ttl__snapshot_generated_contractimpl_code.snap

@@ -52,8 +52,9 @@ impl MyContract {
     pub(crate) fn pub_crate_with_env(env: Env, value: u32) -> u32 {
         value * 7
     }
-    /// Constructor method - should NOT have TTL extension
+    /// Constructor method - should have init_default_ttl_configs
     pub fn __constructor(env: &Env, value: u32) {
+        utils::ttl_configurable::init_default_ttl_configs(env);
         let _ = value * 2;
     }
 }

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__ttl_configurable__snapshot_generated_ttl_configurable_code.snap

@@ -6,10 +6,5 @@ pub struct MyContract {
     some_field: u32,
 }
 use utils::ttl_configurable::TtlConfigurable as _;
-#[doc(hidden)]
-mod __ttl_configurable_impl_my_contract {
-    use super::*;
-    use utils::ttl_configurable::{TtlConfig, TtlConfigurable};
-    #[common_macros::contract_impl(contracttrait)]
-    impl TtlConfigurable for MyContract {}
-}
+#[common_macros::contract_impl(contracttrait)]
+impl utils::ttl_configurable::TtlConfigurable for MyContract {}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__upgradeable__snapshot_generated_upgradeable_code.snap

@@ -1,21 +1,27 @@
 ---
 source: contracts/common-macros/src/tests/upgradeable.rs
-assertion_line: 17
-expression: formatted
+expression: combined
 ---
+// ============================================
+// Default: requires manual UpgradeableInternal
+// ============================================
+
 pub struct MyContract;
 use utils::upgradeable::Upgradeable as _;
 soroban_sdk::contractmeta!(key = "binver", val = "0.0.1");
-type MigrationData = <MyContract as utils::upgradeable::UpgradeableInternal>::MigrationData;
-/// Implement the Upgradeable trait for the contract.
-#[common_macros::contract_impl]
-impl utils::upgradeable::Upgradeable for MyContract {
-    #[common_macros::only_auth]
-    fn upgrade(env: &soroban_sdk::Env, new_wasm_hash: soroban_sdk::BytesN<32>) {
-        utils::upgradeable::upgrade(env, new_wasm_hash)
-    }
-    #[common_macros::only_auth]
-    fn migrate(env: &soroban_sdk::Env, migration_data: &MigrationData) {
-        utils::upgradeable::migrate::<Self>(env, migration_data)
-    }
+#[common_macros::contract_impl(contracttrait)]
+impl utils::upgradeable::Upgradeable for MyContract {}
+
+// ============================================
+// With no_migration: auto-generates impl
+// ============================================
+
+pub struct MyContract;
+use utils::upgradeable::Upgradeable as _;
+soroban_sdk::contractmeta!(key = "binver", val = "0.0.1");
+impl utils::upgradeable::UpgradeableInternal for MyContract {
+    type MigrationData = ();
+    fn __migrate(_env: &soroban_sdk::Env, _migration_data: &Self::MigrationData) {}
 }
+#[common_macros::contract_impl(contracttrait)]
+impl utils::upgradeable::Upgradeable for MyContract {}

package/contracts/common-macros/src/tests/upgradeable.rs

@@ -1,3 +1,4 @@
+use proc_macro2::TokenStream;
 use quote::quote;
 
 use crate::tests::test_helpers::{assert_panics_contains, non_struct_item_inputs};
@@ -11,10 +12,29 @@ fn snapshot_generated_upgradeable_code() {
     let input = quote! {
         pub struct MyContract;
     };
-    let result = crate::upgradeable::generate_upgradeable_impl(input);
-    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
 
-    insta::assert_snapshot!(formatted);
+    // Test default behavior (requires manual UpgradeableInternal impl)
+    let default_result = crate::upgradeable::generate_upgradeable_impl(TokenStream::new(), input.clone());
+    let default_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(default_result).expect("failed to parse generated code"));
+
+    // Test with no_migration (auto-generates UpgradeableInternal impl)
+    let no_migration_result = crate::upgradeable::generate_upgradeable_impl(quote! { no_migration }, input);
+    let no_migration_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(no_migration_result).expect("failed to parse generated code"));
+
+    let combined = format!(
+        "// ============================================\n\
+         // Default: requires manual UpgradeableInternal\n\
+         // ============================================\n\n\
+         {default_formatted}\n\
+         // ============================================\n\
+         // With no_migration: auto-generates impl\n\
+         // ============================================\n\n\
+         {no_migration_formatted}"
+    );
+
+    insta::assert_snapshot!(combined);
 }
 
 // ============================================
@@ -23,9 +43,11 @@ fn snapshot_generated_upgradeable_code() {
 
 #[test]
 fn test_upgradeable_rejects_non_struct_inputs() {
+    let attr = TokenStream::new();
     for (case, input) in non_struct_item_inputs() {
+        let attr_clone = attr.clone();
         assert_panics_contains(case, "failed to parse struct", || {
-            crate::upgradeable::generate_upgradeable_impl(input.clone());
+            crate::upgradeable::generate_upgradeable_impl(attr_clone, input.clone());
         });
     }
 }

package/contracts/common-macros/src/ttl_configurable.rs

@@ -1,6 +1,5 @@
 //! TtlConfigurable macro for Stellar smart contracts.
 
-use crate::utils;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::ItemStruct;
@@ -16,20 +15,13 @@ use syn::ItemStruct;
 pub fn generate_ttl_configurable_impl(input: TokenStream) -> TokenStream {
     let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
     let name = &item_struct.ident;
-    let impl_mod = utils::impl_mod_ident(name, "ttl_configurable");
 
     quote! {
         #item_struct
 
         use utils::ttl_configurable::TtlConfigurable as _;
 
-        #[doc(hidden)]
-        mod #impl_mod {
-            use super::*;
-            use utils::ttl_configurable::{TtlConfig, TtlConfigurable};
-
-            #[common_macros::contract_impl(contracttrait)]
-            impl TtlConfigurable for #name {}
-        }
+        #[common_macros::contract_impl(contracttrait)]
+        impl utils::ttl_configurable::TtlConfigurable for #name {}
     }
 }

package/contracts/common-macros/src/ttl_extendable.rs

@@ -1,6 +1,5 @@
 //! TtlExtendable macro for Stellar smart contracts.
 
-use crate::utils;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::ItemStruct;
@@ -17,20 +16,13 @@ use syn::ItemStruct;
 pub fn generate_ttl_extendable_impl(input: TokenStream) -> TokenStream {
     let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
     let name = &item_struct.ident;
-    let impl_mod = utils::impl_mod_ident(name, "ttl_extendable");
 
     quote! {
         #item_struct
 
         use utils::ttl_extendable::TtlExtendable as _;
 
-        #[doc(hidden)]
-        mod #impl_mod {
-            use super::*;
-            use utils::ttl_extendable::TtlExtendable;
-
-            #[soroban_sdk::contractimpl(contracttrait)]
-            impl TtlExtendable for #name {}
-        }
+        #[soroban_sdk::contractimpl(contracttrait)]
+        impl utils::ttl_extendable::TtlExtendable for #name {}
     }
 }

package/contracts/common-macros/src/upgradeable.rs

@@ -1,6 +1,34 @@
+//! Upgradeable macro for Stellar smart contracts.
+
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::ItemStruct;
+use syn::{
+    parse::{Parse, ParseStream},
+    Ident, ItemStruct,
+};
+
+/// Configuration options for the `#[upgradeable]` macro.
+#[derive(Debug, Default)]
+pub struct UpgradeableConfig {
+    /// If true, generates a default no-op `UpgradeableInternal` implementation.
+    /// Use this for initial deployments when no migration logic is needed yet.
+    pub no_migration: bool,
+}
+
+impl Parse for UpgradeableConfig {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if input.is_empty() {
+            return Ok(Self::default());
+        }
+
+        let ident: Ident = input.parse()?;
+        if ident == "no_migration" {
+            Ok(Self { no_migration: true })
+        } else {
+            Err(syn::Error::new(ident.span(), "expected `no_migration`"))
+        }
+    }
+}
 
 /// Generates the upgradeable implementation from the `#[upgradeable]` attribute macro.
 ///
@@ -10,51 +38,58 @@ use syn::ItemStruct;
 ///
 /// # Behavior
 ///
-/// - Implements the `upgrade` and `migrate` functions with auth-based access control.
+/// - Implements the `Upgradeable` trait using its default methods (which include auth).
 /// - Sets the contract crate version as `"binver"` metadata using
 ///   `soroban_sdk::contractmeta!`. Gets the crate version via the env variable
 ///   `CARGO_PKG_VERSION` which corresponds to the "version" attribute in
 ///   Cargo.toml. If no such attribute or if it is "0.0.0", skips this step.
-/// - Requires the contract to implement `Auth` and `UpgradeableInternal` traits.
+/// - By default, requires the contract to implement `UpgradeableInternal` trait.
+/// - With `no_migration` flag, generates a default no-op `UpgradeableInternal` impl.
 ///
 /// # Example
 /// ```ignore
-/// #[ownable]  // or implement Multisig for self-owning contracts
+/// // Requires manual UpgradeableInternal implementation (default, safety first)
+/// #[ownable]
 /// #[upgradeable]
 /// pub struct MyContract;
+///
+/// // Auto-generates no-op UpgradeableInternal (for initial deployment)
+/// #[ownable]
+/// #[upgradeable(no_migration)]
+/// pub struct MyContract;
 /// ```
-pub fn generate_upgradeable_impl(input: TokenStream) -> TokenStream {
-    let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
+pub fn generate_upgradeable_impl(attr: TokenStream, input: TokenStream) -> TokenStream {
+    let config: UpgradeableConfig =
+        syn::parse2(attr).unwrap_or_else(|e| panic!("failed to parse upgradeable config: {}", e));
+    let item_struct: ItemStruct =
+        syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
     let name = &item_struct.ident;
 
     let binver = set_binver_from_env();
 
-    let upgradeable_impl = quote! {
-        use utils::upgradeable::Upgradeable as _;
-
-        #binver
-
-        // Type alias to avoid path complexity in contractimpl
-        type MigrationData = <#name as utils::upgradeable::UpgradeableInternal>::MigrationData;
-
-        /// Implement the Upgradeable trait for the contract.
-        #[common_macros::contract_impl]
-        impl utils::upgradeable::Upgradeable for #name {
-            #[common_macros::only_auth]
-            fn upgrade(env: &soroban_sdk::Env, new_wasm_hash: soroban_sdk::BytesN<32>) {
-                utils::upgradeable::upgrade(env, new_wasm_hash)
-            }
-
-            #[common_macros::only_auth]
-            fn migrate(env: &soroban_sdk::Env, migration_data: &MigrationData) {
-                utils::upgradeable::migrate::<Self>(env, migration_data)
+    // Generate default UpgradeableInternal impl only when no_migration is set
+    let default_internal_impl = if config.no_migration {
+        quote! {
+            impl utils::upgradeable::UpgradeableInternal for #name {
+                type MigrationData = ();
+                fn __migrate(_env: &soroban_sdk::Env, _migration_data: &Self::MigrationData) {}
             }
         }
+    } else {
+        quote! {}
     };
 
     quote! {
         #item_struct
-        #upgradeable_impl
+
+        use utils::upgradeable::Upgradeable as _;
+
+        #binver
+
+        #default_internal_impl
+
+        #[common_macros::contract_impl(contracttrait)]
+        impl utils::upgradeable::Upgradeable for #name {}
     }
 }
 

package/contracts/common-macros/src/utils.rs

@@ -1,4 +1,3 @@
-use heck::ToSnakeCase;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{punctuated::Punctuated, token::Comma, FnArg, Ident, Pat, Type, TypePath};
@@ -55,11 +54,3 @@ pub fn is_env_type(ty: &Type) -> bool {
 fn is_reference_type(ty: &Type) -> bool {
     matches!(ty, Type::Reference(_))
 }
-
-/// Creates a unique hidden module identifier for trait implementations.
-///
-/// Generates a module name in the format `__{trait_name}_impl_{struct_name}` to avoid
-/// name collisions when multiple traits are implemented for the same struct.
-pub fn impl_mod_ident(struct_name: &Ident, trait_name: &str) -> Ident {
-    Ident::new(&format!("__{}_impl_{}", trait_name, struct_name.to_string().to_snake_case()), struct_name.span())
-}

package/contracts/endpoint-v2/src/lib.rs

@@ -1,11 +1,12 @@
 #![no_std]
 
 pub mod constants;
-mod errors;
 pub mod events;
-mod interfaces;
 pub mod util;
 
+mod errors;
+mod interfaces;
+
 pub use errors::*;
 pub use interfaces::*;
 

package/contracts/endpoint-v2/src/tests/endpoint_v2/clear.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     errors::EndpointError,
@@ -116,7 +116,7 @@ fn test_clear_emits_packet_delivered_event() {
 
     clear_packet_with_auth(&context, &receiver, &origin, &receiver, &guid, &message);
 
-    assert_event(env, &endpoint_client.address, PacketDelivered { origin: origin.clone(), receiver: receiver.clone() });
+    assert_eq_event(env, &endpoint_client.address, PacketDelivered { origin: origin.clone(), receiver: receiver.clone() });
 }
 
 // Lazy inbound nonce updates

package/contracts/endpoint-v2/src/tests/endpoint_v2/lz_receive_alert.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     endpoint_v2::EndpointV2Client, events::LzReceiveAlert, tests::endpoint_setup::setup,
@@ -87,7 +87,7 @@ fn test_lz_receive_alert_auth() {
         &f.reason,
     );
 
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         LzReceiveAlert {
@@ -155,7 +155,7 @@ fn test_lz_receive_alert_with_empty_data() {
         &f.reason,
     );
 
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         LzReceiveAlert {

package/contracts/endpoint-v2/src/tests/endpoint_v2/send.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, vec, Address, Bytes, BytesN, Env};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_contains_event;
 
 use crate::{
     errors::EndpointError,
@@ -53,7 +53,7 @@ fn test_send_with_native_fee_exact_payment() {
 
     // Verify PacketSent event was published
     // MockSendLib::send returns encoded_packet = packet.message.clone()
-    assert_event(
+    assert_contains_event(
         env,
         &endpoint_client.address,
         PacketSent {
@@ -146,7 +146,7 @@ fn test_send_with_zro_fee() {
     assert_eq!(receipt.fee.zro_fee, 25);
 
     // Verify PacketSent event was published
-    assert_event(
+    assert_contains_event(
         env,
         &endpoint_client.address,
         PacketSent {
@@ -436,7 +436,7 @@ fn test_send_with_non_empty_options_emits_event_and_charges_fee() {
     assert_eq!(receipt.fee.zro_fee, 0);
 
     // Verify PacketSent event captures options and encoded packet.
-    assert_event(
+    assert_contains_event(
         env,
         &endpoint_client.address,
         PacketSent { encoded_packet: params.message.clone(), options: options.clone(), send_library: send_lib.clone() },

package/contracts/endpoint-v2/src/tests/endpoint_v2/set_delegate.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, Address};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{events::DelegateSet, tests::endpoint_setup::setup};
 
@@ -21,7 +21,11 @@ fn test_set_delegate() {
     context.set_delegate_with_auth(&oapp, &delegate_option);
 
     // Verify event emission.
-    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: Some(delegate.clone()) });
+    assert_eq_event(
+        env,
+        &endpoint_client.address,
+        DelegateSet { oapp: oapp.clone(), delegate: Some(delegate.clone()) },
+    );
 
     // Verify state update via public interface.
     let actual_delegate = endpoint_client.delegate(&oapp);
@@ -41,13 +45,21 @@ fn test_set_delegate_overwrites_existing_delegate() {
     // Set delegate to A.
     let delegate_a_opt = Some(delegate_a.clone());
     context.set_delegate_with_auth(&oapp, &delegate_a_opt);
-    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: Some(delegate_a.clone()) });
+    assert_eq_event(
+        env,
+        &endpoint_client.address,
+        DelegateSet { oapp: oapp.clone(), delegate: Some(delegate_a.clone()) },
+    );
     assert_eq!(endpoint_client.delegate(&oapp), Some(delegate_a.clone()));
 
     // Overwrite delegate with B.
     let delegate_b_opt = Some(delegate_b.clone());
     context.set_delegate_with_auth(&oapp, &delegate_b_opt);
-    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: Some(delegate_b.clone()) });
+    assert_eq_event(
+        env,
+        &endpoint_client.address,
+        DelegateSet { oapp: oapp.clone(), delegate: Some(delegate_b.clone()) },
+    );
     assert_eq!(endpoint_client.delegate(&oapp), Some(delegate_b.clone()));
 }
 
@@ -91,7 +103,7 @@ fn test_set_delegate_remove() {
     context.set_delegate_with_auth(&oapp, &remove_option);
 
     // Verify event emission.
-    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: None });
+    assert_eq_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: None });
 
     // Verify state update via public interface.
     let stored_delegate_after = endpoint_client.delegate(&oapp);

package/contracts/endpoint-v2/src/tests/endpoint_v2/set_zro.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, Address};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{events::ZroSet, tests::endpoint_setup::setup, tests::endpoint_setup::TestSetup};
 
@@ -23,7 +23,7 @@ fn test_set_zro() {
     set_zro_with_auth(&context, &context.zro_token_client.address);
 
     // Verify event emission.
-    assert_event(env, &endpoint_client.address, ZroSet { zro: context.zro_token_client.address.clone() });
+    assert_eq_event(env, &endpoint_client.address, ZroSet { zro: context.zro_token_client.address.clone() });
 
     // Verify state update via public interface.
     let zro_token = endpoint_client.zro();
@@ -43,12 +43,12 @@ fn test_set_zro_overwrites_existing_zro() {
 
     // Set ZRO to the first address.
     set_zro_with_auth(&context, &context.zro_token_client.address);
-    assert_event(env, &endpoint_client.address, ZroSet { zro: context.zro_token_client.address.clone() });
+    assert_eq_event(env, &endpoint_client.address, ZroSet { zro: context.zro_token_client.address.clone() });
     assert_eq!(endpoint_client.zro(), Some(context.zro_token_client.address.clone()));
 
     // Overwrite ZRO with the second address.
     set_zro_with_auth(&context, &zro_addr_2);
-    assert_event(env, &endpoint_client.address, ZroSet { zro: zro_addr_2.clone() });
+    assert_eq_event(env, &endpoint_client.address, ZroSet { zro: zro_addr_2.clone() });
     assert_eq!(endpoint_client.zro(), Some(zro_addr_2));
 }
 

package/contracts/endpoint-v2/src/tests/endpoint_v2/verify.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{vec, Bytes, BytesN, Env};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     errors::EndpointError,
@@ -51,7 +51,7 @@ fn test_verify_success() {
     endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
 
     // Verify PacketVerified event was published
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         PacketVerified { origin: origin.clone(), receiver: receiver.clone(), payload_hash: payload_hash.clone() },

package/contracts/endpoint-v2/src/tests/message_lib_manager/register_library.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, vec, Address};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     errors::EndpointError,
@@ -27,7 +27,7 @@ fn test_register_library() {
     context.register_library_with_auth(&lib);
 
     // Verify event emission.
-    assert_event(env, &endpoint_client.address, LibraryRegistered { new_lib: lib.clone() });
+    assert_eq_event(env, &endpoint_client.address, LibraryRegistered { new_lib: lib.clone() });
 
     // Verify state update via public interface.
     assert!(endpoint_client.is_registered_library(&lib));

package/contracts/endpoint-v2/src/tests/message_lib_manager/set_default_receive_lib_timeout.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, testutils::Ledger, vec, Address};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     errors::EndpointError,
@@ -171,7 +171,7 @@ fn test_set_default_receive_lib_timeout_success() {
     set_default_receive_lib_timeout_with_auth(&context, context.eid, &timeout);
 
     // Verify event emission.
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         DefaultReceiveLibTimeoutSet { src_eid: context.eid, timeout: timeout.clone() },
@@ -203,7 +203,7 @@ fn test_set_default_receive_lib_timeout_success_with_send_and_receive_type() {
     set_default_receive_lib_timeout_with_auth(&context, context.eid, &timeout);
 
     // Verify event emission.
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         DefaultReceiveLibTimeoutSet { src_eid: context.eid, timeout: timeout.clone() },
@@ -224,7 +224,7 @@ fn test_set_default_receive_lib_timeout_success_with_none() {
     set_default_receive_lib_timeout_with_auth(&context, context.eid, &None);
 
     // Verify event emission.
-    assert_event(env, &endpoint_client.address, DefaultReceiveLibTimeoutSet { src_eid: context.eid, timeout: None });
+    assert_eq_event(env, &endpoint_client.address, DefaultReceiveLibTimeoutSet { src_eid: context.eid, timeout: None });
 
     // Verify state update via public interface.
     assert_eq!(endpoint_client.default_receive_library_timeout(&context.eid), None);
@@ -250,7 +250,7 @@ fn test_set_default_receive_lib_timeout_clears_existing_timeout() {
 
     // First set a timeout.
     set_default_receive_lib_timeout_with_auth(&context, context.eid, &timeout);
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         DefaultReceiveLibTimeoutSet { src_eid: context.eid, timeout: timeout.clone() },
@@ -259,6 +259,6 @@ fn test_set_default_receive_lib_timeout_clears_existing_timeout() {
 
     // Then clear it.
     set_default_receive_lib_timeout_with_auth(&context, context.eid, &None);
-    assert_event(env, &endpoint_client.address, DefaultReceiveLibTimeoutSet { src_eid: context.eid, timeout: None });
+    assert_eq_event(env, &endpoint_client.address, DefaultReceiveLibTimeoutSet { src_eid: context.eid, timeout: None });
     assert_eq!(endpoint_client.default_receive_library_timeout(&context.eid), None);
 }