@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

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

@@ -1,903 +0,0 @@
-//! 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, OFTInternal, 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 OFTInternal for ExtensiveOFT {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        // 1. Pausable check
-        Self::__assert_not_paused(env);
-
-        // 2. Core debit logic
-        let oft_receipt = crate::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid);
-
-        // 3. Rate limit checks
-        Self::__consume_rate_limit_capacity(env, &Direction::Outbound, dst_eid, oft_receipt.amount_received_ld);
-        Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, oft_receipt.amount_received_ld);
-
-        // 4. Charge fee
-        Self::__charge_fee(
-            env,
-            &Self::token(env),
-            sender,
-            oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld,
-        );
-
-        oft_receipt
-    }
-
-    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-        // 1. Pausable check
-        Self::__assert_not_paused(env);
-
-        // 2. Core credit logic
-        let amount_credited = crate::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid);
-
-        // 3. Rate limit checks
-        Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_credited);
-        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_credited);
-
-        amount_credited
-    }
-
-    fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-        let amount_after_fee = Self::__fee_view(env, dst_eid, amount_ld);
-        let amount_received_ld = remove_dust(amount_after_fee, conversion_rate);
-        // Note: when no fee is applied, amount_send_ld is equal to amount_received_ld
-        // this is to align the behavior with the fee extensions on other VMs
-        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 (__charge_fee) - happens before burn
-        // 2. Burn tokens (amount_received_ld, not amount_sent_ld)
-        // 3. Transfer native/zro fees (__lz_send)
-        self.env.mock_auths(&[MockAuth {
-            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 __charge_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)
-    }
-}