@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

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

@@ -3,43 +3,48 @@
 //! This OFT type burns tokens on debit (send) and mints tokens on credit (receive).
 //! Used when the OFT contract has mint/burn authority over the token.
 
-use oft_core::{types::OFTReceipt, OFTCore};
-use soroban_sdk::{token::StellarAssetClient, Address, Env};
+use crate::interfaces::MintBurnableClient;
+use oft_core::OFTCore;
+use soroban_sdk::{Address, Env};
 
 /// Debit tokens using MintBurn OFT type (burns tokens from sender).
 ///
 /// # Parameters
 /// * `env` - The Soroban environment
+/// * `burnable` - Address of the contract responsible for burning tokens
 /// * `sender` - Address of the token sender
 /// * `amount_ld` - Amount to debit in local decimals
 /// * `min_amount_ld` - Minimum amount that must be received (for slippage protection)
 /// * `dst_eid` - Destination endpoint ID
 ///
 /// # Returns
-/// `OFTReceipt` containing the amount sent and amount received
+/// * `amount_sent_ld` - The amount sent in local decimals
+/// * `amount_received_ld` - The amount received in local decimals on the remote
 pub fn debit<T: OFTCore>(
     env: &Env,
+    burnable: &Address,
     sender: &Address,
     amount_ld: i128,
     min_amount_ld: i128,
     dst_eid: u32,
-) -> OFTReceipt {
-    let receipt = T::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
-    StellarAssetClient::new(env, &T::token(env)).burn(sender, &receipt.amount_received_ld);
-    receipt
+) -> (i128, i128) {
+    let (amount_sent_ld, amount_received_ld) = T::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
+    MintBurnableClient::new(env, burnable).burn(sender, &amount_received_ld);
+    (amount_sent_ld, amount_received_ld)
 }
 
 /// Credit tokens using MintBurn OFT type (mints tokens to recipient).
 ///
 /// # Parameters
 /// * `env` - The Soroban environment
+/// * `mintable` - Address of the contract responsible for minting tokens
 /// * `to` - Address of the token recipient
 /// * `amount_ld` - Amount to credit in local decimals
 /// * `_src_eid` - Source endpoint ID (unused)
 ///
 /// # Returns
 /// The amount credited
-pub fn credit<T: OFTCore>(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-    StellarAssetClient::new(env, &T::token(env)).mint(to, &amount_ld);
+pub fn credit<T: OFTCore>(env: &Env, mintable: &Address, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
+    MintBurnableClient::new(env, mintable).mint(to, &amount_ld);
     amount_ld
 }

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

@@ -1,23 +1,25 @@
-//! OFT types implementations.
+//! OFT mode implementations.
 //!
 //! This module provides reference implementations for the two main OFT types:
 //!
-//! - **MintBurn**: Burns tokens on send, mints on receive. Approval not required.
-//! - **LockUnlock**: Locks tokens on send, unlocks on receive. Approval not required.
-//!
+//! - **LockUnlock**: Locks tokens on send, unlocks on receive. Operates directly on the
+//!   token via standard SEP-41 `transfer`.
+//! - **MintBurn**: Burns tokens on send, mints on receive. Operates on any contract
+//!   that implements [`MintBurnable`](crate::interfaces::MintBurnable) —
+//!   whether it's a raw SAC or a token wrapper (e.g. SAC Manager).
 
-use soroban_sdk::contracttype;
+use soroban_sdk::{contracttype, Address};
 
 pub mod lock_unlock;
 pub mod mint_burn;
 
-/// The type of OFT operation mode
+/// The OFT operation type.
 #[contracttype]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[repr(u8)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OftType {
-    /// Lock tokens on send, unlock on receive
-    LockUnlock = 0,
-    /// Burn tokens on send, mint on receive
-    MintBurn = 1,
+    /// Lock tokens on send, unlock on receive.
+    LockUnlock,
+    /// Burn tokens on send, mint on receive.
+    /// The address is the contract responsible for minting and burning tokens.
+    MintBurn(Address),
 }

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

@@ -86,18 +86,17 @@ fn test_fee_view_zero_fee_returns_zero() {
 }
 
 #[test]
-fn test_fee_deposit_address_errors_when_unset() {
+fn test_fee_deposit_address_returns_none_when_unset() {
     let TestSetup { client, .. } = setup();
 
-    let res = client.try_fee_deposit_address();
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeDepositAddress.into());
+    assert_eq!(client.fee_deposit_address(), None);
 }
 
 #[test]
 fn test_fee_view_nonzero_fee_errors_when_deposit_address_unset() {
     let TestSetup { client, .. } = setup();
 
-    client.set_default_fee_bps(&100u64);
+    client.set_default_fee_bps(&Some(100u32));
 
     let res = client.try_fee_view(&7u32, &1_000_000i128);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeDepositAddress.into());
@@ -111,7 +110,12 @@ fn test_fee_view_nonzero_fee_errors_when_deposit_address_unset() {
 fn test_set_default_fee_bps_rejects_invalid_value() {
     let TestSetup { client, .. } = setup();
 
-    let res = client.try_set_default_fee_bps(&10_001u64);
+    // Zero is not a valid default fee (use None to remove instead)
+    let res = client.try_set_default_fee_bps(&Some(0u32));
+    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
+
+    // Exceeds maximum
+    let res = client.try_set_default_fee_bps(&Some(10_001u32));
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
 }
 
@@ -119,11 +123,14 @@ fn test_set_default_fee_bps_rejects_invalid_value() {
 fn test_set_default_fee_bps_rejects_same_value() {
     let TestSetup { client, .. } = setup();
 
-    let res = client.try_set_default_fee_bps(&0u64);
+    // None when already None (not set)
+    let none: Option<u32> = None;
+    let res = client.try_set_default_fee_bps(&none);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 
-    client.set_default_fee_bps(&123u64);
-    let res2 = client.try_set_default_fee_bps(&123u64);
+    // Same value when already set
+    client.set_default_fee_bps(&Some(123u32));
+    let res2 = client.try_set_default_fee_bps(&Some(123u32));
     assert_eq!(res2.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 }
 
@@ -139,7 +146,7 @@ fn test_set_fee_bps_rejects_invalid_and_same_value() {
     let res = client.try_set_fee_bps(&dst_eid, &None);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 
-    let res2 = client.try_set_fee_bps(&dst_eid, &Some(10_001u64));
+    let res2 = client.try_set_fee_bps(&dst_eid, &Some(10_001u32));
     assert_eq!(res2.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
 }
 
@@ -148,14 +155,14 @@ fn test_set_fee_bps_set_and_remove() {
     let TestSetup { client, .. } = setup();
     let dst_eid = 101u32;
 
-    client.set_fee_bps(&dst_eid, &Some(200u64));
-    assert_eq!(client.fee_bps(&dst_eid), Some(200u64));
-    assert_eq!(client.effective_fee_bps(&dst_eid), 200u64);
+    client.set_fee_bps(&dst_eid, &Some(200u32));
+    assert_eq!(client.fee_bps(&dst_eid), Some(200u32));
+    assert_eq!(client.effective_fee_bps(&dst_eid), 200u32);
 
-    client.set_default_fee_bps(&111u64);
+    client.set_default_fee_bps(&Some(111u32));
     client.set_fee_bps(&dst_eid, &None);
     assert_eq!(client.fee_bps(&dst_eid), None);
-    assert_eq!(client.effective_fee_bps(&dst_eid), 111u64);
+    assert_eq!(client.effective_fee_bps(&dst_eid), 111u32);
 }
 
 // ============================================================================
@@ -190,8 +197,9 @@ fn test_charge_fee_errors_without_deposit_address() {
 fn test_set_fee_deposit_address_same_value() {
     let TestSetup { client, fee_deposit, .. } = setup();
 
-    client.set_fee_deposit_address(&fee_deposit);
-    let res = client.try_set_fee_deposit_address(&fee_deposit);
+    let fee_deposit_opt = Some(fee_deposit);
+    client.set_fee_deposit_address(&fee_deposit_opt);
+    let res = client.try_set_fee_deposit_address(&fee_deposit_opt);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 }
 
@@ -199,7 +207,7 @@ fn test_set_fee_deposit_address_same_value() {
 fn test_charge_fee_zero_amount_no_transfer() {
     let TestSetup { env, client, token, from, fee_deposit, .. } = setup();
 
-    client.set_fee_deposit_address(&fee_deposit);
+    client.set_fee_deposit_address(&Some(fee_deposit.clone()));
 
     let token_client = TokenClient::new(&env, &token);
     let from_before = token_client.balance(&from);
@@ -216,7 +224,7 @@ fn test_charge_fee_zero_amount_no_transfer() {
 fn test_charge_fee_transfers() {
     let TestSetup { env, client, token, from, fee_deposit, .. } = setup();
 
-    client.set_fee_deposit_address(&fee_deposit);
+    client.set_fee_deposit_address(&Some(fee_deposit.clone()));
 
     let token_client = TokenClient::new(&env, &token);
     let from_before = token_client.balance(&from);
@@ -232,8 +240,8 @@ fn test_charge_fee_transfers() {
 fn test_fee_view_computes_correct_fee() {
     let TestSetup { client, fee_deposit, .. } = setup();
 
-    client.set_fee_deposit_address(&fee_deposit);
-    client.set_default_fee_bps(&100u64); // 1%
+    client.set_fee_deposit_address(&Some(fee_deposit));
+    client.set_default_fee_bps(&Some(100u32)); // 1%
 
     let fee = client.fee_view(&999u32, &10_000i128);
     assert_eq!(fee, 100); // 1% of 10,000

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

@@ -1,7 +1,7 @@
 extern crate std;
 
 use crate as oft;
-use crate::extensions::rate_limiter::{Direction, RateLimitConfig, RateLimitError, RateLimiter, RateLimiterInternal};
+use crate::extensions::rate_limiter::{Direction, Mode, RateLimitConfig, RateLimitError, RateLimiter, RateLimiterInternal};
 use soroban_sdk::{contract, contractimpl, testutils::Ledger as _, Address, Env};
 use utils::auth::Auth;
 
@@ -55,7 +55,11 @@ fn setup() -> TestSetup {
 }
 
 fn config(limit: i128, window_seconds: u64) -> RateLimitConfig {
-    RateLimitConfig { limit, window_seconds }
+    RateLimitConfig { limit, window_seconds, mode: Mode::Net }
+}
+
+fn config_with_mode(limit: i128, window_seconds: u64, mode: Mode) -> RateLimitConfig {
+    RateLimitConfig { limit, window_seconds, mode }
 }
 
 // ============================================================================
@@ -349,6 +353,136 @@ fn test_different_eids_are_independent() {
     assert_eq!(client.rate_limit_in_flight(&direction, &2u32), 0);
 }
 
+// ============================================================================
+// Gross Mode Tests
+// ============================================================================
+
+#[test]
+fn test_gross_mode_does_not_release_capacity() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 77u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Gross)));
+    client.consume(&direction, &eid, &60i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60);
+
+    // Release should be a no-op in Gross mode
+    client.release(&direction, &eid, &30i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60, "Gross mode should not release");
+}
+
+#[test]
+fn test_net_mode_does_release_capacity() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 77u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Net)));
+    client.consume(&direction, &eid, &60i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60);
+
+    // Release should reduce in-flight in Net mode
+    client.release(&direction, &eid, &30i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 30, "Net mode should release");
+}
+
+#[test]
+fn test_gross_mode_enforces_absolute_limit() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Gross)));
+
+    // Consume 80
+    client.consume(&direction, &eid, &80i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 80);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 20);
+
+    // Try to release 50 (should be no-op)
+    client.release(&direction, &eid, &50i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 80);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 20);
+
+    // Should only be able to consume 20 more
+    client.consume(&direction, &eid, &20i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 100);
+
+    // Should fail to consume more
+    let res = client.try_consume(&direction, &eid, &1i128);
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::ExceededRateLimit.into());
+}
+
+#[test]
+fn test_gross_mode_decay_still_works() {
+    let TestSetup { env, client } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    env.ledger().set_timestamp(1_000);
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 10, Mode::Gross)));
+
+    // Consume full capacity
+    client.consume(&direction, &eid, &100i128);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 0);
+
+    // Release should not affect in-flight in Gross mode
+    client.release(&direction, &eid, &50i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 100);
+
+    // Advance time by 5 seconds => decay 50
+    env.ledger().set_timestamp(1_005);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 50);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 50);
+}
+
+#[test]
+fn test_switching_from_net_to_gross_mode() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    // Start with Net mode
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Net)));
+    client.consume(&direction, &eid, &60i128);
+    client.release(&direction, &eid, &20i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 40, "Net mode should release");
+
+    // Switch to Gross mode
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Gross)));
+    
+    // in-flight should be checkpointed
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 40);
+    
+    // Now releases should be no-op
+    client.release(&direction, &eid, &20i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 40, "Gross mode should not release");
+}
+
+#[test]
+fn test_switching_from_gross_to_net_mode() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    // Start with Gross mode
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Gross)));
+    client.consume(&direction, &eid, &60i128);
+    client.release(&direction, &eid, &20i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60, "Gross mode should not release");
+
+    // Switch to Net mode
+    client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Net)));
+    
+    // in-flight should be checkpointed
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60);
+    
+    // Now releases should work
+    client.release(&direction, &eid, &20i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 40, "Net mode should release");
+}
+
 // ============================================================================
 // Edge Case Tests
 // ============================================================================

package/contracts/oapps/oft/src/tests/oft_types/lock_unlock.rs

@@ -3,7 +3,7 @@ extern crate std;
 use crate::oft_types::lock_unlock;
 use endpoint_v2::Origin;
 use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
-use oft_core::{types::OFTReceipt, OFTCore, OFTInternal};
+use oft_core::{OFTCore, OFTInternal, OFTReceipt};
 use soroban_sdk::{
     contract, contractimpl, contracttype,
     testutils::Address as _,
@@ -49,14 +49,16 @@ impl LockUnlockHarnessOFT {
         token: &Address,
         owner: &Address,
         endpoint: &Address,
-        delegate: &Option<Address>,
+        delegate: &Address,
         shared_decimals: u32,
     ) {
-        Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals);
+        Self::__initialize_oft(env, token, shared_decimals, owner, endpoint, delegate);
     }
 
     pub fn debit(env: Env, sender: Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        <Self as OFTInternal>::__debit(&env, &sender, amount_ld, min_amount_ld, dst_eid)
+        let (amount_sent_ld, amount_received_ld) =
+            <Self as OFTInternal>::__debit(&env, &sender, amount_ld, min_amount_ld, dst_eid);
+        OFTReceipt { amount_sent_ld, amount_received_ld }
     }
 
     pub fn credit(env: Env, to: Address, amount_ld: i128, src_eid: u32) -> i128 {
@@ -85,12 +87,14 @@ impl LzReceiveInternal for LockUnlockHarnessOFT {
 impl OAppReceiver for LockUnlockHarnessOFT {}
 
 impl OFTInternal for LockUnlockHarnessOFT {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        lock_unlock::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
+        let target = Self::token(env);
+        lock_unlock::debit::<Self>(env, &target, sender, amount_ld, min_amount_ld, dst_eid)
     }
 
     fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-        lock_unlock::credit::<Self>(env, to, amount_ld, src_eid)
+        let target = Self::token(env);
+        lock_unlock::credit::<Self>(env, &target, to, amount_ld, src_eid)
     }
 }
 
@@ -117,7 +121,7 @@ fn setup() -> TestSetup {
     let endpoint = env.register(DummyEndpoint, ());
 
     let owner = Address::generate(&env);
-    let delegate: Option<Address> = None;
+    let delegate = owner.clone();
     let shared_decimals: u32 = 6;
 
     let oft_address = env.register(LockUnlockHarnessOFT, (&token, &owner, &endpoint, &delegate, &shared_decimals));

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

@@ -9,7 +9,6 @@ use crate::{
     integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
     oft_core::{OFTClient, OFTCore, OFTInternal},
     storage::OFTStorage,
-    types::OFTReceipt,
 };
 use common_macros::contract_impl;
 use endpoint_v2::{EndpointV2, EndpointV2Client, ILayerZeroComposer, Origin};
@@ -50,10 +49,10 @@ impl TestOFT {
         token: &Address,
         owner: &Address,
         endpoint: &Address,
-        delegate: &Option<Address>,
+        delegate: &Address,
         shared_decimals: u32,
     ) {
-        Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals)
+        Self::__initialize_oft(env, token, shared_decimals, owner, endpoint, delegate)
     }
 }
 
@@ -61,12 +60,12 @@ impl TestOFT {
 impl OFTCore for TestOFT {}
 
 impl OFTInternal for TestOFT {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        // Get the receipt (handles decimal conversion, fees, etc.)
-        let receipt = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
+        // Get the amounts (handles decimal conversion, fees, etc.)
+        let (amount_sent_ld, amount_received_ld) = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
         // Actually burn tokens from sender
-        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).burn(sender, &receipt.amount_sent_ld);
-        receipt
+        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).burn(sender, &amount_sent_ld);
+        (amount_sent_ld, amount_received_ld)
     }
 
     fn __credit(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
@@ -176,7 +175,7 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     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 delegate = owner.clone();
     let shared_decimals: u32 = 6; // Default shared decimals
     let oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals));
     let composer_address = env.register(DummyComposer, (&endpoint_address,));

package/contracts/oapps/oft-core/integration-tests/test_with_sml.rs

@@ -43,7 +43,7 @@ fn test_send_vanilla() {
 
     let send_param = SendParam {
         dst_eid: chain_b.eid,
-        to: address_payload(&receiver),
+        to: address_payload(&env, &receiver),
         amount_ld: 10e7 as i128,
         min_amount_ld: 10e7 as i128,
         extra_options: bytes!(&env),
@@ -51,7 +51,7 @@ fn test_send_vanilla() {
         oft_cmd: bytes!(&env),
     };
     log!(&env, "send_param: {:?}", send_param);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &send_param);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
     log!(&env, "oft_receipt: {:?}", oft_receipt);
 
     let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
@@ -99,7 +99,7 @@ fn test_send_composed() {
 
     let send_param = SendParam {
         dst_eid: chain_b.eid,
-        to: address_payload(&receiver),
+        to: address_payload(&env, &receiver),
         amount_ld: 10e7 as i128,
         min_amount_ld: 10e7 as i128,
         extra_options: bytes!(&env),
@@ -107,7 +107,7 @@ fn test_send_composed() {
         oft_cmd: bytes!(&env),
     };
     log!(&env, "send_param: {:?}", send_param);
-    let (_, _, oft_receipt) = quote_oft(&chain_a, &send_param);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &sender, &send_param);
     log!(&env, "oft_receipt: {:?}", oft_receipt);
 
     let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
@@ -131,12 +131,13 @@ fn test_send_composed() {
     // execute lz_compose
     let extra_data = Bytes::from_array(&env, b"extra data");
     let oft_msg = oft_msg_codec::OFTMessage::decode(&packet.message);
+    let compose = oft_msg.compose.unwrap();
     let oft_compose_msg = OFTComposeMsg {
         nonce: packet.nonce,
         src_eid: packet.src_eid,
         amount_ld: (oft_msg.amount_sd as i128).mul(chain_b.oft.decimal_conversion_rate()),
-        compose_from: oft_msg.compose_from.unwrap(),
-        compose_msg: oft_msg.compose_msg.unwrap(),
+        compose_from: compose.from,
+        compose_msg: compose.msg,
     }
     .encode(&env);
     let compose_value = 100;

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

@@ -26,8 +26,8 @@ pub fn peer_bytes32_to_address(env: &Env, bytes32: &BytesN<32>) -> Address {
     AddressPayload::ContractIdHash(bytes32.clone()).to_address(env)
 }
 
-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(
@@ -141,12 +141,13 @@ pub fn lz_compose(
     value: i128,
 ) {
     let oft_msg = oft_msg_codec::OFTMessage::decode(&packet.message);
+    let compose = oft_msg.compose.unwrap();
     let oft_compose_msg = OFTComposeMsg {
         nonce: packet.nonce,
         src_eid: packet.src_eid,
         amount_ld: (oft_msg.amount_sd as i128).mul(chain.oft.decimal_conversion_rate()),
-        compose_from: oft_msg.compose_from.unwrap(),
-        compose_msg: oft_msg.compose_msg.unwrap(),
+        compose_from: compose.from,
+        compose_msg: compose.msg,
     }
     .encode(&env);
 

package/contracts/oapps/oft-core/src/codec/oft_compose_msg_codec.rs

@@ -31,8 +31,8 @@ impl OFTComposeMsg {
             .write_u32(self.src_eid)
             .write_i128(self.amount_ld)
             .write_bytes_n(&self.compose_from)
-            .write_bytes(&self.compose_msg);
-        writer.to_bytes()
+            .write_bytes(&self.compose_msg)
+            .to_bytes()
     }
 
     /// Decodes Bytes into an OFTComposeMsg struct.