@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,17 @@
+mod layerzero_composer;
+mod layerzero_endpoint_v2;
+mod layerzero_receiver;
+mod message_lib;
+mod message_lib_manager;
+mod messaging_channel;
+mod messaging_composer;
+mod send_lib;
+
+pub use layerzero_composer::*;
+pub use layerzero_endpoint_v2::*;
+pub use layerzero_receiver::*;
+pub use message_lib::*;
+pub use message_lib_manager::*;
+pub use messaging_channel::*;
+pub use messaging_composer::*;
+pub use send_lib::*;

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

@@ -0,0 +1,70 @@
+use super::{IMessageLib, MessagingFee};
+use soroban_sdk::{contractclient, contracttype, Address, Bytes, BytesN, Env, Vec};
+
+/// Outbound packet containing all information for cross-chain transmission.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct OutboundPacket {
+    /// Outbound nonce for this pathway.
+    pub nonce: u64,
+    /// Source endpoint ID.
+    pub src_eid: u32,
+    /// Sender address on source chain.
+    pub sender: Address,
+    /// Destination endpoint ID.
+    pub dst_eid: u32,
+    /// Receiver address on destination chain (32 bytes).
+    pub receiver: BytesN<32>,
+    /// Globally unique identifier for this message.
+    pub guid: BytesN<32>,
+    /// The message payload.
+    pub message: Bytes,
+}
+
+/// A fee recipient with the amount to be paid.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FeeRecipient {
+    /// Address to receive the fee.
+    pub address: Address,
+    /// Amount of fee to pay.
+    pub amount: i128,
+}
+
+/// Result of send operation containing fees and encoded packet.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FeesAndPacket {
+    /// List of native token fee recipients (executor, DVNs, treasury).
+    pub native_fee_recipients: Vec<FeeRecipient>,
+    /// List of ZRO token fee recipients (treasury).
+    pub zro_fee_recipients: Vec<FeeRecipient>,
+    /// The encoded packet ready for transmission.
+    pub encoded_packet: Bytes,
+}
+
+/// Interface for send libraries that handle outbound message encoding and fee calculation.
+#[contractclient(name = "SendLibClient")]
+pub trait ISendLib: IMessageLib {
+    /// Quotes the fee for sending a packet without actually sending.
+    ///
+    /// # Arguments
+    /// * `packet` - The outbound packet containing message metadata and content
+    /// * `options` - Execution options (e.g., gas limit, airdrop amount)
+    /// * `pay_in_zro` - Whether to pay fees in ZRO token
+    ///
+    /// # Returns
+    /// `MessagingFee` containing estimated native and ZRO fees
+    fn quote(env: &Env, packet: &OutboundPacket, options: &Bytes, pay_in_zro: bool) -> MessagingFee;
+
+    /// Sends a packet through the message library.
+    ///
+    /// # Arguments
+    /// * `packet` - The outbound packet containing message metadata and content
+    /// * `options` - Execution options (e.g., gas limit, airdrop amount)
+    /// * `pay_in_zro` - Whether to pay fees in ZRO token
+    ///
+    /// # Returns
+    /// `FeesAndPacket` containing fee recipients and the encoded packet
+    fn send(env: &Env, packet: &OutboundPacket, options: &Bytes, pay_in_zro: bool) -> FeesAndPacket;
+}

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

@@ -0,0 +1,22 @@
+#![no_std]
+
+mod interfaces;
+
+pub use interfaces::*;
+pub mod util;
+
+cfg_if::cfg_if! {
+    // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)
+    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
+        mod endpoint_v2;
+        mod errors;
+        mod events;
+        mod storage;
+        mod constants;
+
+        pub use endpoint_v2::{EndpointV2, EndpointV2Client};
+    }
+}
+
+#[cfg(test)]
+mod tests;

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

@@ -0,0 +1,315 @@
+#[contractimpl]
+impl IMessageLibManager for EndpointV2 {
+    /// Registers a new message library with the endpoint.
+    #[only_owner]
+    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();
+
+        // Check if the library is already registered
+        assert_with_error!(&env, !Self::is_registered_library(env, new_lib), EndpointError::AlreadyRegistered);
+
+        // Register the library
+        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
+
+        LibraryRegistered { new_lib: new_lib.clone() }.publish(env);
+    }
+
+    /// Sets the default send library for a destination endpoint.
+    #[only_owner]
+    fn set_default_send_library(env: &Env, dst_eid: u32, new_lib: &Address) {
+        Self::require_send_lib_for_eid(env, new_lib, dst_eid);
+
+        let old_lib = Self::default_send_library(env, dst_eid);
+        assert_with_error!(env, old_lib.as_ref() != Some(new_lib), EndpointError::SameValue);
+
+        EndpointStorage::set_default_send_library(env, dst_eid, new_lib);
+        DefaultSendLibrarySet { dst_eid, new_lib: new_lib.clone() }.publish(env);
+    }
+
+    /// Sets the default receive library for a source endpoint.
+    ///
+    /// If a grace period is provided and there was a previous library, the old library
+    /// remains valid until the grace period expires.
+    #[only_owner]
+    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);
+
+        let old_lib = Self::default_receive_library(env, src_eid);
+        assert_with_error!(env, old_lib.as_ref() != Some(new_lib), EndpointError::SameValue);
+
+        EndpointStorage::set_default_receive_library(env, src_eid, new_lib);
+        DefaultReceiveLibrarySet { src_eid, new_lib: new_lib.clone() }.publish(env);
+
+        // Set timeout based on grace period and old library
+        let timeout = if grace_period > 0 {
+            old_lib.map(|lib| {
+                let expiry = env.ledger().timestamp() + grace_period;
+                Timeout { lib, expiry }
+            })
+        } else {
+            None
+        };
+        EndpointStorage::set_or_remove_default_receive_library_timeout(env, src_eid, &timeout);
+        DefaultReceiveLibraryTimeoutSet { src_eid, timeout: timeout.clone() }.publish(env);
+    }
+
+    /// Sets or removes the default receive library timeout for a source endpoint.
+    ///
+    /// 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]
+    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);
+            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);
+    }
+
+    // === OApp Control Functions ===
+
+    /// Sets or removes a custom send library for an OApp to a specific destination endpoint.
+    fn set_send_library(env: &Env, caller: &Address, sender: &Address, dst_eid: u32, new_lib: &Option<Address>) {
+        Self::require_oapp_auth(env, caller, sender);
+
+        let old_lib = EndpointStorage::send_library(env, sender, dst_eid);
+        assert_with_error!(env, &old_lib != new_lib, EndpointError::SameValue);
+
+        if let Some(lib) = new_lib {
+            Self::require_send_lib_for_eid(env, lib, dst_eid);
+        }
+        EndpointStorage::set_or_remove_send_library(env, sender, dst_eid, new_lib);
+        SendLibrarySet { sender: sender.clone(), dst_eid, new_lib: new_lib.clone() }.publish(env);
+    }
+
+    /// Sets or removes a custom receive library for an OApp to a specific source endpoint.
+    ///
+    /// If a grace period is provided and there was a previous library, the old library
+    /// remains valid until the grace period expires.
+    fn set_receive_library(
+        env: &Env,
+        caller: &Address,
+        receiver: &Address,
+        src_eid: u32,
+        new_lib: &Option<Address>,
+        grace_period: u64,
+    ) {
+        Self::require_oapp_auth(env, caller, receiver);
+
+        let old_lib = EndpointStorage::receive_library(env, receiver, src_eid);
+        assert_with_error!(env, &old_lib != new_lib, EndpointError::SameValue);
+
+        if let Some(lib) = new_lib {
+            Self::require_receive_lib_for_eid(env, lib, src_eid);
+        }
+        EndpointStorage::set_or_remove_receive_library(env, receiver, src_eid, new_lib);
+        ReceiveLibrarySet { receiver: receiver.clone(), src_eid, new_lib: new_lib.clone() }.publish(env);
+
+        // Set timeout based on grace period and library availability
+        let timeout = if grace_period > 0 {
+            // To simplify timeout logic, we only allow setting timeout when both old and new libraries are custom (non-default).
+            // This avoids complex interactions with default library timeout configurations.
+            //
+            // For other scenarios:
+            // (1) To fall back to default library: set new_lib to None with grace_period = 0
+            // (2) To change from default to custom library: set new_lib to custom with grace_period = 0,
+            //     then use set_receive_library_timeout() to configure timeout separately if needed
+            assert_with_error!(env, old_lib.is_some() && new_lib.is_some(), EndpointError::OnlyNonDefaultLib);
+            Some(Timeout { lib: old_lib.unwrap(), expiry: env.ledger().timestamp() + grace_period })
+        } else {
+            None
+        };
+
+        EndpointStorage::set_or_remove_receive_library_timeout(env, receiver, src_eid, &timeout);
+        ReceiveLibraryTimeoutSet { receiver: receiver.clone(), eid: src_eid, timeout }.publish(env);
+    }
+
+    /// Sets or removes the custom receive library timeout for an OApp.
+    ///
+    /// Allows an OApp to extend or remove the validity period of a previously set library
+    /// after switching to a new one.
+    fn set_receive_library_timeout(
+        env: &Env,
+        caller: &Address,
+        receiver: &Address,
+        src_eid: u32,
+        timeout: &Option<Timeout>,
+    ) {
+        Self::require_oapp_auth(env, caller, receiver);
+
+        // Only if receive_library is set, we can set the timeout
+        let ResolvedLibrary { lib: _, is_default } = Self::get_receive_library(env, receiver, src_eid);
+        assert_with_error!(env, !is_default, EndpointError::OnlyNonDefaultLib);
+
+        if let Some(t) = timeout {
+            Self::require_receive_lib_for_eid(env, &t.lib, src_eid);
+            assert_with_error!(env, !t.is_expired(env), EndpointError::InvalidExpiry);
+        }
+        EndpointStorage::set_or_remove_receive_library_timeout(env, receiver, src_eid, timeout);
+        ReceiveLibraryTimeoutSet { receiver: receiver.clone(), eid: src_eid, timeout: timeout.clone() }.publish(env);
+    }
+
+    /// Sets the configuration for a message library.
+    ///
+    /// Requires the caller to be the OApp or its delegate and the library to be registered.
+    fn set_config(env: &Env, caller: &Address, oapp: &Address, lib: &Address, params: &Vec<SetConfigParam>) {
+        Self::require_oapp_auth(env, caller, oapp);
+        Self::require_registered(env, lib);
+
+        MessageLibClient::new(env, lib).set_config(oapp, params);
+    }
+
+    // === View Functions ===
+
+    /// Checks if a message library is registered.
+    fn is_registered_library(env: &Env, lib: &Address) -> bool {
+        EndpointStorage::has_library_to_index(env, lib)
+    }
+
+    /// Returns the index of a message library.
+    fn get_library_index(env: &Env, lib: &Address) -> Option<u32> {
+        EndpointStorage::library_to_index(env, lib)
+    }
+
+    /// Returns the number of registered message libraries.
+    fn registered_libraries_count(env: &Env) -> u32 {
+        EndpointStorage::registered_library_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);
+        if count == 0 || start >= count {
+            return vec![env];
+        }
+
+        let end = count.min(start + max_count);
+        let mut libraries = vec![env];
+        libraries.extend((start..end).map(|i| EndpointStorage::index_to_library(env, i).unwrap()));
+        libraries
+    }
+
+    /// Checks if an endpoint ID is supported.
+    /// Returns true only if both the default send/receive libraries are set for the given eid
+    fn is_supported_eid(env: &Env, eid: u32) -> bool {
+        EndpointStorage::has_default_send_library(env, eid) && EndpointStorage::has_default_receive_library(env, eid)
+    }
+
+    /// Returns the default send library for a destination endpoint.
+    fn default_send_library(env: &Env, dst_eid: u32) -> Option<Address> {
+        EndpointStorage::default_send_library(env, dst_eid)
+    }
+
+    /// Returns the default receive library for a source endpoint.
+    fn default_receive_library(env: &Env, src_eid: u32) -> Option<Address> {
+        EndpointStorage::default_receive_library(env, src_eid)
+    }
+
+    /// Returns the default receive library timeout for a source endpoint.
+    fn default_receive_library_timeout(env: &Env, src_eid: u32) -> Option<Timeout> {
+        EndpointStorage::default_receive_library_timeout(env, src_eid)
+    }
+
+    // === OApp View Functions ===
+
+    /// Returns the effective send library for an OApp and destination endpoint.
+    fn get_send_library(env: &Env, sender: &Address, dst_eid: u32) -> ResolvedLibrary {
+        EndpointStorage::send_library(env, sender, dst_eid)
+            .map(|lib| ResolvedLibrary { lib, is_default: false })
+            .unwrap_or_else(|| {
+                let default_lib = EndpointStorage::default_send_library(env, dst_eid)
+                    .unwrap_or_panic(env, EndpointError::DefaultSendLibUnavailable);
+                ResolvedLibrary { lib: default_lib, is_default: true }
+            })
+    }
+
+    /// Returns the effective receive library for an OApp and source endpoint.
+    fn get_receive_library(env: &Env, receiver: &Address, src_eid: u32) -> ResolvedLibrary {
+        EndpointStorage::receive_library(env, receiver, src_eid)
+            .map(|lib| ResolvedLibrary { lib, is_default: false })
+            .unwrap_or_else(|| {
+                let default_lib = EndpointStorage::default_receive_library(env, src_eid)
+                    .unwrap_or_panic(env, EndpointError::DefaultReceiveLibUnavailable);
+                ResolvedLibrary { lib: default_lib, is_default: true }
+            })
+    }
+
+    /// Returns the receive library timeout for an OApp and source endpoint.
+    fn receive_library_timeout(env: &Env, receiver: &Address, src_eid: u32) -> Option<Timeout> {
+        EndpointStorage::receive_library_timeout(env, receiver, src_eid)
+    }
+
+    /// Checks if a receive library is valid for an OApp and source endpoint.
+    fn is_valid_receive_library(env: &Env, receiver: &Address, src_eid: u32, actual_lib: &Address) -> bool {
+        // early return true if the lib is the currently configured one
+        let ResolvedLibrary { lib: expected_lib, is_default } = Self::get_receive_library(env, receiver, src_eid);
+        if actual_lib == &expected_lib {
+            return true;
+        }
+
+        // Check if the actual_lib matches a timeout library that hasn't expired
+        let timeout = if is_default {
+            Self::default_receive_library_timeout(env, src_eid)
+        } else {
+            Self::receive_library_timeout(env, receiver, src_eid)
+        };
+
+        timeout.is_some_and(|t| t.is_valid_for(env, actual_lib))
+    }
+
+    /// Returns the configuration for a message library for a specific endpoint ID and configuration type.
+    fn get_config(env: &Env, oapp: &Address, lib: &Address, eid: u32, config_type: u32) -> Bytes {
+        Self::require_registered(env, lib);
+        MessageLibClient::new(env, lib).get_config(&eid, oapp, &config_type)
+    }
+}
+
+// ============================================================================
+// Internal Functions
+// ============================================================================
+
+impl EndpointV2 {
+    /// Requires a message library to be registered.
+    pub(crate) 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) {
+        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) {
+        Self::require_registered(env, lib);
+
+        let message_lib_type = MessageLibClient::new(env, lib).message_lib_type();
+        assert_with_error!(
+            env,
+            message_lib_type == MessageLibType::Send || message_lib_type == MessageLibType::SendAndReceive,
+            EndpointError::OnlySendLib
+        );
+
+        Self::require_supported_eid(env, lib, eid);
+    }
+
+    /// 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) {
+        Self::require_registered(env, lib);
+
+        let message_lib_type = MessageLibClient::new(env, lib).message_lib_type();
+        assert_with_error!(
+            env,
+            message_lib_type == MessageLibType::Receive || message_lib_type == MessageLibType::SendAndReceive,
+            EndpointError::OnlyReceiveLib
+        );
+
+        Self::require_supported_eid(env, lib, eid);
+    }
+}

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

@@ -0,0 +1,218 @@
+#[contractimpl]
+impl IMessagingChannel for EndpointV2 {
+    /// Skips the next expected inbound nonce without verifying.
+    ///
+    /// The nonce to skip must be the next expected nonce.
+    fn skip(env: &Env, caller: &Address, receiver: &Address, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
+        Self::require_oapp_auth(env, caller, receiver);
+
+        let next_nonce = Self::inbound_nonce(env, receiver, src_eid, sender) + 1;
+        assert_with_error!(env, nonce == next_nonce, EndpointError::InvalidNonce);
+        EndpointStorage::set_lazy_inbound_nonce(env, receiver, src_eid, sender, &nonce);
+
+        InboundNonceSkipped { src_eid, sender: sender.clone(), receiver: receiver.clone(), nonce }.publish(env);
+    }
+
+    /// Marks a packet as verified, but disallows execution until it is re-verified.
+    ///
+    /// Requires the payload hash not been executed.
+    fn nilify(
+        env: &Env,
+        caller: &Address,
+        receiver: &Address,
+        src_eid: u32,
+        sender: &BytesN<32>,
+        nonce: u64,
+        payload_hash: &Option<BytesN<32>>,
+    ) {
+        Self::require_oapp_auth(env, caller, receiver);
+
+        let cur_payload_hash = Self::inbound_payload_hash(env, receiver, src_eid, sender, nonce);
+        let lazy_nonce = Self::lazy_inbound_nonce(env, receiver, src_eid, sender);
+
+        assert_with_error!(env, payload_hash == &cur_payload_hash, EndpointError::PayloadHashNotFound);
+        assert_with_error!(env, nonce > lazy_nonce || cur_payload_hash.is_some(), EndpointError::InvalidNonce);
+        EndpointStorage::set_inbound_payload_hash(env, receiver, src_eid, sender, nonce, &Self::nil_payload_hash(env));
+
+        PacketNilified {
+            src_eid,
+            sender: sender.clone(),
+            receiver: receiver.clone(),
+            nonce,
+            payload_hash: payload_hash.clone(),
+        }
+        .publish(env);
+    }
+
+    /// Marks a nonce as unexecutable and un-verifiable. The nonce can never be re-verified or executed.
+    fn burn(
+        env: &Env,
+        caller: &Address,
+        receiver: &Address,
+        src_eid: u32,
+        sender: &BytesN<32>,
+        nonce: u64,
+        payload_hash: &BytesN<32>,
+    ) {
+        Self::require_oapp_auth(env, caller, receiver);
+
+        // Check if current payload hash matches the provided payload hash
+        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
+        let lazy_nonce = Self::lazy_inbound_nonce(env, receiver, src_eid, sender);
+        assert_with_error!(env, nonce <= lazy_nonce, EndpointError::InvalidNonce);
+
+        // Remove the payload hash from storage
+        EndpointStorage::remove_inbound_payload_hash(env, receiver, src_eid, sender, nonce);
+
+        PacketBurnt {
+            src_eid,
+            sender: sender.clone(),
+            receiver: receiver.clone(),
+            nonce,
+            payload_hash: payload_hash.clone(),
+        }
+        .publish(env);
+    }
+
+    // === View Functions ===
+
+    /// Generates the next GUID for an outbound packet.
+    fn next_guid(env: &Env, sender: &Address, dst_eid: u32, receiver: &BytesN<32>) -> BytesN<32> {
+        let next_nonce = Self::outbound_nonce(env, sender, dst_eid, receiver) + 1;
+        compute_guid(env, next_nonce, Self::eid(env), sender, dst_eid, receiver)
+    }
+
+    /// Returns the current outbound nonce for a specific destination.
+    fn outbound_nonce(env: &Env, sender: &Address, dst_eid: u32, receiver: &BytesN<32>) -> u64 {
+        EndpointStorage::outbound_nonce(env, sender, dst_eid, receiver)
+    }
+
+    /// Returns the max index of the longest gapless sequence of verified message nonces.
+    ///
+    /// The uninitialized value is 0. The first nonce is always 1.
+    /// It starts from the `lazy_inbound_nonce` (last checkpoint) and iteratively checks
+    /// if the next nonce has been verified.
+    ///
+    /// Note: OApp explicitly skipped nonces count as "verified" for these purposes.
+    ///
+    /// Examples: `[1,2,3,4,6,7] => 4`, `[1,2,6,8,10] => 2`, `[1,3,4,5,6] => 1`
+    fn inbound_nonce(env: &Env, receiver: &Address, src_eid: u32, sender: &BytesN<32>) -> u64 {
+        let mut nonce_cursor = Self::lazy_inbound_nonce(env, receiver, src_eid, sender);
+
+        // Find the effective inbound current nonce
+        while EndpointStorage::has_inbound_payload_hash(env, receiver, src_eid, sender, nonce_cursor + 1) {
+            nonce_cursor += 1;
+        }
+        nonce_cursor
+    }
+
+    /// Returns the lazy inbound nonce (last checkpoint) for a specific path.
+    fn lazy_inbound_nonce(env: &Env, receiver: &Address, src_eid: u32, sender: &BytesN<32>) -> u64 {
+        EndpointStorage::lazy_inbound_nonce(env, receiver, src_eid, sender)
+    }
+
+    /// Returns the payload hash for a specific inbound nonce.
+    fn inbound_payload_hash(
+        env: &Env,
+        receiver: &Address,
+        src_eid: u32,
+        sender: &BytesN<32>,
+        nonce: u64,
+    ) -> Option<BytesN<32>> {
+        EndpointStorage::inbound_payload_hash(env, receiver, src_eid, sender, nonce)
+    }
+}
+
+// ============================================================================
+// Internal Functions
+// ============================================================================
+
+impl EndpointV2 {
+    /// Increments the outbound nonce and stores it for a specific path.
+    ///
+    /// # Returns
+    /// * `nonce` - The next nonce for the path
+    pub(crate) fn outbound(env: &Env, sender: &Address, dst_eid: u32, receiver: &BytesN<32>) -> u64 {
+        let nonce = Self::outbound_nonce(env, sender, dst_eid, receiver) + 1;
+        EndpointStorage::set_outbound_nonce(env, sender, dst_eid, receiver, &nonce);
+        nonce
+    }
+
+    /// Records an inbound message payload hash for a specific nonce on a specific path.
+    ///
+    /// Inbound won't update the nonce eagerly to allow unordered verification.
+    /// Instead, it will update the nonce lazily when the message is received.
+    /// Messages can only be cleared in order to preserve censorship-resistance.
+    ///
+    /// # Arguments
+    /// * `receiver` - The receiver OApp address
+    /// * `src_eid` - The source endpoint ID
+    /// * `sender` - The sender OApp address on the source chain
+    /// * `nonce` - The nonce of the message
+    /// * `payload_hash` - The payload hash of the message (must not be empty payload hash)
+    pub(crate) fn inbound(
+        env: &Env,
+        receiver: &Address,
+        src_eid: u32,
+        sender: &BytesN<32>,
+        nonce: u64,
+        payload_hash: &BytesN<32>,
+    ) {
+        assert_with_error!(env, payload_hash != &Self::empty_payload_hash(env), EndpointError::InvalidPayloadHash);
+        EndpointStorage::set_inbound_payload_hash(env, receiver, src_eid, sender, nonce, payload_hash);
+    }
+
+    /// Clears a stored message payload and increments the lazy inbound nonce.
+    ///
+    /// Calling this function will clear the stored message and increment the
+    /// `lazy_inbound_nonce` to the provided nonce.
+    ///
+    /// Note: This function does not change `inbound_nonce`, it only changes
+    /// the `lazy_inbound_nonce` up to the provided nonce.
+    ///
+    /// # Arguments
+    /// * `receiver` - The receiver OApp address
+    /// * `src_eid` - The source endpoint ID
+    /// * `sender` - The sender OApp address on the source chain
+    /// * `nonce` - The nonce of the message
+    /// * `payload` - The payload of the message
+    pub(crate) fn clear_payload(
+        env: &Env,
+        receiver: &Address,
+        src_eid: u32,
+        sender: &BytesN<32>,
+        nonce: u64,
+        payload: &Bytes,
+    ) {
+        let current_nonce = Self::lazy_inbound_nonce(env, receiver, src_eid, sender);
+
+        // Try to update the lazy inbound nonce until the target nonce
+        if nonce > current_nonce {
+            let has_payload = (current_nonce + 1..=nonce)
+                .all(|n| EndpointStorage::has_inbound_payload_hash(env, receiver, src_eid, sender, n));
+            assert_with_error!(env, has_payload, EndpointError::InvalidNonce);
+            EndpointStorage::set_lazy_inbound_nonce(env, receiver, src_eid, sender, &nonce);
+        }
+
+        // Check the hash of the payload to verify the executor has given the proper payload that has been verified
+        let actual_hash = keccak256(env, payload);
+        let expected_hash = Self::inbound_payload_hash(env, receiver, src_eid, sender, nonce);
+        assert_with_error!(env, Some(actual_hash) == expected_hash, EndpointError::PayloadHashNotFound);
+
+        // Remove it from storage
+        EndpointStorage::remove_inbound_payload_hash(env, receiver, src_eid, sender, nonce);
+    }
+
+    /// Represents an empty payload hash
+    pub(crate) 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> {
+        BytesN::from_array(env, &NIL_PAYLOAD_HASH_BYTES)
+    }
+}