@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

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

@@ -1,11 +1,7 @@
 use crate::errors::OAppError;
-use common_macros::{event, storage};
-use soroban_sdk::{assert_with_error, contracttype, panic_with_error, Bytes, Env, Vec};
-use utils::ttl::DefaultTtlConfigProvider;
-
-// =====================================================
-// Types and Traits
-// =====================================================
+use common_macros::{event, only_owner, storage};
+use soroban_sdk::{assert_with_error, contracttrait, contracttype, panic_with_error, Bytes, Env, Vec};
+use utils::ownable::Ownable;
 
 pub const OPTION_TYPE3: u32 = 3;
 
@@ -17,19 +13,7 @@ pub struct EnforcedOptionParam {
     pub options: Bytes,
 }
 
-pub trait OAppOptionsType3 {
-    fn enforced_options(env: &Env, eid: u32, msg_type: u32) -> Bytes;
-
-    fn set_enforced_options(env: &Env, options: Vec<EnforcedOptionParam>);
-
-    fn combine_options(env: &Env, eid: u32, msg_type: u32, extra_options: &Bytes) -> Bytes;
-}
-
-// =====================================================
-// Implement overrides for the OAppOptionsType3 trait
-// =====================================================
-
-#[storage(DefaultTtlConfigProvider)]
+#[storage]
 pub enum OAppOptionsType3Storage {
     #[persistent(Bytes)]
     #[default(Bytes::new(env))]
@@ -41,12 +25,18 @@ pub struct EnforcedOptionSet {
     pub enforced_option_params: Vec<EnforcedOptionParam>,
 }
 
-pub trait OAppOptionsType3Overrides {
-    fn __enforced_options(env: &Env, eid: u32, msg_type: u32) -> Bytes {
+// =========================================================================
+// OAppOptionsType3 Trait and Default Implementation
+// =========================================================================
+
+#[contracttrait(client_name = "OAppOptionsType3Client")]
+pub trait OAppOptionsType3: Ownable + Sized {
+    fn enforced_options(env: &Env, eid: u32, msg_type: u32) -> Bytes {
         OAppOptionsType3Storage::enforced_options(env, eid, msg_type)
     }
 
-    fn __set_enforced_options(env: &Env, options: Vec<EnforcedOptionParam>) {
+    #[only_owner]
+    fn set_enforced_options(env: &Env, options: Vec<EnforcedOptionParam>) {
         for option in &options {
             assert_option_type3(env, &option.options);
             OAppOptionsType3Storage::set_enforced_options(env, option.eid, option.msg_type, &option.options);
@@ -54,8 +44,8 @@ pub trait OAppOptionsType3Overrides {
         EnforcedOptionSet { enforced_option_params: options }.publish(env);
     }
 
-    fn __combine_options(env: &Env, eid: u32, msg_type: u32, extra_options: &Bytes) -> Bytes {
-        let mut enforced_options = Self::__enforced_options(env, eid, msg_type);
+    fn combine_options(env: &Env, eid: u32, msg_type: u32, extra_options: &Bytes) -> Bytes {
+        let mut enforced_options = Self::enforced_options(env, eid, msg_type);
 
         if enforced_options.is_empty() {
             return extra_options.clone();
@@ -76,9 +66,9 @@ pub trait OAppOptionsType3Overrides {
     }
 }
 
-// =====================================================
-// Internal Helpers
-// =====================================================
+// =========================================================================
+// Helpers Functions
+// =========================================================================
 
 pub fn assert_option_type3(env: &Env, options: &Bytes) {
     let mut options_version_bytes = [0u8; 2];

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

@@ -1,46 +1,75 @@
 use crate::{errors::OAppError, oapp_core::OAppCore};
-use endpoint_v2::{ILayerZeroReceiver, LayerZeroEndpointV2Client, Origin};
-use soroban_sdk::{assert_with_error, Address, Bytes, BytesN, Env};
+use endpoint_v2::{LayerZeroEndpointV2Client, Origin};
+use soroban_sdk::{assert_with_error, contracttrait, token::TokenClient, Address, Bytes, BytesN, Env};
 
 // =====================================================
-// OAppReceiver Traits
+// OAppReceiver Trait
 // =====================================================
 
-pub trait OAppReceiver: ILayerZeroReceiver {
-    /// 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.
+/// Trait for OApps that can receive cross-chain messages from LayerZero.
+///
+/// This trait combines the functionality of `ILayerZeroReceiver` (from endpoint-v2) with
+/// OApp-specific features. It maintains the same function signatures as `ILayerZeroReceiver`
+/// for `allow_initialize_path`, `next_nonce`, and `lz_receive`, which allows the endpoint
+/// to call these methods via `LayerZeroReceiverClient` (client calls are resolved by function name).
+///
+/// # Default Implementations
+/// - `allow_initialize_path`: Returns true if the origin's sender matches the configured peer
+/// - `next_nonce`: Returns 0 (no nonce ordering enforcement)
+/// - `is_compose_msg_sender`: Returns true if sender is the current contract
+///
+/// # Required Implementation
+/// - `lz_receive`: Must be implemented by each OApp to handle incoming messages
+///
+/// # Usage
+/// When using `#[oapp_macros::oapp]`, the macro generates `lz_receive` that
+/// automatically calls `verify_and_clear_payload` before delegating to `__lz_receive`.
+/// **Do NOT call `verify_and_clear_payload` in your `__lz_receive` implementation.**
+///
+/// ```ignore
+/// #[oapp_macros::oapp]
+/// pub struct MyOApp;
+///
+/// impl MyOApp {
+///     pub fn __lz_receive(env: &Env, executor: &Address, origin: &Origin, ...) {
+///         // Handle the incoming message (verify_and_clear_payload already called)
+///     }
+/// }
+/// ```
+#[contracttrait(client_name = "OAppReceiverClient")]
+pub trait OAppReceiver: OAppCore {
+    /// Checks if a messaging path can be initialized for the given origin.
     ///
     /// # Arguments
-    /// * `origin` - The origin information containing the source endpoint and sender address
-    /// * `message` - The lzReceive payload
-    /// * `sender` - The sender address to check
+    /// * `origin` - The origin of the message
     ///
     /// # Returns
-    /// True if the sender is a valid composeMsg sender, false otherwise
-    fn is_compose_msg_sender(env: &Env, origin: &Origin, message: &Bytes, sender: &Address) -> bool;
-}
-
-// =====================================================
-// Implement overrides for the OAppReceiver trait
-// =====================================================
-
-pub trait OAppReceiverOverrides: OAppCore {
-    fn __is_compose_msg_sender(env: &Env, _origin: &Origin, _message: &Bytes, sender: &Address) -> bool {
-        env.current_contract_address() == *sender
-    }
-
-    fn __allow_initialize_path(env: &Env, origin: &Origin) -> bool {
+    /// True if the path can be initialized, false otherwise
+    fn allow_initialize_path(env: &Env, origin: &Origin) -> bool {
         let peer = Self::peer(env, origin.src_eid);
         peer.is_some_and(|peer| peer == origin.sender)
     }
 
-    fn __next_nonce(_env: &Env, _src_eid: u32, _sender: &BytesN<32>) -> u64 {
+    /// Returns the next expected nonce for ordered message delivery.
+    /// 0 means there is NO nonce ordered enforcement.
+    ///
+    /// # Arguments
+    /// * `src_eid` - The source endpoint ID
+    /// * `sender` - The sender OApp address
+    fn next_nonce(_env: &Env, _src_eid: u32, _sender: &BytesN<32>) -> u64 {
         0
     }
 
-    fn __lz_receive(
+    /// Receives and processes a cross-chain message.
+    ///
+    /// # Arguments
+    /// * `executor` - The executor address delivering the message
+    /// * `origin` - The origin information (source EID, sender, nonce)
+    /// * `guid` - The message GUID
+    /// * `message` - The message content
+    /// * `extra_data` - Additional executor-provided data (untrusted)
+    /// * `value` - The native token value sent with the message
+    fn lz_receive(
         env: &Env,
         executor: &Address,
         origin: &Origin,
@@ -49,6 +78,22 @@ pub trait OAppReceiverOverrides: OAppCore {
         extra_data: &Bytes,
         value: i128,
     );
+
+    /// 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: &Env, _origin: &Origin, _message: &Bytes, sender: &Address) -> bool {
+        env.current_contract_address() == *sender
+    }
 }
 
 // =====================================================
@@ -61,12 +106,18 @@ pub fn verify_and_clear_payload<T: OAppCore>(
     origin: &Origin,
     guid: &BytesN<32>,
     message: &Bytes,
+    value: i128,
 ) {
     executor.require_auth();
     assert_with_error!(env, Some(origin.sender.clone()) == T::peer(env, origin.src_eid), OAppError::OnlyPeer);
 
-    let contract_address = env.current_contract_address();
-    let endpoint_address = T::endpoint(env);
-    let endpoint = LayerZeroEndpointV2Client::new(env, &endpoint_address);
-    endpoint.clear(&contract_address, origin, &contract_address, guid, message);
+    let curr_address = env.current_contract_address();
+    let endpoint = LayerZeroEndpointV2Client::new(env, &T::endpoint(env));
+    endpoint.clear(&curr_address, origin, &curr_address, guid, message);
+
+    if value > 0 {
+        let native_token = endpoint.native_token();
+        let token_client = TokenClient::new(env, &native_token);
+        token_client.transfer(executor, &curr_address, &value);
+    }
 }

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

@@ -3,8 +3,29 @@ use endpoint_v2::{LayerZeroEndpointV2Client, MessagingFee, MessagingParams, Mess
 use soroban_sdk::{token::TokenClient, Address, Bytes, Env};
 use utils::option_ext::OptionExt;
 
-pub trait OAppSenderOverrides: OAppCore {
-    fn __quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
+/// A helper trait for sending cross-chain messages via LayerZero.
+///
+/// Contracts should implement this trait to gain access to the `lz_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 `#[contractimpl]` on
+/// the implementation of this trait). Instead, call these methods internally from your
+/// contract's own public functions.
+pub trait OAppSender: 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 lz_quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
         let endpoint = Self::endpoint(env);
         let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
         let receiver = Self::peer(env, dst_eid).unwrap_or_panic(env, OAppError::NoPeer);
@@ -14,27 +35,38 @@ pub trait OAppSenderOverrides: OAppCore {
         )
     }
 
-    fn __lz_send(
+    /// Send a message to the other chain
+    ///
+    /// # Arguments
+    /// * `payer`: The address of the payer
+    /// * `dst_eid`: The destination endpoint ID
+    /// * `message`: The message to send
+    /// * `options`: The options for the message
+    /// * `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,
-        sender: &Address,
+        payer: &Address,
         dst_eid: u32,
         message: &Bytes,
         options: &Bytes,
         fee: &MessagingFee,
         refund_address: &Address,
     ) -> MessagingReceipt {
-        Self::__pay_native(env, sender, fee.native_fee);
+        // Pay the messaging fees
+        Self::pay_native(env, payer, fee.native_fee);
         if fee.zro_fee > 0 {
-            Self::__pay_zro(env, sender, fee.zro_fee);
+            Self::pay_zro(env, payer, fee.zro_fee);
         }
 
-        let oapp = env.current_contract_address();
-        let endpoint = Self::endpoint(env);
-        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        // Send the message to the other chain
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &Self::endpoint(env));
         let peer = Self::peer(env, dst_eid).unwrap_or_panic(env, OAppError::NoPeer);
-
         endpoint_client.send(
-            &oapp,
+            &env.current_contract_address(),
             &MessagingParams {
                 dst_eid,
                 receiver: peer,
@@ -46,7 +78,12 @@ pub trait OAppSenderOverrides: OAppCore {
         )
     }
 
-    fn __pay_native(env: &Env, payer: &Address, native_fee: i128) {
+    /// Pay the native fee to the endpoint for sending a message to the other chain
+    ///
+    /// # Arguments
+    /// * `payer`: The address of the payer
+    /// * `native_fee`: The native fee to pay
+    fn pay_native(env: &Env, payer: &Address, native_fee: i128) {
         let endpoint = Self::endpoint(env);
         let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
         let native_token = endpoint_client.native_token();
@@ -55,7 +92,12 @@ pub trait OAppSenderOverrides: OAppCore {
         token_client.transfer(payer, &endpoint, &native_fee);
     }
 
-    fn __pay_zro(env: &Env, payer: &Address, zro_fee: i128) {
+    /// Pay the ZRO fee to the endpoint for sending a message to the other chain
+    ///
+    /// # Arguments
+    /// * `payer`: The address of the payer
+    /// * `zro_fee`: The ZRO fee to pay
+    fn pay_zro(env: &Env, payer: &Address, zro_fee: i128) {
         let endpoint = Self::endpoint(env);
         let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
         let zro_token = endpoint_client.zro().unwrap_or_panic(env, OAppError::ZROTokenUnavailable);

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

@@ -17,14 +17,27 @@ impl DummyEndpoint {
     }
 }
 
-#[oapp_macros::oapp_core]
+#[oapp_macros::oapp]
 pub struct DummyOApp;
 
+impl DummyOApp {
+    fn __lz_receive(
+        _env: &Env,
+        _executor: &Address,
+        _origin: &endpoint_v2::Origin,
+        _guid: &BytesN<32>,
+        _message: &soroban_sdk::Bytes,
+        _extra_data: &soroban_sdk::Bytes,
+        _value: i128,
+    ) {
+        // Not used in core tests
+    }
+}
+
 #[contractimpl]
 impl DummyOApp {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        Self::__init_owner(env, owner);
-        Self::__oapp_initialize(env, endpoint, &None);
+        oapp::oapp_core::oapp_initialize::<Self>(env, owner, endpoint, &None);
     }
 }
 

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

@@ -1,10 +1,10 @@
 use crate as oapp;
 use crate::oapp_options_type3::EnforcedOptionParam;
 use crate::oapp_options_type3::EnforcedOptionSet;
-use crate::oapp_options_type3::OAppOptionsType3;
+use common_macros::contract_impl;
+use soroban_sdk::contract;
 use soroban_sdk::contractimpl;
 use soroban_sdk::{
-    contract,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     vec, Address, Bytes, Env, IntoVal,
 };
@@ -18,14 +18,37 @@ const MSG_TYPE_SEND: u32 = 1;
 const MSG_TYPE_RECEIVE: u32 = 2;
 
 #[contract]
-#[common_macros::ownable]
-#[oapp_macros::oapp_options_type3]
-pub struct DummyOAppOptionsType3;
+pub struct DummyEndpoint;
 
 #[contractimpl]
+impl DummyEndpoint {
+    pub fn set_delegate(_env: Env, _oapp: &Address, _delegate: &Option<Address>) {
+        // do nothing
+    }
+}
+
+#[oapp_macros::oapp]
+#[oapp_macros::oapp_manual_impl(core, sender, receiver)]
+pub struct DummyOAppOptionsType3;
+
+#[contract_impl]
+impl DummyOAppOptionsType3 {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
+        oapp::oapp_core::oapp_initialize::<Self>(env, owner, endpoint, delegate);
+    }
+}
+
 impl DummyOAppOptionsType3 {
-    pub fn __constructor(env: &Env, owner: &Address) {
-        Self::__init_owner(env, owner);
+    fn __lz_receive(
+        _env: &Env,
+        _executor: &Address,
+        _origin: &endpoint_v2::Origin,
+        _guid: &soroban_sdk::BytesN<32>,
+        _message: &Bytes,
+        _extra_data: &Bytes,
+        _value: i128,
+    ) {
+        // Dummy implementation for testing
     }
 }
 
@@ -39,7 +62,9 @@ fn setup<'a>() -> TestSetup<'a> {
     let env = Env::default();
 
     let owner = Address::generate(&env);
-    let oapp = env.register(DummyOAppOptionsType3, (&owner,));
+    let endpoint = env.register(DummyEndpoint, ());
+    let delegate: Option<Address> = Some(owner.clone());
+    let oapp = env.register(DummyOAppOptionsType3, (&owner, &endpoint, &delegate));
     let oapp_client = DummyOAppOptionsType3Client::new(&env, &oapp);
 
     TestSetup { env, owner, oapp_client }

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

@@ -1,18 +1,16 @@
 use crate as oapp;
+use crate::errors::OAppError;
 use crate::oapp_core::OAppCoreStorage;
-use crate::oapp_receiver::OAppReceiverOverrides;
 use crate::tests::test_oapp_core::DummyEndpoint;
-use crate::{errors::OAppError, oapp_receiver::OAppReceiver};
-use endpoint_v2::{ILayerZeroReceiver, Origin};
-use soroban_sdk::contractimpl;
-use soroban_sdk::{assert_with_error, testutils::Address as _, Address, Bytes, BytesN, Env};
+use endpoint_v2::Origin;
+use soroban_sdk::{assert_with_error, contractimpl, testutils::Address as _, Address, Bytes, BytesN, Env};
 use utils::option_ext::OptionExt;
 use utils::ownable::Ownable;
 
-#[oapp_macros::oapp_receiver]
+#[oapp_macros::oapp]
 pub struct DummyOAppReceiver;
 
-impl OAppReceiverOverrides for DummyOAppReceiver {
+impl DummyOAppReceiver {
     fn __lz_receive(
         _env: &Env,
         _executor: &Address,
@@ -29,8 +27,7 @@ impl OAppReceiverOverrides for DummyOAppReceiver {
 #[contractimpl]
 impl DummyOAppReceiver {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        Self::__init_owner(env, owner);
-        Self::__oapp_initialize(env, endpoint, &None);
+        oapp::oapp_core::oapp_initialize::<Self>(env, owner, endpoint, &None);
     }
 
     pub fn assert_allowed_peer(env: &Env, origin: &Origin) {

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

@@ -1,5 +1,5 @@
 use crate as oapp;
-use crate::{errors::OAppError, oapp_core::OAppCore};
+use crate::errors::OAppError;
 use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt};
 use soroban_sdk::{
     contract, contractimpl, symbol_short,
@@ -47,21 +47,34 @@ impl MockEndpoint {
     }
 }
 
-#[oapp_macros::oapp_sender]
+#[oapp_macros::oapp]
 pub struct DummyOAppSender;
 
+impl DummyOAppSender {
+    fn __lz_receive(
+        _env: &Env,
+        _executor: &Address,
+        _origin: &endpoint_v2::Origin,
+        _guid: &BytesN<32>,
+        _message: &Bytes,
+        _extra_data: &Bytes,
+        _value: i128,
+    ) {
+        // Not used in sender tests
+    }
+}
+
 #[contractimpl]
 impl DummyOAppSender {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        Self::__init_owner(env, owner);
-        Self::__oapp_initialize(env, endpoint, &None);
+        oapp::oapp_core::oapp_initialize::<Self>(env, owner, endpoint, &None);
     }
 
     pub fn quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
-        Self::__quote(env, dst_eid, message, options, pay_in_zro)
+        Self::lz_quote(env, dst_eid, message, options, pay_in_zro)
     }
 
-    pub fn lz_send(
+    pub fn send(
         env: &Env,
         sender: &Address,
         dst_eid: u32,
@@ -71,17 +84,17 @@ impl DummyOAppSender {
         refund_address: &Address,
     ) -> MessagingReceipt {
         sender.require_auth();
-        Self::__lz_send(env, sender, dst_eid, message, options, fee, refund_address)
+        Self::lz_send(env, sender, dst_eid, message, options, fee, refund_address)
     }
 
-    pub fn pay_native(env: &Env, payer: &Address, native_fee: i128) {
+    pub fn pay_native_fee(env: &Env, payer: &Address, native_fee: i128) {
         payer.require_auth();
-        Self::__pay_native(env, payer, native_fee)
+        Self::pay_native(env, payer, native_fee)
     }
 
-    pub fn pay_zro(env: &Env, payer: &Address, zro_fee: i128) {
+    pub fn pay_zro_fee(env: &Env, payer: &Address, zro_fee: i128) {
         payer.require_auth();
-        Self::__pay_zro(env, payer, zro_fee)
+        Self::pay_zro(env, payer, zro_fee)
     }
 }
 
@@ -202,7 +215,7 @@ fn test_lz_send_native_only() {
     let fee = MessagingFee { native_fee: 1000, zro_fee: 0 };
 
     // Send message (auth is mocked automatically)
-    let receipt = oapp_client.lz_send(&sender, &REMOTE_EID, &message, &options, &fee, &refund_address);
+    let receipt = oapp_client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund_address);
 
     // Verify receipt
     assert_eq!(receipt.nonce, 1);
@@ -238,7 +251,7 @@ fn test_lz_send_with_zro() {
     let refund_address = Address::generate(&env);
 
     // Send message with ZRO payment
-    let receipt = oapp_client.lz_send(&sender, &REMOTE_EID, &message, &options, &fee, &refund_address);
+    let receipt = oapp_client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund_address);
 
     assert_eq!(receipt.fee.zro_fee, fee.zro_fee);
 }
@@ -256,7 +269,7 @@ fn test_pay_native() {
     native_token_admin_client.mint(&payer, &payment_amount);
 
     // Make payment
-    oapp_client.pay_native(&payer, &payment_amount);
+    oapp_client.pay_native_fee(&payer, &payment_amount);
 
     // Verify balances
     assert_eq!(native_token_admin_client.balance(&payer), 0);
@@ -279,5 +292,5 @@ fn test_pay_native_insufficient_balance() {
     native_token_admin_client.mint(&payer, &balance);
 
     // This should panic due to insufficient balance
-    oapp_client.pay_native(&payer, &payment_amount);
+    oapp_client.pay_native_fee(&payer, &payment_amount);
 }

package/contracts/oapps/oft/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "oft"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["rlib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+utils = { workspace = true }
+oapp = { workspace = true }
+common-macros = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+simple-message-lib = { workspace = true }
+message-lib-common = { workspace = true, features = ["testutils"] }
+endpoint-v2 = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
+insta = { workspace = true }
+oapp-macros = { workspace = true }
+stellar-macros = { workspace = true }
+stellar-tokens = { workspace = true }

package/contracts/oapps/oft/integration-tests/mod.rs

@@ -0,0 +1,3 @@
+pub mod setup;
+pub mod test_with_sml;
+pub mod utils;