@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

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

@@ -4,7 +4,7 @@ use utils::{auth::Auth, option_ext::OptionExt};
 
 /// Base fee in basis points (10,000 BPS = 100%)
 /// Used as denominator in fee calculations
-const BASE_FEE_BPS: u64 = 10_000;
+const BASE_FEE_BPS: u32 = 10_000;
 
 // =========================================================================
 // Storage
@@ -12,15 +12,14 @@ const BASE_FEE_BPS: u64 = 10_000;
 
 #[storage]
 pub enum OFTFeeStorage {
-    /// Default fee rate in basis points (0-10,000, where 10,000 = 100%)
+    /// Default fee rate in basis points (1-10,000, where 10,000 = 100%)
     /// Applied to destinations without specific fee configuration
-    /// No fee is charged(default to 0) by default
-    #[instance(u64)]
-    #[default(0)]
+    /// Not set by default (effective rate is 0 when unset)
+    #[instance(u32)]
     DefaultFeeBps,
 
     /// Destination-specific fee rates mapped by endpoint ID (eid)
-    #[persistent(u64)]
+    #[persistent(u32)]
     FeeBps { eid: u32 },
 
     /// Address where collected fees will be deposited
@@ -46,7 +45,8 @@ pub enum OFTFeeError {
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DefaultFeeBpsSet {
-    pub fee_bps: u64,
+    /// The default fee rate in basis points, or None if the default fee is removed
+    pub fee_bps: Option<u32>,
 }
 
 #[contractevent]
@@ -54,13 +54,14 @@ pub struct DefaultFeeBpsSet {
 pub struct FeeBpsSet {
     pub dst_eid: u32,
     /// The fee rate in basis points, or None if the fee is removed
-    pub fee_bps: Option<u64>,
+    pub fee_bps: Option<u32>,
 }
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FeeDepositAddressSet {
-    pub fee_deposit_address: Address,
+    /// The address to deposit fees to, or None to remove the fee deposit address
+    pub fee_deposit_address: Option<Address>,
 }
 
 // =========================================================================
@@ -73,49 +74,56 @@ pub trait OFTFee: OFTFeeInternal + Auth {
     // Management Functions
     // =========================================================================
 
-    /// Sets the default fee rate in basis points.
+    /// Sets or removes the default fee rate in basis points.
+    ///
+    /// - `Some(n)`: sets the default fee to `n` basis points (must be >0 and <=10,000).
+    /// - `Some(0)`: rejected — use `None` to remove the default fee instead.
+    /// - `None`: removes the default fee (effective rate becomes 0).
     #[only_auth]
-    fn set_default_fee_bps(env: &soroban_sdk::Env, default_fee_bps: u64) {
+    fn set_default_fee_bps(env: &soroban_sdk::Env, default_fee_bps: &Option<u32>) {
         Self::__set_default_fee_bps(env, default_fee_bps);
     }
 
     /// Sets or removes the fee rate for a specific destination endpoint.
     ///
+    /// - `Some(0)`: explicitly sets zero fee for this destination, overriding the default fee.
+    /// - `None`: removes the per-destination override; falls back to the default fee.
+    ///
     /// # Arguments
     /// * `dst_eid` - The destination endpoint ID
     /// * `fee_bps` - The fee rate (0-10,000), or None to remove the fee configuration
     #[only_auth]
-    fn set_fee_bps(env: &soroban_sdk::Env, dst_eid: u32, fee_bps: Option<u64>) {
+    fn set_fee_bps(env: &soroban_sdk::Env, dst_eid: u32, fee_bps: &Option<u32>) {
         Self::__set_fee_bps(env, dst_eid, fee_bps);
     }
 
-    /// Sets the address where collected fees will be deposited.
+    /// Sets or removes the address where collected fees will be deposited.
     #[only_auth]
-    fn set_fee_deposit_address(env: &soroban_sdk::Env, fee_deposit_address: soroban_sdk::Address) {
-        Self::__set_fee_deposit_address(env, &fee_deposit_address);
+    fn set_fee_deposit_address(env: &soroban_sdk::Env, fee_deposit_address: &Option<soroban_sdk::Address>) {
+        Self::__set_fee_deposit_address(env, fee_deposit_address);
     }
 
     // =========================================================================
     // View Functions
     // =========================================================================
 
-    /// Returns the default fee rate in basis points.
-    fn default_fee_bps(env: &soroban_sdk::Env) -> u64 {
+    /// Returns the default fee rate in basis points, if set.
+    fn default_fee_bps(env: &soroban_sdk::Env) -> Option<u32> {
         Self::__default_fee_bps(env)
     }
 
     /// Returns the fee rate for a specific destination, if set.
-    fn fee_bps(env: &soroban_sdk::Env, dst_eid: u32) -> Option<u64> {
+    fn fee_bps(env: &soroban_sdk::Env, dst_eid: u32) -> Option<u32> {
         Self::__fee_bps(env, dst_eid)
     }
 
     /// Returns the effective fee rate for a destination (destination-specific or default).
-    fn effective_fee_bps(env: &soroban_sdk::Env, dst_eid: u32) -> u64 {
+    fn effective_fee_bps(env: &soroban_sdk::Env, dst_eid: u32) -> u32 {
         Self::__effective_fee_bps(env, dst_eid)
     }
 
     /// Returns the fee deposit address.
-    fn fee_deposit_address(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+    fn fee_deposit_address(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
         Self::__fee_deposit_address(env)
     }
 }
@@ -157,7 +165,8 @@ pub trait OFTFeeInternal {
     /// * `fee_amount` - The fee amount to transfer
     fn __charge_fee(env: &Env, token: &Address, from: &Address, fee_amount: i128) {
         if fee_amount != 0 {
-            let fee_deposit = Self::__fee_deposit_address(env);
+            let fee_deposit =
+                Self::__fee_deposit_address(env).unwrap_or_panic(env, OFTFeeError::InvalidFeeDepositAddress);
             TokenClient::new(env, token).transfer(from, &fee_deposit, &fee_amount);
         }
     }
@@ -166,52 +175,49 @@ pub trait OFTFeeInternal {
     // Management Functions
     // =========================================================================
 
-    /// Sets the default fee rate in basis points.
+    /// Sets or removes the default fee rate in basis points.
     ///
     /// # Arguments
-    /// * `default_fee_bps` - The default fee rate (0-10,000, where 10,000 = 100%)
-    fn __set_default_fee_bps(env: &Env, default_fee_bps: u64) {
-        assert_with_error!(env, default_fee_bps <= BASE_FEE_BPS, OFTFeeError::InvalidFeeBps);
-
-        let current_default = Self::__default_fee_bps(env);
-        assert_with_error!(env, current_default != default_fee_bps, OFTFeeError::SameValue);
+    /// * `default_fee_bps` - The default fee rate (>0 and <=10,000, where 10,000 = 100%) or None to remove the default fee rate
+    fn __set_default_fee_bps(env: &Env, default_fee_bps: &Option<u32>) {
+        let current = Self::__default_fee_bps(env);
+        assert_with_error!(env, current != *default_fee_bps, OFTFeeError::SameValue);
+        assert_with_error!(
+            env,
+            default_fee_bps.is_none_or(|bps| bps > 0 && bps <= BASE_FEE_BPS),
+            OFTFeeError::InvalidFeeBps
+        );
 
-        OFTFeeStorage::set_default_fee_bps(env, &default_fee_bps);
-
-        DefaultFeeBpsSet { fee_bps: default_fee_bps }.publish(env);
+        OFTFeeStorage::set_or_remove_default_fee_bps(env, default_fee_bps);
+        DefaultFeeBpsSet { fee_bps: *default_fee_bps }.publish(env);
     }
 
     /// Sets or removes the fee rate for a specific destination endpoint.
     ///
+    /// - `Some(0)`: explicitly sets zero fee for this destination, overriding the default fee.
+    /// - `None`: removes the per-destination override; falls back to the default fee.
+    ///
     /// # Arguments
     /// * `dst_eid` - The destination endpoint ID
     /// * `fee_bps` - The fee rate (0-10,000), or None to remove the fee configuration
-    fn __set_fee_bps(env: &Env, dst_eid: u32, fee_bps: Option<u64>) {
+    fn __set_fee_bps(env: &Env, dst_eid: u32, fee_bps: &Option<u32>) {
         let current_fee_bps = Self::__fee_bps(env, dst_eid);
-        assert_with_error!(env, current_fee_bps != fee_bps, OFTFeeError::SameValue);
-
-        match fee_bps {
-            Some(bps) => {
-                assert_with_error!(env, bps <= BASE_FEE_BPS, OFTFeeError::InvalidFeeBps);
-                OFTFeeStorage::set_fee_bps(env, dst_eid, &bps);
-            }
-            None => {
-                OFTFeeStorage::remove_fee_bps(env, dst_eid);
-            }
-        }
+        assert_with_error!(env, current_fee_bps != *fee_bps, OFTFeeError::SameValue);
+        assert_with_error!(env, fee_bps.is_none_or(|bps| bps <= BASE_FEE_BPS), OFTFeeError::InvalidFeeBps);
+
+        OFTFeeStorage::set_or_remove_fee_bps(env, dst_eid, fee_bps);
 
-        FeeBpsSet { dst_eid, fee_bps }.publish(env);
+        FeeBpsSet { dst_eid, fee_bps: *fee_bps }.publish(env);
     }
 
-    /// Sets the address where collected fees will be deposited.
+    /// Sets or removes the address where collected fees will be deposited.
     ///
     /// # Arguments
-    /// * `fee_deposit_address` - The address to deposit fees to
-    fn __set_fee_deposit_address(env: &Env, fee_deposit_address: &Address) {
-        if let Some(current_address) = OFTFeeStorage::fee_deposit_address(env) {
-            assert_with_error!(env, current_address != *fee_deposit_address, OFTFeeError::SameValue);
-        }
-        OFTFeeStorage::set_fee_deposit_address(env, fee_deposit_address);
+    /// * `fee_deposit_address` - The address to deposit fees to, or None to remove the fee deposit address
+    fn __set_fee_deposit_address(env: &Env, fee_deposit_address: &Option<Address>) {
+        let current = Self::__fee_deposit_address(env);
+        assert_with_error!(env, current != *fee_deposit_address, OFTFeeError::SameValue);
+        OFTFeeStorage::set_or_remove_fee_deposit_address(env, fee_deposit_address);
         FeeDepositAddressSet { fee_deposit_address: fee_deposit_address.clone() }.publish(env);
     }
 
@@ -219,27 +225,23 @@ pub trait OFTFeeInternal {
     // View Functions
     // =========================================================================
 
-    /// Returns the effective fee rate for a destination (destination-specific or default).
-    fn __effective_fee_bps(env: &Env, dst_eid: u32) -> u64 {
-        if OFTFeeStorage::has_fee_bps(env, dst_eid) {
-            OFTFeeStorage::fee_bps(env, dst_eid).unwrap()
-        } else {
-            OFTFeeStorage::default_fee_bps(env)
-        }
+    /// Returns the effective fee rate for a destination (destination-specific or default, 0 if neither).
+    fn __effective_fee_bps(env: &Env, dst_eid: u32) -> u32 {
+        Self::__fee_bps(env, dst_eid).or_else(|| Self::__default_fee_bps(env)).unwrap_or(0)
     }
 
-    /// Returns the default fee rate in basis points.
-    fn __default_fee_bps(env: &Env) -> u64 {
+    /// Returns the default fee rate in basis points, if set.
+    fn __default_fee_bps(env: &Env) -> Option<u32> {
         OFTFeeStorage::default_fee_bps(env)
     }
 
     /// Returns the fee rate for a specific destination, if set.
-    fn __fee_bps(env: &Env, dst_eid: u32) -> Option<u64> {
+    fn __fee_bps(env: &Env, dst_eid: u32) -> Option<u32> {
         OFTFeeStorage::fee_bps(env, dst_eid)
     }
 
     /// Returns the fee deposit address.
-    fn __fee_deposit_address(env: &Env) -> Address {
-        OFTFeeStorage::fee_deposit_address(env).unwrap_or_panic(env, OFTFeeError::InvalidFeeDepositAddress)
+    fn __fee_deposit_address(env: &Env) -> Option<Address> {
+        OFTFeeStorage::fee_deposit_address(env)
     }
 }

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

@@ -9,7 +9,6 @@ use utils::auth::Auth;
 #[storage]
 pub enum OFTPausableStorage {
     #[instance(bool)]
-    #[default(false)]
     Paused,
 }
 
@@ -84,7 +83,7 @@ pub trait OFTPausableInternal {
     /// * `paused` - `true` to pause, `false` to unpause
     fn __set_paused(env: &Env, paused: bool) {
         assert_with_error!(env, Self::__is_paused(env) != paused, OFTPausableError::PauseStatusUnchanged);
-        OFTPausableStorage::set_paused(env, &paused);
+        OFTPausableStorage::set_or_remove_paused(env, if paused { &Some(true) } else { &None });
         PausedSet { paused }.publish(env);
     }
 
@@ -94,6 +93,6 @@ pub trait OFTPausableInternal {
 
     /// Returns the paused state of the OFT.
     fn __is_paused(env: &Env) -> bool {
-        OFTPausableStorage::paused(env)
+        OFTPausableStorage::has_paused(env)
     }
 }

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

@@ -15,12 +15,23 @@ pub enum Direction {
     Outbound,
 }
 
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum Mode {
+    /// Net rate limit: releases decrement in-flight amount
+    Net,
+    /// Gross rate limit: releases do not affect in-flight amount
+    Gross,
+}
+
 /// Configuration for rate limiting, used as input parameter.
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct RateLimitConfig {
     pub limit: i128,
     pub window_seconds: u64,
+    pub mode: Mode,
 }
 
 /// Internal storage struct for rate limit state.
@@ -30,6 +41,7 @@ pub struct RateLimitConfig {
 /// - `config.window_seconds` defines how long it takes for the bucket to fully drain
 /// - Tokens decay linearly over time: `decay = elapsed_time * limit / window_seconds`
 /// - Current in-flight = `in_flight_on_last_update - decay` (clamped to 0)
+/// - `config.mode` determines whether releases affect in-flight (Net) or not (Gross)
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct RateLimitState {
@@ -98,7 +110,7 @@ pub trait RateLimiter: RateLimiterInternal + Auth {
         env: &soroban_sdk::Env,
         direction: &oft::rate_limiter::Direction,
         eid: u32,
-        config: Option<oft::rate_limiter::RateLimitConfig>,
+        config: &Option<oft::rate_limiter::RateLimitConfig>,
     ) {
         Self::__set_rate_limit(env, direction, eid, config);
     }
@@ -163,6 +175,7 @@ pub trait RateLimiterInternal {
 
     /// Releases the specified amount back to the rate limit capacity.
     /// Used internally by `__credit` to release outbound capacity on inbound messages.
+    /// Only releases for Net mode; Gross mode ignores releases.
     fn __release_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
         assert_with_error!(env, amount >= 0, RateLimitError::InvalidAmount);
 
@@ -170,6 +183,11 @@ pub trait RateLimiterInternal {
             return;
         };
 
+        // Gross mode does not release capacity
+        if state.config.mode == Mode::Gross {
+            return;
+        }
+
         // Apply decay and update timestamp
         let in_flight = calculate_decayed_in_flight(env, &state);
         state.in_flight_on_last_update = (in_flight - amount).max(0);
@@ -188,10 +206,10 @@ pub trait RateLimiterInternal {
     /// * `direction` - The direction (Inbound or Outbound)
     /// * `eid` - The endpoint ID
     /// * `config` - The rate limit configuration, or None to remove the rate limit
-    fn __set_rate_limit(env: &Env, direction: &Direction, eid: u32, config: Option<RateLimitConfig>) {
+    fn __set_rate_limit(env: &Env, direction: &Direction, eid: u32, config: &Option<RateLimitConfig>) {
         let current_state = RateLimitStorage::rate_limit(env, direction, eid);
         let current_config = current_state.as_ref().map(|s| s.config.clone());
-        assert_with_error!(env, current_config != config, RateLimitError::SameValue);
+        assert_with_error!(env, current_config != *config, RateLimitError::SameValue);
 
         match config {
             Some(cfg) => {
@@ -213,13 +231,12 @@ pub trait RateLimiterInternal {
                 };
 
                 RateLimitStorage::set_rate_limit(env, direction, eid, &state);
-                RateLimitSet { direction: direction.clone(), eid, config: Some(cfg) }.publish(env);
             }
             None => {
                 RateLimitStorage::remove_rate_limit(env, direction, eid);
-                RateLimitSet { direction: direction.clone(), eid, config: None }.publish(env);
             }
         }
+        RateLimitSet { direction: direction.clone(), eid, config: config.clone() }.publish(env);
     }
 
     // =========================================================================

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

@@ -0,0 +1,18 @@
+//! MintBurnable trait - the interface the OFT uses to mint/burn tokens.
+//!
+//! Any contract that implements `mint` and `burn` can serve as a mintburnable
+
+use soroban_sdk::{contractclient, Address, Env};
+
+/// The mint/burn interface for OFT MintBurn operations.
+///
+/// Both a raw Stellar Asset Contract (SAC) and a token wrapper satisfy this
+/// interface, allowing the OFT to be agnostic about the underlying implementation.
+#[contractclient(name = "MintBurnableClient")]
+pub trait MintBurnable {
+    /// Mints `amount` tokens to `to`.
+    fn mint(env: &Env, to: &Address, amount: i128);
+
+    /// Burns `amount` tokens from `from`.
+    fn burn(env: &Env, from: &Address, amount: i128);
+}

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

@@ -0,0 +1,3 @@
+mod mint_burnable;
+
+pub use mint_burnable::*;

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

@@ -1,9 +1,11 @@
 #![no_std]
 
-pub mod extensions;
-pub mod oft_types;
+mod extensions;
+mod interfaces;
+mod oft_types;
 
 pub use extensions::*;
+pub use interfaces::*;
 pub use oft_types::*;
 
 cfg_if::cfg_if! {

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

@@ -10,12 +10,10 @@ use crate::{
 use common_macros::{contract_impl, storage};
 use oapp_macros::oapp;
 use oft_core::{
-    errors::OFTError,
-    impl_oft_lz_receive,
-    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
-    utils as oft_utils, OFTCore, OFTInternal,
+    impl_oft_lz_receive, utils as oft_utils, OFTCore, OFTError, OFTFeeDetail, OFTInternal, OFTLimit, OFTReceipt,
+    SendParam,
 };
-use soroban_sdk::{assert_with_error, vec, Address, Bytes, Env, Vec};
+use soroban_sdk::{assert_with_error, Address, Bytes, Env, Vec};
 
 // =========================================================================
 // Storage
@@ -42,17 +40,17 @@ impl OFT {
     pub fn __constructor(
         env: &Env,
         token: &Address,
-        owner: &Address,
-        endpoint: &Address,
-        delegate: &Option<Address>,
         shared_decimals: u32,
         oft_type: OftType,
+        owner: &Address,
+        endpoint: &Address,
+        delegate: &Address,
     ) {
-        Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals);
+        Self::__initialize_oft(env, token, shared_decimals, owner, endpoint, delegate);
         OFTStorage::set_oft_type(env, &oft_type);
     }
 
-    /// Returns the type of operation for this OFT (LockUnlock or MintBurn)
+    /// Returns the OFT type with its target address and configuration.
     pub fn oft_type(env: &Env) -> OftType {
         OFTStorage::oft_type(env).unwrap()
     }
@@ -61,22 +59,19 @@ impl OFT {
 /// OFTCore trait implementation for standard OFT with extensions
 #[contract_impl(contracttrait)]
 impl OFTCore for OFT {
-    fn quote_oft(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
-        let (_, _, oft_receipt) = Self::__quote_oft(env, send_param);
+    fn quote_oft(env: &Env, from: &Address, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+        let (mut limit, mut fee_details, receipt) = Self::__quote_oft(env, from, send_param);
 
         // fee details (only include if there's an actual fee)
-        let fee_amount_ld = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
-        let fee_details = if fee_amount_ld > 0 {
-            vec![env, OFTFeeDetail { fee_amount_ld, description: Bytes::from_slice(env, b"OFT Fee") }]
-        } else {
-            vec![env]
+        if receipt.amount_sent_ld > receipt.amount_received_ld {
+            let fee_amount_ld = receipt.amount_sent_ld - receipt.amount_received_ld;
+            fee_details.push_back(OFTFeeDetail { fee_amount_ld, description: Bytes::from_slice(env, b"OFT Fee") });
         };
 
         // rate limit capacity
-        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 };
+        limit.max_amount_ld = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
 
-        (oft_limit, fee_details, oft_receipt)
+        (limit, fee_details, receipt)
     }
 }
 
@@ -85,9 +80,9 @@ impl OFTInternal for OFT {
     /// Overrides default to add pausable check and fee calculation.
     ///
     /// Dust handling (consistent with EVM):
-    /// - fee = 0: dust stays with sender
-    /// - fee > 0: dust goes to fee recipient (included in charged fee)
-    fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+    /// - fee = 0: dust stays with sender (amount_sent_ld has dust removed)
+    /// - fee > 0: dust is absorbed into the charged fee (amount_sent_ld is the full amount)
+    fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
         Self::__assert_not_paused(env);
 
         let conversion_rate = Self::__decimal_conversion_rate(env);
@@ -99,32 +94,36 @@ impl OFTInternal for OFT {
             (amount_sent_ld, amount_sent_ld)
         } else {
             // With fee: match EVM OFTFee behavior
-            // - dust is included in charged fee (goes to fee recipient)
+            // - sender pays full amount_ld (no dust removed), dust is absorbed into the charged fee
             let amount_received_ld = oft_utils::remove_dust(amount_ld - fee, conversion_rate);
             (amount_ld, amount_received_ld)
         };
 
         assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
 
-        OFTReceipt { amount_sent_ld, amount_received_ld }
+        (amount_sent_ld, amount_received_ld)
     }
 
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
         // Core debit logic (based on oft_type)
-        let oft_receipt = match Self::oft_type(env) {
-            OftType::LockUnlock => lock_unlock::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid),
-            OftType::MintBurn => mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid),
+        let (amount_sent_ld, amount_received_ld) = match Self::oft_type(env) {
+            OftType::LockUnlock => {
+                lock_unlock::debit::<Self>(env, &Self::token(env), sender, amount_ld, min_amount_ld, dst_eid)
+            }
+            OftType::MintBurn(mint_burnable) => {
+                mint_burn::debit::<Self>(env, &mint_burnable, sender, amount_ld, min_amount_ld, dst_eid)
+            }
         };
 
         // Rate limit checks (using amount_received_ld - the actual cross-chain amount)
-        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);
+        Self::__consume_rate_limit_capacity(env, &Direction::Outbound, dst_eid, amount_received_ld);
+        Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, amount_received_ld);
 
         // Charge fee
-        let fee = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
-        Self::__charge_fee(env, &Self::__token(env), sender, fee);
+        let fee = amount_sent_ld - amount_received_ld;
+        Self::__charge_fee(env, &Self::token(env), sender, fee);
 
-        oft_receipt
+        (amount_sent_ld, amount_received_ld)
     }
 
     fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
@@ -133,8 +132,8 @@ impl OFTInternal for OFT {
 
         // Core credit logic (based on mode)
         let amount_credited = match Self::oft_type(env) {
-            OftType::LockUnlock => lock_unlock::credit::<Self>(env, to, amount_ld, src_eid),
-            OftType::MintBurn => mint_burn::credit::<Self>(env, to, amount_ld, src_eid),
+            OftType::LockUnlock => lock_unlock::credit::<Self>(env, &Self::token(env), to, amount_ld, src_eid),
+            OftType::MintBurn(mint_burnable) => mint_burn::credit::<Self>(env, &mint_burnable, to, amount_ld, src_eid),
         };
 
         // Rate limit checks

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

@@ -2,45 +2,49 @@
 //!
 //! This OFT type locks tokens in the contract on debit (send) and unlocks
 //! tokens from the contract on credit (receive).
-//! Used for OFT adapters that wrap existing tokens.
+//! Operates directly on the token via standard SEP-41 `transfer`.
 
-use oft_core::{types::OFTReceipt, OFTCore};
+use oft_core::OFTCore;
 use soroban_sdk::{token::TokenClient, Address, Env};
 
 /// Debit tokens using LockUnlock OFT type (locks tokens in contract).
 ///
 /// # Parameters
 /// * `env` - The Soroban environment
+/// * `token` - Address of the token
 /// * `sender` - Address of the token sender
 /// * `amount_ld` - Amount to debit in local decimals
 /// * `min_amount_ld` - Minimum amount that must be received (for slippage protection)
 /// * `dst_eid` - Destination endpoint ID
 ///
 /// # Returns
-/// `OFTReceipt` containing the amount sent and amount received
+/// * `amount_sent_ld` - The amount sent in local decimals
+/// * `amount_received_ld` - The amount received in local decimals on the remote
 pub fn debit<T: OFTCore>(
     env: &Env,
+    token: &Address,
     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_received_ld);
-    receipt
+) -> (i128, i128) {
+    let (amount_sent_ld, amount_received_ld) = T::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
+    TokenClient::new(env, token).transfer(sender, env.current_contract_address(), &amount_received_ld);
+    (amount_sent_ld, amount_received_ld)
 }
 
 /// Credit tokens using LockUnlock OFT type (unlocks tokens from contract).
 ///
 /// # Parameters
 /// * `env` - The Soroban environment
+/// * `token` - Address of the token
 /// * `to` - Address of the token recipient
 /// * `amount_ld` - Amount to credit in local decimals
 /// * `_src_eid` - Source endpoint ID (unused)
 ///
 /// # Returns
 /// The amount credited
-pub fn credit<T: OFTCore>(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-    TokenClient::new(env, &T::token(env)).transfer(&env.current_contract_address(), to, &amount_ld);
+pub fn credit<T: OFTCore>(env: &Env, token: &Address, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
+    TokenClient::new(env, token).transfer(&env.current_contract_address(), to, &amount_ld);
     amount_ld
 }