@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

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

@@ -0,0 +1,24 @@
+---
+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)
+        }
+    }
+    #[common_macros::contract_impl(contracttrait)]
+    impl Ownable for MyContract {}
+}

package/contracts/common-macros/src/tests/snapshots/{common_macros__tests__ownable__snapshot_only_owner_preserves_function_signature.snap → common_macros__tests__auth__snapshot_only_auth_preserves_function_signature.snap}

@@ -1,12 +1,12 @@
 ---
-source: contracts/common-macros/src/tests/ownable.rs
-assertion_line: 48
+source: contracts/common-macros/src/tests/auth.rs
+assertion_line: 67
 expression: combined
 ---
 // === Borrowed Env (&Env) ===
 
 pub(crate) async fn admin_action<T: Clone>(env: &Env, value: T) -> Result<T, Error> {
-    utils::ownable::require_owner_auth::<Self>(env);
+    utils::auth::require_auth::<Self>(env);
     Ok(value.clone())
 }
 
@@ -14,6 +14,6 @@ pub(crate) async fn admin_action<T: Clone>(env: &Env, value: T) -> Result<T, Err
 // === Owned Env (Env) ===
 
 pub(crate) async fn admin_action<T: Clone>(env: Env, value: T) -> Result<T, Error> {
-    utils::ownable::require_owner_auth::<Self>(&env);
+    utils::auth::require_auth::<Self>(&env);
     Ok(value.clone())
 }

package/contracts/common-macros/src/tests/snapshots/{common_macros__tests__contract_impl__snapshot_generated_contract_impl_code.snap → common_macros__tests__contract_ttl__snapshot_generated_contractimpl_code.snap}

@@ -1,5 +1,5 @@
 ---
-source: contracts/common-macros/src/tests/contract_impl.rs
+source: contracts/common-macros/src/tests/contract_ttl.rs
 assertion_line: 109
 expression: combined
 ---
@@ -79,8 +79,8 @@ impl SomeTrait for MyContract {
         value * 4
     }
     /// Trait method with macro attribute - should have TTL extension
-    #[common_macros::only_owner]
-    fn trait_method_with_only_owner_attribute(env: Env, value: u32) -> u32 {
+    #[common_macros::only_auth]
+    fn trait_method_with_only_auth_attribute(env: Env, value: u32) -> u32 {
         if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
             &env,
         ) {

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

@@ -0,0 +1,69 @@
+---
+source: contracts/common-macros/src/tests/contract_ttl.rs
+assertion_line: 75
+expression: combined
+---
+// === Trait (no attr) ===
+
+#[soroban_sdk::contracttrait]
+pub trait MyTrait: Sized {
+    /// Default method with Env - should have TTL extension
+    fn default_with_env(env: Env, value: u32) -> u32 {
+        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
+            &env,
+        ) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 2
+    }
+    /// Default method with qualified Env path - should have TTL extension
+    fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
+        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
+            &env,
+        ) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        42
+    }
+    /// Default method with Env not as first parameter - should have TTL extension
+    fn env_second(value: u32, env: &Env) -> u32 {
+        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
+            env,
+        ) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 2
+    }
+    /// Default method without Env - should NOT have TTL extension
+    fn default_without_env(value: u32) -> u32 {
+        value * 4
+    }
+    /// Abstract method with Env - should NOT have TTL extension (no body)
+    fn abstract_with_env(env: Env, value: u32) -> u32;
+    /// Abstract method without Env - should NOT have TTL extension (no body)
+    fn abstract_without_env(value: u32) -> u32;
+}
+
+
+// === Trait (crate attr) ===
+
+#[soroban_sdk::contracttrait(crate = "other_sdk")]
+pub trait AnotherTrait {
+    /// Default method with Env - should have TTL extension
+    fn method_with_env(env: &Env, value: u32) -> u32 {
+        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
+            env,
+        ) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 3
+    }
+}

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

@@ -1,29 +1,15 @@
 ---
 source: contracts/common-macros/src/tests/ttl_configurable.rs
-assertion_line: 20
 expression: formatted
 ---
 pub struct MyContract {
     some_field: u32,
 }
-use utils::ttl_configurable::{TtlConfig, TtlConfigurable};
-use utils::ownable::Ownable as _;
-/// Implement the `TtlConfigurable` trait for the contract with default implementations.
-#[common_macros::contract_impl(contracttrait)]
-impl TtlConfigurable for MyContract {}
-/// 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 MyContract {
-    /// 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);
-    }
+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 {}
 }

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

@@ -10,11 +10,11 @@ type MigrationData = <MyContract as utils::upgradeable::UpgradeableInternal>::Mi
 /// Implement the Upgradeable trait for the contract.
 #[common_macros::contract_impl]
 impl utils::upgradeable::Upgradeable for MyContract {
-    #[common_macros::only_owner]
+    #[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_owner]
+    #[common_macros::only_auth]
     fn migrate(env: &soroban_sdk::Env, migration_data: &MigrationData) {
         utils::upgradeable::migrate::<Self>(env, migration_data)
     }

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

@@ -1,50 +1,35 @@
 //! TtlConfigurable macro for Stellar smart contracts.
 
+use crate::utils;
 use proc_macro2::TokenStream;
 use quote::quote;
+use syn::ItemStruct;
 
 /// Generates the `TtlConfigurable` trait implementation for a contract.
 ///
-/// This macro:
-/// - Implements `TtlConfigurable` using the trait's default methods (which include owner auth)
-/// - Adds an `extend_instance_ttl` helper for manual TTL extension
+/// This macro implements `TtlConfigurable` using the trait's default methods (which include auth).
 ///
-/// The contract must also implement `Ownable` (typically via `#[ownable]`).
+/// The contract must also implement `Auth` (typically via `#[ownable]` or `Multisig`).
+///
+/// For manual TTL extension functionality, use the `#[ttl_extendable]` macro which provides
+/// the `extend_instance_ttl` function.
 pub fn generate_ttl_configurable_impl(input: TokenStream) -> TokenStream {
-    let item_struct: syn::ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
+    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");
 
-    let trait_impl = quote! {
-        use utils::ttl_configurable::{TtlConfig, TtlConfigurable};
-        use utils::ownable::Ownable as _;
+    quote! {
+        #item_struct
 
-        /// Implement the `TtlConfigurable` trait for the contract with default implementations.
-        #[common_macros::contract_impl(contracttrait)]
-        impl TtlConfigurable for #name {}
-    };
+        use utils::ttl_configurable::TtlConfigurable as _;
 
-    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);
-            }
-        }
-    };
+        #[doc(hidden)]
+        mod #impl_mod {
+            use super::*;
+            use utils::ttl_configurable::{TtlConfig, TtlConfigurable};
 
-    quote! {
-        #item_struct
-        #trait_impl
-        #inherent_impl
+            #[common_macros::contract_impl(contracttrait)]
+            impl TtlConfigurable for #name {}
+        }
     }
 }

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

@@ -0,0 +1,36 @@
+//! TtlExtendable macro for Stellar smart contracts.
+
+use crate::utils;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::ItemStruct;
+
+/// Generates the TtlExtendable trait implementation from the `#[ttl_extendable]` attribute macro.
+///
+/// This macro implements the `TtlExtendable` trait for a contract struct,
+/// providing a public `extend_instance_ttl` function for manual TTL extension.
+///
+/// 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`.
+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 {}
+        }
+    }
+}

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

@@ -10,16 +10,16 @@ use syn::ItemStruct;
 ///
 /// # Behavior
 ///
-/// - Implements the `upgrade` and `migrate` functions with owner-based access control.
+/// - Implements the `upgrade` and `migrate` functions with auth-based access control.
 /// - 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 `Ownable` and `UpgradeableInternal` traits.
+/// - Requires the contract to implement `Auth` and `UpgradeableInternal` traits.
 ///
 /// # Example
 /// ```ignore
-/// #[ownable]
+/// #[ownable]  // or implement Multisig for self-owning contracts
 /// #[upgradeable]
 /// pub struct MyContract;
 /// ```
@@ -40,12 +40,12 @@ pub fn generate_upgradeable_impl(input: TokenStream) -> TokenStream {
         /// Implement the Upgradeable trait for the contract.
         #[common_macros::contract_impl]
         impl utils::upgradeable::Upgradeable for #name {
-            #[common_macros::only_owner]
+            #[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_owner]
+            #[common_macros::only_auth]
             fn migrate(env: &soroban_sdk::Env, migration_data: &MigrationData) {
                 utils::upgradeable::migrate::<Self>(env, migration_data)
             }

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

@@ -1,3 +1,4 @@
+use heck::ToSnakeCase;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{punctuated::Punctuated, token::Comma, FnArg, Ident, Pat, Type, TypePath};
@@ -54,3 +55,11 @@ 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/constants.rs

@@ -7,7 +7,7 @@ cfg_if::cfg_if! {
     if #[cfg(any(test, feature = "testutils"))] {
         /// Stellar Endpoint ID for unit test environment.
         /// TODO: This is a placeholder value for testing purposes.
-        pub const STELLAR_EID: u32 = 30111;
+        pub const STELLAR_EID: u32 = 30400;
 
         /// Native token address for unit test environment.
         pub const NATIVE_TOKEN: &str = "CBEPDNVYXQGWB5YUBXKJWYJA7OXTZW5LFLNO5JRRGE6Z6C5OSUZPCCEL";
@@ -15,7 +15,7 @@ cfg_if::cfg_if! {
     } else if #[cfg(feature = "testnet")] {
         /// Stellar Endpoint ID for testnet environment.
         /// TODO: Confirm this EID value with LayerZero before testnet deployment.
-        pub const STELLAR_EID: u32 = 20111;
+        pub const STELLAR_EID: u32 = 20400;
 
         /// Native token address for testnet (Stellar testnet XLM wrapper).
         pub const NATIVE_TOKEN: &str = "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC";
@@ -23,7 +23,7 @@ cfg_if::cfg_if! {
     } else if #[cfg(feature = "sandbox")] {
         /// Stellar Endpoint ID for sandbox environment.
         /// TODO: Confirm this EID value with LayerZero before sandbox deployment.
-        pub const STELLAR_EID: u32 = 30111;
+        pub const STELLAR_EID: u32 = 30400;
 
         /// Native token address for sandbox environment.
         pub const NATIVE_TOKEN: &str = "CDMLFMKMMD7MWZP3FKUBZPVHTUEDLSX4BYGYKH4GCESXYHS3IHQ4EIG4";
@@ -31,7 +31,7 @@ cfg_if::cfg_if! {
     } else {
         /// Stellar Endpoint ID for mainnet environment.
         /// TODO: Confirm this EID value with LayerZero before mainnet deployment.
-        pub const STELLAR_EID: u32 = 30111;
+        pub const STELLAR_EID: u32 = 30400;
 
         /// Native token address for mainnet (Stellar mainnet XLM wrapper).
         pub const NATIVE_TOKEN: &str = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";

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

@@ -1,28 +1,18 @@
 use crate::{
-    constants::{
-        EMPTY_PAYLOAD_HASH_BYTES, MAX_COMPOSE_INDEX, NATIVE_TOKEN, NIL_PAYLOAD_HASH_BYTES, RECEIVED_MESSAGE_HASH_BYTES,
-        STELLAR_EID,
-    },
+    constants::{NATIVE_TOKEN, STELLAR_EID},
     errors::EndpointError,
-    events::{
-        ComposeDelivered, ComposeSent, DefaultReceiveLibTimeoutSet, DefaultReceiveLibrarySet, DefaultSendLibrarySet,
-        DelegateSet, InboundNonceSkipped, LibraryRegistered, LzComposeAlert, LzReceiveAlert, PacketBurnt,
-        PacketDelivered, PacketNilified, PacketSent, PacketVerified, ReceiveLibrarySet, ReceiveLibraryTimeoutSet,
-        SendLibrarySet, ZROSet,
-    },
+    events::{DelegateSet, LzReceiveAlert, PacketDelivered, PacketSent, PacketVerified, ZroSet},
     interfaces::{ILayerZeroEndpointV2, IMessageLibManager, IMessagingChannel, MessagingFee, MessagingReceipt, Origin},
     storage::EndpointStorage,
-    util::{build_payload, compute_guid, keccak256},
-    FeeRecipient, FeesAndPacket, IMessagingComposer, LayerZeroReceiverClient, MessageLibClient, MessageLibType,
-    MessagingParams, OutboundPacket, ResolvedLibrary, SendLibClient, SetConfigParam, Timeout,
+    util::{build_payload, compute_guid},
+    FeeRecipient, FeesAndPacket, LayerZeroReceiverClient, MessagingParams, OutboundPacket, ResolvedLibrary,
+    SendLibClient,
 };
-use common_macros::{contract_impl, only_owner, ownable, ttl_configurable};
-use soroban_sdk::{assert_with_error, contract, token::TokenClient, vec, Address, Bytes, BytesN, Env, Vec};
+use common_macros::{contract_impl, lz_contract, only_auth};
+use soroban_sdk::{assert_with_error, token::TokenClient, Address, Bytes, BytesN, Env, Vec};
 use utils::option_ext::OptionExt;
 
-#[contract]
-#[ttl_configurable]
-#[ownable]
+#[lz_contract]
 pub struct EndpointV2;
 
 #[contract_impl]
@@ -37,7 +27,7 @@ impl EndpointV2 {
     /// * `token` - The token address to recover
     /// * `to` - The address to send the token to
     /// * `amount` - The amount to send
-    #[only_owner]
+    #[only_auth]
     pub fn recover_token(env: &Env, token: &Address, to: &Address, amount: i128) {
         TokenClient::new(env, token).transfer(&env.current_contract_address(), to, &amount);
     }
@@ -51,7 +41,7 @@ impl EndpointV2 {
 impl ILayerZeroEndpointV2 for EndpointV2 {
     /// Quotes the messaging fee for sending a cross-chain message.
     fn quote(env: &Env, sender: &Address, params: &MessagingParams) -> MessagingFee {
-        assert_with_error!(env, !params.pay_in_zro || EndpointStorage::has_zro(env), EndpointError::ZROUnavailable);
+        assert_with_error!(env, !params.pay_in_zro || EndpointStorage::has_zro(env), EndpointError::ZroUnavailable);
 
         let MessagingParams { dst_eid, receiver, message, options, pay_in_zro } = params;
         let ResolvedLibrary { lib: send_lib, .. } = Self::get_send_library(env, sender, *dst_eid);
@@ -67,7 +57,7 @@ impl ILayerZeroEndpointV2 for EndpointV2 {
     /// OApp sender needs to transfer the fees to the endpoint before sending the message
     fn send(env: &Env, sender: &Address, params: &MessagingParams, refund_address: &Address) -> MessagingReceipt {
         sender.require_auth();
-        assert_with_error!(env, !params.pay_in_zro || EndpointStorage::has_zro(env), EndpointError::ZROUnavailable);
+        assert_with_error!(env, !params.pay_in_zro || EndpointStorage::has_zro(env), EndpointError::ZroUnavailable);
 
         let MessagingParams { dst_eid, receiver, message, options, pay_in_zro } = params;
         let ResolvedLibrary { lib: send_library, .. } = Self::get_send_library(env, sender, *dst_eid);
@@ -147,10 +137,10 @@ impl ILayerZeroEndpointV2 for EndpointV2 {
     }
 
     /// Sets the ZRO token address for fee payments.
-    #[only_owner]
+    #[only_auth]
     fn set_zro(env: &Env, zro: &Address) {
         EndpointStorage::set_zro(env, zro);
-        ZROSet { zro: zro.clone() }.publish(env);
+        ZroSet { zro: zro.clone() }.publish(env);
     }
 
     /// Sets or removes a delegate address that can act on behalf of the OApp.
@@ -258,11 +248,17 @@ impl EndpointV2 {
         // Pay native fees
         let native_token_client = TokenClient::new(env, &Self::native_token(env));
         let mut native_fee_supplied = native_token_client.balance(&this_contract);
-        native_fee_recipients.iter().filter(|r| r.amount > 0).for_each(|r| {
-            assert_with_error!(env, native_fee_supplied >= r.amount, EndpointError::InsufficientNativeFee);
-            native_token_client.transfer(&this_contract, &r.to, &r.amount);
-            native_fee_supplied -= r.amount;
-            fee_paid.native_fee += r.amount;
+        native_fee_recipients.iter().for_each(|r| {
+            // Fee amounts are modeled as non-negative values. The field type is i128 for
+            // compatibility with token APIs, but negative fees are always invalid and rejected
+            // here, while zero amounts are treated as a no-op (skipped by the check below).
+            assert_with_error!(env, r.amount >= 0, EndpointError::InvalidFeeAmount);
+            if r.amount > 0 {
+                assert_with_error!(env, native_fee_supplied >= r.amount, EndpointError::InsufficientNativeFee);
+                native_token_client.transfer(&this_contract, &r.to, &r.amount);
+                native_fee_supplied -= r.amount;
+                fee_paid.native_fee += r.amount;
+            }
         });
         // Refund remaining native fees
         if native_fee_supplied > 0 {
@@ -271,7 +267,7 @@ impl EndpointV2 {
 
         // Pay ZRO fees
         if pay_in_zro {
-            let zro_addr = Self::zro(env).unwrap_or_panic(env, EndpointError::ZROUnavailable);
+            let zro_addr = Self::zro(env).unwrap_or_panic(env, EndpointError::ZroUnavailable);
             let zro_client = TokenClient::new(env, &zro_addr);
 
             // If pay_in_zro is true, the supplied fee must be greater than 0 to prevent a race condition
@@ -279,13 +275,19 @@ impl EndpointV2 {
             // being sent and the tx being mined. if the required zro fee is 0 and the old zro token would be
             // locked in the contract instead of being refunded
             let mut zro_fee_supplied = zro_client.balance(&this_contract);
-            assert_with_error!(env, zro_fee_supplied > 0, EndpointError::ZeroZROFee);
-
-            zro_fee_recipients.iter().filter(|r| r.amount > 0).for_each(|r| {
-                assert_with_error!(env, zro_fee_supplied >= r.amount, EndpointError::InsufficientZROFee);
-                zro_client.transfer(&this_contract, &r.to, &r.amount);
-                zro_fee_supplied -= r.amount;
-                fee_paid.zro_fee += r.amount;
+            assert_with_error!(env, zro_fee_supplied > 0, EndpointError::ZeroZroFee);
+
+            zro_fee_recipients.iter().for_each(|r| {
+                // Fee amounts are modeled as non-negative values. The field type is i128 for
+                // compatibility with token APIs, but negative fees are always invalid and rejected
+                // here, while zero amounts are treated as a no-op (skipped by the check below).
+                assert_with_error!(env, r.amount >= 0, EndpointError::InvalidFeeAmount);
+                if r.amount > 0 {
+                    assert_with_error!(env, zro_fee_supplied >= r.amount, EndpointError::InsufficientZroFee);
+                    zro_client.transfer(&this_contract, &r.to, &r.amount);
+                    zro_fee_supplied -= r.amount;
+                    fee_paid.zro_fee += r.amount;
+                }
             });
             // Refund remaining ZRO fees
             if zro_fee_supplied > 0 {
@@ -320,10 +322,6 @@ mod test {
     }
 }
 
-// ============================================================================
-// Include Modules
-// ============================================================================
-
 #[path = "message_lib_manager.rs"]
 mod message_lib_manager;
 #[path = "messaging_channel.rs"]

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

@@ -8,7 +8,8 @@ pub enum EndpointError {
     DefaultReceiveLibUnavailable,
     DefaultSendLibUnavailable,
     InsufficientNativeFee,
-    InsufficientZROFee,
+    InsufficientZroFee,
+    InvalidFeeAmount,
     InvalidExpiry,
     InvalidIndex,
     InvalidNonce,
@@ -24,6 +25,6 @@ pub enum EndpointError {
     SameValue,
     Unauthorized,
     UnsupportedEid,
-    ZeroZROFee,
-    ZROUnavailable,
+    ZeroZroFee,
+    ZroUnavailable,
 }

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

@@ -52,7 +52,7 @@ pub struct LzReceiveAlert {
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ZROSet {
+pub struct ZroSet {
     pub zro: Address,
 }
 

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

@@ -1,9 +1,22 @@
-use super::*;
+use super::{EndpointV2, EndpointV2Args, EndpointV2Client};
+use crate::{
+    errors::EndpointError,
+    events::{
+        DefaultReceiveLibTimeoutSet, DefaultReceiveLibrarySet, DefaultSendLibrarySet, LibraryRegistered,
+        ReceiveLibrarySet, ReceiveLibraryTimeoutSet, SendLibrarySet,
+    },
+    interfaces::IMessageLibManager,
+    storage::EndpointStorage,
+    MessageLibClient, MessageLibType, ResolvedLibrary, SetConfigParam, Timeout,
+};
+use common_macros::{contract_impl, only_auth};
+use soroban_sdk::{assert_with_error, vec, Address, Bytes, Env, Vec};
+use utils::option_ext::OptionExt;
 
 #[contract_impl]
 impl IMessageLibManager for EndpointV2 {
     /// Registers a new message library with the endpoint.
-    #[only_owner]
+    #[only_auth]
     fn register_library(env: &Env, new_lib: &Address) {
         // Call library get type to make sure it's a valid library, will panic if not
         let _ = MessageLibClient::new(env, new_lib).message_lib_type();
@@ -21,7 +34,7 @@ impl IMessageLibManager for EndpointV2 {
     }
 
     /// Sets the default send library for a destination endpoint.
-    #[only_owner]
+    #[only_auth]
     fn set_default_send_library(env: &Env, dst_eid: u32, new_lib: &Address) {
         Self::require_send_lib_for_eid(env, new_lib, dst_eid);
 
@@ -36,7 +49,7 @@ impl IMessageLibManager for EndpointV2 {
     ///
     /// If a grace period is provided and there was a previous library, the old library
     /// remains valid until the grace period expires.
-    #[only_owner]
+    #[only_auth]
     fn set_default_receive_library(env: &Env, src_eid: u32, new_lib: &Address, grace_period: u64) {
         Self::require_receive_lib_for_eid(env, new_lib, src_eid);
 
@@ -63,7 +76,7 @@ impl IMessageLibManager for EndpointV2 {
     ///
     /// If a timeout is provided, it must be valid and not expired. If no timeout is provided,
     /// the default receive library timeout is removed.
-    #[only_owner]
+    #[only_auth]
     fn set_default_receive_lib_timeout(env: &Env, src_eid: u32, timeout: &Option<Timeout>) {
         if let Some(t) = timeout {
             Self::require_receive_lib_for_eid(env, &t.lib, src_eid);

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

@@ -1,4 +1,14 @@
-use super::*;
+use super::{EndpointV2, EndpointV2Args, EndpointV2Client};
+use crate::{
+    constants::{EMPTY_PAYLOAD_HASH_BYTES, NIL_PAYLOAD_HASH_BYTES},
+    errors::EndpointError,
+    events::{InboundNonceSkipped, PacketBurnt, PacketNilified},
+    interfaces::{ILayerZeroEndpointV2, IMessagingChannel},
+    storage::EndpointStorage,
+    util::{compute_guid, keccak256},
+};
+use common_macros::contract_impl;
+use soroban_sdk::{assert_with_error, Address, Bytes, BytesN, Env};
 
 #[contract_impl]
 impl IMessagingChannel for EndpointV2 {

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

@@ -1,4 +1,14 @@
-use super::*;
+use super::{EndpointV2, EndpointV2Args, EndpointV2Client};
+use crate::{
+    constants::{MAX_COMPOSE_INDEX, RECEIVED_MESSAGE_HASH_BYTES},
+    errors::EndpointError,
+    events::{ComposeDelivered, ComposeSent, LzComposeAlert},
+    storage::EndpointStorage,
+    util::keccak256,
+    IMessagingComposer,
+};
+use common_macros::contract_impl;
+use soroban_sdk::{assert_with_error, Address, Bytes, BytesN, Env};
 
 #[contract_impl]
 impl IMessagingComposer for EndpointV2 {

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

@@ -6,7 +6,7 @@ use soroban_sdk::{Address, BytesN};
 pub enum EndpointStorage {
     /// The ZRO token address
     #[instance(Address)]
-    ZRO,
+    Zro,
 
     /// The delegate address for an OApp
     #[persistent(Address)]