@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

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

@@ -1,156 +0,0 @@
-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_payload,
-};
-
-#[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_payload(&env, &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, &sender, &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_payload(&env, &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, &sender, &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 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: compose.from,
-        compose_msg: compose.msg,
-    }
-    .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-core/integration-tests/utils.rs

@@ -1,220 +0,0 @@
-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<'_>, from: &Address, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
-    chain.oft.quote_oft(from, 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_received_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 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: compose.from,
-        compose_msg: compose.msg,
-    }
-    .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)> {
-    use soroban_sdk::TryFromVal;
-
-    let mut packet = None;
-    let events = env.events().all().filter_by_contract(endpoint);
-    for event in events.events().iter() {
-        let v0 = match &event.body {
-            soroban_sdk::xdr::ContractEventBody::V0(v0) => v0,
-        };
-
-        // Check if this is a packet_sent event by looking at topics
-        let mut is_packet_sent = false;
-        for topic in v0.topics.iter() {
-            if let Ok(sym) = Symbol::try_from_val(env, topic) {
-                if sym == Symbol::new(env, "packet_sent") {
-                    is_packet_sent = true;
-                    break;
-                }
-            }
-        }
-
-        if is_packet_sent {
-            let data: Val = Val::try_from_val(env, &v0.data).unwrap();
-            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-core/src/codec/mod.rs

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

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

@@ -1,55 +0,0 @@
-use soroban_sdk::{Bytes, BytesN, Env};
-use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
-
-/// Decoded compose message containing transfer context and payload execution
-#[derive(Clone, Debug)]
-pub struct OFTComposeMsg {
-    /// Unique sequence number for the cross-chain message packet
-    pub nonce: u64,
-    /// Source endpoint ID where the transfer originated
-    pub src_eid: u32,
-    /// Amount received in local decimals
-    pub amount_ld: i128,
-    /// Address that initiated the compose call on the source chain
-    pub compose_from: BytesN<32>,
-    /// Custom payload for compose logic execution
-    pub compose_msg: Bytes,
-}
-
-impl OFTComposeMsg {
-    /// Encodes the OFTComposeMsg struct into Bytes.
-    ///
-    /// # Arguments
-    /// * `env` - The Soroban environment
-    ///
-    /// # Returns
-    /// Encoded bytes representation of the compose message
-    pub fn encode(&self, env: &Env) -> Bytes {
-        let mut writer = BufferWriter::new(env);
-        writer
-            .write_u64(self.nonce)
-            .write_u32(self.src_eid)
-            .write_i128(self.amount_ld)
-            .write_bytes_n(&self.compose_from)
-            .write_bytes(&self.compose_msg)
-            .to_bytes()
-    }
-
-    /// Decodes Bytes into an OFTComposeMsg struct.
-    ///
-    /// # Arguments
-    /// * `bytes` - The encoded bytes to decode
-    ///
-    /// # Returns
-    /// Decoded OFTComposeMsg struct
-    pub fn decode(bytes: &Bytes) -> Self {
-        let mut reader = BufferReader::new(bytes);
-        let nonce = reader.read_u64();
-        let src_eid = reader.read_u32();
-        let amount_ld = reader.read_i128();
-        let compose_from = reader.read_bytes_n::<32>();
-        let compose_msg = reader.read_bytes_until_end();
-
-        OFTComposeMsg { nonce, src_eid, amount_ld, compose_from, compose_msg }
-    }
-}

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

@@ -1,58 +0,0 @@
-use soroban_sdk::{Bytes, BytesN, Env};
-use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
-
-/// Decoded OFT message containing transfer details and optional compose data.
-///
-/// Wire format:
-/// ```text
-/// [send_to: 32 bytes][amount_sd: 8 bytes][compose_from: 32 bytes (optional)][compose_msg: variable (optional)]
-/// ```
-#[derive(Clone, Debug)]
-pub struct OFTMessage {
-    /// Recipient address on the destination chain
-    pub send_to: BytesN<32>,
-    /// Amount to transfer in shared decimals
-    pub amount_sd: u64,
-    /// Optional compose data for cross-chain composed calls
-    pub compose: Option<ComposeData>,
-}
-
-/// Initiator address and payload for a cross-chain composed call.
-#[derive(Clone, Debug)]
-pub struct ComposeData {
-    /// Address that initiated the compose call
-    pub from: BytesN<32>,
-    /// Compose message payload
-    pub msg: Bytes,
-}
-
-impl OFTMessage {
-    /// Encodes the OFTMessage into Bytes.
-    pub fn encode(&self, env: &Env) -> Bytes {
-        let mut writer = BufferWriter::new(env);
-        writer.write_bytes_n(&self.send_to).write_u64(self.amount_sd);
-
-        if let Some(ref compose_data) = self.compose {
-            writer.write_bytes_n(&compose_data.from).write_bytes(&compose_data.msg);
-        }
-
-        writer.to_bytes()
-    }
-
-    /// Decodes Bytes into an OFTMessage.
-    pub fn decode(message: &Bytes) -> Self {
-        let mut reader = BufferReader::new(message);
-        let send_to = reader.read_bytes_n::<32>();
-        let amount_sd = reader.read_u64();
-
-        let compose = if reader.remaining_len() > 0 {
-            let from = reader.read_bytes_n::<32>();
-            let msg = reader.read_bytes_until_end();
-            Some(ComposeData { from, msg })
-        } else {
-            None
-        };
-
-        OFTMessage { send_to, amount_sd, compose }
-    }
-}

package/contracts/oapps/oft-core/src/errors.rs

@@ -1,15 +0,0 @@
-use common_macros::contract_error;
-
-// OFT library error codes: 3000-3099
-// See docs/error-spec.md for allocation rules
-
-/// OFTError: 3000-3099
-#[contract_error]
-pub enum OFTError {
-    InvalidAddress = 3000,
-    InvalidAmount,
-    InvalidLocalDecimals,
-    NotInitialized,
-    Overflow,
-    SlippageExceeded,
-}

package/contracts/oapps/oft-core/src/events.rs

@@ -1,32 +0,0 @@
-use soroban_sdk::{contractevent, Address, BytesN};
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct OFTSent {
-    #[topic]
-    pub guid: BytesN<32>,
-    #[topic]
-    pub dst_eid: u32,
-    #[topic]
-    pub from: Address,
-    pub amount_sent_ld: i128,
-    pub amount_received_ld: i128,
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct OFTReceived {
-    #[topic]
-    pub guid: BytesN<32>,
-    #[topic]
-    pub src_eid: u32,
-    #[topic]
-    pub to: Address,
-    pub amount_received_ld: i128,
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct MsgInspectorSet {
-    pub inspector: Option<Address>,
-}

package/contracts/oapps/oft-core/src/lib.rs

@@ -1,22 +0,0 @@
-#![no_std]
-
-pub mod events;
-pub mod storage;
-pub mod utils;
-
-mod codec;
-mod errors;
-mod oft_core;
-mod types;
-
-pub use codec::*;
-pub use errors::*;
-pub use oft_core::*;
-pub use types::*;
-
-#[cfg(test)]
-#[path = "../integration-tests/mod.rs"]
-mod integration_tests;
-
-#[cfg(test)]
-mod tests;