@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,49 +1,15 @@
 ---
 source: contracts/common-macros/src/tests/ttl_configurable.rs
-assertion_line: 20
 expression: formatted
 ---
-#[common_macros::ownable]
 pub struct MyContract {
     some_field: u32,
 }
-use utils::ttl::TtlConfigurable as _;
-#[common_macros::contract_impl]
-impl utils::ttl::TtlConfigurable for MyContract {
-    #[common_macros::only_owner]
-    fn set_ttl_configs(
-        env: &soroban_sdk::Env,
-        instance: &Option<utils::ttl::TtlConfig>,
-        persistent: &Option<utils::ttl::TtlConfig>,
-    ) {
-        utils::ttl::DefaultTtlConfigurable::set_ttl_configs(env, instance, persistent);
-    }
-    fn ttl_configs(
-        env: &soroban_sdk::Env,
-    ) -> (Option<utils::ttl::TtlConfig>, Option<utils::ttl::TtlConfig>) {
-        utils::ttl::DefaultTtlConfigurable::ttl_configs(env)
-    }
-    #[common_macros::only_owner]
-    fn freeze_ttl_configs(env: &soroban_sdk::Env) {
-        utils::ttl::DefaultTtlConfigurable::freeze_ttl_configs(env);
-    }
-    fn is_ttl_configs_frozen(env: &soroban_sdk::Env) -> bool {
-        utils::ttl::DefaultTtlConfigurable::is_ttl_configs_frozen(env)
-    }
-}
-/// 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

@@ -0,0 +1,21 @@
+---
+source: contracts/common-macros/src/tests/upgradeable.rs
+assertion_line: 17
+expression: formatted
+---
+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)
+    }
+}

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

@@ -0,0 +1,31 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, non_struct_item_inputs};
+
+// ============================================
+// Snapshot Test: Upgradeable Code Generation
+// ============================================
+
+#[test]
+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);
+}
+
+// ============================================
+// Error Cases: upgradeable macro non-struct input
+// ============================================
+
+#[test]
+fn test_upgradeable_rejects_non_struct_inputs() {
+    for (case, input) in non_struct_item_inputs() {
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::upgradeable::generate_upgradeable_impl(input.clone());
+        });
+    }
+}

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

@@ -1,80 +1,35 @@
-//! Default implementation macro for Stellar smart contracts.
-//!
-//! Generates a complete contract setup with:
-//! - `#[contract]` attribute
-//! - Ownable trait implementation
-//! - TtlConfigurable trait implementation with owner auth checks
+//! 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.
+/// Generates the `TtlConfigurable` trait implementation for a contract.
 ///
-/// The implementation delegates to `DefaultTtlConfigurable` and adds
-/// owner authentication checks for mutating functions.
+/// This macro implements `TtlConfigurable` using the trait's default methods (which include auth).
+///
+/// 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 expanded = quote! {
-        use utils::ttl::TtlConfigurable as _;
-
-        #[common_macros::contract_impl]
-        impl utils::ttl::TtlConfigurable for #name {
-
-            #[common_macros::only_owner]
-            fn set_ttl_configs(
-                env: &soroban_sdk::Env,
-                instance: &Option<utils::ttl::TtlConfig>,
-                persistent: &Option<utils::ttl::TtlConfig>,
-            ) {
-                utils::ttl::DefaultTtlConfigurable::set_ttl_configs(env, instance, persistent);
-            }
-
-            fn ttl_configs(
-                env: &soroban_sdk::Env,
-            ) -> (
-                Option<utils::ttl::TtlConfig>,
-                Option<utils::ttl::TtlConfig>,
-            ) {
-                utils::ttl::DefaultTtlConfigurable::ttl_configs(env)
-            }
+    quote! {
+        #item_struct
 
-            #[common_macros::only_owner]
-            fn freeze_ttl_configs(env: &soroban_sdk::Env) {
-                utils::ttl::DefaultTtlConfigurable::freeze_ttl_configs(env);
-            }
+        use utils::ttl_configurable::TtlConfigurable as _;
 
-            fn is_ttl_configs_frozen(env: &soroban_sdk::Env) -> bool {
-                utils::ttl::DefaultTtlConfigurable::is_ttl_configs_frozen(env)
-            }
-        }
-    };
+        #[doc(hidden)]
+        mod #impl_mod {
+            use super::*;
+            use utils::ttl_configurable::{TtlConfig, TtlConfigurable};
 
-    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);
-            }
+            #[common_macros::contract_impl(contracttrait)]
+            impl TtlConfigurable for #name {}
         }
-    };
-
-    quote! {
-        #[common_macros::ownable]
-        #item_struct
-
-        #expanded
-        #inherent_impl
     }
 }

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

@@ -0,0 +1,76 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::ItemStruct;
+
+/// Generates the upgradeable implementation from the `#[upgradeable]` attribute macro.
+///
+/// This function generates the implementation of the `Upgradeable` trait for a
+/// given contract type, enabling the contract to be upgraded by replacing its
+/// WASM bytecode with migration support.
+///
+/// # Behavior
+///
+/// - 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 `Auth` and `UpgradeableInternal` traits.
+///
+/// # Example
+/// ```ignore
+/// #[ownable]  // or implement Multisig for self-owning contracts
+/// #[upgradeable]
+/// 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));
+    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)
+            }
+        }
+    };
+
+    quote! {
+        #item_struct
+        #upgradeable_impl
+    }
+}
+
+/// Sets the value of the environment variable `CARGO_PKG_VERSION` as `binver`
+/// in the wasm binary metadata. This env variable corresponds to the attribute
+/// "version" in Cargo.toml. If the attribute is missing or if it is "0.0.0",
+/// the function does nothing.
+fn set_binver_from_env() -> TokenStream {
+    // However when "version" is missing from Cargo.toml,
+    // the following does not return error, but Ok("0.0.0")
+    let version = std::env::var("CARGO_PKG_VERSION");
+
+    match version {
+        Ok(v) if v != "0.0.0" => {
+            quote! { soroban_sdk::contractmeta!(key = "binver", val = #v); }
+        }
+        _ => quote! {},
+    }
+}

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,27 +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, 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]
+#[lz_contract]
 pub struct EndpointV2;
 
 #[contract_impl]
@@ -36,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);
     }
@@ -50,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);
@@ -66,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);
@@ -146,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.
@@ -257,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 {
@@ -270,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
@@ -278,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 {
@@ -297,9 +300,28 @@ impl EndpointV2 {
 }
 
 // ============================================================================
-// Include Modules
+// Test-only Functions
 // ============================================================================
 
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    impl EndpointV2 {
+        /// Test-only wrapper for build_outbound_packet to enable testing.
+        pub fn build_outbound_packet_for_test(
+            env: &Env,
+            sender: &Address,
+            dst_eid: u32,
+            receiver: &BytesN<32>,
+            message: &Bytes,
+            nonce: u64,
+        ) -> OutboundPacket {
+            Self::build_outbound_packet(env, sender, dst_eid, receiver, message, nonce)
+        }
+    }
+}
+
 #[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 {