@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

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

@@ -8,7 +8,7 @@ extern crate std;
 use crate::integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address};
 use common_macros::contract_impl;
 use endpoint_v2::{EndpointV2, EndpointV2Client, ILayerZeroComposer};
-use oft::oft::{oft_initialize, OFTClient, OFTInner, OFT};
+use oft::oft::{oft_initialize, OFTClient, OFTInternal, OFT};
 use oft::storage::OFTStorage;
 use oft::types::OFTReceipt;
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
@@ -29,7 +29,14 @@ pub struct TestOFT;
 
 #[contract_impl]
 impl TestOFT {
-    pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>, shared_decimals: u32) {
+    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)
     }
 }
@@ -37,7 +44,7 @@ impl TestOFT {
 #[contractimpl(contracttrait)]
 impl OFT for TestOFT {}
 
-impl OFTInner for TestOFT {
+impl OFTInternal for TestOFT {
     fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
         // Get the receipt (handles decimal conversion, fees, etc.)
         let receipt = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);

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

@@ -74,7 +74,7 @@ pub fn send(
                 MockAuthInvoke {
                     contract: &chain.oft_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: &[],
                 },
             ],

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

@@ -62,7 +62,7 @@ pub fn default_lz_receive<T>(
     _extra_data: &Bytes,
     _value: i128,
 ) where
-    T: crate::oft::OFTInner,
+    T: crate::oft::OFTInternal,
 {
     let oft_msg = OFTMessage::decode(message);
     let send_to = resolve_address(env, &oft_msg.send_to);
@@ -91,11 +91,17 @@ pub fn default_lz_receive<T>(
 /// Returns (OFTLimit, fee details, receipt with estimated amounts).
 pub fn default_quote_oft<T>(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt)
 where
-    T: crate::oft::OFTInner,
+    T: crate::oft::OFTInternal,
 {
     let oft_receipt = T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
     let oft_fee_details = if oft_receipt.amount_sent_ld > oft_receipt.amount_received_ld {
-        vec![env, OFTFeeDetail { fee_amount_ld: oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld, description: Bytes::from_array(env, b"OFT Fee") }]
+        vec![
+            env,
+            OFTFeeDetail {
+                fee_amount_ld: oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld,
+                description: Bytes::from_array(env, b"OFT Fee"),
+            },
+        ]
     } else {
         vec![env]
     };

package/contracts/oapps/oft/src/extensions/oft_fee.rs

@@ -118,7 +118,7 @@ pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
 /// Internal trait for OFT fee operations used by OFT hooks.
 /// Contains only truly internal methods that are called from OFTInner implementations.
 pub trait OFTFeeInternal {
-    /// Applies the configured fee to the given amount and returns the amount after fee deduction.
+    /// Calculates the amount after fee deduction (read-only, mirrors `__debit_view`).
     /// Used internally by `__debit_view` to calculate amount after fee.
     ///
     /// # Arguments
@@ -127,7 +127,7 @@ pub trait OFTFeeInternal {
     ///
     /// # Returns
     /// The amount after fee deduction (original amount - calculated fee)
-    fn __apply_fee(env: &Env, dst_eid: u32, amount_ld: i128) -> i128 {
+    fn __fee_view(env: &Env, dst_eid: u32, amount_ld: i128) -> i128 {
         // Calculate effective fee (destination-specific or default)
         let fee_bps = if OFTFeeStorage::has_fee_bps(env, dst_eid) {
             OFTFeeStorage::fee_bps(env, dst_eid).unwrap()
@@ -147,14 +147,14 @@ pub trait OFTFeeInternal {
         amount_ld - preliminary_fee
     }
 
-    /// Transfers the fee amount from sender to the fee deposit address.
-    /// Used internally by `__debit` to collect the fee after calculating the debit amounts.
+    /// Charges the fee by transferring the fee amount from sender to the fee deposit address.
+    /// Used internally by `__debit` to collect the fee (mirrors `__debit`).
     ///
     /// # Arguments
     /// * `token` - The token address to transfer
     /// * `sender` - The sender address to transfer fee from
     /// * `fee_amount` - The fee amount to transfer
-    fn __transfer_fee(env: &Env, token: &Address, sender: &Address, fee_amount: i128) {
+    fn __charge_fee(env: &Env, token: &Address, sender: &Address, fee_amount: i128) {
         if fee_amount > 0 {
             assert_with_error!(
                 env,

package/contracts/oapps/oft/src/extensions/pausable.rs

@@ -37,7 +37,7 @@ pub trait OFTPausable: OFTPausableInternal + Ownable + Sized {
 }
 
 /// Internal trait for pausable operations used by OFT hooks.
-/// Contains only truly internal methods that are called from OFTInner implementations.
+/// Contains only truly internal methods that are called from OFTInternal implementations.
 pub trait OFTPausableInternal {
     /// Asserts that the OFT is not paused, panics otherwise.
     /// Used internally by `send`, `quote_send`, and `__lz_receive` to enforce pause state.

package/contracts/oapps/oft/src/extensions/rate_limiter.rs

@@ -77,6 +77,16 @@ fn calculate_in_flight(env: &Env, direction: &Direction, eid: u32) -> i128 {
     }
 }
 
+/// Checkpoints the current in-flight amount by applying decay and updating timestamp.
+/// Used internally before modifying rate limit state.
+fn checkpoint_rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) {
+    let in_flight = calculate_in_flight(env, direction, eid);
+    let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+    rate_limit.in_flight_on_last_update = in_flight;
+    rate_limit.last_update = env.ledger().timestamp();
+    RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+}
+
 #[contracttrait]
 pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
     #[only_owner]
@@ -90,7 +100,7 @@ pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
                 limit != rate_limit_data.limit || window_seconds != rate_limit_data.window_seconds,
                 RateLimitError::SameValue
             );
-            Self::__checkpoint_rate_limit_in_flight(env, direction, eid);
+            checkpoint_rate_limit_in_flight(env, direction, eid);
             let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
             rate_limit.limit = limit;
             rate_limit.window_seconds = window_seconds;
@@ -146,18 +156,18 @@ pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
 }
 
 /// Internal trait for rate limiter operations used by OFT hooks.
-/// Contains only truly internal methods that are called from OFTInner implementations.
+/// Contains only truly internal methods that are called from OFTInternal implementations.
 pub trait RateLimiterInternal {
-    /// Tries to consume the specified amount from the rate limit capacity.
-    /// Used internally by `send` and `__lz_receive` to enforce rate limits.
+    /// Consumes the specified amount from the rate limit capacity.
+    /// Used internally by `__debit` and `__credit` to enforce rate limits.
     ///
     /// # Errors
     /// * `ExceededRateLimit` - If the amount exceeds the available capacity.
-    fn __try_consume_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
+    fn __consume_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
         if !RateLimitStorage::has_rate_limit(env, direction, eid) {
             return;
         }
-        Self::__checkpoint_rate_limit_in_flight(env, direction, eid);
+        checkpoint_rate_limit_in_flight(env, direction, eid);
         let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
         // Check against remaining capacity (limit - current in_flight), not total limit
         let capacity = if rate_limit.limit > rate_limit.in_flight_on_last_update {
@@ -173,12 +183,12 @@ pub trait RateLimiterInternal {
     }
 
     /// Releases the specified amount back to the rate limit capacity.
-    /// Used internally by `__lz_receive` to release outbound capacity on inbound messages.
+    /// Used internally by `__credit` to release outbound capacity on inbound messages.
     fn __release_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
         if !RateLimitStorage::has_rate_limit(env, direction, eid) {
             return;
         }
-        Self::__checkpoint_rate_limit_in_flight(env, direction, eid);
+        checkpoint_rate_limit_in_flight(env, direction, eid);
         let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
         if amount >= rate_limit.in_flight_on_last_update {
             rate_limit.in_flight_on_last_update = 0;
@@ -187,14 +197,4 @@ pub trait RateLimiterInternal {
         }
         RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
     }
-
-    /// Checkpoints the current in-flight amount by applying decay and updating timestamp.
-    /// Used internally before modifying rate limit state.
-    fn __checkpoint_rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) {
-        let in_flight = calculate_in_flight(env, direction, eid);
-        let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-        rate_limit.in_flight_on_last_update = in_flight;
-        rate_limit.last_update = env.ledger().timestamp();
-        RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
-    }
 }

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

@@ -1,14 +1,14 @@
 //! OFT traits - the main interface for OFT contracts.
 //!
 //! This module provides two traits:
-//! - `OFTInner`: Internal methods NOT exposed as contract endpoints (`__debit`, `__credit`, etc.)
+//! - `OFTInternal`: Internal methods NOT exposed as contract endpoints (`__debit`, `__credit`, etc.)
 //! - `OFT`: Public methods exposed as contract endpoints (using `#[contracttrait]`)
 //!
 //! ## Usage
 //!
 //! ```ignore
 //! use oapp_macros::{oapp, oapp_options_type3};
-//! use oft::oft::{oft_initialize, OFTInner, OFT};
+//! use oft::oft::{oft_initialize, OFTInternal, OFT};
 //!
 //! #[oapp]
 //! pub struct MyOFT;
@@ -26,7 +26,7 @@
 //!
 //! // Internal methods - NOT exposed as contract endpoints
 //! // IMPORTANT: Do NOT use #[contractimpl] here to keep methods internal
-//! impl OFTInner for MyOFT {
+//! impl OFTInternal for MyOFT {
 //!     fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
 //!         // Your debit logic (e.g., burn or lock tokens)
 //!         oft::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
@@ -80,7 +80,7 @@ pub fn oft_initialize<T: OFT + OwnableInitializer>(
 }
 
 // =====================================================
-// OFTInner Trait (NOT exposed as contract endpoints)
+// OFTInternal Trait (NOT exposed as contract endpoints)
 // =====================================================
 
 /// Internal OFT trait containing methods that should NOT be exposed as contract endpoints.
@@ -90,18 +90,18 @@ pub fn oft_initialize<T: OFT + OwnableInitializer>(
 ///
 /// ```ignore
 /// // Correct - methods stay internal
-/// impl OFTInner for MyOFT { ... }
+/// impl OFTInternal for MyOFT { ... }
 ///
 /// // WRONG - would expose methods as endpoints
 /// #[contractimpl]
-/// impl OFTInner for MyOFT { ... }
+/// impl OFTInternal for MyOFT { ... }
 /// ```
 ///
 /// Internal OFT trait for token debit/credit operations.
 ///
 /// This trait contains only the internal token operations. The OApp supertraits
 /// are on `OFT` instead, keeping this trait focused on token logic.
-pub trait OFTInner: OAppCore {
+pub trait OFTInternal: OAppCore {
     // =========================================================================
     // Required Methods (no defaults - user MUST implement)
     // =========================================================================
@@ -175,9 +175,9 @@ pub trait OFTInner: OAppCore {
 /// contract endpoints. Users implement this with `#[contractimpl(contracttrait)]`.
 ///
 /// Internal methods like `__debit`, `__credit`, `__debit_view`, and `__build_msg_and_options`
-/// are in the `OFTInner` trait and are NOT exposed as contract endpoints.
+/// are in the `OFTInternal` trait and are NOT exposed as contract endpoints.
 #[contracttrait(client_name = "OFTClient")]
-pub trait OFT: OFTInner + OAppReceiver + OAppSender + OAppOptionsType3 {
+pub trait OFT: OFTInternal + OAppReceiver + OAppSender + OAppOptionsType3 {
     /// Retrieves the token address associated with this OFT.
     fn token(env: &Env) -> Address {
         OFTStorage::token(env).unwrap()

package/contracts/oapps/oft/src/oft_types/lock_unlock.rs

@@ -22,7 +22,7 @@ use crate::types::OFTReceipt;
 /// `OFTReceipt` containing the amount sent and amount received
 pub fn debit<T: OFT>(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
     let receipt: OFTReceipt = T::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
-    TokenClient::new(env, &T::token(env)).transfer(sender, env.current_contract_address(), &receipt.amount_sent_ld);
+    TokenClient::new(env, &T::token(env)).transfer(sender, env.current_contract_address(), &receipt.amount_received_ld);
     receipt
 }
 

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

@@ -10,7 +10,7 @@ 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::oft::{oft_initialize, OFTInternal, OFT};
 use crate::storage::OFTStorage;
 use crate::tests::test_utils::{
     create_recipient_address, DummyToken, MockEndpointWithCompose, MockEndpointWithComposeClient, DEFAULT_NATIVE_FEE,
@@ -73,31 +73,46 @@ impl OFT for ExtensiveOFT {
 }
 
 // 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(
+
+        // 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 +714,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 +724,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_rate_limiter.rs

@@ -376,7 +376,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_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,15 +2,11 @@
 //!
 //! 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::oft::OFTClient;
 use crate::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,
@@ -103,84 +99,105 @@ 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)
+// ==================== Test OFT Contracts ====================
+
+mod test_mint_burn_oft {
+    extern crate self as oft;
+
+    use crate::oft::{oft_initialize, OFTInternal, OFT};
+    use crate::types::OFTReceipt;
+    use soroban_sdk::{contractimpl, Address, 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,
+        ) {
+            oft_initialize::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+        }
     }
-}
 
-#[contractimpl(contracttrait)]
-impl OFT for TestMintBurnOFT {}
+    #[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)
-    }
+    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)
+        }
 
-    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)
+        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)
+        }
     }
 }
-
-#[oapp_macros::oapp]
-#[oapp_manual_impl(receiver)]
-pub struct TestLockUnlockOFT;
-
-#[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)
+pub use test_mint_burn_oft::TestMintBurnOFT;
+
+mod test_lock_unlock_oft {
+    extern crate self as oft;
+
+    use crate::oft::{oft_initialize, OFTInternal, OFT};
+    use crate::types::OFTReceipt;
+    use endpoint_v2::Origin;
+    use oapp::oapp_receiver::OAppReceiver;
+    use oapp_macros::oapp_manual_impl;
+    use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env};
+
+    #[oapp_macros::oapp]
+    #[oapp_manual_impl(receiver)]
+    pub struct TestLockUnlockOFT;
+
+    #[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)
+        }
     }
-}
-
-#[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);
+    #[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);
+        }
     }
-}
 
-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)
-    }
+    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)
+        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 ====================
 
@@ -664,17 +681,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 +736,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-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;