@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

package/contracts/oapps/oft-core/src/tests/test_lz_receive.rs

@@ -26,7 +26,7 @@ fn run_lz_receive_test(setup: &OFTTestSetup, recipient: &Address, amount_sd: u64
         if setup.is_lock_unlock() { Some(setup.token_client.balance(&setup.oft.address)) } else { None };
 
     // Create OFT message
-    let recipient_bytes32 = address_payload(recipient);
+    let recipient_bytes32 = address_payload(env, recipient);
     let message = encode_oft_message(env, &recipient_bytes32, amount_sd);
 
     let guid = BytesN::from_array(env, &[1u8; 32]);
@@ -111,8 +111,8 @@ fn test_mint_burn_lz_receive_with_compose() {
     setup.set_peer(src_eid, &peer);
 
     // Create OFT message with compose
-    let recipient_bytes32 = address_payload(&recipient);
-    let compose_from = address_payload(&sender_on_src);
+    let recipient_bytes32 = address_payload(&env, &recipient);
+    let compose_from = address_payload(&env, &sender_on_src);
     let compose_msg = Bytes::from_array(&env, b"test compose payload");
     let amount_sd = 1000000u64;
     let message = encode_oft_message_with_compose(&env, &recipient_bytes32, amount_sd, &compose_from, &compose_msg);
@@ -204,8 +204,8 @@ fn test_lock_unlock_lz_receive_with_compose() {
     setup.set_peer(src_eid, &peer);
 
     // Create OFT message with compose
-    let recipient_bytes32 = address_payload(&recipient);
-    let compose_from = address_payload(&sender_on_src);
+    let recipient_bytes32 = address_payload(&env, &recipient);
+    let compose_from = address_payload(&env, &sender_on_src);
     let compose_msg = Bytes::from_array(&env, b"test compose payload");
     let amount_sd = 1000000u64;
     let message = encode_oft_message_with_compose(&env, &recipient_bytes32, amount_sd, &compose_from, &compose_msg);
@@ -261,7 +261,7 @@ fn test_lz_receive_without_giving_authorization() {
     assert_eq!(setup.token_client.balance(&recipient), 0);
 
     // Create OFT message
-    let recipient_bytes32 = address_payload(&recipient);
+    let recipient_bytes32 = address_payload(&env, &recipient);
     let amount_sd = 1000000u64; // 1 token in shared decimals
     let message = encode_oft_message(&env, &recipient_bytes32, amount_sd);
 

package/contracts/oapps/oft-core/src/tests/test_msg_inspector.rs

@@ -3,7 +3,7 @@
 use crate::tests::test_utils::{create_send_param, OFTTestSetup};
 use common_macros::contract_error;
 use endpoint_v2::MessagingFee;
-use oapp::interfaces::IOAppMsgInspector;
+use oapp::IOAppMsgInspector;
 use soroban_sdk::{
     contract, contractimpl, panic_with_error,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
@@ -18,8 +18,9 @@ pub struct PassingInspector;
 
 #[contractimpl]
 impl IOAppMsgInspector for PassingInspector {
-    fn inspect(_env: &Env, _oapp: &Address, _message: &Bytes, _options: &Bytes) {
+    fn inspect(_env: &Env, _oapp: &Address, _message: &Bytes, _options: &Bytes) -> bool {
         // Do nothing - inspection passes
+        true
     }
 }
 
@@ -34,7 +35,7 @@ pub struct FailingInspector;
 
 #[contractimpl]
 impl IOAppMsgInspector for FailingInspector {
-    fn inspect(env: &Env, _oapp: &Address, _message: &Bytes, _options: &Bytes) {
+    fn inspect(env: &Env, _oapp: &Address, _message: &Bytes, _options: &Bytes) -> bool {
         panic_with_error!(env, InspectorError::InspectionFailed);
     }
 }
@@ -162,7 +163,7 @@ fn test_send_without_inspector_succeeds() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     // Send without inspector set - should succeed
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &oft_receipt);
@@ -202,7 +203,7 @@ fn test_send_with_passing_inspector() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     // Send with passing inspector - should succeed
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &oft_receipt);
@@ -242,7 +243,7 @@ fn test_send_with_failing_inspector() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     // Send with failing inspector - should fail
     let result = setup.try_send(&sender, &send_param, &fee, &sender, &oft_receipt);

package/contracts/oapps/oft-core/src/tests/test_oft_msg_codec.rs

@@ -1,4 +1,5 @@
-use crate::{codec::oft_msg_codec::OFTMessage, utils::address_payload};
+use crate::codec::oft_msg_codec::{ComposeData, OFTMessage};
+use crate::utils::address_payload;
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
 
 #[test]
@@ -7,19 +8,14 @@ fn test_encode_and_decode_without_compose() {
     let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
     let amount_sd_val = 1000u64;
 
-    let msg =
-        OFTMessage { send_to: send_to_addr.clone(), amount_sd: amount_sd_val, compose_from: None, compose_msg: None };
-    let (encoded, has_compose) = msg.encode(&env);
-
-    assert_eq!(has_compose, false);
+    let msg = OFTMessage { send_to: send_to_addr.clone(), amount_sd: amount_sd_val, compose: None };
+    let encoded = msg.encode(&env);
 
     // Test decode function
     let decoded = OFTMessage::decode(&encoded);
     assert_eq!(decoded.send_to, send_to_addr);
     assert_eq!(decoded.amount_sd, amount_sd_val);
-    assert_eq!(decoded.compose_from.is_none(), true);
-    assert_eq!(decoded.compose_msg.is_none(), true);
-    assert_eq!(decoded.is_composed(), false);
+    assert!(decoded.compose.is_none());
 }
 
 #[test]
@@ -33,90 +29,23 @@ fn test_encode_and_decode_with_compose() {
     let msg = OFTMessage {
         send_to: send_to_addr.clone(),
         amount_sd: amount_sd_val,
-        compose_from: Some(address_payload(&sender)),
-        compose_msg: Some(compose_msg_val),
+        compose: Some(ComposeData { from: address_payload(&env, &sender), msg: compose_msg_val }),
     };
-    let (encoded, has_compose) = msg.encode(&env);
-
-    assert_eq!(has_compose, true);
+    let encoded = msg.encode(&env);
 
     // Test decode function
     let decoded = OFTMessage::decode(&encoded);
     assert_eq!(decoded.send_to, send_to_addr);
     assert_eq!(decoded.amount_sd, amount_sd_val);
-    assert_eq!(decoded.compose_from.is_some(), true);
-    assert_eq!(decoded.compose_msg.is_some(), true);
-    assert_eq!(decoded.compose_msg.as_ref().unwrap().len(), 4);
-    assert_eq!(decoded.is_composed(), true);
+    let compose = decoded.compose.as_ref().unwrap();
+    assert_eq!(compose.msg.len(), 4);
 
     // Verify compose message structure: sender's bytes32 (32 bytes) + compose_msg (4 bytes)
-    let compose_from_len = decoded.compose_from.as_ref().unwrap().to_array().len() as u32;
-    let compose_msg_len = decoded.compose_msg.as_ref().unwrap().len();
+    let compose_from_len = compose.from.to_array().len() as u32;
+    let compose_msg_len = compose.msg.len();
     assert_eq!(compose_from_len + compose_msg_len, 36);
 }
 
-#[test]
-fn test_is_composed_false_when_only_compose_from() {
-    let env = Env::default();
-    let sender = Address::generate(&env);
-    let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
-    let amount_sd_val = 100u64;
-
-    // Manually construct invalid state: only compose_from, no compose_msg
-    let msg = OFTMessage {
-        send_to: send_to_addr,
-        amount_sd: amount_sd_val,
-        compose_from: Some(address_payload(&sender)),
-        compose_msg: None,
-    };
-
-    // Should return false - both fields are required for compose
-    assert_eq!(msg.is_composed(), false);
-}
-
-#[test]
-fn test_is_composed_false_when_only_compose_msg() {
-    let env = Env::default();
-    let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
-    let amount_sd_val = 100u64;
-    let compose_msg_val = Bytes::from_array(&env, &[1u8, 2u8, 3u8]);
-
-    // Manually construct invalid state: only compose_msg, no compose_from
-    let msg = OFTMessage {
-        send_to: send_to_addr,
-        amount_sd: amount_sd_val,
-        compose_from: None,
-        compose_msg: Some(compose_msg_val),
-    };
-
-    // Should return false - both fields are required for compose
-    assert_eq!(msg.is_composed(), false);
-}
-
-#[test]
-fn test_is_composed_false_when_compose_msg_empty() {
-    let env = Env::default();
-    let sender = Address::generate(&env);
-    let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
-    let amount_sd_val = 100u64;
-    let empty_compose_msg = Bytes::new(&env); // Empty bytes, not None
-
-    // Manually construct state with empty compose_msg
-    let msg = OFTMessage {
-        send_to: send_to_addr.clone(),
-        amount_sd: amount_sd_val,
-        compose_from: Some(address_payload(&sender)),
-        compose_msg: Some(empty_compose_msg),
-    };
-
-    // Should return false - compose_msg must have data
-    assert_eq!(msg.is_composed(), false);
-
-    // Verify encoding also treats it as non-composed
-    let (_, has_compose) = msg.encode(&env);
-    assert_eq!(has_compose, false);
-}
-
 #[test]
 #[should_panic]
 fn test_decode_panic_on_empty_data() {

package/contracts/oapps/oft-core/src/tests/test_quote_oft.rs

@@ -15,11 +15,11 @@ fn test_quote_oft_basic() {
     let dust_removed = (amount_ld / conversion_rate) * conversion_rate; // No dust with last digit 0
     let send_param = create_send_param(&env, 1, amount_ld, dust_removed);
 
-    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+    let (limit, fees, receipt) = setup.oft.quote_oft(&setup.owner, &send_param);
 
     // Check limits
     assert_eq!(limit.min_amount_ld, 0);
-    assert_eq!(limit.max_amount_ld, i128::MAX);
+    assert_eq!(limit.max_amount_ld, u64::MAX as i128);
 
     // Check fees (should be empty for basic OFT)
     assert_eq!(fees.len(), 0);
@@ -40,11 +40,11 @@ fn test_quote_oft_with_dust_removal() {
     let dust_removed = (amount_ld / conversion_rate) * conversion_rate;
     let send_param = create_send_param(&env, 1, amount_ld, dust_removed);
 
-    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+    let (limit, fees, receipt) = setup.oft.quote_oft(&setup.owner, &send_param);
 
     // Check limits
     assert_eq!(limit.min_amount_ld, 0);
-    assert_eq!(limit.max_amount_ld, i128::MAX);
+    assert_eq!(limit.max_amount_ld, u64::MAX as i128);
 
     // Check fees (should be empty for basic OFT)
     assert_eq!(fees.len(), 0);
@@ -61,12 +61,12 @@ fn test_quote_oft_zero_amount() {
 
     let send_param = create_send_param(&env, 1, 0, 0);
 
-    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+    let (limit, fees, receipt) = setup.oft.quote_oft(&setup.owner, &send_param);
 
     assert_eq!(receipt.amount_sent_ld, 0);
     assert_eq!(receipt.amount_received_ld, 0);
     assert_eq!(limit.min_amount_ld, 0);
-    assert_eq!(limit.max_amount_ld, i128::MAX);
+    assert_eq!(limit.max_amount_ld, u64::MAX as i128);
     assert_eq!(fees.len(), 0);
 }
 
@@ -80,7 +80,7 @@ fn test_quote_oft_dust_only_amount() {
     let amount_ld = conversion_rate - 1; // Less than conversion rate
     let send_param = create_send_param(&env, 1, amount_ld, 0);
 
-    let (_, _, receipt) = setup.oft.quote_oft(&send_param);
+    let (_, _, receipt) = setup.oft.quote_oft(&setup.owner, &send_param);
 
     // All dust should be removed
     assert_eq!(receipt.amount_sent_ld, 0);
@@ -97,11 +97,11 @@ fn test_quote_oft_different_dst_eids() {
     // Test with different destination EIDs
     for dst_eid in [1u32, 100, 10000, u32::MAX] {
         let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
-        let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+        let (limit, fees, receipt) = setup.oft.quote_oft(&setup.owner, &send_param);
 
         // Results should be the same regardless of dst_eid
         assert_eq!(limit.min_amount_ld, 0);
-        assert_eq!(limit.max_amount_ld, i128::MAX);
+        assert_eq!(limit.max_amount_ld, u64::MAX as i128);
         assert_eq!(fees.len(), 0);
         assert_eq!(receipt.amount_sent_ld, amount_ld);
         assert_eq!(receipt.amount_received_ld, amount_ld);
@@ -117,10 +117,10 @@ fn test_quote_oft_large_amounts() {
     let amount_ld = 1_000_000_000_000_000_000i128;
     let send_param = create_send_param(&env, 1, amount_ld, amount_ld);
 
-    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+    let (limit, fees, receipt) = setup.oft.quote_oft(&setup.owner, &send_param);
 
     assert_eq!(limit.min_amount_ld, 0);
-    assert_eq!(limit.max_amount_ld, i128::MAX);
+    assert_eq!(limit.max_amount_ld, u64::MAX as i128);
     assert_eq!(fees.len(), 0);
     assert_eq!(receipt.amount_sent_ld, amount_ld);
     assert_eq!(receipt.amount_received_ld, amount_ld);
@@ -139,7 +139,7 @@ fn test_quote_oft_slippage_less_than_received() {
     // min_amount_ld is less than what will be received
     let send_param = create_send_param(&env, 1, amount_ld, dust_removed - conversion_rate);
 
-    let (_, _, receipt) = setup.oft.quote_oft(&send_param);
+    let (_, _, receipt) = setup.oft.quote_oft(&setup.owner, &send_param);
 
     assert_eq!(receipt.amount_sent_ld, dust_removed);
     assert_eq!(receipt.amount_received_ld, dust_removed);
@@ -154,6 +154,6 @@ fn test_quote_oft_slippage_exceeded() {
     // min_amount_ld is higher than what can be received after dust removal
     let send_param = create_send_param(&env, 1, amount_ld, amount_ld);
 
-    let result = setup.oft.try_quote_oft(&send_param);
+    let result = setup.oft.try_quote_oft(&setup.owner, &send_param);
     assert_eq!(result.err().unwrap().ok().unwrap(), OFTError::SlippageExceeded.into());
 }

package/contracts/oapps/oft-core/src/tests/test_quote_send.rs

@@ -1,5 +1,5 @@
 use crate::{errors::OFTError, types::SendParam};
-use oapp::errors::OAppError;
+use oapp::OAppError;
 use soroban_sdk::{bytes, testutils::Address as _, Address, Bytes, BytesN, Env};
 
 use super::test_utils::{create_send_param, OFTTestSetup};

package/contracts/oapps/oft-core/src/tests/test_resolve_address.rs

@@ -12,7 +12,7 @@ fn test_resolve_address_contract_exists() {
     let contract_address = create_recipient_address(&env);
 
     // Convert to bytes32
-    let bytes32 = address_payload(&contract_address);
+    let bytes32 = address_payload(&env, &contract_address);
 
     // Resolve back - should return the same contract address
     let resolved = resolve_address(&env, &bytes32);
@@ -28,7 +28,7 @@ fn test_resolve_address_contract_not_exists_fallback_to_g_address() {
     let g_address = generate_g_address(&env);
 
     // Convert to bytes32
-    let bytes32 = address_payload(&g_address);
+    let bytes32 = address_payload(&env, &g_address);
 
     // Resolve - should fallback to G-address since contract doesn't exist
     let resolved = resolve_address(&env, &bytes32);

package/contracts/oapps/oft-core/src/tests/test_send.rs

@@ -5,7 +5,7 @@ use crate::{
     types::{OFTReceipt, SendParam},
 };
 use endpoint_v2::MessagingFee;
-use oapp::errors::OAppError;
+use oapp::OAppError;
 use soroban_sdk::{
     bytes,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
@@ -41,7 +41,7 @@ fn test_send_basic() {
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
     let refund_address = sender.clone();
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     // Send tokens
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &refund_address, &oft_receipt);
@@ -81,7 +81,7 @@ fn test_send_burns_tokens() {
 
     let send_param = create_send_param(&env, dst_eid, send_amount, send_amount);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     setup.send(&sender, &send_param, &fee, &sender, &oft_receipt);
 
@@ -111,7 +111,7 @@ fn test_send_with_dust_removal() {
     // min_amount_ld should be the dust-removed amount
     let send_param = create_send_param(&env, dst_eid, amount_with_dust, expected_dust_removed);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (_, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -143,7 +143,7 @@ fn test_send_slippage_exactly_met() {
     // min_amount_ld exactly equals amount after dust removal
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (_, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -172,7 +172,7 @@ fn test_send_slippage_exceeded() {
     let send_param = create_send_param(&env, dst_eid, amount_with_dust, min_amount_too_high);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
     // Use a receipt with dust-removed amount for auth (even though it will fail slippage check)
-    let quoted_receipt = setup.quote_oft(&create_send_param(&env, dst_eid, amount_with_dust, 0));
+    let quoted_receipt = setup.quote_oft(&sender, &create_send_param(&env, dst_eid, amount_with_dust, 0));
 
     // Should fail due to slippage
     let result = setup.try_send(&sender, &send_param, &fee, &sender, &quoted_receipt);
@@ -199,7 +199,7 @@ fn test_send_slippage_less_than_received() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, min_amount_low);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (_, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -247,7 +247,7 @@ fn test_send_zero_amount() {
     // Send zero tokens
     let send_param = create_send_param(&env, dst_eid, 0, 0);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (_, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -313,7 +313,7 @@ fn test_send_with_compose_msg() {
     };
 
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -344,7 +344,7 @@ fn test_send_emits_oft_sent_event() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -387,7 +387,7 @@ fn test_send_multiple_times() {
     for amount in send_amounts.iter() {
         let send_param = create_send_param(&env, dst_eid, *amount, *amount);
         let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-        let quoted_receipt = setup.quote_oft(&send_param);
+        let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
         let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -426,7 +426,7 @@ fn test_send_to_multiple_destinations() {
     for dst_eid in dst_eids.iter() {
         let send_param = create_send_param(&env, *dst_eid, amount_per_send, amount_per_send);
         let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-        let quoted_receipt = setup.quote_oft(&send_param);
+        let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
         let (_, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -462,7 +462,7 @@ fn test_send_different_amounts() {
 
         let send_param = create_send_param(&env, dst_eid, *amount, *amount);
         let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-        let quoted_receipt = setup.quote_oft(&send_param);
+        let quoted_receipt = setup.quote_oft(&test_sender, &send_param);
 
         let (_, oft_receipt) = setup.send(&test_sender, &send_param, &fee, &test_sender, &quoted_receipt);
 
@@ -493,7 +493,7 @@ fn test_send_large_amount() {
 
     let send_param = create_send_param(&env, dst_eid, large_amount, large_amount);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (_, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -522,7 +522,7 @@ fn test_send_with_zro_fee() {
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     // Include ZRO fee
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: setup.zro_fee };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -552,7 +552,7 @@ fn test_send_with_custom_fees() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: custom_native_fee, zro_fee: custom_zro_fee };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
@@ -583,7 +583,7 @@ fn test_send_with_different_refund_address() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
-    let quoted_receipt = setup.quote_oft(&send_param);
+    let quoted_receipt = setup.quote_oft(&sender, &send_param);
 
     // Use different refund address
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &refund_address, &quoted_receipt);
@@ -620,7 +620,7 @@ fn test_send_lock_unlock_strategy() {
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
     let refund_address = sender.clone();
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     // Send tokens
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &refund_address, &oft_receipt);
@@ -737,7 +737,7 @@ fn test_giving_partial_authorization_with_burn_wrong_arguments() {
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
     let refund_address = sender.clone();
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     // Send tokens
     env.mock_auths(&[MockAuth {
@@ -782,7 +782,7 @@ fn test_giving_partial_authorization_without_native_fee_authorizations() {
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
     let refund_address = sender.clone();
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
 
     // Send tokens
     env.mock_auths(&[MockAuth {
@@ -826,7 +826,7 @@ fn test_giving_partial_authorization_without_zro_fee_authorizations() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let refund_address = sender.clone();
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
     let fee = setup.oft.quote_send(&sender, &send_param, &true);
 
     // Send tokens
@@ -879,7 +879,7 @@ fn test_giving_full_authorization() {
 
     let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
     let refund_address = sender.clone();
-    let oft_receipt = setup.quote_oft(&send_param);
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
     let fee = setup.oft.quote_send(&sender, &send_param, &true);
 
     // Send tokens

package/contracts/oapps/oft-core/src/tests/test_utils.rs

@@ -75,8 +75,8 @@ pub fn generate_g_address(env: &Env) -> Address {
 }
 
 pub fn encode_oft_message(env: &Env, send_to: &BytesN<32>, amount_sd: u64) -> Bytes {
-    let msg = OFTMessage { send_to: send_to.clone(), amount_sd, compose_from: None, compose_msg: None };
-    msg.encode(env).0
+    let msg = OFTMessage { send_to: send_to.clone(), amount_sd, compose: None };
+    msg.encode(env)
 }
 
 pub fn encode_oft_message_with_compose(
@@ -86,13 +86,13 @@ pub fn encode_oft_message_with_compose(
     compose_from: &BytesN<32>,
     compose_msg: &Bytes,
 ) -> Bytes {
+    use crate::codec::oft_msg_codec::ComposeData;
     let msg = OFTMessage {
         send_to: send_to.clone(),
         amount_sd,
-        compose_from: Some(compose_from.clone()),
-        compose_msg: Some(compose_msg.clone()),
+        compose: Some(ComposeData { from: compose_from.clone(), msg: compose_msg.clone() }),
     };
-    msg.encode(env).0
+    msg.encode(env)
 }
 
 pub fn create_origin(src_eid: u32, sender: &BytesN<32>, nonce: u64) -> Origin {
@@ -105,7 +105,6 @@ mod test_mint_burn_oft {
     use crate::{
         self as oft_core,
         oft_core::{OFTCore, OFTInternal},
-        types::OFTReceipt,
     };
     use endpoint_v2::Origin;
     use oapp::oapp_receiver::LzReceiveInternal;
@@ -128,10 +127,10 @@ mod test_mint_burn_oft {
             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)
         }
     }
 
@@ -153,11 +152,11 @@ mod test_mint_burn_oft {
     }
 
     impl OFTInternal for TestMintBurnOFT {
-        fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
             // Inline mint_burn::debit implementation
-            let receipt = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
-            MintBurnTokenClient::new(env, &Self::token(env)).burn(sender, &receipt.amount_received_ld);
-            receipt
+            let (amount_sent_ld, amount_received_ld) = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
+            MintBurnTokenClient::new(env, &Self::token(env)).burn(sender, &amount_received_ld);
+            (amount_sent_ld, amount_received_ld)
         }
 
         fn __credit(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
@@ -173,7 +172,6 @@ mod test_lock_unlock_oft {
     use crate::{
         self as oft_core,
         oft_core::{OFTCore, OFTInternal},
-        types::OFTReceipt,
     };
     use endpoint_v2::Origin;
     use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
@@ -189,10 +187,10 @@ mod test_lock_unlock_oft {
             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)
         }
     }
 
@@ -218,15 +216,15 @@ mod test_lock_unlock_oft {
     impl OAppReceiver for TestLockUnlockOFT {}
 
     impl OFTInternal for TestLockUnlockOFT {
-        fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
             // Inline lock_unlock::debit implementation
-            let receipt: OFTReceipt = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
+            let (amount_sent_ld, amount_received_ld) = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
             TokenClient::new(env, &Self::token(env)).transfer(
                 sender,
                 env.current_contract_address(),
-                &receipt.amount_received_ld,
+                &amount_received_ld,
             );
-            receipt
+            (amount_sent_ld, amount_received_ld)
         }
 
         fn __credit(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
@@ -582,7 +580,7 @@ impl<'a> OFTTestSetupBuilder<'a> {
         let endpoint_client = MockEndpointWithComposeClient::new(env, &endpoint_address);
 
         // Register OFT based on type
-        let delegate: Option<Address> = Some(owner.clone());
+        let delegate = owner.clone();
         let oft_address = match oft_type {
             OFTType::MintBurn => {
                 env.register(TestMintBurnOFT, (&token, &owner, &endpoint_address, &delegate, &self.shared_decimals))
@@ -732,8 +730,8 @@ impl<'a> OFTTestSetup<'a> {
     }
 
     /// Quote OFT to get the receipt for authorization
-    pub fn quote_oft(&self, send_param: &SendParam) -> OFTReceipt {
-        let (_, _, receipt) = self.oft.quote_oft(send_param);
+    pub fn quote_oft(&self, from: &Address, send_param: &SendParam) -> OFTReceipt {
+        let (_, _, receipt) = self.oft.quote_oft(from, send_param);
         receipt
     }