@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/oapps/oft/src/tests/extensions/setup.rs

@@ -5,21 +5,26 @@
 
 extern crate self as oft;
 
-use crate::default_oft_impl::{default_quote_oft, default_quote_send};
-use crate::errors::OFTError;
-use crate::extensions::oft_fee::{OFTFee, OFTFeeInternal};
-use crate::extensions::pausable::{OFTPausable, OFTPausableInternal};
-use crate::extensions::rate_limiter::{Direction, RateLimiter, RateLimiterInternal};
-use crate::oft::{oft_initialize, OFTInner, OFT};
-use crate::storage::OFTStorage;
-use crate::tests::test_utils::{
-    create_recipient_address, DummyToken, MockEndpointWithCompose, MockEndpointWithComposeClient, DEFAULT_NATIVE_FEE,
-    DEFAULT_SHARED_DECIMALS, DEFAULT_ZRO_FEE, INITIAL_MINT_AMOUNT,
+use crate::{
+    errors::OFTError,
+    extensions::{
+        oft_fee::{OFTFee, OFTFeeInternal},
+        pausable::{OFTPausable, OFTPausableInternal},
+        rate_limiter::{Direction, RateLimiter, RateLimiterInternal},
+    },
+    initialize_oft,
+    oft::{OFTInternal, OFT},
+    oft_impl::{self, quote_oft, quote_send},
+    storage::OFTStorage,
+    tests::test_utils::{
+        create_recipient_address, DummyToken, MockEndpointWithCompose, MockEndpointWithComposeClient,
+        DEFAULT_NATIVE_FEE, DEFAULT_SHARED_DECIMALS, DEFAULT_ZRO_FEE, INITIAL_MINT_AMOUNT,
+    },
+    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
+    utils::remove_dust,
 };
-use crate::types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
-use crate::utils::remove_dust;
 use endpoint_v2::{LayerZeroReceiverClient, MessagingFee, MessagingReceipt, Origin};
-use oapp::oapp_core::OAppCoreClient;
+use oapp::{oapp_core::OAppCoreClient, oapp_receiver::LzReceiveInternal};
 use soroban_sdk::{
     assert_with_error, bytes, contractimpl, log,
     testutils::{Ledger, MockAuth, MockAuthInvoke},
@@ -33,6 +38,20 @@ use soroban_sdk::{
 #[oapp_macros::oapp]
 pub struct ExtensiveOFT;
 
+impl LzReceiveInternal for ExtensiveOFT {
+    fn __lz_receive(
+        env: &Env,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        executor: &Address,
+        value: i128,
+    ) {
+        oft_impl::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+    }
+}
+
 #[contractimpl]
 impl ExtensiveOFT {
     pub fn __constructor(
@@ -43,7 +62,7 @@ impl ExtensiveOFT {
         delegate: &Option<Address>,
         shared_decimals: u32,
     ) {
-        oft_initialize::<Self>(env, owner, token, endpoint, delegate, shared_decimals);
+        initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals);
     }
 }
 
@@ -55,7 +74,7 @@ impl OFT for ExtensiveOFT {
         send_param: &crate::types::SendParam,
     ) -> (OFTLimit, soroban_sdk::Vec<OFTFeeDetail>, OFTReceipt) {
         Self::__assert_not_paused(env);
-        let (_, fee_details, oft_receipt) = default_quote_oft::<Self>(env, send_param);
+        let (_, fee_details, oft_receipt) = quote_oft::<Self>(env, send_param);
         let capacity = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
         let oft_limit = OFTLimit { min_amount_ld: 0, max_amount_ld: capacity };
         (oft_limit, fee_details, oft_receipt)
@@ -68,36 +87,46 @@ impl OFT for ExtensiveOFT {
         pay_in_zro: bool,
     ) -> endpoint_v2::MessagingFee {
         Self::__assert_not_paused(env);
-        default_quote_send::<Self>(env, sender, send_param, pay_in_zro)
+        quote_send::<Self>(env, sender, send_param, pay_in_zro)
     }
 }
 
 // Internal OFT implementation - NOT exposed as contract endpoints
-impl OFTInner for ExtensiveOFT {
+impl OFTInternal for ExtensiveOFT {
     fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        // 1. Pausable check
         Self::__assert_not_paused(env);
-        Self::__try_consume_rate_limit_capacity(env, &Direction::Outbound, dst_eid, amount_ld);
-        Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, amount_ld);
+
+        // 2. Core debit logic
         let oft_receipt = crate::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid);
-        Self::__transfer_fee(
-            env,
-            &Self::token(env),
-            sender,
-            oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld,
-        );
+
+        // 3. Rate limit checks
+        Self::__consume_rate_limit_capacity(env, &Direction::Outbound, dst_eid, oft_receipt.amount_received_ld);
+        Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, oft_receipt.amount_received_ld);
+
+        // 4. Charge fee
+        Self::__charge_fee(env, &Self::token(env), sender, oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld);
+
         oft_receipt
     }
 
     fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+        // 1. Pausable check
         Self::__assert_not_paused(env);
-        Self::__try_consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_ld);
-        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_ld);
-        crate::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid)
+
+        // 2. Core credit logic
+        let amount_credited = crate::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid);
+
+        // 3. Rate limit checks
+        Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_credited);
+        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_credited);
+
+        amount_credited
     }
 
     fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
         let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-        let amount_after_fee = Self::__apply_fee(env, dst_eid, amount_ld);
+        let amount_after_fee = Self::__fee_view(env, dst_eid, amount_ld);
         let amount_received_ld = remove_dust(amount_after_fee, conversion_rate);
         // Note: when no fee is applied, amount_send_ld is equal to amount_received_ld
         // this is to align the behavior with the fee extensions on other VMs
@@ -699,7 +728,7 @@ impl<'a> ExtensiveOFTTestSetup<'a> {
         let fee_amount = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
 
         // Mock auth order must match contract execution order:
-        // 1. Transfer fee (__transfer_fee) - happens before burn
+        // 1. Transfer fee (__charge_fee) - happens before burn
         // 2. Burn tokens (amount_received_ld, not amount_sent_ld)
         // 3. Transfer native/zro fees (__lz_send)
         self.env.mock_auths(&[MockAuth {
@@ -709,7 +738,7 @@ impl<'a> ExtensiveOFTTestSetup<'a> {
                 fn_name: "send",
                 args: (sender, send_param, fee, refund_address).into_val(self.env),
                 sub_invokes: &[
-                    // 1. Transfer fee to fee deposit address - happens in __transfer_fee (BEFORE burn)
+                    // 1. Transfer fee to fee deposit address - happens in __charge_fee (BEFORE burn)
                     MockAuthInvoke {
                         contract: &self.token,
                         fn_name: "transfer",

package/contracts/oapps/oft/src/tests/extensions/test_oft_fee.rs

@@ -6,9 +6,11 @@
 //! - Fee deduction and transfer in send
 //! - Fee deposit address configuration
 
-use crate::extensions::oft_fee::OFTFeeError;
-use crate::tests::test_utils::{create_origin, create_recipient_address, encode_oft_message};
-use crate::utils::address_to_bytes32;
+use crate::{
+    extensions::oft_fee::OFTFeeError,
+    tests::test_utils::{create_origin, create_recipient_address, encode_oft_message},
+    utils::address_to_bytes32,
+};
 use endpoint_v2::MessagingFee;
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env, IntoVal};
 

package/contracts/oapps/oft/src/tests/extensions/test_pausable.rs

@@ -6,9 +6,11 @@
 //! - `quote_send` is blocked
 //! - `quote_oft` works (view function, not blocked)
 
-use crate::extensions::pausable::OFTPausableError;
-use crate::tests::test_utils::{create_origin, create_recipient_address, encode_oft_message};
-use crate::utils::address_to_bytes32;
+use crate::{
+    extensions::pausable::OFTPausableError,
+    tests::test_utils::{create_origin, create_recipient_address, encode_oft_message},
+    utils::address_to_bytes32,
+};
 use endpoint_v2::MessagingFee;
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env, IntoVal};
 

package/contracts/oapps/oft/src/tests/extensions/test_rate_limiter.rs

@@ -7,9 +7,11 @@
 //! - Rate limit enforcement on lz_receive (inbound)
 //! - Capacity release on opposite direction
 
-use crate::extensions::rate_limiter::{Direction, RateLimitError};
-use crate::tests::test_utils::{create_origin, create_recipient_address, encode_oft_message};
-use crate::utils::address_to_bytes32;
+use crate::{
+    extensions::rate_limiter::{Direction, RateLimitError},
+    tests::test_utils::{create_origin, create_recipient_address, encode_oft_message},
+    utils::address_to_bytes32,
+};
 use endpoint_v2::MessagingFee;
 use soroban_sdk::{
     testutils::{Address as _, Ledger as _},
@@ -376,7 +378,7 @@ fn test_consume_rate_limit_when_capacity_exactly_zero() {
     assert_eq!(setup.rate_limit_capacity(&Direction::Outbound, dst_eid), 0);
 
     // Try to send a small amount - should fail because capacity is exactly 0
-    // This tests the branch where capacity = 0 (limit <= in_flight) in __try_consume_rate_limit_capacity
+    // This tests the branch where capacity = 0 (limit <= in_flight) in __consume_rate_limit_capacity
     // Use amount that survives dust removal (conversion_rate = 10)
     let small_amount = 100i128;
     setup.fund_tokens(&sender, small_amount);

package/contracts/oapps/oft/src/tests/test_decimals.rs

@@ -17,7 +17,7 @@ fn test_decimal_conversion_rate() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2100)")] // InvalidLocalDecimals
+#[should_panic(expected = "Error(Contract, #3000)")] // InvalidLocalDecimals
 fn test_invalid_local_decimals() {
     let env = Env::default();
     OFTTestSetupBuilder::new(&env).with_token_decimals(5).with_shared_decimals(6).build();
@@ -34,7 +34,7 @@ fn test_to_ld_overflow() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2101)")] // Overflow
+#[should_panic(expected = "Error(Contract, #3002)")] // Overflow
 fn test_to_sd_overflow() {
     let env = Env::default();
 

package/contracts/oapps/oft/src/tests/test_oft_msg_codec.rs

@@ -1,5 +1,4 @@
-use crate::codec::oft_msg_codec::OFTMessage;
-use crate::utils::address_to_bytes32;
+use crate::{codec::oft_msg_codec::OFTMessage, utils::address_to_bytes32};
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
 
 #[test]

package/contracts/oapps/oft/src/tests/test_send.rs

@@ -749,7 +749,7 @@ fn test_giving_partial_authorization_with_burn_wrong_arguments() {
             sub_invokes: &[MockAuthInvoke {
                 contract: &setup.token,
                 fn_name: "burn",
-                args: (&sender, &oft_receipt.amount_sent_ld + 1).into_val(&env),
+                args: (&sender, &oft_receipt.amount_received_ld + 1).into_val(&env),
                 sub_invokes: &[],
             }],
         },
@@ -794,7 +794,7 @@ fn test_giving_partial_authorization_without_native_fee_authorizations() {
             sub_invokes: &[MockAuthInvoke {
                 contract: &setup.token,
                 fn_name: "burn",
-                args: (&sender, &oft_receipt.amount_sent_ld).into_val(&env),
+                args: (&sender, &oft_receipt.amount_received_ld).into_val(&env),
                 sub_invokes: &[],
             }],
         },
@@ -840,7 +840,7 @@ fn test_giving_partial_authorization_without_zro_fee_authorizations() {
                 MockAuthInvoke {
                     contract: &setup.token,
                     fn_name: "burn",
-                    args: (&sender, &oft_receipt.amount_sent_ld).into_val(&env),
+                    args: (&sender, &oft_receipt.amount_received_ld).into_val(&env),
                     sub_invokes: &[],
                 },
                 MockAuthInvoke {
@@ -893,7 +893,7 @@ fn test_giving_full_authorization() {
                 MockAuthInvoke {
                     contract: &setup.token,
                     fn_name: "burn",
-                    args: (&sender, &oft_receipt.amount_sent_ld).into_val(&env),
+                    args: (&sender, &oft_receipt.amount_received_ld).into_val(&env),
                     sub_invokes: &[],
                 },
                 MockAuthInvoke {

package/contracts/oapps/oft/src/tests/test_utils.rs

@@ -2,21 +2,19 @@
 //!
 //! This module provides common test contracts and helpers used across multiple test files.
 
-extern crate self as oft;
-
-use crate::codec::oft_msg_codec::OFTMessage;
-use crate::oft::{oft_initialize, OFTClient, OFTInner, OFT};
-use crate::types::{OFTReceipt, SendParam};
+use crate::{
+    codec::oft_msg_codec::OFTMessage,
+    oft::OFTClient,
+    types::{OFTReceipt, SendParam},
+};
 use endpoint_v2::{LayerZeroReceiverClient, MessagingFee, MessagingParams, MessagingReceipt, Origin};
 use oapp::oapp_core::OAppCoreClient;
-use oapp::oapp_receiver::OAppReceiver;
-use oapp_macros::oapp_manual_impl;
-use soroban_sdk::{address_payload::AddressPayload, log, String};
 use soroban_sdk::{
-    bytes, contract, contractimpl, symbol_short,
+    address_payload::AddressPayload,
+    bytes, contract, contractimpl, log, symbol_short,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     token::{StellarAssetClient, TokenClient},
-    Address, Bytes, BytesN, Env, IntoVal, Symbol,
+    Address, Bytes, BytesN, Env, IntoVal, String, Symbol,
 };
 use stellar_macros::default_impl;
 use stellar_tokens::fungible::{Base, FungibleToken};
@@ -103,84 +101,125 @@ pub fn create_origin(src_eid: u32, sender: &BytesN<32>, nonce: u64) -> Origin {
     Origin { src_eid, sender: sender.clone(), nonce }
 }
 
-// ==================== Test OFT Contract ====================
-
-#[oapp_macros::oapp]
-pub struct TestMintBurnOFT;
-
-#[contractimpl]
-impl TestMintBurnOFT {
-    pub fn __constructor(
-        env: &Env,
-        token: &Address,
-        owner: &Address,
-        endpoint: &Address,
-        delegate: &Option<Address>,
-        shared_decimals: u32,
-    ) {
-        oft_initialize::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
-    }
-}
-
-#[contractimpl(contracttrait)]
-impl OFT for TestMintBurnOFT {}
-
-impl OFTInner for TestMintBurnOFT {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        crate::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+// ==================== Test OFT Contracts ====================
+
+mod test_mint_burn_oft {
+    extern crate self as oft;
+
+    use crate::initialize_oft;
+    use crate::oft::{OFTInternal, OFT};
+    use crate::oft_impl;
+    use crate::types::OFTReceipt;
+    use endpoint_v2::Origin;
+    use oapp::oapp_receiver::LzReceiveInternal;
+    use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env};
+
+    #[oapp_macros::oapp]
+    pub struct TestMintBurnOFT;
+
+    #[contractimpl]
+    impl TestMintBurnOFT {
+        pub fn __constructor(
+            env: &Env,
+            token: &Address,
+            owner: &Address,
+            endpoint: &Address,
+            delegate: &Option<Address>,
+            shared_decimals: u32,
+        ) {
+            initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+        }
     }
 
-    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-        crate::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid)
+    #[contractimpl(contracttrait)]
+    impl OFT for TestMintBurnOFT {}
+
+    impl LzReceiveInternal for TestMintBurnOFT {
+        fn __lz_receive(
+            env: &Env,
+            origin: &Origin,
+            guid: &BytesN<32>,
+            message: &Bytes,
+            extra_data: &Bytes,
+            executor: &Address,
+            value: i128,
+        ) {
+            oft_impl::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+        }
     }
-}
 
-#[oapp_macros::oapp]
-#[oapp_manual_impl(receiver)]
-pub struct TestLockUnlockOFT;
+    impl OFTInternal for TestMintBurnOFT {
+        fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+            crate::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+        }
 
-#[contractimpl]
-impl TestLockUnlockOFT {
-    pub fn __constructor(
-        env: &Env,
-        token: &Address,
-        owner: &Address,
-        endpoint: &Address,
-        delegate: &Option<Address>,
-        shared_decimals: u32,
-    ) {
-        oft_initialize::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+        fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+            crate::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid)
+        }
     }
 }
-
-#[contractimpl(contracttrait)]
-impl OFT for TestLockUnlockOFT {}
-
-#[contractimpl(contracttrait)]
-impl OAppReceiver for TestLockUnlockOFT {
-    fn lz_receive(
-        env: &Env,
-        executor: &Address,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        extra_data: &Bytes,
-        value: i128,
-    ) {
-        oapp::oapp_receiver::verify_and_clear_payload::<Self>(env, executor, origin, guid, message, value);
-        Self::__lz_receive(env, executor, origin, guid, message, extra_data, value);
+pub use test_mint_burn_oft::TestMintBurnOFT;
+
+mod test_lock_unlock_oft {
+    extern crate self as oft;
+
+    use crate::initialize_oft;
+    use crate::oft::{OFTInternal, OFT};
+    use crate::oft_impl;
+    use crate::types::OFTReceipt;
+    use endpoint_v2::Origin;
+    use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
+    use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env};
+
+    #[oapp_macros::oapp(custom = [receiver])]
+    pub struct TestLockUnlockOFT;
+
+    #[contractimpl]
+    impl TestLockUnlockOFT {
+        pub fn __constructor(
+            env: &Env,
+            token: &Address,
+            owner: &Address,
+            endpoint: &Address,
+            delegate: &Option<Address>,
+            shared_decimals: u32,
+        ) {
+            initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+        }
     }
-}
 
-impl OFTInner for TestLockUnlockOFT {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        crate::oft_types::lock_unlock::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+    #[contractimpl(contracttrait)]
+    impl OFT for TestLockUnlockOFT {}
+
+    impl LzReceiveInternal for TestLockUnlockOFT {
+        fn __lz_receive(
+            env: &Env,
+            origin: &Origin,
+            guid: &BytesN<32>,
+            message: &Bytes,
+            extra_data: &Bytes,
+            executor: &Address,
+            value: i128,
+        ) {
+            oft_impl::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+        }
     }
 
-    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-        crate::oft_types::lock_unlock::credit::<Self>(env, to, amount_ld, src_eid)
+    // Custom receiver to demonstrate overriding next_nonce or other methods
+    #[contractimpl(contracttrait)]
+    impl OAppReceiver for TestLockUnlockOFT {}
+
+    impl OFTInternal for TestLockUnlockOFT {
+        fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+            crate::oft_types::lock_unlock::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+        }
+
+        fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+            crate::oft_types::lock_unlock::credit::<Self>(env, to, amount_ld, src_eid)
+        }
     }
 }
+pub use test_lock_unlock_oft::TestLockUnlockOFT;
 
 // ==================== Dummy Contracts ====================
 
@@ -248,12 +287,12 @@ impl MockEndpointWithCompose {
         env.storage().instance().set(&symbol_short!("zro"), &zro_token);
     }
 
-    /// Returns the native token address (required by OAppSender)
+    /// Returns the native token address (required by OAppSenderInternal)
     pub fn native_token(env: Env) -> Address {
         env.storage().instance().get(&symbol_short!("ntk")).unwrap()
     }
 
-    /// Returns the ZRO token address (required by OAppSender)
+    /// Returns the ZRO token address (required by OAppSenderInternal)
     pub fn zro(env: Env) -> Option<Address> {
         env.storage().instance().get(&symbol_short!("zro"))
     }
@@ -664,17 +703,18 @@ impl<'a> OFTTestSetup<'a> {
         oft_receipt: &OFTReceipt,
     ) -> (MessagingReceipt, OFTReceipt) {
         // Token operation sub-invoke differs based on OFT type
+        // Both MintBurn and LockUnlock use amount_received_ld (after fee/dust removal)
         let token_sub_invoke = match self.oft_type {
             OFTType::MintBurn => MockAuthInvoke {
                 contract: &self.token,
                 fn_name: "burn",
-                args: (sender, &oft_receipt.amount_sent_ld).into_val(self.env),
+                args: (sender, &oft_receipt.amount_received_ld).into_val(self.env),
                 sub_invokes: &[],
             },
             OFTType::LockUnlock => MockAuthInvoke {
                 contract: &self.token,
                 fn_name: "transfer",
-                args: (sender, &self.oft.address, &oft_receipt.amount_sent_ld).into_val(self.env),
+                args: (sender, &self.oft.address, &oft_receipt.amount_received_ld).into_val(self.env),
                 sub_invokes: &[],
             },
         };
@@ -718,17 +758,18 @@ impl<'a> OFTTestSetup<'a> {
         Result<soroban_sdk::Error, soroban_sdk::InvokeError>,
     > {
         // Token operation sub-invoke differs based on OFT type
+        // Both MintBurn and LockUnlock use amount_received_ld (after fee/dust removal)
         let token_sub_invoke = match self.oft_type {
             OFTType::MintBurn => MockAuthInvoke {
                 contract: &self.token,
                 fn_name: "burn",
-                args: (sender, &oft_receipt.amount_sent_ld).into_val(self.env),
+                args: (sender, &oft_receipt.amount_received_ld).into_val(self.env),
                 sub_invokes: &[],
             },
             OFTType::LockUnlock => MockAuthInvoke {
                 contract: &self.token,
                 fn_name: "transfer",
-                args: (sender, &self.oft.address, &oft_receipt.amount_sent_ld).into_val(self.env),
+                args: (sender, &self.oft.address, &oft_receipt.amount_received_ld).into_val(self.env),
                 sub_invokes: &[],
             },
         };

package/contracts/oapps/oft/src/types.rs

@@ -1,15 +1,28 @@
 use soroban_sdk::{contracttype, Bytes, BytesN};
 
+/// Message type for simple OFT send
+pub const SEND: u32 = 1;
+
+/// Message type for OFT send with compose functionality
+pub const SEND_AND_CALL: u32 = 2;
+
 /// Parameters for sending OFT tokens cross-chain
 #[contracttype]
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct SendParam {
+    /// The destination endpoint ID
     pub dst_eid: u32,
+    /// The recipient address on the destination chain (32 bytes)
     pub to: BytesN<32>,
+    /// The amount to send in local decimals
     pub amount_ld: i128,
+    /// The minimum amount to receive in local decimals (slippage protection)
     pub min_amount_ld: i128,
+    /// Additional options for the LayerZero message (Optional)
     pub extra_options: Bytes,
+    /// Compose message to execute on the destination (Optional)
     pub compose_msg: Bytes,
+    /// OFT command for custom behavior (Optional)
     pub oft_cmd: Bytes,
 }
 
@@ -17,7 +30,9 @@ pub struct SendParam {
 #[contracttype]
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct OFTLimit {
+    /// The minimum amount to send in local decimals
     pub min_amount_ld: i128,
+    /// The maximum amount to send in local decimals
     pub max_amount_ld: i128,
 }
 
@@ -25,7 +40,9 @@ pub struct OFTLimit {
 #[contracttype]
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct OFTReceipt {
+    /// The amount sent in local decimals
     pub amount_sent_ld: i128,
+    /// The amount received in local decimals on the remote
     pub amount_received_ld: i128,
 }
 
@@ -33,6 +50,9 @@ pub struct OFTReceipt {
 #[contracttype]
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct OFTFeeDetail {
+    /// The amount of the fee in local decimals. Positive values represent fees charged,
+    /// while negative values represent rewards given.
     pub fee_amount_ld: i128,
+    /// The description of the fee
     pub description: Bytes,
 }

package/contracts/oapps/oft-std/Cargo.toml

@@ -17,3 +17,9 @@ common-macros = { workspace = true }
 oapp-macros = { workspace = true }
 oft = { 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"] }

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

@@ -0,0 +1,3 @@
+mod test_oft_fee;
+mod test_pausable;
+mod test_rate_limiter;