@layerzerolabs/protocol-stellar-v2 0.2.65 → 0.2.66

package/contracts/oapps/console-oft/integration-tests/extensions/test_combined.rs

@@ -1,90 +0,0 @@
-//! Combined extension e2e tests for OFT-STD.
-//!
-//! Tests verify the interaction between multiple extensions when enabled simultaneously.
-
-use crate::integration_tests::{
-    setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
-    utils::{
-        address_to_peer_bytes32, create_send_param, globally_disable_rate_limiter, lz_receive, mint_oft_token_to,
-        mint_to, outbound_rate_limit_usage, quote_oft, quote_send, scan_packet_sent_event, send_with_fee,
-        set_default_fee_bps, set_outbound_rate_limit, set_paused, try_send, validate_packet,
-    },
-};
-use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
-
-/// Test fee + rate limit: rate limit consumes the post-fee amount (amount_received_ld)
-#[test]
-fn test_fee_plus_rate_limit() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-    let executor = Address::generate(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 100_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    // Enable 10% fee and outbound rate limit of 5M.
-    set_default_fee_bps(&env, &chain_a, 1_000); // 10%
-    set_outbound_rate_limit(&env, &chain_a, chain_b.eid, 5_000_000, 3600);
-
-    let to = address_to_peer_bytes32(&receiver);
-    let amount_ld = 2_000_000i128;
-    let send_param = create_send_param(&env, chain_b.eid, amount_ld, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-
-    // Fee = 10% of 2M = 200,000; amount_received = 1,800,000
-    let expected_fee = 200_000i128;
-    assert_eq!(oft_receipt.amount_sent_ld, amount_ld);
-    assert_eq!(oft_receipt.amount_received_ld, amount_ld - expected_fee);
-
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-    send_with_fee(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt, &chain_a.fee_collector);
-
-    // Scan events immediately after send
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
-
-    // Rate limit usage = post-fee amount (amount_received_ld), not the gross amount
-    let usage = outbound_rate_limit_usage(&env, &chain_a, chain_b.eid);
-    assert_eq!(usage, oft_receipt.amount_received_ld);
-
-    // Fee was collected on source chain
-    let fee_collector_balance = TokenClient::new(&env, &chain_a.oft_token).balance(&chain_a.fee_collector);
-    assert_eq!(fee_collector_balance, expected_fee);
-
-    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
-
-    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
-    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
-}
-
-/// Test pause + rate limit: paused overrides rate limit (send fails even if within rate limit)
-#[test]
-fn test_pause_overrides_rate_limit() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 100_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    set_outbound_rate_limit(&env, &chain_a, chain_b.eid, 10_000_000, 3600);
-
-    let to = address_to_peer_bytes32(&receiver);
-    let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-
-    // Pause — send should fail even though rate limit has plenty of capacity
-    set_paused(&env, &chain_a, true);
-    let success = try_send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
-    assert!(!success, "send should fail when paused, regardless of rate limit capacity");
-}

package/contracts/oapps/console-oft/integration-tests/extensions/test_oft_fee.rs

@@ -1,186 +0,0 @@
-//! OFT Fee extension e2e tests for OFT-STD.
-//!
-//! Tests verify that the OFTFee extension properly collects fees on cross-chain transfers.
-//! Key behavior: at debit_view, apply fee first then remove dust.
-//! - If fee is zero: amount_sent_ld == amount_received_ld
-//! - If fee is non-zero: amount_sent_ld is unchanged (original amount)
-
-use crate::integration_tests::{
-    setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
-    utils::{
-        address_to_peer_bytes32, create_send_param, globally_disable_rate_limiter, lz_receive, mint_oft_token_to,
-        mint_to, quote_oft, quote_send, scan_packet_sent_event, send, send_with_fee, set_default_fee_bps, set_fee_bps,
-        set_outbound_rate_limit, token_balance, validate_packet,
-    },
-};
-use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
-
-/// Test e2e cross-chain transfer with zero fee (default)
-#[test]
-fn test_cross_chain_with_zero_fee() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_a);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-    let executor = Address::generate(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    let to = address_to_peer_bytes32(&receiver);
-    let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-
-    // With zero fee, amount_sent_ld == amount_received_ld (after dust removal)
-    assert_eq!(oft_receipt.amount_sent_ld, oft_receipt.amount_received_ld);
-
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
-
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
-
-    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
-
-    // Verify receiver got full amount (no fee)
-    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
-    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
-}
-
-/// Test e2e cross-chain transfer with fee enabled
-#[test]
-fn test_cross_chain_with_fee() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_a);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-    let executor = Address::generate(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    // Enable 1% fee (100 bps).
-    set_default_fee_bps(&env, &chain_a, 100);
-
-    let to = address_to_peer_bytes32(&receiver);
-    let amount_ld = 1_000_000i128;
-    let send_param = create_send_param(&env, chain_b.eid, amount_ld, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-
-    // With fee, amount_sent_ld stays original, amount_received_ld is reduced
-    assert_eq!(oft_receipt.amount_sent_ld, amount_ld);
-    assert!(oft_receipt.amount_received_ld < amount_ld);
-
-    // Expected fee: 1% of 1,000,000 = 10,000
-    let expected_fee = 10_000i128;
-    let actual_fee = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
-    assert_eq!(actual_fee, expected_fee);
-
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-    send_with_fee(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt, &chain_a.fee_collector);
-
-    // IMPORTANT: Scan events immediately after send, before any other operations
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
-
-    // Verify fee was collected on source chain
-    let fee_collector_balance = token_balance(&env, &chain_a.oft_token, &chain_a.fee_collector);
-    assert_eq!(fee_collector_balance, expected_fee);
-
-    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
-
-    // Verify receiver got amount after fee
-    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
-    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
-}
-
-/// Test e2e cross-chain transfer with destination-specific fee
-#[test]
-fn test_cross_chain_with_destination_specific_fee() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_a);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-    let executor = Address::generate(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    // Set default fee 1% and destination-specific fee 2% for chain_b.
-    set_default_fee_bps(&env, &chain_a, 100); // 1%
-    set_fee_bps(&env, &chain_a, chain_b.eid, 200); // 2% for chain_b
-
-    let to = address_to_peer_bytes32(&receiver);
-    let amount_ld = 1_000_000i128;
-    let send_param = create_send_param(&env, chain_b.eid, amount_ld, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-
-    // 2% fee on 1,000,000 = 20,000
-    let expected_fee = 20_000i128;
-    let actual_fee = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
-    assert_eq!(actual_fee, expected_fee);
-
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-    send_with_fee(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt, &chain_a.fee_collector);
-
-    // IMPORTANT: Scan events immediately after send, before any other operations
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
-
-    // Verify fee was collected
-    let fee_collector_balance = token_balance(&env, &chain_a.oft_token, &chain_a.fee_collector);
-    assert_eq!(fee_collector_balance, expected_fee);
-
-    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
-
-    // Verify receiver got correct amount
-    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
-    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
-}
-
-/// Test quote_oft returns accurate OFTLimit and OFTFeeDetail under rate limit + fee
-#[test]
-fn test_quote_oft_reflects_rate_limit_and_fee() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-
-    let sender = Address::generate(&env);
-    mint_oft_token_to(&env, &chain_a, &sender, 100_000_000);
-
-    // Set outbound rate limit = 5M and fee = 2%.
-    set_outbound_rate_limit(&env, &chain_a, chain_b.eid, 5_000_000, 3600);
-    set_default_fee_bps(&env, &chain_a, 200);
-
-    let to = address_to_peer_bytes32(&create_recipient_address(&env));
-    let send_param = create_send_param(&env, chain_b.eid, 3_000_000, 0, &to);
-    let (oft_limit, fee_details, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-
-    // OFTLimit.max_amount_ld = back-calculated pre-fee max so post-fee fits the rate limit
-    // rate_limit_capacity=5M, fee=2%: max_send = 5M * 10000 / 9800 = 5,102,040
-    assert_eq!(oft_limit.max_amount_ld, 5_102_040);
-
-    // Fee detail should show 2% fee
-    assert!(!fee_details.is_empty());
-    let fee_detail = fee_details.first().unwrap();
-    assert_eq!(fee_detail.fee_amount_ld, 60_000); // 2% of 3M = 60,000
-
-    // OFTReceipt should reflect fee deduction
-    assert_eq!(oft_receipt.amount_sent_ld, 3_000_000);
-    assert_eq!(oft_receipt.amount_received_ld, 3_000_000 - 60_000);
-}

package/contracts/oapps/console-oft/integration-tests/extensions/test_ownership.rs

@@ -1,161 +0,0 @@
-//! Ownership & delegate sync integration tests for Console OFT.
-//!
-//! Verifies that:
-//! - Single-step `transfer_ownership` is disabled.
-//! - `renounce_ownership` is disabled.
-//! - `set_delegate` is disabled.
-//! - 2-step ownership transfer works and auto-syncs the endpoint delegate.
-
-use crate::integration_tests::setup::{setup, TestSetup};
-use crate::errors::OFTError;
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Env, IntoVal,
-};
-use utils::errors::OwnableError;
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-fn get_delegate(_env: &Env, setup: &crate::integration_tests::setup::ChainSetup<'_>) -> Option<Address> {
-    setup.endpoint.delegate(&setup.oft.address)
-}
-
-// ============================================================================
-// Disabled operations
-// ============================================================================
-
-#[test]
-fn test_transfer_ownership_disabled() {
-    let TestSetup { env, chain_a, .. } = setup();
-
-    let new_owner = Address::generate(&env);
-    env.mock_auths(&[MockAuth {
-        address: &chain_a.owner,
-        invoke: &MockAuthInvoke {
-            contract: &chain_a.oft.address,
-            fn_name: "transfer_ownership",
-            args: (&new_owner,).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    let res = chain_a.oft.try_transfer_ownership(&new_owner);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTError::Disabled.into());
-}
-
-#[test]
-fn test_renounce_ownership_disabled() {
-    let TestSetup { env, chain_a, .. } = setup();
-
-    env.mock_auths(&[MockAuth {
-        address: &chain_a.owner,
-        invoke: &MockAuthInvoke {
-            contract: &chain_a.oft.address,
-            fn_name: "renounce_ownership",
-            args: ().into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    let res = chain_a.oft.try_renounce_ownership();
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTError::Disabled.into());
-}
-
-#[test]
-fn test_set_delegate_disabled() {
-    let TestSetup { env, chain_a, .. } = setup();
-
-    let new_delegate: Option<Address> = Some(Address::generate(&env));
-    env.mock_auths(&[MockAuth {
-        address: &chain_a.owner,
-        invoke: &MockAuthInvoke {
-            contract: &chain_a.oft.address,
-            fn_name: "set_delegate",
-            args: (&new_delegate, &chain_a.owner).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    let res = chain_a.oft.try_set_delegate(&new_delegate, &chain_a.owner);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTError::Disabled.into());
-}
-
-// ============================================================================
-// 2-step ownership transfer with delegate sync
-// ============================================================================
-
-#[test]
-fn test_two_step_transfer_syncs_delegate() {
-    let TestSetup { env, chain_a, .. } = setup();
-    let new_owner = Address::generate(&env);
-    let ttl = 1000u32;
-
-    // Verify initial state: owner == delegate
-    assert_eq!(chain_a.oft.owner(), Some(chain_a.owner.clone()));
-    assert_eq!(get_delegate(&env, &chain_a), Some(chain_a.owner.clone()));
-
-    // Step 1: begin_ownership_transfer (owner initiates)
-    env.mock_auths(&[MockAuth {
-        address: &chain_a.owner,
-        invoke: &MockAuthInvoke {
-            contract: &chain_a.oft.address,
-            fn_name: "begin_ownership_transfer",
-            args: (&new_owner, &ttl).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    chain_a.oft.begin_ownership_transfer(&new_owner, &ttl);
-
-    // Owner and delegate unchanged during pending state
-    assert_eq!(chain_a.oft.owner(), Some(chain_a.owner.clone()));
-    assert_eq!(chain_a.oft.pending_owner(), Some(new_owner.clone()));
-    assert_eq!(get_delegate(&env, &chain_a), Some(chain_a.owner.clone()));
-
-    // Step 2: accept_ownership (new owner accepts)
-    env.mock_auths(&[MockAuth {
-        address: &new_owner,
-        invoke: &MockAuthInvoke {
-            contract: &chain_a.oft.address,
-            fn_name: "accept_ownership",
-            args: ().into_val(&env),
-            sub_invokes: &[MockAuthInvoke {
-                contract: &chain_a.endpoint.address,
-                fn_name: "set_delegate",
-                args: (&chain_a.oft.address, &Some(new_owner.clone())).into_val(&env),
-                sub_invokes: &[],
-            }],
-        },
-    }]);
-    chain_a.oft.accept_ownership();
-
-    // Verify: owner == delegate == new_owner
-    assert_eq!(chain_a.oft.owner(), Some(new_owner.clone()));
-    assert_eq!(chain_a.oft.pending_owner(), None);
-    assert_eq!(get_delegate(&env, &chain_a), Some(new_owner));
-}
-
-#[test]
-fn test_accept_ownership_fails_without_pending_transfer() {
-    let TestSetup { env, chain_a, .. } = setup();
-
-    let random = Address::generate(&env);
-    env.mock_auths(&[MockAuth {
-        address: &random,
-        invoke: &MockAuthInvoke {
-            contract: &chain_a.oft.address,
-            fn_name: "accept_ownership",
-            args: ().into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    let res = chain_a.oft.try_accept_ownership();
-    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::NoPendingTransfer.into());
-}
-
-#[test]
-fn test_initial_owner_equals_delegate() {
-    let TestSetup { env, chain_a, .. } = setup();
-
-    let owner = chain_a.oft.owner().unwrap();
-    let delegate = get_delegate(&env, &chain_a).unwrap();
-    assert_eq!(owner, delegate);
-}

package/contracts/oapps/console-oft/integration-tests/extensions/test_pausable.rs

@@ -1,154 +0,0 @@
-//! Pausable extension e2e tests for OFT-STD.
-//!
-//! Tests verify that the Pausable extension properly blocks/allows send and receive
-//! operations when the OFT is paused/unpaused. Uses real EndpointV2 and SimpleMessageLib.
-
-use crate::integration_tests::{
-    setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
-    utils::{
-        address_to_peer_bytes32, create_send_param, globally_disable_rate_limiter, is_paused, lz_receive,
-        mint_oft_token_to, mint_to, quote_oft, quote_send, scan_packet_sent_event, send, set_paused, try_send,
-        validate_packet,
-    },
-};
-use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
-
-/// Test e2e send succeeds when unpaused (default state)
-#[test]
-fn test_send_succeeds_when_unpaused() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_a);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    assert!(!is_paused(&chain_a));
-
-    let to = address_to_peer_bytes32(&receiver);
-    let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-
-    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
-
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
-
-    let executor = Address::generate(&env);
-    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
-
-    let sender_balance = TokenClient::new(&env, &chain_a.oft_token).balance(&sender);
-    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
-    assert_eq!(sender_balance, 10_000_000 - oft_receipt.amount_sent_ld);
-    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
-}
-
-/// Test e2e send fails when paused
-#[test]
-fn test_send_fails_when_paused() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_a);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    let to = address_to_peer_bytes32(&receiver);
-    let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-
-    set_paused(&env, &chain_a, true);
-    assert!(is_paused(&chain_a));
-
-    let success = try_send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
-    assert!(!success);
-}
-
-/// Test e2e receive succeeds even when destination is paused.
-///
-/// Matches EVM behavior: `whenNotPaused` is only on `_debit`, not `_credit`.
-/// This prevents in-flight token lockups when a chain is paused mid-transfer.
-#[test]
-fn test_receive_succeeds_when_paused() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_a);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-    let executor = Address::generate(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    let to = address_to_peer_bytes32(&receiver);
-    let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
-
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
-
-    set_paused(&env, &chain_b, true);
-    assert!(is_paused(&chain_b));
-
-    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
-
-    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
-    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
-}
-
-/// Test e2e cross-chain flow works after unpause
-#[test]
-fn test_cross_chain_succeeds_after_unpause() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_oft(&env, &[&chain_a, &chain_b]);
-    globally_disable_rate_limiter(&env, &chain_a);
-    globally_disable_rate_limiter(&env, &chain_b);
-
-    let sender = Address::generate(&env);
-    let receiver = create_recipient_address(&env);
-    let executor = Address::generate(&env);
-
-    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-
-    set_paused(&env, &chain_a, true);
-    assert!(is_paused(&chain_a));
-    set_paused(&env, &chain_a, false);
-    assert!(!is_paused(&chain_a));
-
-    let to = address_to_peer_bytes32(&receiver);
-    let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
-    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
-
-    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
-
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
-
-    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
-
-    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
-    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
-}