@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/message-libs/message-lib-common/src/tests/packet_codec_v1/encode_packet.rs

@@ -0,0 +1,58 @@
+use super::test_helper::*;
+use crate::packet_codec_v1::{encode_packet, encode_packet_header, HEADER_LENGTH};
+use soroban_sdk::{Bytes, BytesN, Env};
+use utils::buffer_reader::BufferReader;
+
+#[test]
+fn test_encode_packet_layout_and_length() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet(&env);
+
+    // Layout: [header (81)] + [guid (32)] + [message (variable)].
+
+    let encoded = encode_packet(&env, &packet);
+    assert_eq!(encoded.len(), HEADER_LENGTH + 32 + packet.message.len());
+
+    let mut reader = BufferReader::new(&encoded);
+    let encoded_header: Bytes = reader.read_bytes(HEADER_LENGTH);
+    let encoded_guid: BytesN<32> = reader.read_bytes_n();
+    let encoded_message: Bytes = reader.read_bytes_until_end();
+
+    assert_eq!(encoded_header, encode_packet_header(&env, &packet));
+    assert_eq!(encoded_guid, packet.guid);
+    assert_eq!(encoded_message, packet.message);
+}
+
+#[test]
+fn test_encode_packet_supports_empty_message() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet_with_message(&env, Bytes::new(&env));
+
+    let encoded = encode_packet(&env, &packet);
+    let (header, guid, message) = decode_packet_for_test(&env, &encoded);
+
+    assert_eq!(header.src_eid, TEST_SRC_EID);
+    assert_eq!(guid, packet.guid);
+    assert_eq!(message.len(), 0);
+}
+
+#[test]
+fn test_encode_packet_supports_large_message() {
+    let env = Env::default();
+
+    // 1KB message.
+    let mut large_msg_array = [0u8; 1024];
+    for (i, byte) in large_msg_array.iter_mut().enumerate() {
+        *byte = (i % 256) as u8;
+    }
+
+    let large_message = Bytes::from_slice(&env, &large_msg_array);
+    let packet = create_test_outbound_packet_with_message(&env, large_message.clone());
+
+    let encoded = encode_packet(&env, &packet);
+    let (header, guid, message) = decode_packet_for_test(&env, &encoded);
+
+    assert_eq!(header.src_eid, TEST_SRC_EID);
+    assert_eq!(guid, packet.guid);
+    assert_eq!(message, large_message);
+}

package/contracts/message-libs/message-lib-common/src/tests/packet_codec_v1/encode_packet_header.rs

@@ -0,0 +1,138 @@
+use super::test_helper::*;
+use crate::packet_codec_v1::{decode_packet_header, encode_packet_header, HEADER_LENGTH, PACKET_VERSION};
+use endpoint_v2::{util::compute_guid, OutboundPacket};
+use soroban_sdk::{address_payload::AddressPayload, Address, Bytes, BytesN, Env};
+
+#[test]
+fn test_encode_packet_header_has_expected_length_and_byte_layout() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet(&env);
+
+    // Validate the byte layout (offsets + endianness).
+
+    let encoded = encode_packet_header(&env, &packet);
+    assert_eq!(encoded.len(), HEADER_LENGTH);
+
+    // Offsets:
+    // [0] version
+    // [1..9] nonce (u64 BE)
+    // [9..13] src_eid (u32 BE)
+    // [13..45] sender (32)
+    // [45..49] dst_eid (u32 BE)
+    // [49..81] receiver (32)
+
+    assert_eq!(encoded.get(0).unwrap(), PACKET_VERSION);
+
+    let nonce_bytes = encoded.slice(1..9);
+    assert_eq!(nonce_bytes, Bytes::from_slice(&env, &TEST_NONCE.to_be_bytes()));
+
+    let src_eid_bytes = encoded.slice(9..13);
+    assert_eq!(src_eid_bytes, Bytes::from_slice(&env, &TEST_SRC_EID.to_be_bytes()));
+
+    let sender_bytes = encoded.slice(13..45);
+    assert_eq!(sender_bytes, Bytes::from_slice(&env, &TEST_SENDER_BYTES));
+
+    let dst_eid_bytes = encoded.slice(45..49);
+    assert_eq!(dst_eid_bytes, Bytes::from_slice(&env, &TEST_DST_EID.to_be_bytes()));
+
+    let receiver_bytes = encoded.slice(49..81);
+    assert_eq!(receiver_bytes, Bytes::from_slice(&env, &TEST_RECEIVER_BYTES));
+}
+
+#[test]
+fn test_encode_packet_header_roundtrips_through_decode_packet_header() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet(&env);
+
+    let encoded_header = encode_packet_header(&env, &packet);
+    let decoded_header = decode_packet_header(&env, &encoded_header);
+
+    assert_eq!(decoded_header.version, PACKET_VERSION);
+    assert_eq!(decoded_header.nonce, TEST_NONCE);
+    assert_eq!(decoded_header.src_eid, TEST_SRC_EID);
+    assert_eq!(decoded_header.dst_eid, TEST_DST_EID);
+    assert_eq!(decoded_header.sender, BytesN::from_array(&env, &TEST_SENDER_BYTES));
+    assert_eq!(decoded_header.receiver, BytesN::from_array(&env, &TEST_RECEIVER_BYTES));
+}
+
+#[test]
+fn test_encode_packet_header_sender_account_address_writes_payload_only() {
+    let env = Env::default();
+
+    let account_pk: [u8; 32] = [0xA5; 32];
+    let sender =
+        Address::from_payload(&env, AddressPayload::AccountIdPublicKeyEd25519(BytesN::from_array(&env, &account_pk)));
+
+    let receiver = BytesN::from_array(&env, &TEST_RECEIVER_BYTES);
+    let guid = compute_guid(&env, TEST_NONCE, TEST_SRC_EID, &sender, TEST_DST_EID, &receiver);
+
+    let packet = OutboundPacket {
+        nonce: TEST_NONCE,
+        src_eid: TEST_SRC_EID,
+        sender,
+        dst_eid: TEST_DST_EID,
+        receiver,
+        guid,
+        message: Bytes::new(&env),
+    };
+
+    let encoded = encode_packet_header(&env, &packet);
+    assert_eq!(encoded.len(), HEADER_LENGTH);
+    assert_eq!(encoded.get(0).unwrap(), PACKET_VERSION);
+
+    // Sender field is [13..45] and must contain only the 32-byte payload (no type byte).
+    let sender_bytes = encoded.slice(13..45);
+    assert_eq!(sender_bytes, Bytes::from_slice(&env, &account_pk));
+
+    // Roundtrip sanity.
+    let decoded = decode_packet_header(&env, &encoded);
+    assert_eq!(decoded.sender, BytesN::from_array(&env, &account_pk));
+}
+
+#[test]
+fn test_encode_packet_header_ignores_guid_and_message() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet(&env);
+
+    let different_packet = OutboundPacket {
+        nonce: packet.nonce,
+        src_eid: packet.src_eid,
+        sender: packet.sender.clone(),
+        dst_eid: packet.dst_eid,
+        receiver: packet.receiver.clone(),
+        guid: BytesN::from_array(&env, &[0xAB; 32]),
+        message: Bytes::from_array(&env, &[0xDE, 0xAD, 0xBE, 0xEF]),
+    };
+
+    assert_eq!(encode_packet_header(&env, &packet), encode_packet_header(&env, &different_packet));
+}
+
+#[test]
+fn test_encode_packet_header_numeric_boundaries_are_big_endian() {
+    let env = Env::default();
+
+    // Reuse the same sender/receiver shapes as other tests (contract sender).
+    let sender =
+        Address::from_payload(&env, AddressPayload::ContractIdHash(BytesN::from_array(&env, &TEST_SENDER_BYTES)));
+    let receiver = BytesN::from_array(&env, &TEST_RECEIVER_BYTES);
+
+    for (nonce, src_eid, dst_eid) in [(0u64, 0u32, 0u32), (u64::MAX, u32::MAX, u32::MAX)] {
+        let guid = compute_guid(&env, nonce, src_eid, &sender, dst_eid, &receiver);
+        let packet = OutboundPacket {
+            nonce,
+            src_eid,
+            sender: sender.clone(),
+            dst_eid,
+            receiver: receiver.clone(),
+            guid,
+            message: Bytes::new(&env),
+        };
+
+        let encoded = encode_packet_header(&env, &packet);
+        assert_eq!(encoded.get(0).unwrap(), PACKET_VERSION);
+
+        assert_eq!(encoded.slice(1..9), Bytes::from_slice(&env, &nonce.to_be_bytes()));
+        assert_eq!(encoded.slice(9..13), Bytes::from_slice(&env, &src_eid.to_be_bytes()));
+        assert_eq!(encoded.slice(45..49), Bytes::from_slice(&env, &dst_eid.to_be_bytes()));
+    }
+}

package/contracts/message-libs/message-lib-common/src/tests/packet_codec_v1/mod.rs

@@ -0,0 +1,6 @@
+mod decode_packet_header;
+mod encode_packet;
+mod encode_packet_header;
+mod payload;
+mod payload_hash;
+mod test_helper;

package/contracts/message-libs/message-lib-common/src/tests/packet_codec_v1/payload.rs

@@ -0,0 +1,30 @@
+use super::test_helper::*;
+use crate::packet_codec_v1::payload;
+use soroban_sdk::{Bytes, Env};
+
+#[test]
+fn test_payload_is_guid_plus_message() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet(&env);
+
+    // - payload(...) returns guid + message
+    let payload_result = payload(&env, &packet);
+
+    let mut expected = Bytes::new(&env);
+    expected.extend_from_array(&packet.guid.to_array());
+    expected.append(&packet.message);
+
+    assert_eq!(payload_result, expected);
+}
+
+#[test]
+fn test_payload_supports_empty_message() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet_with_message(&env, Bytes::new(&env));
+
+    let payload_result = payload(&env, &packet);
+
+    let mut expected = Bytes::new(&env);
+    expected.extend_from_array(&packet.guid.to_array());
+    assert_eq!(payload_result, expected);
+}

package/contracts/message-libs/message-lib-common/src/tests/packet_codec_v1/payload_hash.rs

@@ -0,0 +1,15 @@
+use super::test_helper::*;
+use crate::packet_codec_v1::{payload, payload_hash};
+use endpoint_v2::util::keccak256;
+use soroban_sdk::Env;
+
+#[test]
+fn test_payload_hash_matches_keccak256_of_payload() {
+    let env = Env::default();
+    let packet = create_test_outbound_packet(&env);
+
+    let payload_bytes = payload(&env, &packet);
+    let expected = keccak256(&env, &payload_bytes);
+
+    assert_eq!(payload_hash(&env, &packet), expected);
+}

package/contracts/message-libs/message-lib-common/src/tests/packet_codec_v1/test_helper.rs

@@ -0,0 +1,39 @@
+// Shared constants and helpers for packet_codec_v1 tests.
+
+use crate::packet_codec_v1::{decode_packet_header, PacketHeader, HEADER_LENGTH};
+use endpoint_v2::{util::compute_guid, OutboundPacket};
+use soroban_sdk::{address_payload::AddressPayload, Address, Bytes, BytesN, Env};
+use utils::buffer_reader::BufferReader;
+
+pub(super) const TEST_SRC_EID: u32 = 101;
+pub(super) const TEST_DST_EID: u32 = 102;
+pub(super) const TEST_NONCE: u64 = 0x123456789abcdef0;
+pub(super) const TEST_MESSAGE: [u8; 5] = hex_literal::hex!("0102030405");
+
+// @0x1234567890abcdef1234567890abcdef12345678 padded to 32 bytes
+pub(super) const TEST_SENDER_BYTES: [u8; 32] =
+    hex_literal::hex!("0000000000000000000000001234567890abcdef1234567890abcdef12345678");
+
+// @0x9876543210fedcba9876543210fedcba98765432 padded to 32 bytes
+pub(super) const TEST_RECEIVER_BYTES: [u8; 32] =
+    hex_literal::hex!("0000000000000000000000009876543210fedcba9876543210fedcba98765432");
+
+pub(super) fn create_test_outbound_packet(env: &Env) -> OutboundPacket {
+    create_test_outbound_packet_with_message(env, Bytes::from_array(env, &TEST_MESSAGE))
+}
+
+pub(super) fn create_test_outbound_packet_with_message(env: &Env, message: Bytes) -> OutboundPacket {
+    let sender =
+        Address::from_payload(env, AddressPayload::ContractIdHash(BytesN::from_array(env, &TEST_SENDER_BYTES)));
+    let receiver = BytesN::from_array(env, &TEST_RECEIVER_BYTES);
+    let guid = compute_guid(env, TEST_NONCE, TEST_SRC_EID, &sender, TEST_DST_EID, &receiver);
+    OutboundPacket { nonce: TEST_NONCE, src_eid: TEST_SRC_EID, sender, dst_eid: TEST_DST_EID, receiver, guid, message }
+}
+
+pub(super) fn decode_packet_for_test(env: &Env, encoded: &Bytes) -> (PacketHeader, BytesN<32>, Bytes) {
+    let mut reader = BufferReader::new(encoded);
+    let header = decode_packet_header(env, &reader.read_bytes(HEADER_LENGTH));
+    let guid = reader.read_bytes_n();
+    let message = reader.read_bytes_until_end();
+    (header, guid, message)
+}

package/contracts/message-libs/message-lib-common/src/tests/worker_options/append_dvn_option.rs

@@ -0,0 +1,57 @@
+use crate::worker_options::test;
+use hex_literal::hex;
+use soroban_sdk::{Bytes, Env};
+
+#[test]
+fn test_append_dvn_option_creates_new_entries_for_different_dvn_idx() {
+    let env = Env::default();
+    let mut dvn_options = soroban_sdk::map![&env];
+
+    // dvn_idx=0
+    let option_idx_0 = Bytes::from_slice(&env, &hex!("0200020001"));
+    // dvn_idx=2
+    let option_idx_2 = Bytes::from_slice(&env, &hex!("0200020201"));
+
+    test::append_dvn_option_for_test(&env, &mut dvn_options, option_idx_0);
+    test::append_dvn_option_for_test(&env, &mut dvn_options, option_idx_2);
+
+    assert_eq!(dvn_options.len(), 2);
+    assert!(dvn_options.get(0).is_some());
+    assert!(dvn_options.get(2).is_some());
+}
+
+#[test]
+fn test_append_dvn_option_groups_and_appends_same_dvn_idx() {
+    let env = Env::default();
+    let mut dvn_options = soroban_sdk::map![&env];
+
+    // Multiple DVN options with the same dvn_idx=0 should be concatenated
+    // in encounter order.
+    let option_1 = Bytes::from_slice(&env, &hex!("0200020001"));
+    let option_2 = Bytes::from_slice(&env, &hex!("0200020002"));
+    let option_3 = Bytes::from_slice(&env, &hex!("02000200ff"));
+
+    test::append_dvn_option_for_test(&env, &mut dvn_options, option_1.clone());
+    test::append_dvn_option_for_test(&env, &mut dvn_options, option_2.clone());
+    test::append_dvn_option_for_test(&env, &mut dvn_options, option_3.clone());
+
+    assert_eq!(dvn_options.len(), 1);
+
+    let mut expected = option_1;
+    expected.append(&option_2);
+    expected.append(&option_3);
+    assert_eq!(dvn_options.get(0).unwrap(), expected);
+}
+
+#[test]
+fn test_append_dvn_option_supports_dvn_idx_255() {
+    let env = Env::default();
+    let mut dvn_options = soroban_sdk::map![&env];
+
+    // Minimal DVN option with option_size=1 (only dvn_idx), dvn_idx=255.
+    let option_idx_255 = Bytes::from_slice(&env, &hex!("020001ff"));
+    test::append_dvn_option_for_test(&env, &mut dvn_options, option_idx_255.clone());
+
+    assert_eq!(dvn_options.len(), 1);
+    assert_eq!(dvn_options.get(255).unwrap(), option_idx_255);
+}

package/contracts/message-libs/message-lib-common/src/tests/worker_options/append_lz_receive_option.rs

@@ -0,0 +1,49 @@
+use crate::worker_options::{test, *};
+use hex_literal::hex;
+use soroban_sdk::{Bytes, Env};
+use utils::buffer_reader::BufferReader;
+
+#[test]
+fn test_append_lz_receive_option_encodes_expected_layout() {
+    let env = Env::default();
+
+    let executor_option = test::append_lz_receive_option_for_test(&env, 200_000);
+    let mut reader = BufferReader::new(&executor_option);
+
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 17); // option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE); // option_type
+    assert_eq!(reader.read_u128(), 200_000); // execution gas
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_append_lz_receive_option_zero_gas_matches_expected_bytes() {
+    let env = Env::default();
+
+    let actual = test::append_lz_receive_option_for_test(&env, 0);
+    let expected = Bytes::from_slice(&env, &hex!("0100110100000000000000000000000000000000"));
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_append_lz_receive_option_u128_max_gas_matches_expected_bytes() {
+    let env = Env::default();
+
+    let actual = test::append_lz_receive_option_for_test(&env, u128::MAX);
+    let expected = Bytes::from_slice(&env, &hex!("01001101ffffffffffffffffffffffffffffffff"));
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_append_lz_receive_option_encodes_gas_big_endian() {
+    let env = Env::default();
+
+    // Use a non-symmetric value so endianness mistakes are obvious.
+    let execution_gas: u128 = 0x0102030405060708090a0b0c0d0e0f10;
+    let actual = test::append_lz_receive_option_for_test(&env, execution_gas);
+
+    // [worker_id=01][option_size=0011][option_type=01][gas(16 bytes, big-endian)]
+    let expected = Bytes::from_slice(&env, &hex!("010011010102030405060708090a0b0c0d0e0f10"));
+    assert_eq!(actual, expected);
+}

package/contracts/message-libs/message-lib-common/src/tests/worker_options/append_native_drop_option.rs

@@ -0,0 +1,73 @@
+use crate::worker_options::{test, *};
+use hex_literal::hex;
+use soroban_sdk::{Bytes, BytesN, Env};
+use utils::buffer_reader::BufferReader;
+
+#[test]
+fn test_append_native_drop_option_encodes_expected_layout() {
+    let env = Env::default();
+
+    let receiver = BytesN::from_array(&env, &hex!("000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
+    let executor_option = test::append_native_drop_option_for_test(&env, 10_000_000, &receiver);
+    let mut reader = BufferReader::new(&executor_option);
+
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 49); // option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP); // option_type
+    assert_eq!(reader.read_u128(), 10_000_000); // amount
+    assert_eq!(reader.read_bytes_n(), receiver); // receiver
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_append_native_drop_option_zero_amount_and_zero_receiver_matches_expected_bytes() {
+    let env = Env::default();
+
+    let receiver = BytesN::from_array(&env, &[0u8; 32]);
+    let actual = test::append_native_drop_option_for_test(&env, 0, &receiver);
+
+    let mut expected = Bytes::new(&env);
+    expected.extend_from_slice(&[EXECUTOR_WORKER_ID]);
+    expected.extend_from_slice(&49u16.to_be_bytes());
+    expected.extend_from_slice(&[EXECUTOR_OPTION_TYPE_NATIVE_DROP]);
+    expected.extend_from_slice(&0u128.to_be_bytes());
+    expected.extend_from_slice(&[0u8; 32]);
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_append_native_drop_option_u128_max_amount_matches_expected_bytes() {
+    let env = Env::default();
+
+    let receiver = BytesN::from_array(&env, &[0x11u8; 32]);
+    let actual = test::append_native_drop_option_for_test(&env, u128::MAX, &receiver);
+
+    let mut expected = Bytes::new(&env);
+    expected.extend_from_slice(&[EXECUTOR_WORKER_ID]);
+    expected.extend_from_slice(&49u16.to_be_bytes());
+    expected.extend_from_slice(&[EXECUTOR_OPTION_TYPE_NATIVE_DROP]);
+    expected.extend_from_slice(&u128::MAX.to_be_bytes());
+    expected.extend_from_slice(&[0x11u8; 32]);
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_append_native_drop_option_encodes_amount_big_endian() {
+    let env = Env::default();
+
+    // Use a non-symmetric value so endianness mistakes are obvious.
+    let amount: u128 = 0x0102030405060708090a0b0c0d0e0f10;
+    let receiver = BytesN::from_array(&env, &[0u8; 32]);
+    let actual = test::append_native_drop_option_for_test(&env, amount, &receiver);
+
+    // [worker_id=01][option_size=0031][option_type=02][amount(16 bytes, big-endian)][receiver(32 bytes)]
+    let expected = Bytes::from_slice(
+        &env,
+        &hex!(
+            "01003102\
+             0102030405060708090a0b0c0d0e0f10\
+             0000000000000000000000000000000000000000000000000000000000000000"
+        ),
+    );
+    assert_eq!(actual, expected);
+}