@layerzerolabs/protocol-stellar-v2 0.2.10 → 0.2.12

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

@@ -0,0 +1,267 @@
+use quote::quote;
+use syn::{parse_quote, punctuated::Punctuated, token::Comma, FnArg};
+
+use crate::tests::test_helpers::assert_panics_contains;
+
+// ============================================
+// find_env_param Tests
+// ============================================
+
+fn parse_fn_args(input: proc_macro2::TokenStream) -> Punctuated<FnArg, Comma> {
+    let item_fn: syn::ItemFn = syn::parse2(input).expect("failed to parse function");
+    item_fn.sig.inputs
+}
+
+#[test]
+fn test_find_env_param_owned_env_is_not_reference() {
+    let args = parse_fn_args(quote! { fn f(env: Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(!param.is_reference, "Env should not be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_ref_env_is_reference() {
+    let args = parse_fn_args(quote! { fn f(env: &Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(param.is_reference, "&Env should be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_mut_ref_env_is_reference() {
+    let args = parse_fn_args(quote! { fn f(env: &mut Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(param.is_reference, "&mut Env should be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_qualified_owned_env() {
+    let args = parse_fn_args(quote! { fn f(my_env: soroban_sdk::Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "my_env");
+    assert!(!param.is_reference, "soroban_sdk::Env should not be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_qualified_ref_env() {
+    let args = parse_fn_args(quote! { fn f(my_env: &soroban_sdk::Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "my_env");
+    assert!(param.is_reference, "&soroban_sdk::Env should be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_returns_none_for_no_env() {
+    let args = parse_fn_args(quote! { fn f(x: u32) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_none());
+}
+
+#[test]
+fn test_find_env_param_finds_deeply_nested_env() {
+    let args = parse_fn_args(quote! { fn f(e: some::deep::module::Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "e");
+    assert!(!param.is_reference, "some::deep::module::Env should not be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_finds_env_not_first_param() {
+    let args = parse_fn_args(quote! { fn f(x: u32, y: String, env: &Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(param.is_reference, "&Env should be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_returns_first_env_when_multiple() {
+    let args = parse_fn_args(quote! { fn f(first_env: Env, second_env: Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "first_env");
+    assert!(!param.is_reference, "first_env should not be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_returns_none_for_empty_args() {
+    let args = parse_fn_args(quote! { fn f() {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_none());
+}
+
+#[test]
+fn test_find_env_param_returns_none_for_wildcard_pattern() {
+    // Wildcard pattern _ is not a valid identifier pattern
+    let args = parse_fn_args(quote! { fn f(_: Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_none());
+}
+
+#[test]
+fn test_find_env_param_returns_none_for_tuple_pattern() {
+    // Tuple destructuring is not a simple identifier pattern
+    let args = parse_fn_args(quote! { fn f((env, _): (Env, u32)) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_none());
+}
+
+#[test]
+fn test_find_env_param_ignores_self_receiver() {
+    // Method with self receiver - find_env_param should skip receiver and find env
+    let args: Punctuated<FnArg, Comma> = parse_quote!(&self, env: &Env);
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(param.is_reference, "&Env should be marked as reference");
+}
+
+#[test]
+fn test_find_env_param_returns_none_for_self_only() {
+    // Method with only self receiver
+    let args: Punctuated<FnArg, Comma> = parse_quote!(&self);
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_none());
+}
+
+#[test]
+fn test_find_env_param_with_double_reference() {
+    let args = parse_fn_args(quote! { fn f(env: &&Env) {} });
+    let param = crate::utils::find_env_param(&args);
+    assert!(param.is_some());
+    let param = param.unwrap();
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(param.is_reference, "&&Env should be marked as reference");
+}
+
+// ============================================
+// expect_env_param Tests
+// ============================================
+
+#[test]
+fn test_expect_env_param_returns_param_for_owned_env() {
+    let args = parse_fn_args(quote! { fn f(env: Env) {} });
+    let param = crate::utils::expect_env_param(&args);
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(!param.is_reference);
+}
+
+#[test]
+fn test_expect_env_param_returns_param_for_ref_env() {
+    let args = parse_fn_args(quote! { fn f(env: &Env) {} });
+    let param = crate::utils::expect_env_param(&args);
+    assert_eq!(param.ident.to_string(), "env");
+    assert!(param.is_reference);
+}
+
+#[test]
+fn test_expect_env_param_panics_when_no_env() {
+    assert_panics_contains("no Env param", "function must have an Env argument", || {
+        let args = parse_fn_args(quote! { fn f(x: u32) {} });
+        crate::utils::expect_env_param(&args);
+    });
+}
+
+// ============================================
+// EnvParam::as_ref_tokens Tests
+// ============================================
+
+#[test]
+fn test_as_ref_tokens_for_owned_env_adds_ampersand() {
+    let args = parse_fn_args(quote! { fn f(env: Env) {} });
+    let param = crate::utils::find_env_param(&args).unwrap();
+    let tokens = param.as_ref_tokens();
+    // For owned Env, as_ref_tokens should produce `&env`
+    assert_eq!(tokens.to_string(), "& env");
+}
+
+#[test]
+fn test_as_ref_tokens_for_ref_env_no_ampersand() {
+    let args = parse_fn_args(quote! { fn f(env: &Env) {} });
+    let param = crate::utils::find_env_param(&args).unwrap();
+    let tokens = param.as_ref_tokens();
+    // For reference Env, as_ref_tokens should produce `env` (no extra &)
+    assert_eq!(tokens.to_string(), "env");
+}
+
+#[test]
+fn test_as_ref_tokens_for_custom_named_owned_env() {
+    let args = parse_fn_args(quote! { fn f(my_environment: Env) {} });
+    let param = crate::utils::find_env_param(&args).unwrap();
+    let tokens = param.as_ref_tokens();
+    assert_eq!(tokens.to_string(), "& my_environment");
+}
+
+#[test]
+fn test_as_ref_tokens_for_custom_named_ref_env() {
+    let args = parse_fn_args(quote! { fn f(my_environment: &Env) {} });
+    let param = crate::utils::find_env_param(&args).unwrap();
+    let tokens = param.as_ref_tokens();
+    assert_eq!(tokens.to_string(), "my_environment");
+}
+
+// ============================================
+// is_env_type Tests (comprehensive coverage)
+// ============================================
+
+#[test]
+fn test_is_env_type_recognizes_env_types() {
+    let env_types = [
+        "Env",
+        "&Env",
+        "&&Env",
+        "&mut Env",
+        "soroban_sdk::Env",
+        "&soroban_sdk::Env",
+        "some::deeply::nested::module::Env",
+    ];
+
+    for ty_str in env_types {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(crate::utils::is_env_type(&ty), "{ty_str} should be recognized as an Env type");
+    }
+}
+
+#[test]
+fn test_is_env_type_rejects_non_env_types() {
+    let non_env_types = ["u32", "bool", "String", "Address", "&u32", "soroban_sdk::Address", "Environment"];
+
+    for ty_str in non_env_types {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(!crate::utils::is_env_type(&ty), "{ty_str} should NOT be recognized as an Env type");
+    }
+}
+
+#[test]
+fn test_is_env_type_rejects_other_type_variants() {
+    let other_variants = [
+        ("(Env, u32)", "tuple"),
+        ("[Env; 1]", "array"),
+        ("[Env]", "slice"),
+        ("Option<Env>", "generic"),
+        ("!", "never"),
+        ("fn() -> Env", "fn pointer"),
+    ];
+
+    for (ty_str, label) in other_variants {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(!crate::utils::is_env_type(&ty), "{label} type {ty_str} should NOT be recognized as an Env type");
+    }
+}

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

@@ -19,8 +19,7 @@ pub fn generate_ttl_configurable_impl(input: TokenStream) -> TokenStream {
     let expanded = quote! {
         use utils::ttl::TtlConfigurable as _;
 
-        // TODO: should use custom contract_impl macro instead of soroban_sdk::contractimpl
-        #[soroban_sdk::contractimpl]
+        #[common_macros::contract_impl]
         impl utils::ttl::TtlConfigurable for #name {
 
             #[common_macros::only_owner]
@@ -53,17 +52,21 @@ pub fn generate_ttl_configurable_impl(input: TokenStream) -> TokenStream {
     };
 
     let inherent_impl = quote! {
+        /// Uses `soroban_sdk::contractimpl` directly instead of `common_macros::contract_impl`
+        /// because `contract_impl` automatically extends TTL on every invocation. Since this
+        /// impl block provides manual TTL extension control, auto-extension would be redundant
+        /// and could mask the intended behavior of `extend_instance_ttl`.
         #[soroban_sdk::contractimpl]
-            impl #name {
-                /// Extends the instance TTL.
-                ///
-                /// # Arguments
-                ///
-                /// * `threshold` - The threshold to extend the TTL.
-                /// * `extend_to` - The TTL to extend to.
-                pub fn extend_instance_ttl(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
-                    env.storage().instance().extend_ttl(threshold, extend_to);
-                }
+        impl #name {
+            /// Extends the instance TTL.
+            ///
+            /// # Arguments
+            ///
+            /// * `threshold` - The threshold to extend the TTL.
+            /// * `extend_to` - The TTL to extend to.
+            pub fn extend_instance_ttl(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
+                env.storage().instance().extend_ttl(threshold, extend_to);
+            }
         }
     };
 

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

@@ -1,20 +1,44 @@
+use proc_macro2::TokenStream;
+use quote::quote;
 use syn::{punctuated::Punctuated, token::Comma, FnArg, Ident, Pat, Type, TypePath};
 
-/// Finds the `Env` argument identifier in a function signature.
-pub fn find_env_ident(args: &Punctuated<FnArg, Comma>) -> Option<&Ident> {
+/// Information about an `Env` parameter in a function signature.
+pub struct EnvParam<'a> {
+    /// The identifier of the Env parameter
+    pub ident: &'a Ident,
+    /// Whether the parameter is a reference type (`&Env` or `&mut Env`)
+    pub is_reference: bool,
+}
+
+impl EnvParam<'_> {
+    /// Returns a token stream that produces a `&Env` reference.
+    /// - If the parameter is already a reference (`&Env`), returns the ident as-is
+    /// - If the parameter is owned (`Env`), returns `&ident`
+    pub fn as_ref_tokens(&self) -> TokenStream {
+        let ident = self.ident;
+        if self.is_reference {
+            quote!(#ident)
+        } else {
+            quote!(&#ident)
+        }
+    }
+}
+
+/// Finds the `Env` argument in a function signature and returns its info.
+pub fn find_env_param(args: &Punctuated<FnArg, Comma>) -> Option<EnvParam<'_>> {
     args.iter().find_map(|arg| {
         let FnArg::Typed(pat_type) = arg else { return None };
         if !is_env_type(&pat_type.ty) {
             return None;
         }
         let Pat::Ident(pat) = pat_type.pat.as_ref() else { return None };
-        Some(&pat.ident)
+        Some(EnvParam { ident: &pat.ident, is_reference: is_reference_type(&pat_type.ty) })
     })
 }
 
-/// Expects the `Env` argument identifier in a function signature.
-pub fn expect_env_ident(args: &Punctuated<FnArg, Comma>) -> &Ident {
-    find_env_ident(args).expect("function must have an Env argument")
+/// Expects the `Env` argument in a function signature and returns its info.
+pub fn expect_env_param(args: &Punctuated<FnArg, Comma>) -> EnvParam<'_> {
+    find_env_param(args).expect("function must have an Env argument")
 }
 
 /// Checks if a type is an `Env` type.
@@ -25,3 +49,8 @@ pub fn is_env_type(ty: &Type) -> bool {
         _ => false,
     }
 }
+
+/// Checks if a type is a reference type.
+fn is_reference_type(ty: &Type) -> bool {
+    matches!(ty, Type::Reference(_))
+}

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

@@ -5,10 +5,10 @@ use crate::{
     },
     errors::EndpointError,
     events::{
-        ComposeDelivered, ComposeSent, DefaultReceiveLibrarySet, DefaultReceiveLibraryTimeoutSet,
-        DefaultSendLibrarySet, DelegateSet, InboundNonceSkipped, LibraryRegistered, LzComposeAlert, LzReceiveAlert,
-        PacketBurnt, PacketDelivered, PacketNilified, PacketSent, PacketVerified, ReceiveLibrarySet,
-        ReceiveLibraryTimeoutSet, SendLibrarySet, ZROSet,
+        ComposeDelivered, ComposeSent, DefaultReceiveLibTimeoutSet, DefaultReceiveLibrarySet, DefaultSendLibrarySet,
+        DelegateSet, InboundNonceSkipped, LibraryRegistered, LzComposeAlert, LzReceiveAlert, PacketBurnt,
+        PacketDelivered, PacketNilified, PacketSent, PacketVerified, ReceiveLibrarySet, ReceiveLibraryTimeoutSet,
+        SendLibrarySet, ZROSet,
     },
     interfaces::{ILayerZeroEndpointV2, IMessageLibManager, IMessagingChannel, MessagingFee, MessagingReceipt, Origin},
     storage::EndpointStorage,

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

@@ -1,19 +1,20 @@
 use crate::{Origin, Timeout};
-use common_macros::event;
-use soroban_sdk::{Address, Bytes, BytesN};
+use soroban_sdk::{contractevent, Address, Bytes, BytesN};
 
 // ============================================================================
 // EndpointV2 Events
 // ============================================================================
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PacketSent {
     pub encoded_packet: Bytes,
     pub options: Bytes,
     pub send_library: Address,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PacketVerified {
     #[topic]
     pub origin: Origin,
@@ -22,7 +23,8 @@ pub struct PacketVerified {
     pub payload_hash: BytesN<32>,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PacketDelivered {
     #[topic]
     pub origin: Origin,
@@ -30,7 +32,8 @@ pub struct PacketDelivered {
     pub receiver: Address,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct LzReceiveAlert {
     #[topic]
     pub receiver: Address,
@@ -47,12 +50,14 @@ pub struct LzReceiveAlert {
     pub reason: Bytes,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ZROSet {
     pub zro: Address,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DelegateSet {
     #[topic]
     pub oapp: Address,
@@ -63,7 +68,8 @@ pub struct DelegateSet {
 // Messaging Channel Events
 // ============================================================================
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct InboundNonceSkipped {
     #[topic]
     pub src_eid: u32,
@@ -75,7 +81,8 @@ pub struct InboundNonceSkipped {
     pub nonce: u64,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PacketNilified {
     #[topic]
     pub src_eid: u32,
@@ -88,7 +95,8 @@ pub struct PacketNilified {
     pub payload_hash: Option<BytesN<32>>,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PacketBurnt {
     #[topic]
     pub src_eid: u32,
@@ -105,33 +113,38 @@ pub struct PacketBurnt {
 // Message Lib Manager Events
 // ============================================================================
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct LibraryRegistered {
     pub new_lib: Address,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DefaultSendLibrarySet {
     #[topic]
     pub dst_eid: u32,
     pub new_lib: Address,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DefaultReceiveLibrarySet {
     #[topic]
     pub src_eid: u32,
     pub new_lib: Address,
 }
 
-#[event]
-pub struct DefaultReceiveLibraryTimeoutSet {
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DefaultReceiveLibTimeoutSet {
     #[topic]
     pub src_eid: u32,
     pub timeout: Option<Timeout>,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct SendLibrarySet {
     #[topic]
     pub sender: Address,
@@ -140,7 +153,8 @@ pub struct SendLibrarySet {
     pub new_lib: Option<Address>,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ReceiveLibrarySet {
     #[topic]
     pub receiver: Address,
@@ -149,7 +163,8 @@ pub struct ReceiveLibrarySet {
     pub new_lib: Option<Address>,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ReceiveLibraryTimeoutSet {
     #[topic]
     pub receiver: Address,
@@ -162,7 +177,8 @@ pub struct ReceiveLibraryTimeoutSet {
 // Message Composer Events
 // ============================================================================
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ComposeSent {
     #[topic]
     pub from: Address,
@@ -175,7 +191,8 @@ pub struct ComposeSent {
     pub message: Bytes,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ComposeDelivered {
     #[topic]
     pub from: Address,
@@ -187,7 +204,8 @@ pub struct ComposeDelivered {
     pub index: u32,
 }
 
-#[event]
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct LzComposeAlert {
     #[topic]
     pub from: Address,

package/contracts/endpoint-v2/src/interfaces/message_lib.rs

@@ -1,5 +1,5 @@
 use crate::SetConfigParam;
-use soroban_sdk::{contracttrait, contracttype, Address, Bytes, Env, Vec};
+use soroban_sdk::{contractclient, contracttype, Address, Bytes, Env, Vec};
 
 /// Type of message library indicating supported operations.
 #[contracttype]
@@ -30,7 +30,7 @@ pub struct MessageLibVersion {
 }
 
 /// Interface for message libraries that handle cross-chain message verification and delivery.
-#[contracttrait(client_name = "MessageLibClient")]
+#[contractclient(name = "MessageLibClient")]
 pub trait IMessageLib {
     /// Sets the configuration for an OApp by the Endpoint.
     ///

package/contracts/endpoint-v2/src/interfaces/message_lib_manager.rs

@@ -1,4 +1,4 @@
-use soroban_sdk::{contracttrait, contracttype, Address, Bytes, Env, Vec};
+use soroban_sdk::{contractclient, contracttype, Address, Bytes, Env, Vec};
 
 /// Timeout configuration for receive library transitions.
 #[contracttype]
@@ -45,7 +45,7 @@ pub struct ResolvedLibrary {
 }
 
 /// EndpointV2's Interface for managing message libraries.
-#[contracttrait(client_name = "MessageLibManagerClient")]
+#[contractclient(name = "MessageLibManagerClient")]
 pub trait IMessageLibManager {
     /// Registers a new message library with the endpoint.
     ///

package/contracts/endpoint-v2/src/interfaces/messaging_channel.rs

@@ -1,7 +1,7 @@
-use soroban_sdk::{contracttrait, Address, BytesN, Env};
+use soroban_sdk::{contractclient, Address, BytesN, Env};
 
 /// EndpointV2's Interface for managing messaging channels, nonces, and payload hashes.
-#[contracttrait(client_name = "MessagingChannelClient")]
+#[contractclient(name = "MessagingChannelClient")]
 pub trait IMessagingChannel {
     /// Skips the next expected inbound nonce without verifying.
     ///

package/contracts/endpoint-v2/src/interfaces/messaging_composer.rs

@@ -1,7 +1,7 @@
-use soroban_sdk::{contracttrait, Address, Bytes, BytesN, Env};
+use soroban_sdk::{contractclient, Address, Bytes, BytesN, Env};
 
 /// EndpointV2's Interface for managing composed messages between OApps and composers.
-#[contracttrait(client_name = "MessagingComposerClient")]
+#[contractclient(name = "MessagingComposerClient")]
 pub trait IMessagingComposer {
     /// Sends a composed message from an OApp to a composer.
     /// The OApp can send compose to multiple composers with the same GUID.

package/contracts/endpoint-v2/src/interfaces/send_lib.rs

@@ -1,5 +1,5 @@
 use super::{IMessageLib, MessagingFee};
-use soroban_sdk::{contracttrait, contracttype, Address, Bytes, BytesN, Env, Vec};
+use soroban_sdk::{contractclient, contracttype, Address, Bytes, BytesN, Env, Vec};
 
 /// Outbound packet containing all information for cross-chain transmission.
 #[contracttype]
@@ -44,7 +44,7 @@ pub struct FeesAndPacket {
 }
 
 /// Interface for send libraries that handle outbound message encoding and fee calculation.
-#[contracttrait(client_name = "SendLibClient")]
+#[contractclient(name = "SendLibClient")]
 pub trait ISendLib: IMessageLib {
     /// Quotes the fee for sending a packet without actually sending.
     ///

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

@@ -1,6 +1,6 @@
 use super::*;
 
-#[contract_impl(contracttrait)]
+#[contract_impl]
 impl IMessageLibManager for EndpointV2 {
     /// Registers a new message library with the endpoint.
     #[only_owner]
@@ -56,7 +56,7 @@ impl IMessageLibManager for EndpointV2 {
             None
         };
         EndpointStorage::set_or_remove_default_receive_library_timeout(env, src_eid, &timeout);
-        DefaultReceiveLibraryTimeoutSet { src_eid, timeout: timeout.clone() }.publish(env);
+        DefaultReceiveLibTimeoutSet { src_eid, timeout: timeout.clone() }.publish(env);
     }
 
     /// Sets or removes the default receive library timeout for a source endpoint.
@@ -70,7 +70,7 @@ impl IMessageLibManager for EndpointV2 {
             assert_with_error!(env, !t.is_expired(env), EndpointError::InvalidExpiry);
         }
         EndpointStorage::set_or_remove_default_receive_library_timeout(env, src_eid, timeout);
-        DefaultReceiveLibraryTimeoutSet { src_eid, timeout: timeout.clone() }.publish(env);
+        DefaultReceiveLibTimeoutSet { src_eid, timeout: timeout.clone() }.publish(env);
     }
 
     // ============================================================================================

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

@@ -1,6 +1,6 @@
 use super::*;
 
-#[contract_impl(contracttrait)]
+#[contract_impl]
 impl IMessagingChannel for EndpointV2 {
     /// Skips the next expected inbound nonce without verifying.
     ///

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

@@ -1,6 +1,6 @@
 use super::*;
 
-#[contract_impl(contracttrait)]
+#[contract_impl]
 impl IMessagingComposer for EndpointV2 {
     /// Sends a composed message from an OApp to a composer.
     ///