@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/oapps/counter/integration_tests/setup.rs

@@ -0,0 +1,201 @@
+extern crate std;
+
+use crate::{
+    counter::{Counter, CounterClient},
+    integration_tests::utils::address_to_bytes32,
+};
+use endpoint_v2::{EndpointV2, EndpointV2Client};
+use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    log,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, BytesN, Env, IntoVal,
+};
+use utils::buffer_reader::BufferReader;
+
+pub struct ChainSetup<'a> {
+    pub eid: u32,
+    pub owner: Address,
+    pub native_token: Address,
+    pub endpoint: EndpointV2Client<'a>,
+    pub sml: SimpleMessageLibClient<'a>,
+    pub counter: CounterClient<'a>,
+}
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+
+    pub chain_a: ChainSetup<'a>,
+    pub chain_b: ChainSetup<'a>,
+}
+
+fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
+    // Create ZRO token
+    let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let zro_token = zro_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 counter_address = env.register(Counter, (owner, &endpoint_address, owner));
+
+    let endpoint = EndpointV2Client::new(env, &endpoint_address);
+    let sml = SimpleMessageLibClient::new(env, &sml_address);
+    let counter = CounterClient::new(env, &counter_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();
+    let native_token = endpoint.native_token();
+    ChainSetup { owner: owner.clone(), endpoint, sml, counter, eid, native_token }
+}
+
+pub fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let sac = env.register_stellar_asset_contract_v2(owner.clone());
+    log!(&env, "native_token: {:?}", sac.address());
+
+    let chain_a = setup_chain(&env, &owner);
+    let chain_b = setup_chain(&env, &owner);
+
+    log!(&env, "endpoint_a: {:?}", chain_a.endpoint.address);
+    log!(&env, "native_token_a: {:?}", chain_a.native_token);
+    log!(&env, "counter_a: {:?}", chain_a.counter.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, "counter_b: {:?}", chain_b.counter.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_counter(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.counter,
+                other_chain.eid,
+                &address_to_bytes32(&other_chain.counter.address),
+            );
+        }
+    }
+}
+
+pub fn set_peer(env: &Env, owner: &Address, counter: &CounterClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
+    let peer_option = Some(peer.clone());
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "set_peer",
+            args: (&dst_eid, &peer_option).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    counter.set_peer(&dst_eid, &peer_option);
+}
+
+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::*;
+
+    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: Address::from_payload(env, AddressPayload::ContractIdHash(header.sender)),
+        dst_eid: header.dst_eid,
+        receiver: header.receiver,
+        guid,
+        message,
+    }
+}

package/contracts/oapps/counter/integration_tests/test_with_sml.rs

@@ -0,0 +1,166 @@
+use crate::codec::MsgType;
+use crate::integration_tests::{setup::*, utils::*};
+use crate::tests::{approve, mint_to};
+use soroban_sdk::{testutils::Address as _, Address, Bytes};
+
+#[test]
+fn test_increment_vanilla() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_counter(&env, &[&chain_a, &chain_b]);
+
+    // on Chain A, quote and increment
+    let sender = Address::generate(&env);
+    let options = Bytes::new(&env);
+    let msg_type = MsgType::Vanilla;
+
+    let fee = quote(&chain_a, chain_b.eid, msg_type, &options);
+
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee);
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+
+    // // validate packet on Chain B
+    validate_packet(&env, &chain_b, &packet_event);
+    let packet = decode_packet(&env, &packet_event.0);
+
+    // deliver the message on Chain B
+    let executor = Address::generate(&env);
+    lz_receive(&env, &chain_b, &executor, &packet, 0, false);
+
+    // state assertion
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+}
+
+#[test]
+fn test_increment_aba() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_counter(&env, &[&chain_a, &chain_b]);
+
+    // on Chain A, quote and increment
+    let sender = Address::generate(&env);
+    let msg_type = MsgType::ABA;
+    let options = Bytes::new(&env);
+
+    let fee = quote(&chain_a, chain_b.eid, msg_type, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee);
+
+    // validate packet on Chain B
+    let packet_event_chain_a = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event_chain_a);
+    let packet_chain_a = decode_packet(&env, &packet_event_chain_a.0);
+
+    // deliver the message on Chain B and execute lz_receive
+    let executor = Address::generate(&env);
+    mint_to(&env, &chain_b.owner, &chain_b.native_token, &executor, fee.native_fee);
+    approve(&env, &executor, &chain_b.native_token, fee.native_fee);
+    lz_receive(&env, &chain_b, &executor, &packet_chain_a, fee.native_fee, true);
+
+    // validate packet on Chain A
+    let packet_event_chain_b = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
+    validate_packet(&env, &chain_a, &packet_event_chain_b);
+    let packet_chain_b = decode_packet(&env, &packet_event_chain_b.0);
+
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &executor, fee.native_fee);
+    approve(&env, &executor, &chain_a.native_token, fee.native_fee);
+    // deliver the message on Chain A and execute lz_receive
+    lz_receive(&env, &chain_a, &executor, &packet_chain_b, fee.native_fee, false);
+
+    // state assertion
+    assert_eq!(chain_a.counter.count(), 1);
+    assert_eq!(chain_a.counter.inbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+}
+
+#[test]
+fn test_increment_composed() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_counter(&env, &[&chain_a, &chain_b]);
+
+    // increment
+    let sender = Address::generate(&env);
+    let msg_type = MsgType::Composed;
+    let options = Bytes::new(&env);
+
+    let fee = quote(&chain_a, chain_b.eid, msg_type, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee);
+
+    // validate packet on Chain B
+    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);
+    lz_receive(&env, &chain_b, &executor, &packet, 0, false);
+
+    // execute lz_compose
+    lz_compose(&env, &chain_b, &executor, &packet, 0);
+
+    // state assertion
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_b.counter.composed_count(), 1);
+}
+
+#[test]
+fn test_increment_composed_aba() {
+    let TestSetup { env, chain_a, chain_b } = setup();
+
+    wire_endpoint(&env, &[&chain_a, &chain_b]);
+    wire_counter(&env, &[&chain_a, &chain_b]);
+
+    // on Chain A, quote and increment
+    let sender = Address::generate(&env);
+    let msg_type = MsgType::ComposedABA;
+    let options = Bytes::new(&env);
+
+    let fee = quote(&chain_a, chain_b.eid, msg_type, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee);
+
+    // validate packet on Chain B
+    let packet_event_chain_a = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    validate_packet(&env, &chain_b, &packet_event_chain_a);
+    let packet_chain_a = decode_packet(&env, &packet_event_chain_a.0);
+
+    // deliver the message on Chain B and execute lz_receive
+    let executor = Address::generate(&env);
+    lz_receive(&env, &chain_b, &executor, &packet_chain_a, 0, false);
+    // supply native token for lz_send(inside lz_compose) on Chain B
+    mint_to(&env, &chain_b.owner, &chain_b.native_token, &executor, fee.native_fee);
+    approve(&env, &executor, &chain_b.native_token, fee.native_fee);
+    lz_compose(&env, &chain_b, &executor, &packet_chain_a, fee.native_fee);
+
+    // validate packet on Chain A(packet emitted on Chain B)
+    let packet_event_chain_b = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
+    validate_packet(&env, &chain_a, &packet_event_chain_b);
+    let packet_chain_b = decode_packet(&env, &packet_event_chain_b.0);
+
+    // deliver the message on Chain A and execute lz_receive
+    lz_receive(&env, &chain_a, &executor, &packet_chain_b, 0, false);
+
+    // state assertion
+    assert_eq!(chain_a.counter.count(), 1);
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_a.counter.inbound_count(&chain_b.eid), 1);
+
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_b.counter.outbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_b.counter.composed_count(), 1);
+}

package/contracts/oapps/counter/integration_tests/utils.rs

@@ -0,0 +1,144 @@
+use crate::{
+    codec::MsgType,
+    integration_tests::setup::{decode_packet, ChainSetup},
+};
+use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    testutils::{Events, MockAuth, MockAuthInvoke},
+    Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val,
+};
+
+/// Helper to extract BytesN<32> payload from an Address
+pub fn address_to_bytes32(address: &Address) -> BytesN<32> {
+    match address.to_payload().unwrap() {
+        AddressPayload::AccountIdPublicKeyEd25519(payload) => payload,
+        AddressPayload::ContractIdHash(payload) => payload,
+    }
+}
+
+pub fn quote(chain: &ChainSetup<'_>, dst_eid: u32, msg_type: MsgType, options: &Bytes) -> MessagingFee {
+    chain.counter.quote(&dst_eid, &(msg_type as u32), options, &false)
+}
+
+pub fn increment(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    dst_eid: u32,
+    msg_type: MsgType,
+    options: &Bytes,
+    fee: &MessagingFee,
+) {
+    let msg_type = msg_type as u32;
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.counter.address,
+            fn_name: "increment",
+            args: (sender, &dst_eid, &msg_type, options, fee).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: &[],
+            }],
+        },
+    }]);
+    chain.counter.increment(sender, &dst_eid, &msg_type, options, fee);
+}
+
+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: (&chain.owner, &encoded_header, &payload_hash).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.sml.validate_packet(&chain.owner, &encoded_header, &payload_hash);
+}
+
+pub fn lz_receive(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    executor: &Address,
+    packet: &OutboundPacket,
+    value: i128,
+    _aba: bool,
+) {
+    let origin = Origin { src_eid: packet.src_eid, sender: address_to_bytes32(&packet.sender), nonce: packet.nonce };
+
+    let sub_invokes_with_transfer = [MockAuthInvoke {
+        contract: &chain.native_token,
+        fn_name: "transfer_from",
+        args: (executor, executor, &chain.counter.address, &value).into_val(env),
+        sub_invokes: &[],
+    }];
+
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.counter.address,
+            fn_name: "lz_receive",
+            args: (executor, &origin, &packet.guid, &packet.message, &Bytes::new(env), &value).into_val(env),
+            sub_invokes: if value > 0 { &sub_invokes_with_transfer } else { &[] },
+        },
+    }]);
+    chain.counter.lz_receive(executor, &origin, &packet.guid, &packet.message, &Bytes::new(env), &value);
+}
+
+pub fn lz_compose(env: &Env, chain: &ChainSetup<'_>, executor: &Address, packet: &OutboundPacket, value: i128) {
+    let sub_invokes_with_transfer = [MockAuthInvoke {
+        contract: &chain.native_token,
+        fn_name: "transfer_from",
+        args: (executor, executor, &chain.counter.address, &value).into_val(env),
+        sub_invokes: &[],
+    }];
+
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.counter.address,
+            fn_name: "lz_compose",
+            args: (executor, &chain.counter.address, &packet.guid, &0_u32, &packet.message, &Bytes::new(env), &value)
+                .into_val(env),
+            sub_invokes: if value > 0 { &sub_invokes_with_transfer } else { &[] },
+        },
+    }]);
+    chain.counter.lz_compose(
+        executor,
+        &chain.counter.address,
+        &packet.guid,
+        &0,
+        &packet.message,
+        &Bytes::new(env),
+        &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
+}

package/contracts/oapps/counter/src/codec.rs

@@ -0,0 +1,63 @@
+use soroban_sdk::{Bytes, Env, U256};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum MsgType {
+    Vanilla = 1,
+    Composed = 2,
+    #[allow(clippy::upper_case_acronyms)]
+    ABA = 3,
+    ComposedABA = 4,
+}
+
+impl From<u8> for MsgType {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => MsgType::Vanilla,
+            2 => MsgType::Composed,
+            3 => MsgType::ABA,
+            4 => MsgType::ComposedABA,
+            _ => panic!("invalid msg type"),
+        }
+    }
+}
+
+pub const _MSG_TYPE_OFFSET: u8 = 0;
+pub const SRC_EID_OFFSET: u8 = 1;
+pub const VALUE_OFFSET: u8 = 5;
+
+pub fn encode(env: &Env, msg_type: MsgType, src_eid: u32) -> Bytes {
+    let msg_type: u8 = msg_type as u8;
+
+    let mut data = Bytes::new(env);
+    data.extend_from_array(&msg_type.to_be_bytes());
+    data.extend_from_array(&src_eid.to_be_bytes());
+
+    data
+}
+
+pub fn encode_with_value(env: &Env, msg_type: MsgType, src_eid: u32, value: U256) -> Bytes {
+    let mut data = encode(env, msg_type, src_eid);
+    data.append(&value.to_be_bytes());
+
+    data
+}
+
+pub fn msg_type(data: &Bytes) -> MsgType {
+    data.get(0).unwrap_or_else(|| panic!("cannot get msg type")).into()
+}
+
+pub fn src_eid(data: &Bytes) -> u32 {
+    let mut src_eid_bytes = [0u8; 4];
+    data.slice((SRC_EID_OFFSET as u32)..(VALUE_OFFSET as u32)).copy_into_slice(&mut src_eid_bytes);
+    u32::from_be_bytes(src_eid_bytes)
+}
+
+pub fn value(env: &Env, data: &Bytes) -> U256 {
+    let slice = data.slice((VALUE_OFFSET as u32)..data.len());
+    if slice.is_empty() {
+        U256::from_u32(env, 0)
+    } else {
+        U256::from_be_bytes(env, &slice)
+    }
+}