@layerzerolabs/protocol-stellar-v2 0.2.64 → 0.2.66

package/Cargo.lock

@@ -292,22 +292,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "console-oft"
-version = "0.0.1"
-dependencies = [
- "cfg-if",
- "common-macros",
- "endpoint-v2",
- "message-lib-common",
- "oapp",
- "oapp-macros",
- "oft-core",
- "simple-message-lib",
- "soroban-sdk",
- "utils",
-]
-
 [[package]]
 name = "const-oid"
 version = "0.9.6"

package/Cargo.toml

@@ -50,7 +50,6 @@ blocked-message-lib = { path = "contracts/message-libs/blocked-message-lib" }
 oapp = { path = "contracts/oapps/oapp" }
 oapp-macros = { path = "contracts/oapps/oapp-macros" }
 oft = { path = "contracts/oapps/oft" }
-console-oft = { path = "contracts/oapps/console-oft" }
 oft-core = { path = "contracts/oapps/oft-core" }
 price-feed = { path = "contracts/workers/price-feed" }
 simple-message-lib = { path = "contracts/message-libs/simple-message-lib" }

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

@@ -29,6 +29,14 @@ fn test_cross_chain_with_zero_fee() {
     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);
 
+    // Default fee state on both OFTs
+    assert_eq!(chain_a.oft.default_fee_bps(), None);
+    assert_eq!(chain_a.oft.fee_deposit_address(), None);
+    assert_eq!(chain_a.oft.effective_fee_bps(&chain_b.eid), 0);
+    assert_eq!(chain_b.oft.default_fee_bps(), None);
+    assert_eq!(chain_b.oft.fee_deposit_address(), None);
+    assert_eq!(chain_b.oft.effective_fee_bps(&chain_a.eid), 0);
+
     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);
@@ -67,6 +75,12 @@ fn test_cross_chain_with_fee() {
     // Enable 1% fee (100 bps)
     set_fee_deposit_address(&env, &chain_a, &chain_a.fee_collector);
     set_default_fee_bps(&env, &chain_a, 100);
+    assert_eq!(chain_a.oft.default_fee_bps(), Some(100));
+    assert_eq!(chain_a.oft.fee_deposit_address(), Some(chain_a.fee_collector.clone()));
+    assert_eq!(chain_a.oft.effective_fee_bps(&chain_b.eid), 100);
+    assert_eq!(chain_b.oft.default_fee_bps(), None);
+    assert_eq!(chain_b.oft.fee_deposit_address(), None);
+    assert_eq!(chain_b.oft.effective_fee_bps(&chain_a.eid), 0);
 
     let to = address_to_peer_bytes32(&receiver);
     let amount_ld = 1_000_000i128;
@@ -119,6 +133,14 @@ fn test_cross_chain_with_destination_specific_fee() {
     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
+    assert_eq!(chain_a.oft.default_fee_bps(), Some(100));
+    assert_eq!(chain_a.oft.fee_bps(&chain_b.eid), Some(200));
+    assert_eq!(chain_a.oft.fee_deposit_address(), Some(chain_a.fee_collector.clone()));
+    assert_eq!(chain_a.oft.effective_fee_bps(&chain_b.eid), 200);
+    assert_eq!(chain_b.oft.default_fee_bps(), None);
+    assert_eq!(chain_b.oft.fee_bps(&chain_a.eid), None);
+    assert_eq!(chain_b.oft.fee_deposit_address(), None);
+    assert_eq!(chain_b.oft.effective_fee_bps(&chain_a.eid), 0);
 
     let to = address_to_peer_bytes32(&receiver);
     let amount_ld = 1_000_000i128;

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

@@ -26,8 +26,9 @@ fn test_send_succeeds_when_unpaused() {
     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);
 
-    // Default state should be unpaused
+    // Default state should be unpaused on both OFTs
     assert!(!is_paused(&chain_a));
+    assert!(!is_paused(&chain_b));
 
     let to = address_to_peer_bytes32(&receiver);
     let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
@@ -74,6 +75,7 @@ fn test_send_fails_when_paused() {
     // Pause the OFT
     set_paused(&env, &chain_a, true);
     assert!(is_paused(&chain_a));
+    assert!(!is_paused(&chain_b));
 
     // Send should fail when paused
     let success = try_send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
@@ -108,6 +110,7 @@ fn test_receive_fails_when_paused() {
     // Pause chain_b's OFT before receiving
     set_paused(&env, &chain_b, true);
     assert!(is_paused(&chain_b));
+    assert!(!is_paused(&chain_a));
 
     // Receive should fail on paused destination
     let success = try_lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
@@ -128,11 +131,15 @@ fn test_cross_chain_succeeds_after_unpause() {
     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);
 
-    // Pause and then unpause
+    // Pause and then unpause on chain_a; chain_b remains unpaused throughout
+    assert!(!is_paused(&chain_a));
+    assert!(!is_paused(&chain_b));
     set_paused(&env, &chain_a, true);
     assert!(is_paused(&chain_a));
+    assert!(!is_paused(&chain_b));
     set_paused(&env, &chain_a, false);
     assert!(!is_paused(&chain_a));
+    assert!(!is_paused(&chain_b));
 
     // Send should work after unpause
     let to = address_to_peer_bytes32(&receiver);

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

@@ -31,6 +31,9 @@ fn test_send_without_rate_limit() {
     // Default capacity should be i128::MAX (unlimited)
     let capacity = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
     assert_eq!(capacity, i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid), 0);
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 
     let to = address_to_peer_bytes32(&receiver);
     let send_param = create_send_param(&env, chain_b.eid, 50_000_000, 0, &to);
@@ -66,8 +69,9 @@ fn test_send_within_rate_limit() {
     // 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);
+    assert_eq!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid), 10_000_000);
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 
     // Send 5M (within limit)
     let to = address_to_peer_bytes32(&receiver);
@@ -113,6 +117,9 @@ fn test_send_exceeds_rate_limit() {
 
     // Set rate limit: 1M per 3600 seconds
     set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 1_000_000, 3600);
+    assert_eq!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid), 1_000_000);
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 
     // Try to send 5M (exceeds limit)
     let to = address_to_peer_bytes32(&receiver);
@@ -122,6 +129,8 @@ fn test_send_exceeds_rate_limit() {
 
     let success = try_send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
     assert!(!success);
+    assert_eq!(rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid), 0);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 }
 
 /// Test rate limit decay over time
@@ -140,6 +149,9 @@ fn test_rate_limit_decay() {
 
     // Set rate limit: 10M per 1000 seconds
     set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 1000);
+    assert_eq!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid), 10_000_000);
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 
     let to = address_to_peer_bytes32(&receiver);
 
@@ -176,6 +188,9 @@ fn test_rate_limit_decay() {
     validate_packet(&env, &chain_b, &packet_event2);
     let packet2 = decode_packet(&env, &packet_event2.0);
     lz_receive(&env, &chain_b, &executor, &packet2, &receiver, 0);
+    assert!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid) < 10_000_000);
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 }
 
 /// Test gross mode: round-trip shows gross mode doesn't release outbound capacity
@@ -199,6 +214,9 @@ fn test_gross_mode_does_not_release() {
 
     // Set Gross mode rate limit on chain_a outbound: 10M per 3600 seconds
     set_rate_limit_with_mode(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 3600, Mode::Gross);
+    assert_eq!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid), 10_000_000);
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 
     // Step 1: Send 8M from chain_a to chain_b
     let to_b = address_to_peer_bytes32(&receiver_b);
@@ -242,6 +260,8 @@ fn test_gross_mode_does_not_release() {
     // Should only have ~2M capacity left, NOT 8M (if it were Net mode)
     let capacity_after_return = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
     assert!(capacity_after_return < 3_000_000, "Gross mode: capacity should remain low");
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 }
 
 /// Test net mode (default): round-trip shows net mode releases outbound capacity
@@ -265,6 +285,9 @@ fn test_net_mode_does_release() {
 
     // Set Net mode rate limit on chain_a outbound: 10M per 3600 seconds
     set_rate_limit_with_mode(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 3600, Mode::Net);
+    assert_eq!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid), 10_000_000);
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 
     // Step 1: Send 8M from chain_a to chain_b
     let to_b = address_to_peer_bytes32(&receiver_b);
@@ -308,4 +331,6 @@ fn test_net_mode_does_release() {
     // Should have much more capacity now (8M sent - 6M received back = ~2M net)
     let capacity_after_return = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
     assert!(capacity_after_return > 7_000_000, "Net mode: capacity should increase after receiving");
+    assert_eq!(rate_limit_capacity(&chain_b, &Direction::Outbound, chain_a.eid), i128::MAX);
+    assert_eq!(rate_limit_in_flight(&chain_b, &Direction::Outbound, chain_a.eid), 0);
 }

package/contracts/oapps/oft/integration-tests/setup.rs

@@ -89,7 +89,7 @@ pub struct TestSetup<'a> {
     pub chain_b: ChainSetup<'a>,
 }
 
-fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
+fn setup_chain<'a>(env: &Env, use_mint_burn: bool) -> ChainSetup<'a> {
     let owner = Address::generate(env);
 
     // Create native token FIRST - this must match the endpoint's NATIVE_TOKEN constant
@@ -107,26 +107,31 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let oft_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let oft_token = oft_sac.address();
     let sac_wrapper_address = env.register(MockSacWrapper, (&oft_token,));
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &oft_token,
-            fn_name: "set_admin",
-            args: (&sac_wrapper_address,).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    StellarAssetClient::new(env, &oft_token).set_admin(&sac_wrapper_address);
+
+    let mode = if use_mint_burn {
+        env.mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &oft_token,
+                fn_name: "set_admin",
+                args: (&sac_wrapper_address,).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        StellarAssetClient::new(env, &oft_token).set_admin(&sac_wrapper_address);
+        OftType::MintBurn(sac_wrapper_address.clone())
+    } else {
+        OftType::LockUnlock
+    };
 
     let eid: u32 = 30400; // Test EID
     let endpoint_address = env.register(EndpointV2, (&owner, eid, &native_token));
     let fee_recipient = Address::generate(env);
     let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
     let delegate: Option<Address> = Some(owner.clone());
-    let shared_decimals: u32 = 6; // Default shared decimals
-                                  // MintBurn with SAC wrapper: OFT uses wrapper for mint on credit; burn is on token directly.
-    let mode = OftType::MintBurn(sac_wrapper_address.clone());
-    let oft_address = env.register(OFT, (&oft_token, &shared_decimals, &mode, &endpoint_address, delegate.as_ref().unwrap()));
+    let shared_decimals: u32 = 6;
+    let oft_address =
+        env.register(OFT, (&oft_token, &shared_decimals, &mode, &endpoint_address, delegate.as_ref().unwrap()));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
     let sml = SimpleMessageLibClient::new(env, &sml_address);
@@ -161,8 +166,8 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
 
 pub fn setup<'a>() -> TestSetup<'a> {
     let env = Env::default();
-    let chain_a = setup_chain(&env);
-    let chain_b = setup_chain(&env);
+    let chain_a = setup_chain(&env, false);
+    let chain_b = setup_chain(&env, true);
 
     let chain_a_oft_token_decimals = TokenClient::new(&env, &chain_a.oft_token).decimals();
     let chain_b_oft_token_decimals = TokenClient::new(&env, &chain_b.oft_token).decimals();
@@ -214,7 +219,6 @@ pub fn wire_oft(env: &Env, chains: &[&ChainSetup<'_>]) {
 }
 
 pub fn set_peer(env: &Env, owner: &Address, oft: &OFTClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
-
     let peer_option = Some(peer.clone());
     env.mock_auths(&[MockAuth {
         address: owner,

package/contracts/oapps/oft/integration-tests/utils.rs

@@ -1,9 +1,10 @@
 //! Utility functions for OFT-STD integration tests.
 
-use crate::extensions::rate_limiter::{Direction, Mode, RateLimitConfig, RATE_LIMITER_MANAGER_ROLE};
 use crate::extensions::oft_fee::FEE_CONFIG_MANAGER_ROLE;
 use crate::extensions::pausable::{PAUSER_ROLE, UNPAUSER_ROLE};
+use crate::extensions::rate_limiter::{Direction, Mode, RateLimitConfig, RATE_LIMITER_MANAGER_ROLE};
 use crate::integration_tests::setup::{decode_packet, ChainSetup};
+use crate::oft_types::OftType;
 use crate::MintableClient;
 use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
 use message_lib_common::packet_codec_v1;
@@ -78,6 +79,21 @@ pub fn send(
     refund_address: &Address,
     oft_receipt: &OFTReceipt,
 ) {
+    let token_sub_invoke = match chain.oft.oft_type() {
+        OftType::LockUnlock => MockAuthInvoke {
+            contract: &chain.oft_token,
+            fn_name: "transfer",
+            args: (sender, &chain.oft.address, &oft_receipt.amount_received_ld).into_val(env),
+            sub_invokes: &[],
+        },
+        OftType::MintBurn(_) => MockAuthInvoke {
+            contract: &chain.oft_token,
+            fn_name: "burn",
+            args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+            sub_invokes: &[],
+        },
+    };
+
     env.mock_auths(&[MockAuth {
         address: sender,
         invoke: &MockAuthInvoke {
@@ -85,18 +101,13 @@ pub fn send(
             fn_name: "send",
             args: (sender, send_param, fee, refund_address).into_val(env),
             sub_invokes: &[
+                token_sub_invoke,
                 MockAuthInvoke {
                     contract: &chain.native_token,
                     fn_name: "transfer",
                     args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
                     sub_invokes: &[],
                 },
-                MockAuthInvoke {
-                    contract: &chain.oft_token,
-                    fn_name: "burn",
-                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
-                    sub_invokes: &[],
-                },
             ],
         },
     }]);
@@ -116,6 +127,21 @@ pub fn send_with_fee(
     fee_deposit_address: &Address,
 ) {
     let fee_amount = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
+    let token_sub_invoke = match chain.oft.oft_type() {
+        OftType::LockUnlock => MockAuthInvoke {
+            contract: &chain.oft_token,
+            fn_name: "transfer",
+            args: (sender, &chain.oft.address, &oft_receipt.amount_received_ld).into_val(env),
+            sub_invokes: &[],
+        },
+        OftType::MintBurn(_) => MockAuthInvoke {
+            contract: &chain.oft_token,
+            fn_name: "burn",
+            args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+            sub_invokes: &[],
+        },
+    };
+
     env.mock_auths(&[MockAuth {
         address: sender,
         invoke: &MockAuthInvoke {
@@ -123,18 +149,13 @@ pub fn send_with_fee(
             fn_name: "send",
             args: (sender, send_param, fee, refund_address).into_val(env),
             sub_invokes: &[
+                token_sub_invoke,
                 MockAuthInvoke {
                     contract: &chain.oft_token,
                     fn_name: "transfer",
                     args: (sender, fee_deposit_address, &fee_amount).into_val(env),
                     sub_invokes: &[],
                 },
-                MockAuthInvoke {
-                    contract: &chain.oft_token,
-                    fn_name: "burn",
-                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
-                    sub_invokes: &[],
-                },
                 MockAuthInvoke {
                     contract: &chain.native_token,
                     fn_name: "transfer",
@@ -156,6 +177,21 @@ pub fn try_send(
     refund_address: &Address,
     oft_receipt: &OFTReceipt,
 ) -> bool {
+    let token_sub_invoke = match chain.oft.oft_type() {
+        OftType::LockUnlock => MockAuthInvoke {
+            contract: &chain.oft_token,
+            fn_name: "transfer",
+            args: (sender, &chain.oft.address, &oft_receipt.amount_received_ld).into_val(env),
+            sub_invokes: &[],
+        },
+        OftType::MintBurn(_) => MockAuthInvoke {
+            contract: &chain.oft_token,
+            fn_name: "burn",
+            args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+            sub_invokes: &[],
+        },
+    };
+
     env.mock_auths(&[MockAuth {
         address: sender,
         invoke: &MockAuthInvoke {
@@ -163,18 +199,13 @@ pub fn try_send(
             fn_name: "send",
             args: (sender, send_param, fee, refund_address).into_val(env),
             sub_invokes: &[
+                token_sub_invoke,
                 MockAuthInvoke {
                     contract: &chain.native_token,
                     fn_name: "transfer",
                     args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
                     sub_invokes: &[],
                 },
-                MockAuthInvoke {
-                    contract: &chain.oft_token,
-                    fn_name: "burn",
-                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
-                    sub_invokes: &[],
-                },
             ],
         },
     }]);
@@ -318,21 +349,37 @@ pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount
 /// Mints the OFT token (via the Mintable wrapper) to the given address.
 /// Use when OFT is MintBurn; the wrapper calls the underlying SAC mint.
 pub fn mint_oft_token_to(env: &Env, chain: &ChainSetup<'_>, to: &Address, amount: i128) {
-    env.mock_auths(&[MockAuth {
-        address: &chain.owner,
-        invoke: &MockAuthInvoke {
-            contract: &chain.sac_wrapper,
-            fn_name: "mint",
-            args: (to, &amount, &chain.owner).into_val(env),
-            sub_invokes: &[MockAuthInvoke {
-                contract: &chain.oft_token,
-                fn_name: "mint",
-                args: (to, &amount).into_val(env),
-                sub_invokes: &[],
-            }],
-        },
-    }]);
-    MintableClient::new(env, &chain.sac_wrapper).mint(to, &amount, &chain.owner);
+    match chain.oft.oft_type() {
+        OftType::LockUnlock => {
+            env.mock_auths(&[MockAuth {
+                address: &chain.owner,
+                invoke: &MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "mint",
+                    args: (to, &amount).into_val(env),
+                    sub_invokes: &[],
+                },
+            }]);
+            StellarAssetClient::new(env, &chain.oft_token).mint(to, &amount);
+        }
+        OftType::MintBurn(_) => {
+            env.mock_auths(&[MockAuth {
+                address: &chain.owner,
+                invoke: &MockAuthInvoke {
+                    contract: &chain.sac_wrapper,
+                    fn_name: "mint",
+                    args: (to, &amount, &chain.owner).into_val(env),
+                    sub_invokes: &[MockAuthInvoke {
+                        contract: &chain.oft_token,
+                        fn_name: "mint",
+                        args: (to, &amount).into_val(env),
+                        sub_invokes: &[],
+                    }],
+                },
+            }]);
+            MintableClient::new(env, &chain.sac_wrapper).mint(to, &amount, &chain.owner);
+        }
+    }
 }
 
 pub fn transfer_sac_admin(env: &Env, owner: &Address, token: &Address, new_admin: &Address) {

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

@@ -265,4 +265,17 @@ pub trait OFTFeeInternal {
     fn __fee_deposit_address(env: &Env) -> Option<Address> {
         OFTFeeStorage::fee_deposit_address(env)
     }
+
+    /// Back-calculates the pre-fee amount given a post-fee amount.
+    /// Returns the smallest `x` such that `x - fee(x) >= amount_after_fee`.
+    fn __amount_before_fee(env: &Env, dst_eid: u32, amount_after_fee: i128) -> i128 {
+        let fee_bps = Self::__effective_fee_bps(env, dst_eid);
+        if fee_bps == 0 {
+            return amount_after_fee;
+        }
+        if fee_bps == BASE_FEE_BPS {
+            return 0;
+        }
+        (amount_after_fee * BASE_FEE_BPS as i128) / (BASE_FEE_BPS - fee_bps) as i128
+    }
 }

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

@@ -68,8 +68,16 @@ impl OFTCore for OFT {
             fee_details.push_back(OFTFeeDetail { fee_amount_ld, description: Bytes::from_slice(env, b"OFT Fee") });
         };
 
-        // rate limit capacity
-        limit.max_amount_ld = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
+        // Rate limit capacity, capped to u64::MAX (the safe ceiling from __quote_oft default)
+        let mut max_amount_ld = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
+        if max_amount_ld != i128::MAX {
+            // Back-calculate pre-fee amount so max_amount_ld represents the largest input to send()
+            max_amount_ld = Self::__amount_before_fee(env, send_param.dst_eid, max_amount_ld);
+        } else {
+            // No rate limit configured — use the bounded default
+            max_amount_ld = u64::MAX as i128;
+        }
+        limit.max_amount_ld = max_amount_ld;
 
         (limit, fee_details, receipt)
     }

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@layerzerolabs/protocol-stellar-v2",
-  "version": "0.2.64",
+  "version": "0.2.66",
   "private": false,
   "license": "LZBL-1.2",
   "devDependencies": {
     "@types/node": "^22.18.6",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "@layerzerolabs/vm-tooling-stellar": "0.2.64",
-    "@layerzerolabs/stellar-ts-bindings-gen": "0.2.64",
-    "@layerzerolabs/common-node-utils": "0.2.64"
+    "@layerzerolabs/common-node-utils": "0.2.66",
+    "@layerzerolabs/vm-tooling-stellar": "0.2.66",
+    "@layerzerolabs/stellar-ts-bindings-gen": "0.2.66"
   },
   "publishConfig": {
     "access": "restricted",
@@ -18,7 +18,7 @@
   "externalRepoConfig": {
     "targets": [
       "audit-external",
-      "everdawn-asset0"
+      "onesig-client"
     ]
   },
   "scripts": {