@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -61,10 +61,9 @@ impl Parse for UpgradeableConfig {
 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 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();
 
     // Generate default UpgradeableInternal impl only when no_migration is set
@@ -109,3 +108,22 @@ fn set_binver_from_env() -> TokenStream {
         _ => quote! {},
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::env;
+
+    use super::*;
+
+    #[test]
+    fn test_set_binver_from_env_zero_version() {
+        // Set version to 0.0.0
+        env::set_var("CARGO_PKG_VERSION", "0.0.0");
+
+        let result = set_binver_from_env();
+        let result_str = result.to_string();
+
+        // Should return empty tokens
+        assert_eq!(result_str.trim(), "");
+    }
+}

package/contracts/endpoint-v2/Cargo.toml

@@ -12,10 +12,6 @@ doctest = false
 [features]
 library = []
 testutils = []
-# Network selection
-mainnet = []
-testnet = []
-sandbox = []
 
 [dependencies]
 cfg-if = { workspace = true }

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

@@ -1,5 +1,4 @@
 use crate::{
-    constants::{NATIVE_TOKEN, STELLAR_EID},
     errors::EndpointError,
     events::{DelegateSet, LzReceiveAlert, PacketDelivered, PacketSent, PacketVerified, ZroSet},
     interfaces::{ILayerZeroEndpointV2, IMessageLibManager, IMessagingChannel, MessagingFee, MessagingReceipt, Origin},
@@ -17,8 +16,10 @@ pub struct EndpointV2;
 
 #[contract_impl]
 impl EndpointV2 {
-    pub fn __constructor(env: &Env, owner: &Address) {
+    pub fn __constructor(env: &Env, owner: &Address, eid: u32, native_token: &Address) {
         Self::init_owner(env, owner);
+        EndpointStorage::set_eid(env, &eid);
+        EndpointStorage::set_native_token(env, native_token);
     }
 
     /// Recovers tokens sent to this contract by mistake.
@@ -49,7 +50,10 @@ impl ILayerZeroEndpointV2 for EndpointV2 {
         let nonce = Self::outbound_nonce(env, sender, *dst_eid, receiver) + 1;
         let packet = Self::build_outbound_packet(env, sender, *dst_eid, receiver, message, nonce);
 
-        SendLibClient::new(env, &send_lib).quote(&packet, options, pay_in_zro)
+        let fee = SendLibClient::new(env, &send_lib).quote(&packet, options, pay_in_zro);
+        assert_with_error!(env, fee.native_fee >= 0 && fee.zro_fee >= 0, EndpointError::InvalidFeeAmount);
+
+        fee
     }
 
     /// Sends a cross-chain message to a destination endpoint.
@@ -155,8 +159,8 @@ impl ILayerZeroEndpointV2 for EndpointV2 {
     // ============================================================================================
 
     /// Returns the endpoint ID.
-    fn eid(_env: &Env) -> u32 {
-        STELLAR_EID
+    fn eid(env: &Env) -> u32 {
+        EndpointStorage::eid(env).unwrap()
     }
 
     /// Checks if a messaging path can be/has been initialized for the given origin and receiver.
@@ -174,7 +178,7 @@ impl ILayerZeroEndpointV2 for EndpointV2 {
 
     /// Returns the native token address used for fee payments.
     fn native_token(env: &Env) -> Address {
-        Address::from_str(env, NATIVE_TOKEN)
+        EndpointStorage::native_token(env).unwrap()
     }
 
     /// Returns the ZRO token address if set.
@@ -216,7 +220,7 @@ impl EndpointV2 {
     }
 
     /// Requires authorization from either the OApp itself or its delegate.
-    pub(crate) fn require_oapp_auth(env: &Env, caller: &Address, oapp: &Address) {
+    fn require_oapp_auth(env: &Env, caller: &Address, oapp: &Address) {
         assert_with_error!(
             env,
             caller == oapp || Self::delegate(env, oapp).as_ref() == Some(caller),
@@ -235,7 +239,7 @@ impl EndpointV2 {
     ///
     /// # Returns
     /// The total `MessagingFee` paid (native_fee + zro_fee)
-    pub(crate) fn pay_messaging_fees(
+    fn pay_messaging_fees(
         env: &Env,
         pay_in_zro: bool,
         native_fee_recipients: &Vec<FeeRecipient>,
@@ -255,9 +259,9 @@ impl EndpointV2 {
             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;
+                native_token_client.transfer(&this_contract, &r.to, &r.amount);
             }
         });
         // Refund remaining native fees
@@ -284,9 +288,9 @@ impl EndpointV2 {
                 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;
+                    zro_client.transfer(&this_contract, &r.to, &r.amount);
                 }
             });
             // Refund remaining ZRO fees
@@ -299,6 +303,13 @@ impl EndpointV2 {
     }
 }
 
+#[path = "message_lib_manager.rs"]
+mod message_lib_manager;
+#[path = "messaging_channel.rs"]
+mod messaging_channel;
+#[path = "messaging_composer.rs"]
+mod messaging_composer;
+
 // ============================================================================
 // Test-only Functions
 // ============================================================================
@@ -319,12 +330,21 @@ mod test {
         ) -> OutboundPacket {
             Self::build_outbound_packet(env, sender, dst_eid, receiver, message, nonce)
         }
+
+        /// Test-only wrapper for require_oapp_auth.
+        pub fn require_oapp_auth_for_test(env: &Env, caller: &Address, oapp: &Address) {
+            Self::require_oapp_auth(env, caller, oapp)
+        }
+
+        /// Test-only wrapper for pay_messaging_fees.
+        pub fn pay_messaging_fees_for_test(
+            env: &Env,
+            pay_in_zro: bool,
+            native_fee_recipients: &Vec<FeeRecipient>,
+            zro_fee_recipients: &Vec<FeeRecipient>,
+            refund_address: &Address,
+        ) -> MessagingFee {
+            Self::pay_messaging_fees(env, pay_in_zro, native_fee_recipients, zro_fee_recipients, refund_address)
+        }
     }
 }
-
-#[path = "message_lib_manager.rs"]
-mod message_lib_manager;
-#[path = "messaging_channel.rs"]
-mod messaging_channel;
-#[path = "messaging_composer.rs"]
-mod messaging_composer;

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

@@ -2,29 +2,54 @@ use common_macros::contract_error;
 
 #[contract_error]
 pub enum EndpointError {
+    /// Library is already registered with the endpoint
     AlreadyRegistered,
+    /// Compose message already exists for this GUID and index
     ComposeExists,
+    /// Compose message not found for the given GUID and index
     ComposeNotFound,
+    /// Default receive library is not set for the source endpoint
     DefaultReceiveLibUnavailable,
+    /// Default send library is not set for the destination endpoint
     DefaultSendLibUnavailable,
+    /// Supplied native token fee is less than required
     InsufficientNativeFee,
+    /// Supplied ZRO token fee is less than required
     InsufficientZroFee,
-    InvalidFeeAmount,
+    /// Timeout expiry is invalid (already expired)
     InvalidExpiry,
+    /// Fee amount is invalid (negative)
+    InvalidFeeAmount,
+    /// Compose index exceeds maximum allowed value
     InvalidIndex,
+    /// Nonce is invalid for the requested operation
     InvalidNonce,
+    /// Payload hash is invalid (empty hash not allowed)
     InvalidPayloadHash,
+    /// Receive library is not valid for the receiver and source endpoint
     InvalidReceiveLibrary,
+    /// Operation requires a non-default (custom) library
     OnlyNonDefaultLib,
+    /// Library must support receiving messages
     OnlyReceiveLib,
+    /// Library must be registered with the endpoint
     OnlyRegisteredLib,
+    /// Library must support sending messages
     OnlySendLib,
+    /// Messaging path cannot be initialized for the given origin
     PathNotInitializable,
+    /// Message cannot be verified for the given origin
     PathNotVerifiable,
+    /// Payload hash does not match the stored hash
     PayloadHashNotFound,
+    /// New value is the same as existing value
     SameValue,
+    /// Caller is not authorized (not OApp or delegate)
     Unauthorized,
+    /// Endpoint ID is not supported by the library
     UnsupportedEid,
+    /// ZRO fee must be greater than zero when pay_in_zro is true
     ZeroZroFee,
+    /// ZRO token address is not set
     ZroUnavailable,
 }

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

@@ -122,7 +122,7 @@ pub trait ILayerZeroEndpointV2: IMessageLibManager + IMessagingChannel + IMessag
     /// * `origin` - The origin of the message
     /// * `receiver` - The OApp address
     /// * `guid` - The message GUID
-    /// * `gas` - The gas provided for execution
+    /// * `gas` - The fee provided for execution (named "gas" for cross-chain interface consistency, though Stellar uses fees not gas)
     /// * `value` - The value provided for execution
     /// * `message` - The message content
     /// * `extra_data` - Additional data for execution

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

@@ -4,9 +4,9 @@ use soroban_sdk::{contractclient, contracttype, Address, Bytes, Env, Vec};
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Timeout {
-    /// The new library address to transition to.
+    /// The old library address that remains valid during the grace period.
     pub lib: Address,
-    /// Unix timestamp when the timeout expires.
+    /// Unix timestamp in seconds when the timeout expires.
     pub expiry: u64,
 }
 
@@ -144,7 +144,7 @@ pub trait IMessageLibManager {
     ///
     /// # Arguments
     /// * `caller` - The caller address, must be the OApp or its delegate
-    /// * `sender` - The receiver OApp address
+    /// * `sender` - The sender OApp address
     /// * `dst_eid` - The destination endpoint ID
     /// * `new_lib` - The library address, or `None` to use the default
     fn set_send_library(env: &Env, caller: &Address, sender: &Address, dst_eid: u32, new_lib: &Option<Address>);
@@ -152,7 +152,7 @@ pub trait IMessageLibManager {
     /// Returns the effective send library for an OApp and destination endpoint.
     ///
     /// # Arguments
-    /// * `sender` - The receiver OApp address
+    /// * `sender` - The sender OApp address
     /// * `dst_eid` - The destination endpoint ID
     fn get_send_library(env: &Env, sender: &Address, dst_eid: u32) -> ResolvedLibrary;
 

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

@@ -33,7 +33,7 @@ pub trait IMessagingComposer {
     /// * `to` - The composer address
     /// * `guid` - The message GUID
     /// * `index` - The compose message index
-    /// * `gas` - The gas provided for execution
+    /// * `gas` - The fee provided for execution (named "gas" for cross-chain interface consistency, though Stellar uses fees not gas)
     /// * `value` - The value provided for execution
     /// * `message` - The composed message content
     /// * `extra_data` - Additional data for execution
@@ -45,7 +45,7 @@ pub trait IMessagingComposer {
         to: &Address,
         guid: &BytesN<32>,
         index: u32,
-        gas: i128, // TODO: should rename to fee cuz there's no gas in stellar
+        gas: i128,
         value: i128,
         message: &Bytes,
         extra_data: &Bytes,

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

@@ -1,6 +1,5 @@
 #![no_std]
 
-pub mod constants;
 pub mod events;
 pub mod util;
 

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

@@ -28,7 +28,7 @@ impl IMessageLibManager for EndpointV2 {
         let index = Self::registered_libraries_count(env);
         EndpointStorage::set_library_to_index(env, new_lib, &index);
         EndpointStorage::set_index_to_library(env, index, new_lib);
-        EndpointStorage::set_registered_library_count(env, &(index + 1)); // increment the registered library count
+        EndpointStorage::set_registered_libraries_count(env, &(index + 1)); // increment the registered library count
 
         LibraryRegistered { new_lib: new_lib.clone() }.publish(env);
     }
@@ -159,7 +159,7 @@ impl IMessageLibManager for EndpointV2 {
     ) {
         Self::require_oapp_auth(env, caller, receiver);
 
-        // Only if receive_library is set, we can set the timeout
+        // OApp can only set timeout for non-default receive libraries
         let ResolvedLibrary { lib: _, is_default } = Self::get_receive_library(env, receiver, src_eid);
         assert_with_error!(env, !is_default, EndpointError::OnlyNonDefaultLib);
 
@@ -197,12 +197,12 @@ impl IMessageLibManager for EndpointV2 {
 
     /// Returns the number of registered message libraries.
     fn registered_libraries_count(env: &Env) -> u32 {
-        EndpointStorage::registered_library_count(env)
+        EndpointStorage::registered_libraries_count(env)
     }
 
     /// Returns a list of registered message libraries within the specified range.
     fn get_registered_libraries(env: &Env, start: u32, max_count: u32) -> Vec<Address> {
-        let count = EndpointStorage::registered_library_count(env);
+        let count = EndpointStorage::registered_libraries_count(env);
         if count == 0 || start >= count {
             return vec![env];
         }
@@ -296,18 +296,18 @@ impl IMessageLibManager for EndpointV2 {
 
 impl EndpointV2 {
     /// Requires a message library to be registered.
-    pub(crate) fn require_registered(env: &Env, lib: &Address) {
+    fn require_registered(env: &Env, lib: &Address) {
         assert_with_error!(env, Self::is_registered_library(env, lib), EndpointError::OnlyRegisteredLib);
     }
 
     /// Requires an endpoint ID to be supported.
-    pub(crate) fn require_supported_eid(env: &Env, lib: &Address, eid: u32) {
+    fn require_supported_eid(env: &Env, lib: &Address, eid: u32) {
         let is_supported = MessageLibClient::new(env, lib).is_supported_eid(&eid);
         assert_with_error!(env, is_supported, EndpointError::UnsupportedEid);
     }
 
     /// Requires a library to be a registered send library and supported for the given endpoint ID.
-    pub(crate) fn require_send_lib_for_eid(env: &Env, lib: &Address, eid: u32) {
+    fn require_send_lib_for_eid(env: &Env, lib: &Address, eid: u32) {
         Self::require_registered(env, lib);
 
         let message_lib_type = MessageLibClient::new(env, lib).message_lib_type();
@@ -321,7 +321,7 @@ impl EndpointV2 {
     }
 
     /// Requires a library to be a registered receive library and supported for the given endpoint ID.
-    pub(crate) fn require_receive_lib_for_eid(env: &Env, lib: &Address, eid: u32) {
+    fn require_receive_lib_for_eid(env: &Env, lib: &Address, eid: u32) {
         Self::require_registered(env, lib);
 
         let message_lib_type = MessageLibClient::new(env, lib).message_lib_type();
@@ -334,3 +334,34 @@ impl EndpointV2 {
         Self::require_supported_eid(env, lib, eid);
     }
 }
+
+// ============================================================================
+// Test-only Functions
+// ============================================================================
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    impl EndpointV2 {
+        /// Test-only wrapper for require_registered.
+        pub fn require_registered_for_test(env: &Env, lib: &Address) {
+            Self::require_registered(env, lib)
+        }
+
+        /// Test-only wrapper for require_supported_eid.
+        pub fn require_supported_eid_for_test(env: &Env, lib: &Address, eid: u32) {
+            Self::require_supported_eid(env, lib, eid)
+        }
+
+        /// Test-only wrapper for require_send_lib_for_eid.
+        pub fn require_send_lib_for_eid_for_test(env: &Env, lib: &Address, eid: u32) {
+            Self::require_send_lib_for_eid(env, lib, eid)
+        }
+
+        /// Test-only wrapper for require_receive_lib_for_eid.
+        pub fn require_receive_lib_for_eid_for_test(env: &Env, lib: &Address, eid: u32) {
+            Self::require_receive_lib_for_eid(env, lib, eid)
+        }
+    }
+}

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

@@ -1,6 +1,5 @@
 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},
@@ -10,6 +9,12 @@ use crate::{
 use common_macros::contract_impl;
 use soroban_sdk::{assert_with_error, Address, Bytes, BytesN, Env};
 
+/// Represents an empty payload hash (equivalent to bytes32(uint256(0)) in Solidity)
+const EMPTY_PAYLOAD_HASH_BYTES: [u8; 32] = [0u8; 32];
+
+/// Represents a nilified payload hash (equivalent to bytes32(type(uint256).max) in Solidity)
+const NIL_PAYLOAD_HASH_BYTES: [u8; 32] = [0xffu8; 32];
+
 #[contract_impl]
 impl IMessagingChannel for EndpointV2 {
     /// Skips the next expected inbound nonce without verifying.
@@ -72,7 +77,7 @@ impl IMessagingChannel for EndpointV2 {
         let cur_payload_hash = Self::inbound_payload_hash(env, receiver, src_eid, sender, nonce);
         assert_with_error!(env, cur_payload_hash.as_ref() == Some(payload_hash), EndpointError::PayloadHashNotFound);
 
-        // Check if nonce is greater than lazy nonce
+        // Check if nonce is at or below the lazy nonce
         let lazy_nonce = Self::lazy_inbound_nonce(env, receiver, src_eid, sender);
         assert_with_error!(env, nonce <= lazy_nonce, EndpointError::InvalidNonce);
 
@@ -187,6 +192,12 @@ impl EndpointV2 {
     /// Note: This function does not change `inbound_nonce`, it only changes
     /// the `lazy_inbound_nonce` up to the provided nonce.
     ///
+    /// # EVM Alignment
+    /// This implementation aligns with the EVM endpoint behavior. Executors should call
+    /// `clear` from lower nonce to higher nonce sequentially. This ensures the range check
+    /// `(current_nonce + 1..=nonce)` remains small, avoiding long iteration when verifying
+    /// that all intermediate nonces have been verified.
+    ///
     /// # Arguments
     /// * `receiver` - The receiver OApp address
     /// * `src_eid` - The source endpoint ID
@@ -221,12 +232,33 @@ impl EndpointV2 {
     }
 
     /// Represents an empty payload hash
-    pub(crate) fn empty_payload_hash(env: &Env) -> BytesN<32> {
+    fn empty_payload_hash(env: &Env) -> BytesN<32> {
         BytesN::from_array(env, &EMPTY_PAYLOAD_HASH_BYTES)
     }
 
     /// Represents a nilified payload hash
-    pub(crate) fn nil_payload_hash(env: &Env) -> BytesN<32> {
+    fn nil_payload_hash(env: &Env) -> BytesN<32> {
         BytesN::from_array(env, &NIL_PAYLOAD_HASH_BYTES)
     }
 }
+
+// ============================================================================
+// Test-only Functions
+// ============================================================================
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    impl EndpointV2 {
+        /// Test-only wrapper for empty_payload_hash.
+        pub fn empty_payload_hash_for_test(env: &Env) -> BytesN<32> {
+            Self::empty_payload_hash(env)
+        }
+
+        /// Test-only wrapper for nil_payload_hash.
+        pub fn nil_payload_hash_for_test(env: &Env) -> BytesN<32> {
+            Self::nil_payload_hash(env)
+        }
+    }
+}

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

@@ -1,6 +1,5 @@
 use super::{EndpointV2, EndpointV2Args, EndpointV2Client};
 use crate::{
-    constants::{MAX_COMPOSE_INDEX, RECEIVED_MESSAGE_HASH_BYTES},
     errors::EndpointError,
     events::{ComposeDelivered, ComposeSent, LzComposeAlert},
     storage::EndpointStorage,
@@ -10,6 +9,13 @@ use crate::{
 use common_macros::contract_impl;
 use soroban_sdk::{assert_with_error, Address, Bytes, BytesN, Env};
 
+/// Represents a received message hash marker (equivalent to bytes32(uint256(1)) in Solidity)
+const RECEIVED_MESSAGE_HASH_BYTES: [u8; 32] =
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
+
+/// Represents the maximum compose index (equivalent to uint16.max in Solidity)
+const MAX_COMPOSE_INDEX: u32 = u16::MAX as u32;
+
 #[contract_impl]
 impl IMessagingComposer for EndpointV2 {
     /// Sends a composed message from an OApp to a composer.
@@ -18,7 +24,7 @@ impl IMessagingComposer for EndpointV2 {
     /// With the same GUID, the OApp can send compose to multiple composers at the same time.
     fn send_compose(env: &Env, from: &Address, to: &Address, guid: &BytesN<32>, index: u32, message: &Bytes) {
         from.require_auth();
-        assert_with_error!(env, index <= MAX_COMPOSE_INDEX, EndpointError::InvalidIndex);
+        assert_compose_index(env, index);
 
         let compose_queue = Self::compose_queue(env, from, to, guid, index);
         assert_with_error!(env, compose_queue.is_none(), EndpointError::ComposeExists);
@@ -34,12 +40,16 @@ impl IMessagingComposer for EndpointV2 {
     /// This is a PULL mode versus the PUSH mode of `lz_compose`.
     fn clear_compose(env: &Env, composer: &Address, from: &Address, guid: &BytesN<32>, index: u32, message: &Bytes) {
         composer.require_auth();
-        assert_with_error!(env, index <= MAX_COMPOSE_INDEX, EndpointError::InvalidIndex);
+        assert_compose_index(env, index);
 
         let expected_hash = Self::compose_queue(env, from, composer, guid, index);
         let actual_hash = keccak256(env, message);
         assert_with_error!(env, expected_hash == Some(actual_hash), EndpointError::ComposeNotFound);
 
+        // Marks the message as received to prevent reentrancy.
+        // Cannot just delete the value, otherwise the message can be sent again and could result
+        // in some undefined behaviour even though the sender (composing OApp) is implicitly fully
+        // trusted by the composer. e.g. sender may not even realize it has such a bug.
         let received_hash = BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES);
         EndpointStorage::set_compose_queue(env, from, composer, guid, index, &received_hash);
 
@@ -63,7 +73,7 @@ impl IMessagingComposer for EndpointV2 {
         reason: &Bytes,
     ) {
         executor.require_auth();
-        assert_with_error!(env, index <= MAX_COMPOSE_INDEX, EndpointError::InvalidIndex);
+        assert_compose_index(env, index);
         LzComposeAlert {
             executor: executor.clone(),
             from: from.clone(),
@@ -88,3 +98,7 @@ impl IMessagingComposer for EndpointV2 {
         EndpointStorage::compose_queue(env, from, to, guid, index)
     }
 }
+
+fn assert_compose_index(env: &Env, index: u32) {
+    assert_with_error!(env, index <= MAX_COMPOSE_INDEX, EndpointError::InvalidIndex);
+}

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

@@ -4,6 +4,14 @@ use soroban_sdk::{Address, BytesN};
 
 #[storage]
 pub enum EndpointStorage {
+    /// The endpoint ID for this chain
+    #[instance(u32)]
+    Eid,
+
+    /// The native token address used for messaging fee payments
+    #[instance(Address)]
+    NativeToken,
+
     /// The ZRO token address
     #[instance(Address)]
     Zro,
@@ -37,7 +45,7 @@ pub enum EndpointStorage {
     /// The number of registered libraries
     #[instance(u32)]
     #[default(0)]
-    RegisteredLibraryCount,
+    RegisteredLibrariesCount,
 
     /// The mapping of library to index
     #[persistent(u32)]

package/contracts/endpoint-v2/src/tests/endpoint_setup.rs

@@ -40,9 +40,9 @@ pub fn setup<'a>() -> TestSetup<'a> {
     let zro_token_client = StellarAssetClient::new(&env, &zro_token_address);
 
     // Deploy the endpoint contract
-    let contract_id = env.register(EndpointV2, (&owner,));
+    let eid: u32 = 30400; // Test EID
+    let contract_id = env.register(EndpointV2, (&owner, eid, &native_token_address));
     let endpoint_client = EndpointV2Client::new(&env, &contract_id);
-    let eid = endpoint_client.eid();
 
     TestSetup { eid, endpoint_client, env, owner, contract_id, native_token_client, zro_token_client }
 }

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

@@ -23,7 +23,7 @@ fn pay_messaging_fees(
     let env = &context.env;
     let endpoint_addr = &context.endpoint_client.address;
     env.as_contract(endpoint_addr, || {
-        EndpointV2::pay_messaging_fees(env, pay_in_zro, native_fee_recipients, zro_fee_recipients, refund_address)
+        EndpointV2::pay_messaging_fees_for_test(env, pay_in_zro, native_fee_recipients, zro_fee_recipients, refund_address)
     })
 }
 

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

@@ -30,7 +30,7 @@ fn test_require_oapp_auth_unauthorized() {
 
     // Unauthorized address (not oapp itself and not delegate) should fail with Unauthorized error
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::require_oapp_auth(env, &unauthorized, &oapp);
+        EndpointV2::require_oapp_auth_for_test(env, &unauthorized, &oapp);
     });
 }
 
@@ -51,6 +51,6 @@ fn test_require_oapp_auth_wrong_delegate() {
 
     // Wrong delegate (not the actual delegate) should fail with Unauthorized error
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::require_oapp_auth(env, &wrong_delegate, &oapp);
+        EndpointV2::require_oapp_auth_for_test(env, &wrong_delegate, &oapp);
     });
 }

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

@@ -45,7 +45,7 @@ fn test_register_library() {
         let stored_lib = storage::EndpointStorage::index_to_library(env, 0);
         assert_eq!(stored_lib, Some(lib_clone.clone()));
 
-        let new_count = storage::EndpointStorage::registered_library_count(env);
+        let new_count = storage::EndpointStorage::registered_libraries_count(env);
         assert_eq!(new_count, 1);
 
         let has_library = storage::EndpointStorage::has_library_to_index(env, &lib_clone);
@@ -90,7 +90,7 @@ fn test_register_library_is_unsupported_interface() {
 
     // Verify no partial storage updates.
     env.as_contract(&endpoint_client.address, || {
-        assert_eq!(storage::EndpointStorage::registered_library_count(env), 0);
+        assert_eq!(storage::EndpointStorage::registered_libraries_count(env), 0);
         assert_eq!(storage::EndpointStorage::library_to_index(env, &invalid_lib), None);
         assert!(!storage::EndpointStorage::has_library_to_index(env, &invalid_lib));
     });
@@ -144,7 +144,7 @@ fn test_register_multiple_libraries_assigns_sequential_indices_and_orders_result
     let lib0c = lib0.clone();
     let lib1c = lib1.clone();
     env.as_contract(&endpoint_client.address, || {
-        assert_eq!(storage::EndpointStorage::registered_library_count(env), 2);
+        assert_eq!(storage::EndpointStorage::registered_libraries_count(env), 2);
         assert_eq!(storage::EndpointStorage::library_to_index(env, &lib0c), Some(0));
         assert_eq!(storage::EndpointStorage::library_to_index(env, &lib1c), Some(1));
         assert_eq!(storage::EndpointStorage::index_to_library(env, 0), Some(lib0c));