@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -0,0 +1,157 @@
+//! 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, lz_receive, mint_to,
+        quote_oft, quote_send, scan_packet_sent_event, send, send_with_fee,
+        set_default_fee_bps, set_fee_bps, set_fee_deposit_address, token_balance,
+        transfer_sac_admin, 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]);
+
+    let sender = Address::generate(&env);
+    let receiver = create_recipient_address(&env);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    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, &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]);
+
+    let sender = Address::generate(&env);
+    let receiver = create_recipient_address(&env);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Enable 1% fee (100 bps)
+    set_fee_deposit_address(&env, &chain_a, &chain_a.fee_collector);
+    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, &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]);
+
+    let sender = Address::generate(&env);
+    let receiver = create_recipient_address(&env);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Set default fee 1% and destination-specific fee 2% for chain_b
+    set_fee_deposit_address(&env, &chain_a, &chain_a.fee_collector);
+    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, &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);
+}

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

@@ -0,0 +1,162 @@
+//! 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, is_paused, lz_receive, mint_to,
+        quote_oft, quote_send, scan_packet_sent_event, send, set_paused, transfer_sac_admin,
+        try_lz_receive, 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]);
+
+    let sender = Address::generate(&env);
+    let receiver = create_recipient_address(&env);
+
+    // Mint tokens and transfer admin rights
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Default state should be unpaused
+    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, &send_param);
+    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
+
+    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
+
+    // Validate packet and deliver on chain B
+    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);
+
+    // Verify balances
+    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]);
+
+    let sender = Address::generate(&env);
+    let receiver = create_recipient_address(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+
+    let to = address_to_peer_bytes32(&receiver);
+    let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
+
+    // Get quote BEFORE pausing (since quote_oft also checks pause state)
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &send_param);
+    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
+
+    // Pause the OFT
+    set_paused(&env, &chain_a, true);
+    assert!(is_paused(&chain_a));
+
+    // Send should fail when paused
+    let success = try_send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
+    assert!(!success);
+}
+
+/// Test e2e receive fails when destination is paused
+#[test]
+fn test_receive_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]);
+
+    let sender = Address::generate(&env);
+    let receiver = create_recipient_address(&env);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Send from chain_a to chain_b
+    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, &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);
+
+    // Pause chain_b's OFT before receiving
+    set_paused(&env, &chain_b, true);
+    assert!(is_paused(&chain_b));
+
+    // Receive should fail on paused destination
+    let success = try_lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
+    assert!(!success);
+}
+
+/// 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]);
+
+    let sender = Address::generate(&env);
+    let receiver = create_recipient_address(&env);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Pause and then unpause
+    set_paused(&env, &chain_a, true);
+    assert!(is_paused(&chain_a));
+    set_paused(&env, &chain_a, false);
+    assert!(!is_paused(&chain_a));
+
+    // Send should work after unpause
+    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, &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);
+
+    // Verify successful transfer
+    let receiver_balance = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
+    assert_eq!(receiver_balance, oft_receipt.amount_received_ld);
+}

package/contracts/oapps/oft-std/integration-tests/extensions/test_rate_limiter.rs

@@ -0,0 +1,186 @@
+//! Rate Limiter extension e2e tests for OFT-STD.
+//!
+//! Tests verify that the RateLimiter extension properly enforces rate limits
+//! on cross-chain transfers. 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, advance_time, create_send_param, lz_receive, mint_to, quote_oft, quote_send,
+        rate_limit_capacity, rate_limit_in_flight, scan_packet_sent_event, send, set_rate_limit, transfer_sac_admin,
+        try_send, validate_packet,
+    },
+};
+use oft::extensions::rate_limiter::Direction;
+use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
+
+/// Test e2e send without rate limit (default - unlimited)
+#[test]
+fn test_send_without_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);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Default capacity should be i128::MAX (unlimited)
+    let capacity = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert_eq!(capacity, i128::MAX);
+
+    let to = address_to_peer_bytes32(&receiver);
+    let send_param = create_send_param(&env, chain_b.eid, 50_000_000, 0, &to);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &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);
+}
+
+/// Test e2e send within rate limit succeeds
+#[test]
+fn test_send_within_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);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Set rate limit: 10M per 3600 seconds (1 hour)
+    set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 3600);
+
+    let capacity = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert_eq!(capacity, 10_000_000);
+
+    // Send 5M (within limit)
+    let to = address_to_peer_bytes32(&receiver);
+    let send_param = create_send_param(&env, chain_b.eid, 5_000_000, 0, &to);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &send_param);
+    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
+
+    // Check in_flight BEFORE send
+    let in_flight_before = rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert_eq!(in_flight_before, 0, "in_flight should be 0 before send");
+
+    // Send within rate limit
+    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
+
+    // IMPORTANT: Scan events immediately after send, before any other operations
+    let packet_event =
+        scan_packet_sent_event(&env, &chain_a.endpoint.address).expect("packet_sent event should be emitted");
+
+    // Verify capacity reduced
+    let in_flight = rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert_eq!(in_flight, oft_receipt.amount_received_ld, "in_flight should match amount sent");
+    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);
+}
+
+/// Test e2e send exceeding rate limit fails
+#[test]
+fn test_send_exceeds_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_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+
+    // Set rate limit: 1M per 3600 seconds
+    set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 1_000_000, 3600);
+
+    // Try to send 5M (exceeds limit)
+    let to = address_to_peer_bytes32(&receiver);
+    let send_param = create_send_param(&env, chain_b.eid, 5_000_000, 0, &to);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &send_param);
+    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
+
+    let success = try_send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
+    assert!(!success);
+}
+
+/// Test rate limit decay over time
+#[test]
+fn test_rate_limit_decay() {
+    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);
+    let executor = Address::generate(&env);
+
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
+    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
+    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
+
+    // Set rate limit: 10M per 1000 seconds
+    set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 1000);
+
+    let to = address_to_peer_bytes32(&receiver);
+
+    // Send 8M
+    let send_param1 = create_send_param(&env, chain_b.eid, 8_000_000, 0, &to);
+    let (_, _, oft_receipt1) = quote_oft(&chain_a, &send_param1);
+    let fee1 = quote_send(&env, &chain_a, &sender, &send_param1, false);
+    send(&env, &chain_a, &sender, &send_param1, &fee1, &sender, &oft_receipt1);
+
+    let packet_event1 = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event1);
+    let packet1 = decode_packet(&env, &packet_event1.0);
+    lz_receive(&env, &chain_b, &executor, &packet1, &receiver, 0);
+
+    // Only ~2M capacity remaining
+    let capacity_before = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert!(capacity_before < 3_000_000);
+
+    // Advance time by 500 seconds (50% of window) - should recover ~5M
+    advance_time(&env, 500);
+
+    let capacity_after = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
+    // Capacity should have increased due to decay
+    assert!(capacity_after > capacity_before);
+
+    // Now we should be able to send more
+    let send_param2 = create_send_param(&env, chain_b.eid, 4_000_000, 0, &to);
+    let (_, _, oft_receipt2) = quote_oft(&chain_a, &send_param2);
+    let fee2 = quote_send(&env, &chain_a, &sender, &send_param2, false);
+    send(&env, &chain_a, &sender, &send_param2, &fee2, &sender, &oft_receipt2);
+
+    // Verify second send succeeded
+    let packet_event2 = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event2);
+    let packet2 = decode_packet(&env, &packet_event2.0);
+    lz_receive(&env, &chain_b, &executor, &packet2, &receiver, 0);
+}

package/contracts/oapps/oft-std/integration-tests/mod.rs

@@ -0,0 +1,3 @@
+pub mod extensions;
+pub mod setup;
+pub mod utils;