@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

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

@@ -0,0 +1,55 @@
+use soroban_sdk::{Bytes, BytesN, Env};
+use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
+
+/// Decoded compose message containing transfer context and payload execution
+#[derive(Clone, Debug)]
+pub struct OFTComposeMsg {
+    /// Unique sequence number for the cross-chain message packet
+    pub nonce: u64,
+    /// Source chain endpoint ID where the transfer originated
+    pub src_eid: u32,
+    /// Amount received in local decimals
+    pub amount_ld: i128,
+    /// Address that initiated the compose call on the source chain
+    pub compose_from: BytesN<32>,
+    /// Custom payload for compose logic execution
+    pub compose_msg: Bytes,
+}
+
+impl OFTComposeMsg {
+    /// Encodes the OFTComposeMsg struct into Bytes.
+    ///
+    /// # Arguments
+    /// * `env` - The Soroban environment
+    ///
+    /// # Returns
+    /// Encoded bytes representation of the compose message
+    pub fn encode(&self, env: &Env) -> Bytes {
+        let mut writer = BufferWriter::new(env);
+        writer
+            .write_u64(self.nonce)
+            .write_u32(self.src_eid)
+            .write_i128(self.amount_ld)
+            .write_bytes_n(&self.compose_from)
+            .write_bytes(&self.compose_msg);
+        writer.to_bytes()
+    }
+
+    /// Decodes Bytes into an OFTComposeMsg struct.
+    ///
+    /// # Arguments
+    /// * `bytes` - The encoded bytes to decode
+    ///
+    /// # Returns
+    /// Decoded OFTComposeMsg struct
+    pub fn decode(bytes: &Bytes) -> Self {
+        let mut reader = BufferReader::new(bytes);
+        let nonce = reader.read_u64();
+        let src_eid = reader.read_u32();
+        let amount_ld = reader.read_i128();
+        let compose_from = reader.read_bytes_n::<32>();
+        let compose_msg = reader.read_bytes_until_end();
+
+        OFTComposeMsg { nonce, src_eid, amount_ld, compose_from, compose_msg }
+    }
+}

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

@@ -0,0 +1,62 @@
+use soroban_sdk::{Bytes, BytesN, Env};
+use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
+
+/// Decoded OFT message containing transfer details and optional compose data
+#[derive(Clone, Debug)]
+pub struct OFTMessage {
+    /// Recipient address on the destination chain
+    pub send_to: BytesN<32>,
+    /// Amount to transfer in shared decimals (normalized cross-chain format)
+    pub amount_sd: u64,
+    /// Address that initiated the compose call (optional)
+    pub compose_from: Option<BytesN<32>>,
+    /// Compose message payload for additional logic (optional)
+    pub compose_msg: Option<Bytes>,
+}
+
+impl OFTMessage {
+    /// Returns true if this message includes compose functionality
+    pub fn is_composed(&self) -> bool {
+        self.compose_from.is_some() && self.compose_msg.as_ref().is_some_and(|msg| !msg.is_empty())
+    }
+
+    /// Encodes the OFTMessage struct into Bytes.
+    ///
+    /// # Returns
+    /// A tuple containing:
+    /// - Encoded bytes representation of the message
+    /// - Boolean indicating if compose functionality is included
+    pub fn encode(&self, env: &Env) -> (Bytes, bool) {
+        let has_compose = self.is_composed();
+
+        let mut writer = BufferWriter::new(env);
+        writer.write_bytes_n(&self.send_to).write_u64(self.amount_sd);
+        if has_compose {
+            // compose_from should already be set when compose is enabled
+            writer.write_bytes_n(self.compose_from.as_ref().unwrap()).write_bytes(self.compose_msg.as_ref().unwrap());
+        }
+
+        (writer.to_bytes(), has_compose)
+    }
+
+    /// Decodes Bytes into an OFTMessage struct.
+    ///
+    /// # Arguments
+    /// * `message` - The encoded bytes to decode
+    ///
+    /// # Returns
+    /// Decoded OFTMessage struct
+    pub fn decode(message: &Bytes) -> Self {
+        let mut reader = BufferReader::new(message);
+        let send_to = reader.read_bytes_n::<32>();
+        let amount_sd = reader.read_u64();
+
+        if reader.remaining_len() > 0 {
+            let compose_from = reader.read_bytes_n::<32>();
+            let compose_msg = reader.read_bytes_until_end();
+            OFTMessage { send_to, amount_sd, compose_from: Some(compose_from), compose_msg: Some(compose_msg) }
+        } else {
+            OFTMessage { send_to, amount_sd, compose_from: None, compose_msg: None }
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+/// 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;

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

@@ -0,0 +1,8 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum OFTError {
+    InvalidLocalDecimals = 2100,
+    Overflow,
+    SlippageExceeded,
+}

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

@@ -0,0 +1,19 @@
+use common_macros::event;
+use soroban_sdk::{Address, BytesN};
+
+#[event]
+pub struct OFTSent {
+    pub guid: BytesN<32>,
+    pub dst_eid: u32,
+    pub from: Address,
+    pub amount_sent_ld: i128,
+    pub amount_received_ld: i128,
+}
+
+#[event]
+pub struct OFTReceived {
+    pub guid: BytesN<32>,
+    pub src_eid: u32,
+    pub to: Address,
+    pub amount_received_ld: i128,
+}

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

@@ -0,0 +1,23 @@
+use soroban_sdk::{contractclient, Address, Env};
+
+/// Contract interface for mint and burn token operations.
+///
+/// This interface abstracts the token mint/burn functionality, allowing different
+/// token implementations (e.g., StellarAssetContract, custom tokens) to be used
+/// with the MintBurn OFT.
+#[contractclient(name = "MintBurnTokenClient")]
+pub trait MintBurnToken {
+    /// Mints tokens to the specified address.
+    ///
+    /// # Parameters
+    /// * `to` - The address to mint tokens to
+    /// * `amount` - The amount of tokens to mint (must be non-negative)
+    fn mint(env: Env, to: Address, amount: i128);
+
+    /// Burns tokens from the specified address.
+    ///
+    /// # Parameters
+    /// * `from` - The address to burn tokens from
+    /// * `amount` - The amount of tokens to burn (must be non-negative)
+    fn burn(env: Env, from: Address, amount: i128);
+}

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

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

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

@@ -0,0 +1,22 @@
+#![no_std]
+
+pub mod codec;
+pub mod constants;
+pub mod errors;
+pub mod events;
+pub mod interfaces;
+pub mod oft;
+pub mod oft_types;
+pub mod storage;
+pub mod types;
+pub mod utils;
+
+#[cfg(test)]
+#[path = "../integration-tests/mod.rs"]
+pub mod integration_tests;
+
+#[cfg(test)]
+pub mod macro_tests;
+
+#[cfg(test)]
+pub mod tests;

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

@@ -0,0 +1,2 @@
+pub mod test_all_default;
+pub mod test_override;

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

@@ -0,0 +1,41 @@
+//! Test OFT with default `__lz_receive` pattern.
+//!
+//! This demonstrates the simplest OFT usage where:
+//! - `#[oapp]` provides OApp functionality (including OAppOptionsType3)
+//! - User implements `OFTInner` trait for internal methods (`__debit`, `__credit`)
+//! - User implements `OFT` trait (with default implementations)
+//! - Default `__lz_receive` is provided by `OFTInner` trait
+
+extern crate self as oft;
+
+use oft::oft::{OFTInner, OFT};
+use oft::types::OFTReceipt;
+use soroban_sdk::{contractimpl, Address};
+
+#[oapp_macros::oapp]
+pub struct TestOFT;
+
+#[contractimpl(contracttrait)]
+impl OFT for TestOFT {}
+
+// Internal methods - NOT exposed as contract endpoints
+impl OFTInner for TestOFT {
+    fn __debit(
+        _env: &soroban_sdk::Env,
+        _sender: &Address,
+        amount_ld: i128,
+        _min_amount_ld: i128,
+        _dst_eid: u32,
+    ) -> OFTReceipt {
+        OFTReceipt { amount_sent_ld: amount_ld, amount_received_ld: amount_ld }
+    }
+
+    fn __credit(_env: &soroban_sdk::Env, _to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
+        amount_ld
+    }
+}
+
+#[test]
+fn test_all_default() {
+    assert!(true);
+}

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

@@ -0,0 +1,83 @@
+//! Test OFT with manual OApp implementations.
+//!
+//! This demonstrates overriding OApp traits while using the OFT pattern.
+
+extern crate self as oft;
+
+use endpoint_v2::{EndpointV2, Origin};
+use oapp::{
+    oapp_core::{oapp_initialize, OAppCore},
+    oapp_options_type3::{EnforcedOptionParam, OAppOptionsType3},
+    oapp_receiver::OAppReceiver,
+};
+use common_macros::contract_impl;
+use oapp_macros::oapp_manual_impl;
+use oft::oft::{OFTInner, OFT};
+use oft::types::OFTReceipt;
+use soroban_sdk::{contractimpl, testutils::Address as _, Address, Bytes, BytesN, Env, Vec};
+
+#[oapp_macros::oapp]
+#[oapp_manual_impl(core, options_type3, receiver)]
+pub struct TestOFT;
+
+#[contract_impl]
+impl TestOFT {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
+        oapp_initialize::<Self>(env, owner, endpoint, delegate);
+    }
+}
+
+// Implement OAppReceiver trait with custom behavior
+#[contractimpl(contracttrait)]
+impl OAppReceiver for TestOFT {
+    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);
+    }
+}
+
+// Implement OFTInner trait - NOT exposed as contract endpoints
+impl OFTInner for TestOFT {
+    fn __debit(_env: &Env, _sender: &Address, amount_ld: i128, _min_amount_ld: i128, _dst_eid: u32) -> OFTReceipt {
+        OFTReceipt { amount_sent_ld: amount_ld, amount_received_ld: amount_ld }
+    }
+
+    fn __credit(_env: &Env, _to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
+        amount_ld
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OAppCore for TestOFT {
+    fn oapp_version(_env: &Env) -> (u64, u64) {
+        (100, 1)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OAppOptionsType3 for TestOFT {}
+
+#[contractimpl(contracttrait)]
+impl OFT for TestOFT {}
+
+#[test]
+fn test_macro_compiles() {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let endpoint = env.register(EndpointV2, (&owner,));
+    let delegate: Option<Address> = None;
+    let oft = env.register(TestOFT, (&owner, &endpoint, &delegate));
+
+    let oft_client = TestOFTClient::new(&env, &oft);
+    let (major, minor) = oft_client.oapp_version();
+    assert_eq!(major, 100);
+    assert_eq!(minor, 1);
+}

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

@@ -0,0 +1,320 @@
+//! OFT traits - the main interface for OFT contracts.
+//!
+//! This module provides two traits:
+//! - `OFTInner`: 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};
+//!
+//! #[oapp]
+//! pub struct MyOFT;
+//!
+//! #[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)
+//!     }
+//! }
+//!
+//! // Public methods - exposed as contract endpoints
+//! #[contractimpl(contracttrait)]
+//! impl OFT for MyOFT {}
+//!
+//! // Internal methods - NOT exposed as contract endpoints
+//! // IMPORTANT: Do NOT use #[contractimpl] here to keep methods internal
+//! impl OFTInner 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)
+//!     }
+//!
+//!     fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+//!         // Your credit logic (e.g., mint or unlock tokens)
+//!         oft::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid)
+//!     }
+//! }
+//! ```
+
+// Alias for the current crate, allowing `oft::types::SendParam` paths to work both
+// inside this crate and in external crates implementing the OFT trait.
+extern crate self as oft;
+
+use crate::{
+    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec::OFTMessage},
+    constants,
+    errors::OFTError,
+    events::{self, OFTSent},
+    storage::OFTStorage,
+    types::OFTReceipt,
+    utils::{address_to_bytes32, remove_dust, resolve_address, to_ld, to_sd},
+};
+use endpoint_v2::{MessagingComposerClient, Origin};
+use oapp::{
+    oapp_core::{oapp_initialize, OAppCore},
+    oapp_options_type3::OAppOptionsType3,
+    oapp_receiver::OAppReceiver,
+    oapp_sender::OAppSender,
+};
+use soroban_sdk::{assert_with_error, contracttrait, token::TokenClient, vec, Address, Bytes, BytesN, Env};
+use utils::ownable::OwnableInitializer;
+
+// =====================================================
+// 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>,
+) {
+    // Initialize OApp (includes owner initialization)
+    oapp_initialize::<T>(env, owner, endpoint, delegate);
+
+    let local_decimals = TokenClient::new(env, token).decimals();
+    let shared_decimals = T::shared_decimals(env);
+    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)
+// =====================================================
+
+/// Internal OFT trait containing methods that should NOT be exposed as contract endpoints.
+///
+/// **IMPORTANT**: Implement this trait WITHOUT the `#[contractimpl]` macro to keep
+/// `__debit`, `__credit`, and other internal methods private to the contract.
+///
+/// ```ignore
+/// // Correct - methods stay internal
+/// impl OFTInner for MyOFT { ... }
+///
+/// // WRONG - would expose methods as endpoints
+/// #[contractimpl]
+/// impl OFTInner 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 {
+    // =========================================================================
+    // Required Methods (no defaults - user MUST implement)
+    // =========================================================================
+
+    /// Debits tokens from sender 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
+    ///
+    /// # 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;
+
+    /// Credits tokens to recipient after receiving cross-chain transfer.
+    ///
+    /// # Arguments
+    /// * `to` - The address to credit tokens to
+    /// * `amount_ld` - Amount in local decimals to credit
+    /// * `src_eid` - Source endpoint ID
+    ///
+    /// # Returns
+    /// The amount actually credited
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128;
+
+    // =========================================================================
+    // Optional Methods (have defaults - override as needed)
+    // =========================================================================
+
+    /// Calculates debit amounts without executing (view function).
+    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_sent_ld = 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 OFT message and combines options for cross-chain transfer.
+    fn __build_msg_and_options(
+        env: &Env,
+        sender: &Address,
+        send_param: &oft::types::SendParam,
+        amount_ld: i128,
+    ) -> (Bytes, Bytes)
+    where
+        Self: OAppOptionsType3,
+    {
+        let has_compose = !send_param.compose_msg.is_empty();
+        let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
+        let msg = OFTMessage {
+            send_to: send_param.to.clone(),
+            amount_sd: to_sd(env, amount_ld, conversion_rate),
+            compose_from: if has_compose { Some(address_to_bytes32(sender)) } else { None },
+            compose_msg: if has_compose { Some(send_param.compose_msg.clone()) } else { None },
+        };
+        let (msg, _) = msg.encode(env);
+        let msg_type = if has_compose { constants::SEND_AND_CALL } else { constants::SEND };
+
+        (msg, Self::combine_options(env, send_param.dst_eid, msg_type, &send_param.extra_options))
+    }
+
+    /// Handles OFT receive logic.
+    fn __lz_receive(
+        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 = resolve_address(env, &oft_msg.send_to);
+
+        let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
+        let amount_received_ld =
+            Self::__credit(env, &send_to, 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 = MessagingComposerClient::new(env, &Self::endpoint(env));
+            endpoint.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);
+    }
+}
+
+// =====================================================
+// OFT Trait (exposed as contract endpoints)
+// =====================================================
+
+/// The public OFT trait defining the cross-chain token transfer interface.
+///
+/// This trait is marked with `#[contracttrait]` so all its methods are exposed as
+/// 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 {
+    /// Retrieves the token address associated with this OFT.
+    fn token(env: &Env) -> Address {
+        OFTStorage::token(env).unwrap()
+    }
+
+    /// Returns OFT version as (major, minor).
+    fn oft_version(_env: &Env) -> (u64, u64) {
+        (1, 1)
+    }
+
+    /// Retrieves the shared decimals used for cross-chain normalization.
+    fn shared_decimals(_env: &Env) -> u32 {
+        6
+    }
+
+    /// Retrieves the decimal conversion rate used for cross-chain normalization.
+    fn decimal_conversion_rate(env: &Env) -> i128 {
+        OFTStorage::decimal_conversion_rate(env).unwrap()
+    }
+
+    /// Whether a separate token approval is required before sending.
+    ///
+    /// Helps wallet implementers determine integration requirements.
+    ///
+    /// # Returns
+    /// - `true` if a separate token approval step is required
+    /// - `false` if no separate approval is needed
+    fn approval_required(_env: &Env) -> bool {
+        false
+    }
+
+    /// Quotes an OFT transfer without executing.
+    ///
+    /// # Returns
+    /// (OFTLimit, fee details, receipt with estimated amounts)
+    fn quote_oft(
+        env: &Env,
+        send_param: &oft::types::SendParam,
+    ) -> (oft::types::OFTLimit, soroban_sdk::Vec<oft::types::OFTFeeDetail>, oft::types::OFTReceipt) {
+        let oft_receipt = Self::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+        (oft::types::OFTLimit { min_amount_ld: 0, max_amount_ld: i128::MAX }, vec![env], oft_receipt)
+    }
+
+    /// Quotes a send operation including LayerZero messaging fees.
+    fn quote_send(
+        env: &Env,
+        sender: &Address,
+        send_param: &oft::types::SendParam,
+        pay_in_zro: bool,
+    ) -> endpoint_v2::MessagingFee {
+        let oft::types::OFTReceipt { amount_received_ld, .. } =
+            Self::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+        let (msg, options) = Self::__build_msg_and_options(env, sender, send_param, amount_received_ld);
+        Self::lz_quote(env, send_param.dst_eid, &msg, &options, pay_in_zro)
+    }
+
+    /// Sends tokens cross-chain to another endpoint.
+    ///
+    /// Sender must be authenticated.
+    ///
+    /// # Returns
+    /// (MessagingReceipt, OFTReceipt)
+    fn send(
+        env: &Env,
+        sender: &Address,
+        send_param: &oft::types::SendParam,
+        fee: &endpoint_v2::MessagingFee,
+        refund_address: &Address,
+    ) -> (endpoint_v2::MessagingReceipt, oft::types::OFTReceipt) {
+        sender.require_auth();
+
+        let oft_receipt =
+            Self::__debit(env, sender, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+        let (msg, options) = Self::__build_msg_and_options(env, sender, send_param, oft_receipt.amount_received_ld);
+        let msg_receipt = Self::lz_send(env, sender, send_param.dst_eid, &msg, &options, fee, refund_address);
+
+        OFTSent {
+            guid: msg_receipt.guid.clone(),
+            dst_eid: send_param.dst_eid,
+            from: sender.clone(),
+            amount_sent_ld: oft_receipt.amount_sent_ld,
+            amount_received_ld: oft_receipt.amount_received_ld,
+        }
+        .publish(env);
+
+        (msg_receipt, oft_receipt)
+    }
+
+    // NOTE: `next_nonce`, `lz_receive`, etc. are inherited from OAppReceiver supertrait.
+    // Do NOT redefine them here to avoid method conflicts.
+}