@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

package/contracts/oapps/oapp-macros/src/tests/parse_custom_impls.rs

@@ -6,7 +6,7 @@ use quote::quote;
 
 #[test]
 fn test_custom_impls_parse_empty_is_default() {
-    let parsed: crate::CustomImpls = syn::parse2(quote! {}).expect("failed to parse empty attrs");
+    let parsed: crate::generators::CustomImpls = syn::parse2(quote! {}).expect("failed to parse empty attrs");
     assert!(!parsed.core);
     assert!(!parsed.sender);
     assert!(!parsed.receiver);
@@ -15,7 +15,7 @@ fn test_custom_impls_parse_empty_is_default() {
 
 #[test]
 fn test_custom_impls_parse_valid_all_list() {
-    let parsed: crate::CustomImpls =
+    let parsed: crate::generators::CustomImpls =
         syn::parse2(quote! { custom = [core, sender, receiver, options_type3] }).expect("failed to parse attrs");
     assert!(parsed.core);
     assert!(parsed.sender);
@@ -25,7 +25,7 @@ fn test_custom_impls_parse_valid_all_list() {
 
 #[test]
 fn test_custom_impls_parse_empty_custom_list_is_default() {
-    let parsed: crate::CustomImpls = syn::parse2(quote! { custom = [] }).expect("failed to parse attrs");
+    let parsed: crate::generators::CustomImpls = syn::parse2(quote! { custom = [] }).expect("failed to parse attrs");
     assert!(!parsed.core);
     assert!(!parsed.sender);
     assert!(!parsed.receiver);
@@ -34,7 +34,8 @@ fn test_custom_impls_parse_empty_custom_list_is_default() {
 
 #[test]
 fn test_custom_impls_allows_trailing_comma() {
-    let parsed: crate::CustomImpls = syn::parse2(quote! { custom = [core,] }).expect("failed to parse attrs");
+    let parsed: crate::generators::CustomImpls =
+        syn::parse2(quote! { custom = [core,] }).expect("failed to parse attrs");
     assert!(parsed.core);
     assert!(!parsed.sender);
     assert!(!parsed.receiver);
@@ -44,7 +45,7 @@ fn test_custom_impls_allows_trailing_comma() {
 #[test]
 fn test_custom_impls_allows_duplicates() {
     // Duplicates are harmless and should not cause parsing to fail.
-    let parsed: crate::CustomImpls =
+    let parsed: crate::generators::CustomImpls =
         syn::parse2(quote! { custom = [core, core, receiver, receiver] }).expect("failed to parse attrs");
     assert!(parsed.core);
     assert!(!parsed.sender);
@@ -54,14 +55,15 @@ fn test_custom_impls_allows_duplicates() {
 
 #[test]
 fn test_custom_impls_rejects_wrong_key() {
-    let err = syn::parse2::<crate::CustomImpls>(quote! { nope = [core] }).expect_err("expected parse failure");
+    let err =
+        syn::parse2::<crate::generators::CustomImpls>(quote! { nope = [core] }).expect_err("expected parse failure");
     assert!(err.to_string().contains("expected `custom`"), "unexpected error: {err}");
 }
 
 #[test]
 fn test_custom_impls_rejects_unknown_ident() {
-    let err =
-        syn::parse2::<crate::CustomImpls>(quote! { custom = [core, not_a_real_option] }).expect_err("expected failure");
+    let err = syn::parse2::<crate::generators::CustomImpls>(quote! { custom = [core, not_a_real_option] })
+        .expect_err("expected failure");
     assert!(
         err.to_string().contains("expected one of `core`, `sender`, `receiver`, `options_type3`"),
         "unexpected error: {err}"
@@ -71,16 +73,18 @@ fn test_custom_impls_rejects_unknown_ident() {
 #[test]
 fn test_custom_impls_rejects_trailing_tokens_after_list() {
     // `syn::parse2` expects the parser to consume the full stream.
-    syn::parse2::<crate::CustomImpls>(quote! { custom = [core] extra })
+    syn::parse2::<crate::generators::CustomImpls>(quote! { custom = [core] extra })
         .expect_err("expected parse failure due to trailing tokens");
 }
 
 #[test]
 fn test_custom_impls_rejects_missing_equals() {
-    syn::parse2::<crate::CustomImpls>(quote! { custom [core] }).expect_err("expected parse failure (missing `=`)");
+    syn::parse2::<crate::generators::CustomImpls>(quote! { custom [core] })
+        .expect_err("expected parse failure (missing `=`)");
 }
 
 #[test]
 fn test_custom_impls_rejects_non_bracketed_list() {
-    syn::parse2::<crate::CustomImpls>(quote! { custom = (core) }).expect_err("expected parse failure (not `[...]`)");
+    syn::parse2::<crate::generators::CustomImpls>(quote! { custom = (core) })
+        .expect_err("expected parse failure (not `[...]`)");
 }

package/contracts/oapps/oft/Cargo.toml

@@ -24,7 +24,7 @@ oft-core = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
-simple-message-lib = { workspace = true }
+simple-message-lib = { workspace = true, features = ["testutils"] }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
 utils = { workspace = true, features = ["testutils"] }

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

@@ -33,7 +33,7 @@ fn test_cross_chain_with_zero_fee() {
 
     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 (_, _, 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);
@@ -75,7 +75,7 @@ fn test_cross_chain_with_fee() {
     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);
+    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);
@@ -129,7 +129,7 @@ fn test_cross_chain_with_destination_specific_fee() {
     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);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
 
     // 2% fee on 1,000,000 = 20,000
     let expected_fee = 20_000i128;

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

@@ -33,7 +33,7 @@ fn test_send_succeeds_when_unpaused() {
 
     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 (_, _, 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);
@@ -71,7 +71,7 @@ fn test_send_fails_when_paused() {
     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 (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
     let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
 
     // Pause the OFT
@@ -102,7 +102,7 @@ fn test_receive_fails_when_paused() {
     // 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 (_, _, 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);
 
@@ -144,7 +144,7 @@ fn test_cross_chain_succeeds_after_unpause() {
     // 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 (_, _, 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);

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

@@ -3,13 +3,13 @@
 //! Tests verify that the RateLimiter extension properly enforces rate limits
 //! on cross-chain transfers. Uses real EndpointV2 and SimpleMessageLib.
 
-use crate::extensions::rate_limiter::Direction;
+use crate::extensions::rate_limiter::{Direction, Mode};
 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,
+        rate_limit_capacity, rate_limit_in_flight, scan_packet_sent_event, send, set_rate_limit, set_rate_limit_with_mode,
+        transfer_sac_admin, try_send, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
@@ -36,7 +36,7 @@ fn test_send_without_rate_limit() {
 
     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 (_, _, 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);
@@ -76,7 +76,7 @@ fn test_send_within_rate_limit() {
     // 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 (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
     let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
 
     // Check in_flight BEFORE send
@@ -122,7 +122,7 @@ fn test_send_exceeds_rate_limit() {
     // 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 (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &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);
@@ -152,7 +152,7 @@ fn test_rate_limit_decay() {
 
     // 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 (_, _, oft_receipt1) = quote_oft(&chain_a, &sender, &send_param1);
     let fee1 = quote_send(&env, &chain_a, &sender, &send_param1, false);
     send(&env, &chain_a, &sender, &send_param1, &fee1, &sender, &oft_receipt1);
 
@@ -174,7 +174,7 @@ fn test_rate_limit_decay() {
 
     // 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 (_, _, oft_receipt2) = quote_oft(&chain_a, &sender, &send_param2);
     let fee2 = quote_send(&env, &chain_a, &sender, &send_param2, false);
     send(&env, &chain_a, &sender, &send_param2, &fee2, &sender, &oft_receipt2);
 
@@ -184,3 +184,139 @@ fn test_rate_limit_decay() {
     let packet2 = decode_packet(&env, &packet_event2.0);
     lz_receive(&env, &chain_b, &executor, &packet2, &receiver, 0);
 }
+
+/// Test gross mode: round-trip shows gross mode doesn't release outbound capacity
+#[test]
+fn test_gross_mode_does_not_release() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_oft(&env, &[&chain_a, &chain_b]);
+
+    let sender_a = Address::generate(&env);
+    let sender_b = Address::generate(&env);
+    let receiver_b = create_recipient_address(&env);
+    let receiver_a = create_recipient_address(&env);
+    let executor = Address::generate(&env);
+
+    // Setup tokens for both chains
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender_a, 100_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender_a, 10_000_000_000);
+    mint_to(&env, &chain_b.owner, &chain_b.oft_token, &sender_b, 100_000_000);
+    mint_to(&env, &chain_b.owner, &chain_b.native_token, &sender_b, 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 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);
+
+    // Step 1: Send 8M from chain_a to chain_b
+    let to_b = address_to_peer_bytes32(&receiver_b);
+    let send_param_1 = create_send_param(&env, chain_b.eid, 8_000_000, 0, &to_b);
+    let (_, _, oft_receipt_1) = quote_oft(&chain_a, &sender_a, &send_param_1);
+    let fee_1 = quote_send(&env, &chain_a, &sender_a, &send_param_1, false);
+    send(&env, &chain_a, &sender_a, &send_param_1, &fee_1, &sender_a, &oft_receipt_1);
+
+    let packet_event_1 = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event_1);
+    let packet_1 = decode_packet(&env, &packet_event_1.0);
+
+    // chain_a outbound should have 8M in-flight
+    let in_flight_after_send = rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert_eq!(in_flight_after_send, oft_receipt_1.amount_received_ld);
+    assert_eq!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid), 10_000_000 - in_flight_after_send);
+
+    // Step 2: Receive on chain_b and send 6M back to chain_a
+    lz_receive(&env, &chain_b, &executor, &packet_1, &receiver_b, 0);
+
+    let to_a = address_to_peer_bytes32(&receiver_a);
+    let send_param_2 = create_send_param(&env, chain_a.eid, 6_000_000, 0, &to_a);
+    let (_, _, oft_receipt_2) = quote_oft(&chain_b, &sender_b, &send_param_2);
+    let fee_2 = quote_send(&env, &chain_b, &sender_b, &send_param_2, false);
+    send(&env, &chain_b, &sender_b, &send_param_2, &fee_2, &sender_b, &oft_receipt_2);
+
+    let packet_event_2 = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
+    validate_packet(&env, &chain_a, &packet_event_2);
+    let packet_2 = decode_packet(&env, &packet_event_2.0);
+
+    // Step 3: Receive back on chain_a - this calls __release_rate_limit_capacity for outbound
+    lz_receive(&env, &chain_a, &executor, &packet_2, &receiver_a, 0);
+
+    // In Gross mode, receiving back should NOT release the outbound capacity
+    let in_flight_after_return = rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert_eq!(
+        in_flight_after_return, in_flight_after_send,
+        "Gross mode: outbound in-flight should not decrease when receiving"
+    );
+
+    // 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");
+}
+
+/// Test net mode (default): round-trip shows net mode releases outbound capacity
+#[test]
+fn test_net_mode_does_release() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_oft(&env, &[&chain_a, &chain_b]);
+
+    let sender_a = Address::generate(&env);
+    let sender_b = Address::generate(&env);
+    let receiver_b = create_recipient_address(&env);
+    let receiver_a = create_recipient_address(&env);
+    let executor = Address::generate(&env);
+
+    // Setup tokens for both chains
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender_a, 100_000_000);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender_a, 10_000_000_000);
+    mint_to(&env, &chain_b.owner, &chain_b.oft_token, &sender_b, 100_000_000);
+    mint_to(&env, &chain_b.owner, &chain_b.native_token, &sender_b, 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 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);
+
+    // Step 1: Send 8M from chain_a to chain_b
+    let to_b = address_to_peer_bytes32(&receiver_b);
+    let send_param_1 = create_send_param(&env, chain_b.eid, 8_000_000, 0, &to_b);
+    let (_, _, oft_receipt_1) = quote_oft(&chain_a, &sender_a, &send_param_1);
+    let fee_1 = quote_send(&env, &chain_a, &sender_a, &send_param_1, false);
+    send(&env, &chain_a, &sender_a, &send_param_1, &fee_1, &sender_a, &oft_receipt_1);
+
+    let packet_event_1 = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event_1);
+    let packet_1 = decode_packet(&env, &packet_event_1.0);
+
+    // chain_a outbound should have 8M in-flight
+    let in_flight_after_send = rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert_eq!(in_flight_after_send, oft_receipt_1.amount_received_ld);
+    assert_eq!(rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid), 10_000_000 - in_flight_after_send);
+
+    // Step 2: Receive on chain_b and send 6M back to chain_a
+    lz_receive(&env, &chain_b, &executor, &packet_1, &receiver_b, 0);
+
+    let to_a = address_to_peer_bytes32(&receiver_a);
+    let send_param_2 = create_send_param(&env, chain_a.eid, 6_000_000, 0, &to_a);
+    let (_, _, oft_receipt_2) = quote_oft(&chain_b, &sender_b, &send_param_2);
+    let fee_2 = quote_send(&env, &chain_b, &sender_b, &send_param_2, false);
+    send(&env, &chain_b, &sender_b, &send_param_2, &fee_2, &sender_b, &oft_receipt_2);
+
+    let packet_event_2 = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
+    validate_packet(&env, &chain_a, &packet_event_2);
+    let packet_2 = decode_packet(&env, &packet_event_2.0);
+
+    // Step 3: Receive back on chain_a - this calls __release_rate_limit_capacity for outbound
+    lz_receive(&env, &chain_a, &executor, &packet_2, &receiver_a, 0);
+
+    // In Net mode, receiving back SHOULD release the outbound capacity
+    let in_flight_after_return = rate_limit_in_flight(&chain_a, &Direction::Outbound, chain_b.eid);
+    assert!(
+        in_flight_after_return < in_flight_after_send,
+        "Net mode: outbound in-flight should decrease when receiving"
+    );
+
+    // 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");
+}

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

@@ -82,8 +82,10 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     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
-    let mode = OftType::MintBurn;
-    let oft_address = env.register(OFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals, &mode));
+    // Both chains use MintBurn — the SAC itself implements mint/burn.
+    // This exercises the MintBurnableClient code path.
+    let mode = OftType::MintBurn(oft_token.clone());
+    let oft_address = env.register(OFT, (&oft_token, &shared_decimals, &mode, &owner, &endpoint_address, &delegate));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
     let sml = SimpleMessageLibClient::new(env, &sml_address);

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

@@ -1,10 +1,10 @@
 //! Utility functions for OFT-STD integration tests.
 
-use crate::extensions::rate_limiter::{Direction, RateLimitConfig};
+use crate::extensions::rate_limiter::{Direction, Mode, RateLimitConfig};
 use crate::integration_tests::setup::{decode_packet, ChainSetup};
 use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
 use message_lib_common::packet_codec_v1;
-use oft_core::types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
+use oft_core::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
 use soroban_sdk::{
     address_payload::AddressPayload,
     testutils::{Events, Ledger, MockAuth, MockAuthInvoke},
@@ -38,8 +38,8 @@ pub fn create_recipient_address(env: &Env) -> Address {
 // OFT Core Operations
 // ============================================================================
 
-pub fn quote_oft(chain: &ChainSetup<'_>, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
-    chain.oft.quote_oft(send_param)
+pub fn quote_oft(chain: &ChainSetup<'_>, from: &Address, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+    chain.oft.quote_oft(from, send_param)
 }
 
 pub fn quote_send(
@@ -351,32 +351,34 @@ pub fn is_paused(chain: &ChainSetup<'_>) -> bool {
 // ============================================================================
 
 pub fn set_fee_deposit_address(env: &Env, chain: &ChainSetup<'_>, deposit_address: &Address) {
+    let deposit_address_opt = Some(deposit_address.clone());
     env.mock_auths(&[MockAuth {
         address: &chain.owner,
         invoke: &MockAuthInvoke {
             contract: &chain.oft.address,
             fn_name: "set_fee_deposit_address",
-            args: (deposit_address,).into_val(env),
+            args: (&deposit_address_opt,).into_val(env),
             sub_invokes: &[],
         },
     }]);
-    chain.oft.set_fee_deposit_address(deposit_address);
+    chain.oft.set_fee_deposit_address(&deposit_address_opt);
 }
 
-pub fn set_default_fee_bps(env: &Env, chain: &ChainSetup<'_>, fee_bps: u64) {
+pub fn set_default_fee_bps(env: &Env, chain: &ChainSetup<'_>, fee_bps: u32) {
+    let fee_bps_opt = Some(fee_bps);
     env.mock_auths(&[MockAuth {
         address: &chain.owner,
         invoke: &MockAuthInvoke {
             contract: &chain.oft.address,
             fn_name: "set_default_fee_bps",
-            args: (&fee_bps,).into_val(env),
+            args: (&fee_bps_opt,).into_val(env),
             sub_invokes: &[],
         },
     }]);
-    chain.oft.set_default_fee_bps(&fee_bps);
+    chain.oft.set_default_fee_bps(&fee_bps_opt);
 }
 
-pub fn set_fee_bps(env: &Env, chain: &ChainSetup<'_>, dst_eid: u32, fee_bps: u64) {
+pub fn set_fee_bps(env: &Env, chain: &ChainSetup<'_>, dst_eid: u32, fee_bps: u32) {
     let fee_bps_opt = Some(fee_bps);
     env.mock_auths(&[MockAuth {
         address: &chain.owner,
@@ -402,7 +404,19 @@ pub fn set_rate_limit(
     limit: i128,
     window_seconds: u64,
 ) {
-    let config = Some(RateLimitConfig { limit, window_seconds });
+    set_rate_limit_with_mode(env, chain, direction, dst_eid, limit, window_seconds, Mode::Net);
+}
+
+pub fn set_rate_limit_with_mode(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    direction: &Direction,
+    dst_eid: u32,
+    limit: i128,
+    window_seconds: u64,
+    mode: Mode,
+) {
+    let config = Some(RateLimitConfig { limit, window_seconds, mode });
     env.mock_auths(&[MockAuth {
         address: &chain.owner,
         invoke: &MockAuthInvoke {