@layerzerolabs/protocol-stellar-v2 0.2.10 → 0.2.12

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

@@ -0,0 +1,888 @@
+//! Test setup for ExtensiveOFT with all extensions (pausable, oft_fee, rate_limiter).
+//!
+//! This module provides a comprehensive test setup similar to `test_utils.rs` but
+//! specifically for testing ExtensiveOFT with extension functionality.
+
+extern crate self as oft;
+
+use crate::default_oft_impl::{default_quote_oft, default_quote_send};
+use crate::errors::OFTError;
+use crate::extensions::oft_fee::{OFTFee, OFTFeeInternal};
+use crate::extensions::pausable::{OFTPausable, OFTPausableInternal};
+use crate::extensions::rate_limiter::{Direction, RateLimiter, RateLimiterInternal};
+use crate::oft::{oft_initialize, OFTInner, OFT};
+use crate::storage::OFTStorage;
+use crate::tests::test_utils::{
+    create_recipient_address, DummyToken, MockEndpointWithCompose, MockEndpointWithComposeClient, DEFAULT_NATIVE_FEE,
+    DEFAULT_SHARED_DECIMALS, DEFAULT_ZRO_FEE, INITIAL_MINT_AMOUNT,
+};
+use crate::types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
+use crate::utils::remove_dust;
+use endpoint_v2::{LayerZeroReceiverClient, MessagingFee, MessagingReceipt, Origin};
+use oapp::oapp_core::OAppCoreClient;
+use soroban_sdk::{
+    assert_with_error, bytes, contractimpl, log,
+    testutils::{Ledger, MockAuth, MockAuthInvoke},
+    token::{StellarAssetClient, TokenClient},
+    Address, Bytes, BytesN, Env, IntoVal,
+};
+
+// ==================== ExtensiveOFT Contract ====================
+
+/// OFT contract with all three extensions enabled: pausable, oft_fee, rate_limiter.
+#[oapp_macros::oapp]
+pub struct ExtensiveOFT;
+
+#[contractimpl]
+impl ExtensiveOFT {
+    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);
+    }
+}
+
+// Implement OFT trait with custom overrides for extensions
+#[contractimpl(contracttrait)]
+impl OFT for ExtensiveOFT {
+    fn quote_oft(
+        env: &Env,
+        send_param: &crate::types::SendParam,
+    ) -> (OFTLimit, soroban_sdk::Vec<OFTFeeDetail>, OFTReceipt) {
+        Self::__assert_not_paused(env);
+        let (_, fee_details, oft_receipt) = default_quote_oft::<Self>(env, send_param);
+        let capacity = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
+        let oft_limit = OFTLimit { min_amount_ld: 0, max_amount_ld: capacity };
+        (oft_limit, fee_details, oft_receipt)
+    }
+
+    fn quote_send(
+        env: &Env,
+        sender: &Address,
+        send_param: &crate::types::SendParam,
+        pay_in_zro: bool,
+    ) -> endpoint_v2::MessagingFee {
+        Self::__assert_not_paused(env);
+        default_quote_send::<Self>(env, sender, send_param, pay_in_zro)
+    }
+}
+
+// Internal OFT implementation - NOT exposed as contract endpoints
+impl OFTInner for ExtensiveOFT {
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        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);
+        let oft_receipt = crate::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid);
+        Self::__transfer_fee(
+            env,
+            &Self::token(env),
+            sender,
+            oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld,
+        );
+        oft_receipt
+    }
+
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+        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)
+    }
+
+    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_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
+        let amount_sent_ld = if amount_after_fee == amount_ld { amount_received_ld } else { amount_ld };
+        assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
+
+        OFTReceipt { amount_sent_ld, amount_received_ld }
+    }
+}
+
+// Extension traits - exposed as contract endpoints
+#[contractimpl(contracttrait)]
+impl OFTFee for ExtensiveOFT {}
+
+impl OFTFeeInternal for ExtensiveOFT {}
+
+#[contractimpl(contracttrait)]
+impl OFTPausable for ExtensiveOFT {}
+
+impl OFTPausableInternal for ExtensiveOFT {}
+
+#[contractimpl(contracttrait)]
+impl RateLimiter for ExtensiveOFT {}
+
+impl RateLimiterInternal for ExtensiveOFT {}
+
+// ==================== ExtensiveOFT Test Setup ====================
+
+/// Test setup for ExtensiveOFT with all three extensions enabled.
+pub struct ExtensiveOFTTestSetup<'a> {
+    pub env: &'a Env,
+    pub oft: ExtensiveOFTClient<'a>,
+    pub endpoint_client: MockEndpointWithComposeClient<'a>,
+    pub token: Address,
+    pub token_client: TokenClient<'a>,
+    pub native_token: Address,
+    pub zro_token: Address,
+    pub owner: Address,
+    pub fee_collector: Address,
+    pub native_fee: i128,
+    pub zro_fee: i128,
+    pub token_decimals: u32,
+    pub shared_decimals: u32,
+}
+
+/// Builder for ExtensiveOFTTestSetup
+pub struct ExtensiveOFTTestSetupBuilder<'a> {
+    env: &'a Env,
+    native_fee: i128,
+    zro_fee: i128,
+    token_decimals: u32,
+    shared_decimals: u32,
+}
+
+impl<'a> ExtensiveOFTTestSetupBuilder<'a> {
+    pub fn new(env: &'a Env) -> Self {
+        Self {
+            env,
+            native_fee: DEFAULT_NATIVE_FEE,
+            zro_fee: DEFAULT_ZRO_FEE,
+            token_decimals: 7,
+            shared_decimals: DEFAULT_SHARED_DECIMALS,
+        }
+    }
+
+    pub fn with_token_decimals(mut self, decimals: u32) -> Self {
+        self.token_decimals = decimals;
+        self
+    }
+
+    pub fn with_shared_decimals(mut self, decimals: u32) -> Self {
+        self.shared_decimals = decimals;
+        self
+    }
+
+    pub fn with_fees(mut self, native_fee: i128, zro_fee: i128) -> Self {
+        self.native_fee = native_fee;
+        self.zro_fee = zro_fee;
+        self
+    }
+
+    pub fn build(self) -> ExtensiveOFTTestSetup<'a> {
+        let env = self.env;
+        let native_fee = self.native_fee;
+        let zro_fee = self.zro_fee;
+
+        let owner = create_recipient_address(env);
+        let fee_collector = create_recipient_address(env);
+
+        // Create native token for fees
+        let native_sac = env.register_stellar_asset_contract_v2(owner.clone());
+        let native_token = native_sac.address();
+
+        // Create ZRO token
+        let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
+        let zro_token = zro_sac.address();
+
+        // Create OFT token (DummyToken with mint/burn capabilities)
+        let token = env.register(DummyToken, (&owner, self.token_decimals));
+        let token_client = TokenClient::new(env, &token);
+
+        // Register mock endpoint
+        let endpoint_address =
+            env.register(MockEndpointWithCompose, (&native_fee, &zro_fee, &native_token, &zro_token));
+        let endpoint_client = MockEndpointWithComposeClient::new(env, &endpoint_address);
+
+        // Register ExtensiveOFT
+        let delegate: Option<Address> = Some(owner.clone());
+        let shared_decimals = self.shared_decimals;
+        let oft_address = env.register(ExtensiveOFT, (&token, &owner, &endpoint_address, &delegate, &shared_decimals));
+        let oft = ExtensiveOFTClient::new(env, &oft_address);
+
+        // Pre-mint large amounts to owner
+        ExtensiveOFTTestSetup::mint_to(env, &owner, &token, &owner, INITIAL_MINT_AMOUNT);
+        ExtensiveOFTTestSetup::mint_to(env, &owner, &native_token, &owner, INITIAL_MINT_AMOUNT);
+        ExtensiveOFTTestSetup::mint_to(env, &owner, &zro_token, &owner, INITIAL_MINT_AMOUNT);
+
+        // Transfer token ownership to OFT so it can mint/burn tokens
+        ExtensiveOFTTestSetup::transfer_token_ownership(env, &owner, &token, &oft_address);
+
+        log!(&env, "token decimals: {}", self.token_decimals);
+        log!(&env, "token address: {}", token);
+        log!(&env, "native token address: {}", native_token);
+        log!(&env, "zro token address: {}", zro_token);
+        log!(&env, "owner: {}", owner);
+        log!(&env, "fee_collector: {}", fee_collector);
+        log!(&env, "native fee: {}", native_fee);
+        log!(&env, "zro fee: {}", zro_fee);
+        log!(&env, "oft address: {}", oft_address);
+
+        ExtensiveOFTTestSetup {
+            env,
+            oft,
+            endpoint_client,
+            token,
+            token_client,
+            native_token,
+            zro_token,
+            owner,
+            fee_collector,
+            native_fee,
+            zro_fee,
+            token_decimals: self.token_decimals,
+            shared_decimals: self.shared_decimals,
+        }
+    }
+}
+
+impl<'a> ExtensiveOFTTestSetup<'a> {
+    /// Create a new test setup with default configuration
+    pub fn new(env: &'a Env) -> Self {
+        ExtensiveOFTTestSetupBuilder::new(env).build()
+    }
+
+    /// Create a builder for customized test setup
+    pub fn builder(env: &'a Env) -> ExtensiveOFTTestSetupBuilder<'a> {
+        ExtensiveOFTTestSetupBuilder::new(env)
+    }
+
+    // ==================== Token Helpers ====================
+
+    pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount: i128) {
+        env.mock_auths(&[MockAuth {
+            address: owner,
+            invoke: &MockAuthInvoke {
+                contract: token,
+                fn_name: "mint",
+                args: (to, amount).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        StellarAssetClient::new(env, token).mint(to, &amount);
+    }
+
+    pub fn transfer_token_ownership(env: &Env, owner: &Address, token: &Address, new_admin: &Address) {
+        env.mock_auths(&[MockAuth {
+            address: owner,
+            invoke: &MockAuthInvoke {
+                contract: token,
+                fn_name: "set_admin",
+                args: (new_admin,).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        StellarAssetClient::new(env, token).set_admin(new_admin);
+    }
+
+    /// Fund an account with native fees (transfers from owner)
+    pub fn fund_native_fees(&self, to: &Address, amount: i128) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.native_token,
+                fn_name: "transfer",
+                args: (&self.owner, to, amount).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        TokenClient::new(self.env, &self.native_token).transfer(&self.owner, to, &amount);
+    }
+
+    /// Fund an account with ZRO fees (transfers from owner)
+    pub fn fund_zro_fees(&self, to: &Address, amount: i128) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.zro_token,
+                fn_name: "transfer",
+                args: (&self.owner, to, amount).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        TokenClient::new(self.env, &self.zro_token).transfer(&self.owner, to, &amount);
+    }
+
+    /// Fund an account with OFT tokens (transfers from owner)
+    pub fn fund_tokens(&self, to: &Address, amount: i128) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.token,
+                fn_name: "transfer",
+                args: (&self.owner, to, amount).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.token_client.transfer(&self.owner, to, &amount);
+    }
+
+    // ==================== OApp Helpers ====================
+
+    pub fn set_peer(&self, eid: u32, peer: &BytesN<32>) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_peer",
+                args: (&eid, peer).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        OAppCoreClient::new(self.env, &self.oft.address).set_peer(&eid, &Some(peer.clone()));
+    }
+
+    // ==================== Pausable Extension Helpers ====================
+
+    /// Set the paused state (owner only)
+    pub fn set_paused(&self, paused: bool) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_paused",
+                args: (paused,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.set_paused(&paused);
+    }
+
+    /// Try to set paused state (returns Result)
+    pub fn try_set_paused(
+        &self,
+        paused: bool,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_paused",
+                args: (paused,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.try_set_paused(&paused)
+    }
+
+    /// Check if paused
+    pub fn is_paused(&self) -> bool {
+        self.oft.is_paused()
+    }
+
+    // ==================== OFT Fee Extension Helpers ====================
+
+    /// Set the default fee in basis points (owner only)
+    pub fn set_default_fee_bps(&self, fee_bps: u64) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_default_fee_bps",
+                args: (fee_bps,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.set_default_fee_bps(&fee_bps);
+    }
+
+    /// Try to set default fee bps (returns Result)
+    pub fn try_set_default_fee_bps(
+        &self,
+        fee_bps: u64,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_default_fee_bps",
+                args: (fee_bps,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.try_set_default_fee_bps(&fee_bps)
+    }
+
+    /// Set fee bps for a specific destination (owner only)
+    pub fn set_fee_bps(&self, dst_eid: u32, fee_bps: u64) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_fee_bps",
+                args: (dst_eid, fee_bps).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.set_fee_bps(&dst_eid, &fee_bps);
+    }
+
+    /// Try to set fee bps (returns Result)
+    pub fn try_set_fee_bps(
+        &self,
+        dst_eid: u32,
+        fee_bps: u64,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_fee_bps",
+                args: (dst_eid, fee_bps).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.try_set_fee_bps(&dst_eid, &fee_bps)
+    }
+
+    /// Unset fee bps for a specific destination (owner only)
+    pub fn unset_fee_bps(&self, dst_eid: u32) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "unset_fee_bps",
+                args: (dst_eid,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.unset_fee_bps(&dst_eid);
+    }
+
+    /// Try to unset fee bps (returns Result)
+    pub fn try_unset_fee_bps(
+        &self,
+        dst_eid: u32,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "unset_fee_bps",
+                args: (dst_eid,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.try_unset_fee_bps(&dst_eid)
+    }
+
+    /// Set the fee deposit address (owner only)
+    pub fn set_fee_deposit_address(&self, address: &Address) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_fee_deposit_address",
+                args: (address,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.set_fee_deposit_address(address);
+    }
+
+    /// Try to set fee deposit address (returns Result)
+    pub fn try_set_fee_deposit_address(
+        &self,
+        address: &Address,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_fee_deposit_address",
+                args: (address,).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.try_set_fee_deposit_address(address)
+    }
+
+    /// Get the default fee bps
+    pub fn default_fee_bps(&self) -> u64 {
+        self.oft.default_fee_bps()
+    }
+
+    /// Get the fee bps for a specific destination
+    pub fn fee_bps(&self, dst_eid: u32) -> u64 {
+        self.oft.fee_bps(&dst_eid).unwrap_or(0)
+    }
+
+    /// Get the effective fee bps for a specific destination
+    pub fn effective_fee_bps(&self, dst_eid: u32) -> u64 {
+        self.oft.effective_fee_bps(&dst_eid)
+    }
+
+    /// Check if fee bps is set for a specific destination
+    pub fn has_fee_bps(&self, dst_eid: u32) -> bool {
+        self.oft.has_fee_bps(&dst_eid)
+    }
+
+    /// Get the fee deposit address
+    pub fn fee_deposit_address(&self) -> Address {
+        self.oft.fee_deposit_address()
+    }
+
+    // ==================== Rate Limiter Extension Helpers ====================
+
+    /// Set rate limit for a direction and eid (owner only)
+    pub fn set_rate_limit(&self, direction: &Direction, eid: u32, limit: i128, window_seconds: u64) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_rate_limit",
+                args: (direction, eid, limit, window_seconds).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.set_rate_limit(direction, &eid, &limit, &window_seconds);
+    }
+
+    /// Try to set rate limit (returns Result)
+    pub fn try_set_rate_limit(
+        &self,
+        direction: &Direction,
+        eid: u32,
+        limit: i128,
+        window_seconds: u64,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "set_rate_limit",
+                args: (direction, eid, limit, window_seconds).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.try_set_rate_limit(direction, &eid, &limit, &window_seconds)
+    }
+
+    /// Unset rate limit for a direction and eid (owner only)
+    pub fn unset_rate_limit(&self, direction: &Direction, eid: u32) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "unset_rate_limit",
+                args: (direction, eid).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.unset_rate_limit(direction, &eid);
+    }
+
+    /// Try to unset rate limit (returns Result)
+    pub fn try_unset_rate_limit(
+        &self,
+        direction: &Direction,
+        eid: u32,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "unset_rate_limit",
+                args: (direction, eid).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.oft.try_unset_rate_limit(direction, &eid)
+    }
+
+    /// Get rate limit config (limit, window_seconds)
+    pub fn rate_limit_config(&self, direction: &Direction, eid: u32) -> (i128, u64) {
+        self.oft.rate_limit_config(direction, &eid)
+    }
+
+    /// Get rate limit in flight
+    pub fn rate_limit_in_flight(&self, direction: &Direction, eid: u32) -> i128 {
+        self.oft.rate_limit_in_flight(direction, &eid)
+    }
+
+    /// Try to get rate limit in-flight (returns Result for testing error cases)
+    pub fn try_rate_limit_in_flight(
+        &self,
+        direction: &Direction,
+        eid: u32,
+    ) -> Result<Result<i128, soroban_sdk::Error>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.oft.try_rate_limit_in_flight(direction, &eid)
+    }
+
+    /// Get rate limit capacity
+    pub fn rate_limit_capacity(&self, direction: &Direction, eid: u32) -> i128 {
+        self.oft.rate_limit_capacity(direction, &eid)
+    }
+
+    // ==================== Time Helpers ====================
+
+    /// Advance the ledger timestamp by the given number of seconds
+    pub fn advance_time(&self, seconds: u64) {
+        let current = self.env.ledger().timestamp();
+        self.env.ledger().set_timestamp(current + seconds);
+    }
+
+    /// Set the ledger timestamp to a specific value
+    pub fn set_timestamp(&self, timestamp: u64) {
+        self.env.ledger().set_timestamp(timestamp);
+    }
+
+    // ==================== OFT Core Operations ====================
+
+    /// Create a SendParam for testing
+    pub fn create_send_param(&self, dst_eid: u32, amount_ld: i128, min_amount_ld: i128) -> SendParam {
+        SendParam {
+            dst_eid,
+            to: BytesN::from_array(self.env, &[1u8; 32]),
+            amount_ld,
+            min_amount_ld,
+            extra_options: bytes!(self.env),
+            compose_msg: bytes!(self.env),
+            oft_cmd: bytes!(self.env),
+        }
+    }
+
+    /// Quote OFT to get the receipt for authorization
+    pub fn quote_oft(&self, send_param: &SendParam) -> OFTReceipt {
+        let (_, _, receipt) = self.oft.quote_oft(send_param);
+        receipt
+    }
+
+    /// Try quote OFT (returns Result)
+    pub fn try_quote_oft(
+        &self,
+        send_param: &SendParam,
+    ) -> Result<
+        Result<(crate::types::OFTLimit, soroban_sdk::Vec<crate::types::OFTFeeDetail>, OFTReceipt), soroban_sdk::Error>,
+        Result<soroban_sdk::Error, soroban_sdk::InvokeError>,
+    > {
+        self.oft.try_quote_oft(send_param)
+    }
+
+    /// Quote send to get messaging fees
+    pub fn quote_send(&self, sender: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee {
+        self.oft.quote_send(sender, send_param, &pay_in_zro)
+    }
+
+    /// Try quote send (returns Result)
+    pub fn try_quote_send(
+        &self,
+        sender: &Address,
+        send_param: &SendParam,
+        pay_in_zro: bool,
+    ) -> Result<Result<MessagingFee, soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>>
+    {
+        self.oft.try_quote_send(sender, send_param, &pay_in_zro)
+    }
+
+    /// Send tokens cross-chain with proper sender authentication and fee transfer
+    /// Use this when OFT fee extension is configured and fee > 0
+    pub fn send_with_fee(
+        &self,
+        sender: &Address,
+        send_param: &SendParam,
+        fee: &MessagingFee,
+        refund_address: &Address,
+        oft_receipt: &OFTReceipt,
+        fee_deposit_address: &Address,
+    ) -> (MessagingReceipt, OFTReceipt) {
+        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
+        // 2. Burn tokens (amount_received_ld, not amount_sent_ld)
+        // 3. Transfer native/zro fees (__lz_send)
+        self.env.mock_auths(&[MockAuth {
+            address: sender,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                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)
+                    MockAuthInvoke {
+                        contract: &self.token,
+                        fn_name: "transfer",
+                        args: (sender, fee_deposit_address, &fee_amount).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                    // 2. Burn tokens (amount_received_ld, not amount_sent_ld)
+                    MockAuthInvoke {
+                        contract: &self.token,
+                        fn_name: "burn",
+                        args: (sender, &oft_receipt.amount_received_ld).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                    // 3. Transfer native fee - happens in __lz_send
+                    MockAuthInvoke {
+                        contract: &self.native_token,
+                        fn_name: "transfer",
+                        args: (sender, &self.endpoint_client.address, &fee.native_fee).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                    // 4. Transfer zro fee - happens in __lz_send
+                    MockAuthInvoke {
+                        contract: &self.zro_token,
+                        fn_name: "transfer",
+                        args: (sender, &self.endpoint_client.address, &fee.zro_fee).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                ],
+            },
+        }]);
+        self.oft.send(sender, send_param, fee, refund_address)
+    }
+
+    /// Send tokens cross-chain without fee transfer (for cases where no fee is configured)
+    pub fn send(
+        &self,
+        sender: &Address,
+        send_param: &SendParam,
+        fee: &MessagingFee,
+        refund_address: &Address,
+        oft_receipt: &OFTReceipt,
+    ) -> (MessagingReceipt, OFTReceipt) {
+        // When no fee is configured, amount_sent_ld == amount_received_ld
+        // Mock auth order must match contract execution order:
+        // 1. Burn tokens (amount_received_ld)
+        // 2. Transfer native/zro fees (__lz_send)
+        self.env.mock_auths(&[MockAuth {
+            address: sender,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "send",
+                args: (sender, send_param, fee, refund_address).into_val(self.env),
+                sub_invokes: &[
+                    // 1. Burn tokens (mint-burn strategy) - amount_received_ld == amount_sent_ld when no fee
+                    MockAuthInvoke {
+                        contract: &self.token,
+                        fn_name: "burn",
+                        args: (sender, &oft_receipt.amount_received_ld).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                    // 2. Transfer native fee - happens in __lz_send
+                    MockAuthInvoke {
+                        contract: &self.native_token,
+                        fn_name: "transfer",
+                        args: (sender, &self.endpoint_client.address, &fee.native_fee).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                    // 3. Transfer zro fee - happens in __lz_send
+                    MockAuthInvoke {
+                        contract: &self.zro_token,
+                        fn_name: "transfer",
+                        args: (sender, &self.endpoint_client.address, &fee.zro_fee).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                ],
+            },
+        }]);
+        self.oft.send(sender, send_param, fee, refund_address)
+    }
+
+    /// Try send tokens cross-chain without fee (returns Result)
+    pub fn try_send(
+        &self,
+        sender: &Address,
+        send_param: &SendParam,
+        fee: &MessagingFee,
+        refund_address: &Address,
+        oft_receipt: &OFTReceipt,
+    ) -> Result<
+        Result<(MessagingReceipt, OFTReceipt), soroban_sdk::Error>,
+        Result<soroban_sdk::Error, soroban_sdk::InvokeError>,
+    > {
+        // When no fee is configured, amount_sent_ld == amount_received_ld
+        // Mock auth order must match contract execution order:
+        // 1. Burn tokens (amount_received_ld)
+        // 2. Transfer native/zro fees (__lz_send)
+        self.env.mock_auths(&[MockAuth {
+            address: sender,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "send",
+                args: (sender, send_param, fee, refund_address).into_val(self.env),
+                sub_invokes: &[
+                    // 1. Burn tokens (mint-burn strategy) - amount_received_ld == amount_sent_ld when no fee
+                    MockAuthInvoke {
+                        contract: &self.token,
+                        fn_name: "burn",
+                        args: (sender, &oft_receipt.amount_received_ld).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                    // 2. Transfer native fee - happens in __lz_send
+                    MockAuthInvoke {
+                        contract: &self.native_token,
+                        fn_name: "transfer",
+                        args: (sender, &self.endpoint_client.address, &fee.native_fee).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                    // 3. Transfer zro fee - happens in __lz_send
+                    MockAuthInvoke {
+                        contract: &self.zro_token,
+                        fn_name: "transfer",
+                        args: (sender, &self.endpoint_client.address, &fee.zro_fee).into_val(self.env),
+                        sub_invokes: &[],
+                    },
+                ],
+            },
+        }]);
+        self.oft.try_send(sender, send_param, fee, refund_address)
+    }
+
+    /// Execute lz_receive with proper executor authentication
+    pub fn lz_receive(
+        &self,
+        executor: &Address,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        value: i128,
+    ) {
+        self.env.mock_auths(&[MockAuth {
+            address: executor,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "lz_receive",
+                args: (executor, origin, guid, message, extra_data, value).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        LayerZeroReceiverClient::new(self.env, &self.oft.address)
+            .lz_receive(executor, origin, guid, message, extra_data, &value);
+    }
+
+    /// Try lz_receive (returns Result)
+    pub fn try_lz_receive(
+        &self,
+        executor: &Address,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        value: i128,
+    ) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+        self.env.mock_auths(&[MockAuth {
+            address: executor,
+            invoke: &MockAuthInvoke {
+                contract: &self.oft.address,
+                fn_name: "lz_receive",
+                args: (executor, origin, guid, message, extra_data, value).into_val(self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        LayerZeroReceiverClient::new(self.env, &self.oft.address)
+            .try_lz_receive(executor, origin, guid, message, extra_data, &value)
+    }
+}