@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,5 +1,5 @@
-use common_macros::{contract_error, only_owner, storage};
-use soroban_sdk::{assert_with_error, contractevent, contracttrait, contracttype, panic_with_error, Env};
+use common_macros::{contract_error, contract_trait, only_auth, storage};
+use soroban_sdk::{assert_with_error, contractevent, contracttype, panic_with_error, Env};
 use utils::ownable::Ownable;
 
 #[contracttype]
@@ -77,9 +77,19 @@ fn calculate_in_flight(env: &Env, direction: &Direction, eid: u32) -> i128 {
     }
 }
 
-#[contracttrait]
+/// 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);
+}
+
+#[contract_trait]
 pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
-    #[only_owner]
+    #[only_auth]
     fn set_rate_limit(env: &Env, direction: &Direction, eid: u32, limit: i128, window_seconds: u64) {
         assert_with_error!(env, limit > 0, RateLimitError::InvalidLimit);
         assert_with_error!(env, window_seconds > 0, RateLimitError::InvalidWindowSeconds);
@@ -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;
@@ -112,7 +122,7 @@ pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
         }
     }
 
-    #[only_owner]
+    #[only_auth]
     fn unset_rate_limit(env: &Env, direction: &Direction, eid: u32) {
         assert_with_error!(env, RateLimitStorage::has_rate_limit(env, direction, eid), RateLimitError::SameValue);
         RateLimitStorage::remove_rate_limit(env, direction, eid);
@@ -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/lib.rs

@@ -1,18 +1,20 @@
 #![no_std]
 
 pub mod codec;
-pub mod constants;
-pub mod default_oft_impl;
 pub mod errors;
 pub mod events;
 pub mod extensions;
 pub mod interfaces;
 pub mod oft;
+pub mod oft_impl;
 pub mod oft_types;
 pub mod storage;
 pub mod types;
 pub mod utils;
 
+// Re-export commonly used items
+pub use oft_impl::initialize_oft;
+
 #[cfg(test)]
 #[path = "../integration-tests/mod.rs"]
 pub mod integration_tests;

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

@@ -1,14 +1,15 @@
 //! 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::{OFTInternal, OFT};
+//! use oft::initialize_oft;
 //!
 //! #[oapp]
 //! pub struct MyOFT;
@@ -16,7 +17,7 @@
 //! #[contractimpl]
 //! impl MyOFT {
 //!     pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
-//!         oft_initialize::<Self>(env, owner, token, endpoint, delegate)
+//!         initialize_oft::<Self>(env, owner, token, endpoint, delegate)
 //!     }
 //! }
 //!
@@ -26,7 +27,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)
@@ -43,44 +44,16 @@
 // inside this crate and in external crates implementing the OFT trait.
 extern crate self as oft;
 
-use crate::{errors::OFTError, storage::OFTStorage, types::OFTReceipt};
-use endpoint_v2::Origin;
+use crate::{oft_impl, storage::OFTStorage, types::OFTReceipt};
+use common_macros::contract_trait;
 use oapp::{
-    oapp_core::{oapp_initialize, OAppCore},
-    oapp_options_type3::OAppOptionsType3,
-    oapp_receiver::OAppReceiver,
-    oapp_sender::OAppSender,
+    oapp_core::OAppCore, oapp_options_type3::OAppOptionsType3, oapp_receiver::OAppReceiver,
+    oapp_sender::OAppSenderInternal,
 };
-use soroban_sdk::{assert_with_error, contracttrait, token::TokenClient, Address, Bytes, BytesN, Env};
-use utils::ownable::OwnableInitializer;
+use soroban_sdk::{Address, Bytes, Env};
 
 // =====================================================
-// OFT Initialization
-// =====================================================
-
-/// Initializes the OFT contract with token, endpoint, and decimal configuration.
-/// The `shared_decimals` must be <= token's local decimals.
-pub fn oft_initialize<T: OFT + OwnableInitializer>(
-    env: &Env,
-    owner: &Address,
-    token: &Address,
-    endpoint: &Address,
-    delegate: &Option<Address>,
-    shared_decimals: u32,
-) {
-    // Initialize OApp (includes owner initialization)
-    oapp_initialize::<T>(env, owner, endpoint, delegate);
-
-    let local_decimals = TokenClient::new(env, token).decimals();
-    assert_with_error!(env, local_decimals >= shared_decimals, OFTError::InvalidLocalDecimals);
-
-    // Initialize OFT storage
-    OFTStorage::set_token(env, token);
-    OFTStorage::set_decimal_conversion_rate(env, &10_i128.pow(local_decimals - shared_decimals));
-}
-
-// =====================================================
-// 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,33 +63,33 @@ 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)
     // =========================================================================
 
-    /// Debits tokens from sender for cross-chain transfer.
+    /// Debits tokens from the specified address for cross-chain transfer.
     ///
     /// # Arguments
-    /// * `sender` - The address sending tokens
-    /// * `amount_ld` - Amount in local decimals to debit
-    /// * `min_amount_ld` - Minimum amount acceptable (slippage protection)
-    /// * `dst_eid` - Destination endpoint ID
+    /// * `from` - The address to debit the tokens from
+    /// * `amount_ld` - The amount of tokens to send in local decimals
+    /// * `min_amount_ld` - The minimum amount to send in local decimals
+    /// * `dst_eid` - The destination chain ID
     ///
     /// # Returns
-    /// Receipt with amounts sent and received (after fees/dust removal)
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt;
+    /// `OFTReceipt` containing the amount sent and amount received
+    fn __debit(env: &Env, from: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt;
 
     /// Credits tokens to recipient after receiving cross-chain transfer.
     ///
@@ -135,33 +108,20 @@ pub trait OFTInner: OAppCore {
 
     /// Calculates debit amounts without executing (view function).
     fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        crate::default_oft_impl::default_debit_view(env, amount_ld, min_amount_ld, dst_eid)
+        oft_impl::debit_view(env, amount_ld, min_amount_ld, dst_eid)
     }
 
     /// Builds OFT message and combines options for cross-chain transfer.
     fn __build_msg_and_options(
         env: &Env,
-        sender: &Address,
+        from: &Address,
         send_param: &oft::types::SendParam,
-        amount_ld: i128,
+        receive_amount_ld: i128,
     ) -> (Bytes, Bytes)
     where
         Self: OAppOptionsType3,
     {
-        crate::default_oft_impl::default_build_msg_and_options::<Self>(env, sender, send_param, amount_ld)
-    }
-
-    /// Handles OFT receive logic.
-    fn __lz_receive(
-        env: &Env,
-        _executor: &Address,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        _extra_data: &Bytes,
-        _value: i128,
-    ) {
-        crate::default_oft_impl::default_lz_receive::<Self>(env, _executor, origin, guid, message, _extra_data, _value)
+        oft_impl::build_msg_and_options::<Self>(env, from, send_param, receive_amount_ld)
     }
 }
 
@@ -175,9 +135,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.
-#[contracttrait(client_name = "OFTClient")]
-pub trait OFT: OFTInner + OAppReceiver + OAppSender + OAppOptionsType3 {
+/// are in the `OFTInternal` trait and are NOT exposed as contract endpoints.
+#[contract_trait]
+pub trait OFT: OFTInternal + OAppReceiver + OAppSenderInternal + OAppOptionsType3 {
     /// Retrieves the token address associated with this OFT.
     fn token(env: &Env) -> Address {
         OFTStorage::token(env).unwrap()
@@ -220,7 +180,7 @@ pub trait OFT: OFTInner + OAppReceiver + OAppSender + OAppOptionsType3 {
         env: &Env,
         send_param: &oft::types::SendParam,
     ) -> (oft::types::OFTLimit, soroban_sdk::Vec<oft::types::OFTFeeDetail>, oft::types::OFTReceipt) {
-        crate::default_oft_impl::default_quote_oft::<Self>(env, send_param)
+        oft_impl::quote_oft::<Self>(env, send_param)
     }
 
     /// Quotes a send operation including LayerZero messaging fees.
@@ -230,7 +190,7 @@ pub trait OFT: OFTInner + OAppReceiver + OAppSender + OAppOptionsType3 {
         send_param: &oft::types::SendParam,
         pay_in_zro: bool,
     ) -> endpoint_v2::MessagingFee {
-        crate::default_oft_impl::default_quote_send::<Self>(env, sender, send_param, pay_in_zro)
+        oft_impl::quote_send::<Self>(env, sender, send_param, pay_in_zro)
     }
 
     /// Sends tokens cross-chain to another endpoint.
@@ -246,6 +206,6 @@ pub trait OFT: OFTInner + OAppReceiver + OAppSender + OAppOptionsType3 {
         fee: &endpoint_v2::MessagingFee,
         refund_address: &Address,
     ) -> (endpoint_v2::MessagingReceipt, oft::types::OFTReceipt) {
-        crate::default_oft_impl::default_send::<Self>(env, sender, send_param, fee, refund_address)
+        oft_impl::send::<Self>(env, sender, send_param, fee, refund_address)
     }
 }

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

@@ -0,0 +1,201 @@
+//! Default OFT implementations.
+//!
+//! This module provides default standalone functions for common OFT operations that can be
+//! reused by trait implementations.
+
+use crate::{
+    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec::OFTMessage},
+    errors::OFTError,
+    events::{self, OFTSent},
+    oft::{OFTInternal, OFT},
+    storage::OFTStorage,
+    types::{self, OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
+    utils,
+};
+use ::utils::{option_ext::OptionExt, ownable::OwnableInitializer};
+use endpoint_v2::{MessagingComposerClient, MessagingFee, MessagingReceipt, Origin};
+use oapp::{oapp_core::initialize_oapp, oapp_options_type3::OAppOptionsType3};
+use soroban_sdk::{assert_with_error, token::TokenClient, vec, Address, Bytes, BytesN, Env, Vec};
+
+/// Initializes the OFT contract with token, endpoint, and decimal configuration.
+/// The `shared_decimals` must be <= token's local decimals.
+pub fn initialize_oft<T: OFT + OwnableInitializer>(
+    env: &Env,
+    owner: &Address,
+    token: &Address,
+    endpoint: &Address,
+    delegate: &Option<Address>,
+    shared_decimals: u32,
+) {
+    // Initialize OApp (includes owner initialization)
+    initialize_oapp::<T>(env, owner, endpoint, delegate);
+
+    let local_decimals = TokenClient::new(env, token).decimals();
+    assert_with_error!(env, local_decimals >= shared_decimals, OFTError::InvalidLocalDecimals);
+
+    // Initialize OFT storage
+    OFTStorage::set_token(env, token);
+    OFTStorage::set_decimal_conversion_rate(env, &10_i128.pow(local_decimals - shared_decimals));
+}
+
+/// Simulates a debit operation without executing, used for quoting.
+///
+/// # Arguments
+/// * `amount_ld` - The amount of tokens to send in local decimals
+/// * `min_amount_ld` - The minimum amount to send in local decimals (slippage protection)
+/// * `dst_eid` - The destination chain ID (unused in default implementation)
+///
+/// # Returns
+/// `OFTReceipt` containing the amount sent and amount received after dust removal
+pub 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_or_panic(env, OFTError::NotInitialized);
+    let amount_sent_ld = utils::remove_dust(amount_ld, conversion_rate);
+    let amount_received_ld = amount_sent_ld;
+
+    assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
+
+    OFTReceipt { amount_sent_ld, amount_received_ld }
+}
+
+/// Builds the OFT message payload and combines enforced options for cross-chain transfer.
+///
+/// # Arguments
+/// * `from` - The address initiating the transfer
+/// * `send_param` - The send parameters including destination, recipient, and options
+/// * `receive_amount_ld` - The amount to be received in local decimals (after dust removal)
+///
+/// # Returns
+/// A tuple of (encoded message, combined options)
+pub fn build_msg_and_options<T: OAppOptionsType3>(
+    env: &Env,
+    from: &Address,
+    send_param: &SendParam,
+    receive_amount_ld: i128,
+) -> (Bytes, Bytes) {
+    let has_compose = !send_param.compose_msg.is_empty();
+    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap_or_panic(env, OFTError::NotInitialized);
+    let (msg, _) = OFTMessage {
+        send_to: send_param.to.clone(),
+        amount_sd: utils::to_sd(env, receive_amount_ld, conversion_rate),
+        compose_from: if has_compose { Some(utils::address_to_bytes32(from)) } else { None },
+        compose_msg: if has_compose { Some(send_param.compose_msg.clone()) } else { None },
+    }
+    .encode(env);
+    let msg_type = if has_compose { types::SEND_AND_CALL } else { types::SEND };
+
+    (msg, T::combine_options(env, send_param.dst_eid, msg_type, &send_param.extra_options))
+}
+
+/// Quotes an OFT transfer without executing.
+///
+/// # Arguments
+/// * `send_param` - The send parameters to quote
+///
+/// # Returns
+/// A tuple of (transfer limits, fee details, estimated receipt)
+pub fn quote_oft<T: OFTInternal>(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+    let limit = OFTLimit { min_amount_ld: 0, max_amount_ld: i128::MAX }; // No limits in default implementation
+    let fee_details = vec![env]; // No fee details in default implementation
+    let oft_receipt = T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+    (limit, fee_details, oft_receipt)
+}
+
+/// Quotes the LayerZero messaging fee for a send operation.
+///
+/// # Arguments
+/// * `from` - The address initiating the transfer
+/// * `send_param` - The send parameters to quote
+/// * `pay_in_zro` - Whether to pay the fee in ZRO token
+///
+/// # Returns
+/// The messaging fee required for the transfer
+pub fn quote_send<T: OFT>(env: &Env, from: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee {
+    let OFTReceipt { amount_received_ld, .. } =
+        T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+    let (msg, options) = build_msg_and_options::<T>(env, from, send_param, amount_received_ld);
+    T::__quote(env, send_param.dst_eid, &msg, &options, pay_in_zro)
+}
+
+/// Executes a cross-chain token transfer via LayerZero.
+///
+/// Debits tokens from the `from` address, builds the message, and sends via the endpoint.
+/// The `from` address must be authenticated.
+///
+/// # Arguments
+/// * `from` - The address sending tokens (must authorize)
+/// * `send_param` - The send parameters (destination, recipient, amount, options)
+/// * `fee` - The messaging fee to pay
+/// * `refund_address` - The address to refund excess fees to
+///
+/// # Returns
+/// A tuple of (messaging receipt, OFT receipt with amounts)
+pub fn send<T: OFT>(
+    env: &Env,
+    from: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+) -> (MessagingReceipt, OFTReceipt) {
+    from.require_auth();
+
+    let oft_receipt = T::__debit(env, from, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+    let (msg, options) = build_msg_and_options::<T>(env, from, send_param, oft_receipt.amount_received_ld);
+    let msg_receipt = T::__lz_send(env, send_param.dst_eid, &msg, &options, from, fee, refund_address);
+
+    OFTSent {
+        guid: msg_receipt.guid.clone(),
+        dst_eid: send_param.dst_eid,
+        from: from.clone(),
+        amount_sent_ld: oft_receipt.amount_sent_ld,
+        amount_received_ld: oft_receipt.amount_received_ld,
+    }
+    .publish(env);
+
+    (msg_receipt, oft_receipt)
+}
+
+/// Handles incoming cross-chain OFT transfer from LayerZero endpoint.
+///
+/// Credits tokens to the recipient and optionally queues a compose message.
+///
+/// # Arguments
+/// * `executor` - The address of the executor handling the message (unused in default implementation)
+/// * `origin` - The origin information (source chain, sender, nonce)
+/// * `guid` - The unique message identifier
+/// * `message` - The encoded OFT message payload
+/// * `extra_data` - Additional data (unused in default implementation)
+/// * `value` - The native token value sent with the message (unused in default implementation)
+pub fn lz_receive<T: OFTInternal>(
+    env: &Env,
+    _executor: &Address,
+    origin: &Origin,
+    guid: &BytesN<32>,
+    message: &Bytes,
+    _extra_data: &Bytes,
+    _value: i128,
+) {
+    let oft_msg = OFTMessage::decode(message);
+    let send_to = utils::resolve_address(env, &oft_msg.send_to);
+
+    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap_or_panic(env, OFTError::NotInitialized);
+    let amount_received_ld =
+        T::__credit(env, &send_to, utils::to_ld(oft_msg.amount_sd, conversion_rate), origin.src_eid);
+
+    if oft_msg.is_composed() {
+        let compose_msg = OFTComposeMsg {
+            nonce: origin.nonce,
+            src_eid: origin.src_eid,
+            amount_ld: amount_received_ld,
+            compose_from: oft_msg.compose_from.unwrap(),
+            compose_msg: oft_msg.compose_msg.unwrap(),
+        }
+        .encode(env);
+
+        let endpoint_client = MessagingComposerClient::new(env, &T::endpoint(env));
+        endpoint_client.send_compose(&env.current_contract_address(), &send_to, guid, &0, &compose_msg);
+    }
+
+    events::OFTReceived { guid: guid.clone(), src_eid: origin.src_eid, to: send_to, amount_received_ld }.publish(env);
+}

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

@@ -4,11 +4,9 @@
 //! tokens from the contract on credit (receive).
 //! Used for OFT adapters that wrap existing tokens.
 
+use crate::{oft::OFT, types::OFTReceipt};
 use soroban_sdk::{token::TokenClient, Address, Env};
 
-use crate::oft::OFT;
-use crate::types::OFTReceipt;
-
 /// Debit tokens using LockUnlock OFT type (locks tokens in contract).
 ///
 /// # Parameters
@@ -22,7 +20,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/oft_types/mint_burn.rs

@@ -3,12 +3,9 @@
 //! This OFT type burns tokens on debit (send) and mints tokens on credit (receive).
 //! Used when the OFT contract has mint/burn authority over the token.
 
+use crate::{interfaces::MintBurnTokenClient, oft::OFT, types::OFTReceipt};
 use soroban_sdk::{Address, Env};
 
-use crate::interfaces::MintBurnTokenClient;
-use crate::oft::OFT;
-use crate::types::OFTReceipt;
-
 /// Debit tokens using MintBurn OFT type (burns tokens from sender).
 ///
 /// # Parameters

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

@@ -3,9 +3,11 @@ use soroban_sdk::Address;
 
 #[storage]
 pub enum OFTStorage {
+    /// The decimal conversion rate used for cross-chain normalization
     #[instance(i128)]
     DecimalConversionRate,
 
+    /// The address of the underlying token contract
     #[instance(Address)]
     Token,
 }