@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

package/contracts/oapps/oapp/src/lib.rs

@@ -1,15 +0,0 @@
-#![no_std]
-
-pub mod oapp_core;
-pub mod oapp_options_type3;
-pub mod oapp_receiver;
-pub mod oapp_sender;
-
-mod errors;
-mod interfaces;
-
-pub use errors::*;
-pub use interfaces::*;
-
-#[cfg(test)]
-mod tests;

package/contracts/oapps/oapp/src/oapp_core.rs

@@ -1,143 +0,0 @@
-use crate::{errors::OAppError, oapp_receiver::RECEIVER_VERSION, oapp_sender::SENDER_VERSION};
-use common_macros::{contract_trait, only_role, storage};
-use endpoint_v2::LayerZeroEndpointV2Client;
-use soroban_sdk::{contractevent, Address, BytesN, Env};
-use utils::{
-    option_ext::OptionExt,
-    ownable::{Ownable, OwnableInitializer},
-    rbac::{RoleBasedAccessControl, AUTHORIZER},
-};
-
-// =====================================================
-// OAppCore Storage and Events
-// =====================================================
-
-#[storage]
-pub enum OAppCoreStorage {
-    // Endpoint address - set once during initialization
-    #[instance(Address)]
-    Endpoint,
-
-    // Mapping from endpoint ID to remote peer address
-    #[persistent(BytesN<32>)]
-    Peer { eid: u32 },
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct PeerSet {
-    pub eid: u32,
-    pub peer: Option<BytesN<32>>,
-}
-
-// =====================================================
-// OAppCore Interface and Default Implementation
-// =====================================================
-
-#[contract_trait]
-pub trait OAppCore: Ownable + RoleBasedAccessControl {
-    /// Retrieves the OApp version information.
-    ///
-    /// # Returns
-    /// A tuple containing:
-    /// - `sender_version`: The version of the OAppSender
-    /// - `receiver_version`: The version of the OAppReceiver
-    fn oapp_version(_env: &soroban_sdk::Env) -> (u64, u64) {
-        (SENDER_VERSION, RECEIVER_VERSION)
-    }
-
-    /// Retrieves the LayerZero endpoint address associated with the OApp.
-    ///
-    /// # Returns
-    /// The LayerZero endpoint address
-    fn endpoint(env: &soroban_sdk::Env) -> soroban_sdk::Address {
-        OAppCoreStorage::endpoint(env).unwrap()
-    }
-
-    /// Retrieves the peer (OApp) associated with a corresponding endpoint.
-    ///
-    /// # Arguments
-    /// * `eid` - The endpoint ID
-    ///
-    /// # Returns
-    /// The peer address (OApp instance) associated with the corresponding endpoint
-    fn peer(env: &soroban_sdk::Env, eid: u32) -> Option<soroban_sdk::BytesN<32>> {
-        OAppCoreStorage::peer(env, eid)
-    }
-
-    /// Sets or removes the peer address (OApp instance) for a corresponding endpoint.
-    ///
-    /// # Arguments
-    /// * `eid` - The endpoint ID
-    /// * `peer` - The address of the peer to be associated with the corresponding endpoint, or None to remove the peer
-    /// * `operator` - The authorizer address
-    #[only_role(operator, AUTHORIZER)]
-    fn set_peer(
-        env: &soroban_sdk::Env,
-        eid: u32,
-        peer: &Option<soroban_sdk::BytesN<32>>,
-        operator: &soroban_sdk::Address,
-    ) {
-        OAppCoreStorage::set_or_remove_peer(env, eid, peer);
-        PeerSet { eid, peer: peer.clone() }.publish(env);
-    }
-
-    /// Sets the delegate address for the OApp Core.
-    ///
-    /// # Arguments
-    /// * `delegate` - The address of the delegate to be set, or None to remove the delegate
-    /// * `operator` - The authorizer address
-    #[only_role(operator, AUTHORIZER)]
-    fn set_delegate(env: &soroban_sdk::Env, delegate: &Option<soroban_sdk::Address>, operator: &soroban_sdk::Address) {
-        endpoint_client::<Self>(env).set_delegate(&env.current_contract_address(), delegate);
-    }
-}
-
-// =====================================================
-// Helper Functions
-// =====================================================
-
-/// Initializes the OApp with the specified configuration.
-///
-/// This function sets up the OApp by initializing ownership, storing the LayerZero endpoint,
-/// and setting a delegate address for the endpoint.
-///
-/// # Arguments
-/// * `env` - The Soroban environment
-/// * `owner` - The address that will own this OApp
-/// * `endpoint` - The LayerZero endpoint address to associate with this OApp
-/// * `delegate` - The delegate address to set on the endpoint for this OApp
-pub fn init_ownable_oapp<T: OAppCore + OwnableInitializer>(
-    env: &Env,
-    owner: &Address,
-    endpoint: &Address,
-    delegate: &Address,
-) {
-    T::init_owner(env, owner);
-    OAppCoreStorage::set_endpoint(env, endpoint);
-    LayerZeroEndpointV2Client::new(env, endpoint)
-        .set_delegate(&env.current_contract_address(), &Some(delegate.clone()));
-}
-
-/// Retrieves the peer address associated with a specific endpoint ID; panics if NOT set.
-///
-/// This is a safe getter that ensures a peer has been configured for the given endpoint.
-/// If no peer is set (i.e., the peer is `None`), it will panic with `OAppError::NoPeer`.
-///
-/// # Arguments
-/// * `env` - The Soroban environment
-/// * `eid` - The endpoint ID
-///
-/// # Returns
-/// The peer address (`BytesN<32>`) associated with the specified endpoint
-///
-/// # Panics
-/// Panics with `OAppError::NoPeer` if no peer is set for the given endpoint ID
-pub fn get_peer_or_panic<T: OAppCore>(env: &Env, eid: u32) -> BytesN<32> {
-    T::peer(env, eid).unwrap_or_panic(env, OAppError::NoPeer)
-}
-
-/// Returns a client for the LayerZero endpoint.
-pub fn endpoint_client<'a, T: OAppCore>(env: &'a Env) -> LayerZeroEndpointV2Client<'a> {
-    LayerZeroEndpointV2Client::new(env, &T::endpoint(env))
-}

package/contracts/oapps/oapp/src/oapp_options_type3.rs

@@ -1,133 +0,0 @@
-use crate::{self as oapp, errors::OAppError};
-use common_macros::{contract_trait, only_role, storage};
-use soroban_sdk::{assert_with_error, contractevent, contracttype, panic_with_error, Bytes, Env, Vec};
-use utils::{buffer_reader::BufferReader, rbac::{RoleBasedAccessControl, AUTHORIZER}};
-
-pub const OPTION_TYPE3: u16 = 3;
-
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct EnforcedOptionParam {
-    pub eid: u32,
-    pub msg_type: u32,
-    pub options: Option<Bytes>,
-}
-
-#[storage]
-pub enum OAppOptionsType3Storage {
-    #[persistent(Bytes)]
-    EnforcedOptions { eid: u32, msg_type: u32 },
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct EnforcedOptionSet {
-    pub enforced_options: Vec<EnforcedOptionParam>,
-}
-
-// =========================================================================
-// OAppOptionsType3 Trait and Default Implementation
-// =========================================================================
-
-#[contract_trait]
-pub trait OAppOptionsType3: RoleBasedAccessControl {
-    /// Retrieves the enforced options for a given endpoint and message type.
-    ///
-    /// # Arguments
-    /// * `eid` - The endpoint ID
-    /// * `msg_type` - The OApp message type
-    ///
-    /// # Returns
-    /// The enforced options for the given endpoint and message type
-    fn enforced_options(env: &soroban_sdk::Env, eid: u32, msg_type: u32) -> Option<soroban_sdk::Bytes> {
-        OAppOptionsType3Storage::enforced_options(env, eid, msg_type)
-    }
-
-    /// Sets or removes the enforced options for specific endpoint and message type combinations.
-    ///
-    /// Only the `authorizer` of the OApp can call this function.
-    /// Provides a way for the OApp to enforce things like paying for PreCrime, AND/OR minimum dst lzReceive gas amounts etc.
-    /// These enforced options can vary as the potential options/execution on the remote may differ as per the msg_type.
-    /// e.g. Amount of lzReceive() gas necessary to deliver a lzCompose() message adds overhead you don't want to pay
-    /// if you are only making a standard LayerZero message ie. lzReceive() WITHOUT sendCompose().
-    ///
-    /// # Arguments
-    /// * `options` - A vector of EnforcedOptionParam structures specifying enforced options
-    /// * `operator` - The authorizer address
-    #[only_role(operator, AUTHORIZER)]
-    fn set_enforced_options(
-        env: &soroban_sdk::Env,
-        options: &soroban_sdk::Vec<oapp::oapp_options_type3::EnforcedOptionParam>,
-        operator: &soroban_sdk::Address,
-    ) {
-        for param in options {
-            if let Some(ref opts) = param.options {
-                assert_option_type3(env, opts);
-            }
-            OAppOptionsType3Storage::set_or_remove_enforced_options(env, param.eid, param.msg_type, &param.options);
-        }
-        EnforcedOptionSet { enforced_options: options.clone() }.publish(env);
-    }
-
-    /// Combines options for a given endpoint and message type.
-    ///
-    /// If there is an enforced lzReceive option:
-    /// - {gas_limit: 200k, value: 1 XLM} AND a caller supplies a lzReceive option: {gas_limit: 100k, value: 0.5 XLM}
-    /// - The resulting options will be {gas_limit: 300k, value: 1.5 XLM} when the message is executed on the remote lz_receive() function.
-    /// The presence of duplicated options is handled off-chain in the verifier/executor.
-    ///
-    /// # Arguments
-    /// * `eid` - The endpoint ID
-    /// * `msg_type` - The OApp message type
-    /// * `extra_options` - Additional options passed by the caller
-    ///
-    /// # Returns
-    /// The combination of caller specified options AND enforced options
-    fn combine_options(
-        env: &soroban_sdk::Env,
-        eid: u32,
-        msg_type: u32,
-        extra_options: &soroban_sdk::Bytes,
-    ) -> soroban_sdk::Bytes {
-        let enforced_options_opt = Self::enforced_options(env, eid, msg_type);
-
-        // No enforced options, pass whatever the caller supplied, even if it's empty or legacy type 1/2 options.
-        if enforced_options_opt.is_none() {
-            return extra_options.clone();
-        }
-
-        // No caller options, return enforced
-        let mut enforced_options = enforced_options_opt.unwrap(); // unwrap is safe because we checked if it is none above
-        if extra_options.is_empty() {
-            return enforced_options;
-        }
-
-        // If caller provided extra_options, must be type 3 as its the ONLY type that can be combined.
-        if extra_options.len() >= 2 {
-            assert_option_type3(env, extra_options);
-
-            // Remove the first 2 bytes containing the type from the extra_options and combine with enforced.
-            enforced_options.append(&extra_options.slice(2..));
-            return enforced_options;
-        }
-
-        // No valid set of options was found.
-        panic_with_error!(env, OAppError::InvalidOptions);
-    }
-}
-
-// =========================================================================
-// Helpers Functions
-// =========================================================================
-
-/// Asserts that the provided options are of type 3.
-///
-/// # Arguments
-/// * `options` - The options to be checked
-///
-/// # Panics
-/// If the options are not of type 3
-pub fn assert_option_type3(env: &Env, options: &Bytes) {
-    let options_type = BufferReader::new(options).read_u16();
-    assert_with_error!(env, options_type == OPTION_TYPE3, OAppError::InvalidOptions);
-}

package/contracts/oapps/oapp/src/oapp_receiver.rs

@@ -1,195 +0,0 @@
-use crate::{
-    errors::OAppError,
-    oapp_core::{endpoint_client, get_peer_or_panic, OAppCore},
-};
-use common_macros::contract_trait;
-use endpoint_v2::Origin;
-use soroban_sdk::{assert_with_error, token::TokenClient, Address, Bytes, BytesN, Env};
-
-/// The version of the OAppReceiver implementation.
-/// Version is bumped when changes are made to this contract.
-pub const RECEIVER_VERSION: u64 = 1;
-
-// =====================================================
-// LzReceiveInternal Trait
-// =====================================================
-
-/// Application-specific handler for incoming LayerZero messages.
-///
-/// Implement this trait to define how your OApp processes cross-chain messages.
-/// The default `OAppReceiver::lz_receive` calls `clear_payload_and_transfer` first,
-/// then delegates to your `__lz_receive` implementation.
-///
-/// **Important:** Do NOT call `clear_payload_and_transfer` in your implementation -
-/// it is handled automatically by the default `lz_receive`.
-pub trait LzReceiveInternal {
-    /// Processes a verified cross-chain message.
-    ///
-    /// Called after payload verification. Implement your message handling logic here.
-    fn __lz_receive(
-        env: &Env,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        extra_data: &Bytes,
-        executor: &Address,
-        value: i128,
-    );
-}
-
-// =====================================================
-// OAppReceiver Trait
-// =====================================================
-
-/// Receiver trait for OApps that accept cross-chain messages from LayerZero.
-///
-/// Mirrors `ILayerZeroReceiver` function signatures, allowing the executor to call
-/// these methods via `LayerZeroReceiverClient`.
-///
-/// # Default Implementations
-/// | Method                   | Behavior                                                       |
-/// |--------------------------|----------------------------------------------------------------|
-/// | `allow_initialize_path`  | Returns true if origin sender matches configured peer          |
-/// | `next_nonce`             | Returns 0 (unordered delivery)                                 |
-/// | `lz_receive`             | Verifies payload, then calls `LzReceiveInternal::__lz_receive` |
-/// | `is_compose_msg_sender`  | Returns true if sender is current contract                     |
-///
-/// # Usage
-///
-/// ```ignore
-/// use oapp::oapp_receiver::LzReceiveInternal;
-///
-/// #[common_macros::lz_contract]
-/// #[oapp_macros::oapp]
-/// pub struct MyOApp;
-///
-/// impl LzReceiveInternal for MyOApp {
-///     fn __lz_receive(env: &Env, origin: &Origin, guid: &BytesN<32>,
-///                     message: &Bytes, extra_data: &Bytes, executor: &Address, value: i128) {
-///         // Your message handling logic here
-///     }
-/// }
-/// ```
-///
-/// # Customization
-/// For custom behavior (e.g., ordered nonce enforcement), use `#[oapp(custom = [receiver])]`
-/// and implement both `LzReceiveInternal` and `OAppReceiver`.
-#[contract_trait]
-pub trait OAppReceiver: OAppCore + LzReceiveInternal {
-    /// Checks if a messaging path can be initialized for the given origin.
-    ///
-    /// # Arguments
-    /// * `origin` - The origin of the message
-    ///
-    /// # Returns
-    /// True if the path can be initialized, false otherwise
-    fn allow_initialize_path(env: &soroban_sdk::Env, origin: &endpoint_v2::Origin) -> bool {
-        let peer = Self::peer(env, origin.src_eid);
-        peer.is_some_and(|peer| peer == origin.sender)
-    }
-
-    /// Retrieves the next nonce for a given source endpoint and sender address.
-    ///
-    /// The path nonce starts from 1. If 0 is returned it means that there is NO nonce ordered enforcement.
-    /// This is required by the off-chain executor to determine if the OApp expects message execution to be ordered.
-    /// This is also enforced by the OApp.
-    /// By default this is NOT enabled, i.e. next_nonce is hardcoded to return 0.
-    ///
-    /// # Arguments
-    /// * `src_eid` - The source endpoint ID
-    /// * `sender` - The sender OApp address
-    ///
-    /// # Returns
-    /// The next nonce
-    fn next_nonce(_env: &soroban_sdk::Env, _src_eid: u32, _sender: &soroban_sdk::BytesN<32>) -> u64 {
-        0
-    }
-
-    /// Entry point for receiving messages or packets from the LayerZero endpoint.
-    ///
-    /// The default implementation calls `clear_payload_and_transfer` to validate the message
-    /// and clear it from the endpoint, then delegates to `__lz_receive` for application logic.
-    ///
-    /// # Arguments
-    /// * `executor` - The address of the executor for the received message
-    /// * `origin` - The origin information containing the source endpoint and sender address:
-    ///   - `src_eid`: The source endpoint ID
-    ///   - `sender`: The sender address on the source chain
-    ///   - `nonce`: The nonce of the message
-    /// * `guid` - The unique identifier for the received LayerZero message
-    /// * `message` - The payload of the received message
-    /// * `extra_data` - Additional arbitrary data provided by the corresponding executor
-    /// * `value` - The native token value sent with the message
-    fn lz_receive(
-        env: &soroban_sdk::Env,
-        executor: &soroban_sdk::Address,
-        origin: &endpoint_v2::Origin,
-        guid: &soroban_sdk::BytesN<32>,
-        message: &soroban_sdk::Bytes,
-        extra_data: &soroban_sdk::Bytes,
-        value: i128,
-    ) {
-        clear_payload_and_transfer::<Self>(env, executor, origin, guid, message, value);
-        Self::__lz_receive(env, origin, guid, message, extra_data, executor, value)
-    }
-
-    /// Indicates whether an address is an approved composeMsg sender to the Endpoint.
-    ///
-    /// Applications can optionally choose to implement separate composeMsg senders that are NOT the bridging layer.
-    /// The default sender IS the OAppReceiver implementer.
-    ///
-    /// # Arguments
-    /// * `origin` - The origin information containing the source endpoint and sender address
-    /// * `message` - The lzReceive payload
-    /// * `sender` - The sender address to check
-    ///
-    /// # Returns
-    /// True if the sender is a valid composeMsg sender, false otherwise
-    fn is_compose_msg_sender(
-        env: &soroban_sdk::Env,
-        _origin: &endpoint_v2::Origin,
-        _message: &soroban_sdk::Bytes,
-        sender: &soroban_sdk::Address,
-    ) -> bool {
-        env.current_contract_address() == *sender
-    }
-}
-
-// =====================================================
-// Helper functions
-// =====================================================
-
-/// Clears the message payload from the endpoint and transfers native tokens from the executor to the oapp if has value.
-///
-/// # Arguments
-/// * `env` - The environment
-/// * `executor` - The address of the executor delivering the message
-/// * `origin` - The origin information (source EID, sender, nonce)
-/// * `guid` - The unique identifier for the LayerZero message to clear the payload from
-/// * `message` - The message payload to clear
-/// * `value` - The native token value to transfer from the executor to the oapp if has value
-pub fn clear_payload_and_transfer<T: OAppCore>(
-    env: &Env,
-    executor: &Address,
-    origin: &Origin,
-    guid: &BytesN<32>,
-    message: &Bytes,
-    value: i128,
-) {
-    // Require authorization from the executor and transfer the value from the executor to the oapp if has value
-    executor.require_auth();
-    // Assert that the message is from the expected peer
-    assert_with_error!(env, get_peer_or_panic::<T>(env, origin.src_eid) == origin.sender, OAppError::OnlyPeer);
-
-    let this_address = env.current_contract_address();
-    let endpoint_client = endpoint_client::<T>(env);
-
-    // Transfer the value from the executor to the oapp if has value
-    if value != 0 {
-        let token_client = TokenClient::new(env, &endpoint_client.native_token());
-        token_client.transfer(executor, &this_address, &value);
-    }
-
-    // Clear the message payload from the endpoint
-    endpoint_client.clear(&this_address, origin, &this_address, guid, message);
-}

package/contracts/oapps/oapp/src/oapp_sender.rs

@@ -1,152 +0,0 @@
-use crate::{
-    errors::OAppError,
-    oapp_core::{endpoint_client, get_peer_or_panic, OAppCore},
-};
-use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt};
-use soroban_sdk::{contracttype, token::TokenClient, Address, Bytes, Env};
-use utils::option_ext::OptionExt;
-
-/// The version of the OAppSender implementation.
-/// Version is bumped when changes are made to this contract.
-pub const SENDER_VERSION: u64 = 1;
-
-/// Represents a fee payer address with explicit authorization state.
-///
-/// This enum forces callers of `__lz_send` to explicitly declare whether
-/// `require_auth()` has already been called for the fee payer address.
-/// This prevents the common mistake of forgetting to authorize the fee payer.
-///
-/// # Variants
-/// - `Unverified` — Safe default. `__lz_send` will call `require_auth()` on the address.
-///   Use this when the caller has **not** already authorized the fee payer.
-/// - `Verified` — Caller asserts that `require_auth()` has already been called.
-///   Use this to avoid a duplicate `require_auth()` node in the Soroban auth tree
-///   (e.g., when the same address was already authorized as the message sender).
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum FeePayer {
-    /// The fee payer has **not** been authorized yet.
-    /// `__lz_send` will call `fee_payer.require_auth()` before transferring fees.
-    /// This is the safe default — use this if unsure.
-    Unverified(Address),
-
-    /// The fee payer has **already** been authorized by the caller via `require_auth()`.
-    /// `__lz_send` will skip the auth check to avoid creating a duplicate auth node
-    /// in the Soroban authorization tree.
-    ///
-    /// # Safety
-    /// Only use this variant if you have already called `require_auth()` on this address
-    /// in the current contract invocation. Misuse may allow unauthorized fee deductions.
-    Verified(Address),
-}
-
-impl FeePayer {
-    /// Returns a reference to the underlying address.
-    pub fn address(&self) -> &Address {
-        match self {
-            FeePayer::Unverified(addr) | FeePayer::Verified(addr) => addr,
-        }
-    }
-}
-
-/// A helper trait for sending cross-chain messages via LayerZero.
-///
-/// Contracts should implement this trait to gain access to the `__quote` and `__lz_send` helper
-/// methods for cross-chain messaging. This trait provides default implementations that handle
-/// fee payment and message dispatch through the LayerZero endpoint.
-///
-/// # Important
-/// This trait is intended to be used as an **internal helper** only. Do **NOT** expose these
-/// methods as part of your contract's public interface (i.e., do not use `#[contract_impl]` on
-/// the implementation of this trait). Instead, call these methods internally from your
-/// contract's own public functions.
-pub trait OAppSenderInternal: OAppCore {
-    /// Quote the messaging fee for sending a message to the other chain
-    ///
-    /// # Arguments
-    /// * `dst_eid`: The destination endpoint ID
-    /// * `message`: The message to send
-    /// * `options`: The options for the message
-    /// * `pay_in_zro`: Whether to pay the fee in ZRO
-    ///
-    /// # Returns
-    /// * `MessagingFee`: The messaging fee for the message
-    fn __quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
-        let receiver = get_peer_or_panic::<Self>(env, dst_eid);
-        endpoint_client::<Self>(env).quote(
-            &env.current_contract_address(),
-            &MessagingParams { dst_eid, receiver, message: message.clone(), options: options.clone(), pay_in_zro },
-        )
-    }
-
-    /// Send a message to the other chain
-    ///
-    /// # Arguments
-    /// * `dst_eid`: The destination endpoint ID
-    /// * `message`: The message to send
-    /// * `options`: The options for the message
-    /// * `fee_payer`: The fee payer, wrapped in [`FeePayer`] to indicate authorization state.
-    ///   Use `FeePayer::Unverified(addr)` if auth has not been checked (safe default),
-    ///   or `FeePayer::Verified(addr)` if `addr.require_auth()` was already called by the caller.
-    /// * `fee`: The messaging fee
-    /// * `refund_address`: The address to receive any excess fees
-    ///
-    /// # Returns
-    /// * `MessagingReceipt`: The receipt for the sent message
-    fn __lz_send(
-        env: &Env,
-        dst_eid: u32,
-        message: &Bytes,
-        options: &Bytes,
-        fee_payer: &FeePayer,
-        fee: &MessagingFee,
-        refund_address: &Address,
-    ) -> MessagingReceipt {
-        // Enforce fee payer authorization if not already verified by the caller
-        let payer = match fee_payer {
-            FeePayer::Unverified(addr) => {
-                addr.require_auth();
-                addr
-            }
-            FeePayer::Verified(addr) => addr,
-        };
-
-        // Pay the messaging fees
-        Self::__pay_native(env, payer, fee.native_fee);
-        // Skip the ZRO payment call only when the fee is exactly zero. Using `!= 0` instead of
-        // `> 0` so that an invalid negative value still reaches `__pay_zro` and fails loudly
-        // rather than being silently ignored.
-        let pay_in_zro = fee.zro_fee != 0;
-        if pay_in_zro {
-            Self::__pay_zro(env, payer, fee.zro_fee);
-        }
-
-        // Send the message to the other chain
-        let receiver = get_peer_or_panic::<Self>(env, dst_eid);
-        endpoint_client::<Self>(env).send(
-            &env.current_contract_address(),
-            &MessagingParams { dst_eid, receiver, message: message.clone(), options: options.clone(), pay_in_zro },
-            refund_address,
-        )
-    }
-
-    /// Pay the native fee to the endpoint for sending a message to the other chain
-    ///
-    /// # Arguments
-    /// * `fee_payer`: The address of the fee payer
-    /// * `native_fee`: The native fee to pay
-    fn __pay_native(env: &Env, fee_payer: &Address, native_fee: i128) {
-        let token_client = TokenClient::new(env, &endpoint_client::<Self>(env).native_token());
-        token_client.transfer(fee_payer, Self::endpoint(env), &native_fee);
-    }
-
-    /// Pay the ZRO fee to the endpoint for sending a message to the other chain
-    ///
-    /// # Arguments
-    /// * `fee_payer`: The address of the fee payer
-    /// * `zro_fee`: The ZRO fee to pay
-    fn __pay_zro(env: &Env, fee_payer: &Address, zro_fee: i128) {
-        let zro_token = endpoint_client::<Self>(env).zro().unwrap_or_panic(env, OAppError::ZroTokenUnavailable);
-        TokenClient::new(env, &zro_token).transfer(fee_payer, Self::endpoint(env), &zro_fee);
-    }
-}

package/contracts/oapps/oapp/src/tests/mod.rs

@@ -1,5 +0,0 @@
-mod oapp_core;
-mod oapp_options_type3;
-mod oapp_receiver;
-mod oapp_sender;
-mod test_macros;