@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

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

@@ -0,0 +1,320 @@
+//! Integration test setup for OFT.
+//!
+//! This file contains TestOFT contract and test setup utilities.
+
+extern crate self as oft;
+extern crate std;
+
+use crate::integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address};
+use common_macros::contract_impl;
+use endpoint_v2::{EndpointV2, EndpointV2Client, ILayerZeroComposer};
+use oft::oft::{oft_initialize, OFTClient, OFTInner, OFT};
+use oft::storage::OFTStorage;
+use oft::types::OFTReceipt;
+use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
+use soroban_sdk::contractimpl;
+use soroban_sdk::{
+    contract, contracttype, log, symbol_short,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token::{StellarAssetClient, TokenClient},
+    Address, Bytes, BytesN, Env, IntoVal,
+};
+
+// ============================================================================
+// Test OFT Contract
+// ============================================================================
+
+#[oapp_macros::oapp]
+pub struct TestOFT;
+
+#[contract_impl]
+impl TestOFT {
+    pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
+        oft_initialize::<Self>(env, owner, token, endpoint, delegate)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OFT for TestOFT {}
+
+impl OFTInner 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);
+        // Actually burn tokens from sender
+        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).burn(sender, &receipt.amount_sent_ld);
+        receipt
+    }
+
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
+        // Actually mint tokens to recipient
+        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).mint(to, &amount_ld);
+        amount_ld
+    }
+}
+
+// ============================================================================
+// Dummy Composer for testing compose messages
+// ============================================================================
+
+#[contracttype]
+pub struct ComposeMessage {
+    pub executor: Address,
+    pub from: Address,
+    pub guid: BytesN<32>,
+    pub index: u32,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+}
+
+#[contract]
+pub struct DummyComposer;
+
+#[contract_impl]
+impl DummyComposer {
+    pub fn __constructor(env: &Env, endpoint: &Address) {
+        env.storage().instance().set(&symbol_short!("endpoint"), endpoint);
+    }
+
+    pub fn compose_message(env: &Env) -> Option<ComposeMessage> {
+        env.storage().instance().get(&symbol_short!("msg"))
+    }
+}
+
+#[contract_impl]
+impl ILayerZeroComposer for DummyComposer {
+    fn lz_compose(
+        env: &Env,
+        executor: &Address,
+        from: &Address,
+        guid: &BytesN<32>,
+        index: u32,
+        message: &Bytes,
+        extra_data: &Bytes,
+        value: i128,
+    ) {
+        let endpoint_address: Address = env.storage().instance().get(&symbol_short!("endpoint")).unwrap();
+        let endpoint = endpoint_v2::MessagingComposerClient::new(env, &endpoint_address);
+        endpoint.clear_compose(&env.current_contract_address(), from, guid, &index, message);
+
+        env.storage().instance().set(
+            &symbol_short!("msg"),
+            &ComposeMessage {
+                executor: executor.clone(),
+                from: from.clone(),
+                guid: guid.clone(),
+                index,
+                message: message.clone(),
+                extra_data: extra_data.clone(),
+                value,
+            },
+        );
+    }
+}
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+pub struct ChainSetup<'a> {
+    pub eid: u32,
+    pub owner: Address,
+    pub native_token: Address,
+    pub oft_token: Address,
+    pub endpoint: EndpointV2Client<'a>,
+    pub sml: SimpleMessageLibClient<'a>,
+    pub oft: OFTClient<'a>,
+    pub composer: DummyComposerClient<'a>,
+}
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+
+    pub chain_a: ChainSetup<'a>,
+    pub chain_b: ChainSetup<'a>,
+}
+
+fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
+    let owner = Address::generate(env);
+
+    let sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let native_token = sac.address();
+
+    // Create ZRO token
+    let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let zro_token = zro_sac.address();
+
+    // Create OFT token
+    let oft_sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let oft_token = oft_sac.address();
+
+    let endpoint_address = env.register(EndpointV2, (&owner,));
+    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 oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate));
+    let composer_address = env.register(DummyComposer, (&endpoint_address,));
+
+    let endpoint = EndpointV2Client::new(env, &endpoint_address);
+    let sml = SimpleMessageLibClient::new(env, &sml_address);
+    let oft = OFTClient::new(env, &oft_address);
+    let composer = DummyComposerClient::new(env, &composer_address);
+
+    // Set ZRO token in endpoint
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_address,
+            fn_name: "set_zro",
+            args: (&zro_token,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint.set_zro(&zro_token);
+
+    register_library(env, &owner, &endpoint, &sml.address);
+
+    let eid = endpoint.eid();
+    ChainSetup { eid, owner, native_token, oft_token, endpoint, sml, oft, composer }
+}
+
+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_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();
+
+    log!(&env, "endpoint_a: {:?}", chain_a.endpoint.address);
+    log!(&env, "native_token_a: {:?}", chain_a.native_token);
+    log!(&env, "oft_token_a: {:?}", chain_a.oft.token());
+    log!(&env, "oft_token_a decimals: {:?}", chain_a_oft_token_decimals);
+    log!(&env, "oft_a: {:?}", chain_a.oft.address);
+    log!(&env, "sml_a: {:?}", chain_a.sml.address);
+
+    log!(&env, "endpoint_b: {:?}", chain_b.endpoint.address);
+    log!(&env, "native_token_b: {:?}", chain_b.native_token);
+    log!(&env, "oft_token_b: {:?}", chain_b.oft.token());
+    log!(&env, "oft_token_b decimals: {:?}", chain_b_oft_token_decimals);
+    log!(&env, "oft_b: {:?}", chain_b.oft.address);
+    log!(&env, "sml_b: {:?}", chain_b.sml.address);
+
+    TestSetup { env, chain_a, chain_b }
+}
+
+pub fn wire_endpoint(env: &Env, chains: &[&ChainSetup<'_>]) {
+    for chain in chains {
+        for other_chain in chains {
+            if chain.endpoint.address == other_chain.endpoint.address {
+                continue;
+            }
+            set_default_send_library(env, &chain.owner, &chain.endpoint, other_chain.eid, &chain.sml.address);
+            set_default_receive_library(env, &chain.owner, &chain.endpoint, other_chain.eid, &chain.sml.address);
+        }
+    }
+}
+
+pub fn wire_oft(env: &Env, chains: &[&ChainSetup<'_>]) {
+    for chain in chains {
+        for other_chain in chains {
+            if chain.endpoint.address == other_chain.endpoint.address {
+                continue;
+            }
+            set_peer(
+                env,
+                &chain.owner,
+                &chain.oft,
+                other_chain.eid,
+                &address_to_peer_bytes32(&other_chain.oft.address),
+            );
+        }
+    }
+}
+
+pub fn set_peer(env: &Env, owner: &Address, oft: &OFTClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &oft.address,
+            fn_name: "set_peer",
+            args: (&dst_eid, &Some(peer.clone())).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    oapp::oapp_core::OAppCoreClient::new(env, &oft.address).set_peer(&dst_eid, &Some(peer.clone()));
+}
+
+pub fn register_library(env: &Env, owner: &Address, endpoint: &EndpointV2Client<'_>, lib: &Address) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint.address,
+            fn_name: "register_library",
+            args: (lib,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint.register_library(lib);
+}
+
+pub fn set_default_send_library(
+    env: &Env,
+    owner: &Address,
+    endpoint: &EndpointV2Client<'_>,
+    dst_eid: u32,
+    lib: &Address,
+) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint.address,
+            fn_name: "set_default_send_library",
+            args: (&dst_eid, lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint.set_default_send_library(&dst_eid, lib);
+}
+
+pub fn set_default_receive_library(
+    env: &Env,
+    owner: &Address,
+    endpoint: &EndpointV2Client<'_>,
+    src_eid: u32,
+    lib: &Address,
+) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint.address,
+            fn_name: "set_default_receive_library",
+            args: (&src_eid, lib, &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint.set_default_receive_library(&src_eid, lib, &0u64);
+}
+
+pub fn decode_packet(env: &Env, encoded_packet: &soroban_sdk::Bytes) -> endpoint_v2::OutboundPacket {
+    use message_lib_common::packet_codec_v1::*;
+    use utils::buffer_reader::BufferReader;
+
+    let header = decode_packet_header(env, &encoded_packet.slice(0..HEADER_LENGTH));
+    let payload = encoded_packet.slice(HEADER_LENGTH..);
+
+    let mut payload_reader = BufferReader::new(&payload);
+    let guid = payload_reader.read_bytes_n::<32>();
+    let message = payload_reader.read_bytes_until_end();
+
+    endpoint_v2::OutboundPacket {
+        nonce: header.nonce,
+        src_eid: header.src_eid,
+        sender: peer_bytes32_to_address(env, &header.sender),
+        dst_eid: header.dst_eid,
+        receiver: header.receiver,
+        guid,
+        message,
+    }
+}

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

@@ -0,0 +1,155 @@
+use core::ops::Mul;
+
+use soroban_sdk::{bytes, log, testutils::Address as _, token::TokenClient, Address, Bytes, Env};
+
+use crate::{
+    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec},
+    integration_tests::{
+        setup::{decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
+        utils::{
+            lz_compose, lz_receive, mint_to, quote_oft, quote_send, scan_packet_sent_event, send, transfer_sac_admin,
+            validate_packet,
+        },
+    },
+    tests::test_utils::create_recipient_address,
+    types::SendParam,
+    utils::address_to_bytes32,
+};
+
+#[test]
+fn test_send_vanilla() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_oft(&env, &[&chain_a, &chain_b]);
+
+    let sender = Address::generate(&env);
+    // Register a dummy contract for the receiver so it passes the .exists() check
+    let receiver = create_recipient_address(&env);
+    log!(&env, "sender: {:?}", sender);
+    log!(&env, "receiver: {:?}", receiver);
+
+    // mint tokens and transfer oft token admin rights
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10e7 as i128);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10e18 as i128);
+    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);
+
+    // initial balances
+    let sender_balance_chain_a = TokenClient::new(&env, &chain_a.oft_token).balance(&sender);
+    let receiver_balance_chain_b = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
+    assert_eq!(sender_balance_chain_a, 10e7 as i128);
+    assert_eq!(receiver_balance_chain_b, 0);
+
+    let send_param = SendParam {
+        dst_eid: chain_b.eid,
+        to: address_to_bytes32(&receiver),
+        amount_ld: 10e7 as i128,
+        min_amount_ld: 10e7 as i128,
+        extra_options: bytes!(&env),
+        compose_msg: bytes!(&env),
+        oft_cmd: bytes!(&env),
+    };
+    log!(&env, "send_param: {:?}", send_param);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &send_param);
+    log!(&env, "oft_receipt: {:?}", oft_receipt);
+
+    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
+    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
+
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event);
+    let packet = decode_packet(&env, &packet_event.0);
+
+    // deliver the message on Chain B and execute lz_receive
+    let executor = Address::generate(&env);
+    log!(&env, "executor: {:?}", executor);
+    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
+
+    // assertions
+    let sender_balance_chain_a = TokenClient::new(&env, &chain_a.oft_token).balance(&sender);
+    let receiver_balance_chain_b = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
+    assert_eq!(sender_balance_chain_a, 0);
+    assert_eq!(receiver_balance_chain_b, 10e7 as i128);
+}
+
+#[test]
+fn test_send_composed() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_oft(&env, &[&chain_a, &chain_b]);
+
+    let sender = Address::generate(&env);
+    let receiver = chain_b.composer.address.clone();
+    log!(&env, "sender: {:?}", sender);
+    log!(&env, "receiver: {:?}", receiver);
+
+    // mint tokens and transfer oft token admin rights
+    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10e7 as i128);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10e18 as i128);
+    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);
+
+    // initial balances
+    let sender_balance_chain_a = TokenClient::new(&env, &chain_a.oft_token).balance(&sender);
+    let receiver_balance_chain_b = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
+    assert_eq!(sender_balance_chain_a, 10e7 as i128);
+    assert_eq!(receiver_balance_chain_b, 0);
+
+    let send_param = SendParam {
+        dst_eid: chain_b.eid,
+        to: address_to_bytes32(&receiver),
+        amount_ld: 10e7 as i128,
+        min_amount_ld: 10e7 as i128,
+        extra_options: bytes!(&env),
+        compose_msg: Bytes::from_array(&env, b"compose_msg"),
+        oft_cmd: bytes!(&env),
+    };
+    log!(&env, "send_param: {:?}", send_param);
+    let (_, _, oft_receipt) = quote_oft(&chain_a, &send_param);
+    log!(&env, "oft_receipt: {:?}", oft_receipt);
+
+    let fee = quote_send(&env, &chain_a, &sender, &send_param, false);
+    send(&env, &chain_a, &sender, &send_param, &fee, &sender, &oft_receipt);
+
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event);
+    let packet = decode_packet(&env, &packet_event.0);
+
+    // deliver the message on Chain B and execute lz_receive
+    let executor = Address::generate(&env);
+    log!(&env, "executor: {:?}", executor);
+    lz_receive(&env, &chain_b, &executor, &packet, &receiver, 0);
+
+    // assertions
+    let sender_balance_chain_a = TokenClient::new(&env, &chain_a.oft_token).balance(&sender);
+    let receiver_balance_chain_b = TokenClient::new(&env, &chain_b.oft_token).balance(&receiver);
+    assert_eq!(sender_balance_chain_a, 0);
+    assert_eq!(receiver_balance_chain_b, 10e7 as i128);
+
+    // execute lz_compose
+    let extra_data = Bytes::from_array(&env, b"extra data");
+    let oft_msg = oft_msg_codec::OFTMessage::decode(&packet.message);
+    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(),
+    }
+    .encode(&env);
+    let compose_value = 100;
+    let compose_index = 0;
+    lz_compose(&env, &chain_b, &executor, &packet, compose_index, &extra_data, compose_value);
+
+    // assertions
+    let compose_message = chain_b.composer.compose_message().unwrap();
+    assert_eq!(compose_message.executor, executor);
+    assert_eq!(compose_message.from, chain_b.oft.address);
+    assert_eq!(compose_message.guid, packet.guid);
+    assert_eq!(compose_message.index, compose_index);
+    assert_eq!(compose_message.message, oft_compose_msg);
+    assert_eq!(compose_message.extra_data, extra_data);
+    assert_eq!(compose_message.value, compose_value);
+}

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

@@ -0,0 +1,201 @@
+use core::ops::Mul;
+
+use crate::{
+    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec},
+    integration_tests::setup::{decode_packet, ChainSetup},
+    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
+};
+use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    testutils::{Events, MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    xdr::ToXdr,
+    Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
+};
+
+pub fn address_to_peer_bytes32(address: &Address) -> BytesN<32> {
+    match address.to_payload().unwrap() {
+        AddressPayload::ContractIdHash(payload) => payload,
+        AddressPayload::AccountIdPublicKeyEd25519(_) => panic!("peer must be a contract"),
+    }
+}
+
+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_send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    pay_in_zro: bool,
+) -> MessagingFee {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "quote_send",
+            args: (sender, send_param, &pay_in_zro).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.quote_send(sender, send_param, &pay_in_zro)
+}
+
+pub fn send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+) {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                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_sent_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.send(sender, send_param, fee, refund_address);
+}
+
+pub fn validate_packet(env: &Env, chain: &ChainSetup<'_>, packet_event: &(Bytes, Bytes, Address)) {
+    let packet = decode_packet(env, &packet_event.0);
+    let encoded_header = packet_codec_v1::encode_packet_header(env, &packet);
+    let payload_hash = packet_codec_v1::payload_hash(env, &packet);
+
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.sml.address,
+            fn_name: "validate_packet",
+            args: (&encoded_header, &payload_hash).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.sml.validate_packet(&encoded_header, &payload_hash);
+}
+
+pub fn lz_receive(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    executor: &Address,
+    packet: &OutboundPacket,
+    recipient: &Address,
+    value: i128,
+) {
+    let origin =
+        Origin { src_eid: packet.src_eid, sender: address_to_peer_bytes32(&packet.sender), nonce: packet.nonce };
+    let extra_options = recipient.to_xdr(env);
+
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "lz_receive",
+            args: (executor, &origin, &packet.guid, &packet.message, &extra_options, &value).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_v2::LayerZeroReceiverClient::new(env, &chain.oft.address).lz_receive(
+        executor,
+        &origin,
+        &packet.guid,
+        &packet.message,
+        &extra_options,
+        &value,
+    );
+}
+
+pub fn lz_compose(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    executor: &Address,
+    packet: &OutboundPacket,
+    index: u32,
+    extra_data: &Bytes,
+    value: i128,
+) {
+    let oft_msg = oft_msg_codec::OFTMessage::decode(&packet.message);
+    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(),
+    }
+    .encode(&env);
+
+    chain.composer.lz_compose(executor, &chain.oft.address, &packet.guid, &index, &oft_compose_msg, extra_data, &value);
+}
+
+// returns (encoded_payload, options, send_library)
+pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, Bytes, Address)> {
+    let mut packet = None;
+    for (emitter, topics, data) in env.events().all() {
+        let packet_sent_symbol = Symbol::new(env, "PacketSent").to_val();
+        if emitter == *endpoint && topics.contains(packet_sent_symbol) {
+            let map: Map<Symbol, Val> = data.into_val(env);
+
+            let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);
+            let options: Bytes = map.get(Symbol::new(env, "options")).unwrap().into_val(env);
+            let send_library: Address = map.get(Symbol::new(env, "send_library")).unwrap().into_val(env);
+
+            packet = Some((encoded_payload, options, send_library));
+        }
+    }
+
+    packet
+}
+
+pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount: i128) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "mint",
+            args: (to, amount).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let sac = StellarAssetClient::new(env, token);
+    sac.mint(to, &amount);
+}
+
+pub fn transfer_sac_admin(env: &Env, owner: &Address, token: &Address, new_admin: &Address) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "set_admin",
+            args: (new_admin,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    StellarAssetClient::new(env, token).set_admin(new_admin);
+}

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

@@ -0,0 +1,2 @@
+pub mod oft_compose_msg_codec;
+pub mod oft_msg_codec;