@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/src/workers/price_feed/structs.cairo

@@ -0,0 +1,74 @@
+//! Price feed structs
+
+/// Fee estimate
+#[derive(Drop, Serde, Default, PartialEq, Debug)]
+pub struct FeeEstimate {
+    pub gas_fee: u256,
+    pub price_ratio: u128,
+}
+
+/// Response for a fee estimation
+#[derive(Drop, Serde, Default, PartialEq, Debug)]
+pub struct GetFeeResponse {
+    pub gas_fee: u256,
+    pub price_ratio: u128,
+    pub price_ratio_denominator: u128,
+    pub native_price_usd: u128,
+}
+
+/// Price for a given EID
+#[derive(Drop, Serde, starknet::Store, Default, PartialEq, Clone, Debug)]
+pub struct Price {
+    /// Conversion multiplier used to translate the destination chain's native token value
+    /// into the source chain's native token units.
+    ///
+    /// This is a fixed-point number encoded as a `u128`, where the float value is scaled
+    /// by 10^20 for precision (i.e., 1.0 = 10^20).
+    ///
+    /// The `price_ratio` incorporates two factors:
+    ///   1. Decimal normalization between destination and source tokens.
+    ///   2. The actual relative price (exchange rate) between the two tokens.
+    ///
+    /// For example, if the source is an EVM chain (18 decimals) and the destination is Aptos (8
+    /// decimals), with a 1:1 token price, the base multiplier would be (10^18 / 10^8) = 10^10.
+    /// To represent this in fixed-point form, you multiply by 10^20, giving a `price_ratio` of
+    /// 10^30.
+    ///
+    /// In real usage, `price_ratio` reflects both decimal scaling and fluctuating market prices.
+    pub price_ratio: u128,
+    pub gas_price_in_unit: u64, // for evm, it is in wei, for aptos, it is in octas.
+    pub gas_per_byte: u32,
+}
+
+#[derive(Drop, Serde, Default, PartialEq)]
+pub struct SetEidToModelTypeParam {
+    pub eid: u32,
+    pub model_type: ModelType,
+}
+
+#[derive(Drop, Serde, Default, PartialEq)]
+pub struct SetPriceParam {
+    pub eid: u32,
+    pub price: Price,
+}
+
+#[derive(Drop, Serde, starknet::Store, Default, PartialEq, Clone, Debug)]
+pub struct ArbitrumPriceExt {
+    pub gas_per_l2_tx: u64,
+    pub gas_per_l1_call_data_byte: u32,
+}
+
+#[derive(Drop, Serde, Default, PartialEq, Clone)]
+pub struct UpdatePriceExt {
+    pub eid: u32,
+    pub price: Price,
+    pub extend: ArbitrumPriceExt,
+}
+
+#[derive(Drop, Serde, starknet::Store, Default, PartialEq, Debug)]
+pub enum ModelType {
+    #[default]
+    DEFAULT,
+    OP_STACK,
+    ARB_STACK,
+}

package/layerzero/tests/common/test_constants.cairo

@@ -0,0 +1,21 @@
+use layerzero::endpoint::constants::{EMPTY_PAYLOAD_HASH, NIL_PAYLOAD_HASH};
+use layerzero::message_lib::uln::ultra_light_node::UltraLightNode::EMPTY_VERIFICATION;
+use lz_utils::bytes::Bytes32;
+
+#[test]
+fn empty_payload_hash_should_be_default() {
+    assert(EMPTY_PAYLOAD_HASH == Default::default(), 'Empty payload hash should be 0');
+}
+
+#[test]
+fn nil_payload_hash_should_be_max_u256() {
+    assert(
+        NIL_PAYLOAD_HASH == Bytes32 { value: core::num::traits::Bounded::<u256>::MAX },
+        'Nil payload hash != max u256',
+    );
+}
+
+#[test]
+fn empty_verification_should_be_default() {
+    assert(EMPTY_VERIFICATION == Default::default(), 'Empty verification should be 0');
+}

package/layerzero/tests/common/test_guid.cairo

@@ -0,0 +1,232 @@
+//! GUID generation tests
+
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+use core::num::traits::Bounded;
+use layerzero::common::guid::GUID;
+use lz_utils::bytes::Bytes32;
+use lz_utils::keccak::keccak256;
+
+// Test constants
+pub const MAX_U64: u64 = Bounded::MAX;
+pub const MAX_U32: u32 = Bounded::MAX;
+pub const MAX_U256: u256 = Bounded::MAX;
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_generate_deterministic_guid(
+    nonce: u64, src_eid: u32, sender_value: u256, dst_eid: u32, receiver_value: u256,
+) {
+    let sender = Bytes32 { value: sender_value };
+    let receiver = Bytes32 { value: receiver_value };
+
+    let guid1 = GUID::generate(nonce, src_eid, sender, dst_eid, receiver);
+    let guid2 = GUID::generate(nonce, src_eid, sender, dst_eid, receiver);
+
+    // Same inputs should produce same GUID
+    assert(guid1.value == guid2.value, 'GUID should be deterministic');
+    // GUID should not be zero (extremely unlikely with keccak256)
+    assert(guid1.value != 0, 'GUID should not be zero');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_generate_different_guid_for_different_nonces(
+    nonce_1: u64,
+    nonce_2: u64,
+    src_eid: u32,
+    sender_value: u256,
+    dst_eid: u32,
+    receiver_value: u256,
+) {
+    // Ensure the nonces are different
+    // Same nonces are tested in should_generate_deterministic_guid
+    if nonce_1 == nonce_2 {
+        return;
+    }
+
+    let sender = Bytes32 { value: sender_value };
+    let receiver = Bytes32 { value: receiver_value };
+
+    let guid_1 = GUID::generate(nonce_1, src_eid, sender, dst_eid, receiver);
+    let guid_2 = GUID::generate(nonce_2, src_eid, sender, dst_eid, receiver);
+
+    assert(guid_1.value != guid_2.value, 'Different nonces should change');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_generate_different_guid_for_different_src_eid(
+    nonce: u64,
+    src_eid_1: u32,
+    src_eid_2: u32,
+    sender_value: u256,
+    dst_eid: u32,
+    receiver_value: u256,
+) {
+    // Ensure the src_eids are different
+    // Same src_eid are tested in should_generate_deterministic_guid
+    if src_eid_1 == src_eid_2 {
+        return;
+    }
+
+    let sender = Bytes32 { value: sender_value };
+    let receiver = Bytes32 { value: receiver_value };
+
+    let guid_1 = GUID::generate(nonce, src_eid_1, sender, dst_eid, receiver);
+    let guid_2 = GUID::generate(nonce, src_eid_2, sender, dst_eid, receiver);
+
+    assert(guid_1.value != guid_2.value, 'Different src_eid should change');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_generate_different_guid_for_different_sender(
+    nonce: u64, src_eid: u32, sender_1: u256, sender_2: u256, dst_eid: u32, receiver_value: u256,
+) {
+    // Ensure the senders are different
+    // Same sender are tested in should_generate_deterministic_guid
+    if sender_1 == sender_2 {
+        return;
+    }
+
+    let sender_1 = Bytes32 { value: sender_1 };
+    let sender_2 = Bytes32 { value: sender_2 };
+    let receiver = Bytes32 { value: receiver_value };
+
+    let guid_1 = GUID::generate(nonce, src_eid, sender_1, dst_eid, receiver);
+    let guid_2 = GUID::generate(nonce, src_eid, sender_2, dst_eid, receiver);
+
+    assert(guid_1.value != guid_2.value, 'Different sender should change');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_generate_different_guid_for_different_dst_eid(
+    nonce: u64,
+    src_eid: u32,
+    sender_value: u256,
+    dst_eid_1: u32,
+    dst_eid_2: u32,
+    receiver_value: u256,
+) {
+    // Ensure the dst_eids are different
+    // Same dst_eid are tested in should_generate_deterministic_guid
+    if dst_eid_1 == dst_eid_2 {
+        return;
+    }
+
+    let sender = Bytes32 { value: sender_value };
+    let receiver = Bytes32 { value: receiver_value };
+
+    let guid_1 = GUID::generate(nonce, src_eid, sender, dst_eid_1, receiver);
+    let guid_2 = GUID::generate(nonce, src_eid, sender, dst_eid_2, receiver);
+
+    assert(guid_1.value != guid_2.value, 'Different dst_eid should change');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_generate_different_guid_for_different_receiver(
+    nonce: u64, src_eid: u32, sender_value: u256, dst_eid: u32, receiver_1: u256, receiver_2: u256,
+) {
+    // Ensure the receivers are different
+    // Same receiver are tested in should_generate_deterministic_guid
+    if receiver_1 == receiver_2 {
+        return;
+    }
+
+    let sender = Bytes32 { value: sender_value };
+    let receiver_1 = Bytes32 { value: receiver_1 };
+    let receiver_2 = Bytes32 { value: receiver_2 };
+
+    let guid_1 = GUID::generate(nonce, src_eid, sender, dst_eid, receiver_1);
+    let guid_2 = GUID::generate(nonce, src_eid, sender, dst_eid, receiver_2);
+
+    assert_ne!(guid_1.value, guid_2.value, "Different receivers should change");
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_match_manual_hash_calculation(
+    nonce: u64, src_eid: u32, sender_value: u256, dst_eid: u32, receiver_value: u256,
+) {
+    let sender = Bytes32 { value: sender_value };
+    let receiver = Bytes32 { value: receiver_value };
+
+    let guid = GUID::generate(nonce, src_eid, sender, dst_eid, receiver);
+
+    // Manually construct the expected ByteArray and hash it
+    let mut expected_bytes: ByteArray = Default::default();
+    expected_bytes.append_u64(nonce);
+    expected_bytes.append_u32(src_eid);
+    expected_bytes.append_u256(sender.value);
+    expected_bytes.append_u32(dst_eid);
+    expected_bytes.append_u256(receiver.value);
+
+    let expected_guid = keccak256(@expected_bytes);
+
+    assert(guid.value == expected_guid.value, 'GUID should match manual');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_have_collision_resistance(
+    nonce: u64, src_eid: u32, sender_value: u256, dst_eid: u32, receiver_value: u256,
+) {
+    let sender = Bytes32 { value: sender_value };
+    let receiver1 = Bytes32 { value: receiver_value };
+    let receiver2 = Bytes32 { value: receiver_value + 1 };
+
+    let guid1 = GUID::generate(nonce, src_eid, sender, dst_eid, receiver1);
+    let guid2 = GUID::generate(nonce, src_eid, sender, dst_eid, receiver2);
+
+    // Verify the GUIDs are different (collision resistance)
+    assert(guid1.value != guid2.value, 'Should be different');
+
+    // Verify the difference is significant (not just a small bit flip)
+    let xor_diff = guid1.value ^ guid2.value;
+    assert(xor_diff != 0, 'Should be different');
+}
+
+#[test]
+fn should_generate_guid_with_zero_values() {
+    let guid = GUID::generate(0, 0, Bytes32 { value: 0 }, 0, Bytes32 { value: 0 });
+    // Even zero inputs should produce non-zero GUID due to keccak256 properties
+    assert(guid.value != 0, 'Should be different');
+}
+
+#[test]
+fn should_generate_guid_with_max_values() {
+    let max_bytes = Bytes32 { value: MAX_U256 };
+
+    let guid = GUID::generate(MAX_U64, MAX_U32, max_bytes, MAX_U32, max_bytes);
+    assert(guid.value != 0, 'Should be different');
+}
+
+#[test]
+fn should_generate_realistic_layerzero_guid() {
+    const REALISTIC_NONCE: u64 = 987654321;
+    const ETHEREUM_EID: u32 = 30101;
+    const ARBITRUM_EID: u32 = 30110;
+    const MOCK_SENDER_ADDRESS: u256 = 0x742d35Cc6634C0532925a3b8D8E3C9b6b32a1E5A;
+    const MOCK_RECEIVER_ADDRESS: u256 = 0x8ba1f109551bD432803012645bac136c22afBa93;
+
+    // Test with realistic LayerZero values
+    let sender = Bytes32 { value: MOCK_SENDER_ADDRESS };
+    let receiver = Bytes32 { value: MOCK_RECEIVER_ADDRESS };
+
+    let guid = GUID::generate(REALISTIC_NONCE, ETHEREUM_EID, sender, ARBITRUM_EID, receiver);
+
+    // Verify GUID properties
+    assert(guid.value != 0, 'Should be different');
+
+    // Test deterministic behavior
+    let guid_repeat = GUID::generate(REALISTIC_NONCE, ETHEREUM_EID, sender, ARBITRUM_EID, receiver);
+    assert(guid.value == guid_repeat.value, 'Should be the same');
+
+    // Test that incrementing nonce changes GUID
+    let guid_next_nonce = GUID::generate(
+        REALISTIC_NONCE + 1, ETHEREUM_EID, sender, ARBITRUM_EID, receiver,
+    );
+    assert(guid.value != guid_next_nonce.value, 'Should be different');
+}

package/layerzero/tests/common/test_packet_v1_codec.cairo

@@ -0,0 +1,372 @@
+//! Test packet v1 codec
+
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+use layerzero::common::packet_v1_codec::PacketV1Codec;
+use layerzero::common::packet_v1_codec::PacketV1Codec::{PacketPayload, PacketSenderBytes};
+use layerzero::common::structs::packet::Packet;
+use lz_utils::bytes::{Bytes32, ContractAddressIntoBytes32};
+use snforge_std::fuzzable::{FuzzableU32, FuzzableU64, FuzzableU8};
+use starknet::ContractAddress;
+use starkware_utils::constants::MAX_U256;
+use crate::fuzzable::bytes32::FuzzableBytes32;
+use crate::fuzzable::contract_address::FuzzableContractAddress;
+use crate::fuzzable::eid::{Eid, FuzzableEid};
+use crate::fuzzable::small_byte_array::FuzzableByteArray;
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_encode_decode_packet(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+    let encoded = PacketV1Codec::encode(@packet);
+
+    // Verify decoding individual fields
+    assert(PacketV1Codec::version(@encoded) == PacketV1Codec::PACKET_VERSION, 'version mismatch');
+    assert(PacketV1Codec::nonce(@encoded) == nonce, 'nonce mismatch');
+    assert(PacketV1Codec::src_eid(@encoded) == src_eid, 'src_eid mismatch');
+    assert(PacketV1Codec::dst_eid(@encoded) == dst_eid, 'dst_eid mismatch');
+    assert(PacketV1Codec::receiver(@encoded) == receiver, 'receiver mismatch');
+    assert(PacketV1Codec::guid(@encoded) == guid, 'guid mismatch');
+    assert(PacketV1Codec::message(@encoded) == message, 'message mismatch');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_encode_packet_header(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet { nonce, src_eid, sender, dst_eid, receiver, guid, message };
+
+    // Header should be exactly 81 bytes (up to GUID_OFFSET)
+    let header = PacketV1Codec::encode_header(@packet);
+    assert(header.len() == PacketV1Codec::GUID_OFFSET, 'header length mismatch');
+
+    // Verify header extraction from full packet
+    let encoded = PacketV1Codec::encode(@packet);
+    assert(PacketV1Codec::header(@encoded) == header, 'header extraction mismatch');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_encode_payload(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    // Verify payload extraction from full packet
+    let encoded = PacketV1Codec::encode(@packet);
+    let payload = PacketV1Codec::payload(@encoded);
+    assert(PacketV1Codec::encode_payload(@packet) == payload, 'payload extraction mismatch');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_payload_hash(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    // Payload hash should not be zero
+    let encoded = PacketV1Codec::encode(@packet);
+    let payload_hash = PacketV1Codec::payload_hash(@encoded);
+    assert(payload_hash.value != 0, 'payload hash is zero');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_sender_address_conversion(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    // Should be able to decode the sender address
+    let encoded = PacketV1Codec::encode(@packet);
+    let decoded_sender = PacketV1Codec::sender_address(@encoded);
+    assert(decoded_sender == sender, 'Decoded sender should match');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[should_panic(expected: "LZ_PACKET_V1_CODEC_INVALID_SENDER_ADDRESS")]
+fn test_invalid_sender_address(random_8_bytes: u64, random_4_bytes: u32, random_byte: u8) {
+    // This will fail since its not a valid felt252, so its not a valid contract address
+    let mut encoded: ByteArray = Default::default();
+    // adding 13 bytes since its the sender offset
+    encoded.append_u64(random_8_bytes);
+    encoded.append_u32(random_4_bytes);
+    encoded.append_u8(random_byte);
+    encoded.append_u256(MAX_U256);
+    // this should return the expected error
+    PacketV1Codec::sender_address(@encoded);
+}
+
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_receiver_address_conversion(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver_bytes = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver: receiver_bytes, guid, message: message.clone(),
+    };
+
+    // Should be able to decode the receiver address
+    let encoded = PacketV1Codec::encode(@packet);
+    let decoded_receiver = PacketV1Codec::receiver_address(@encoded);
+    assert(decoded_receiver == receiver, 'Decoded receiver should match');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[should_panic(expected: "LZ_PACKET_V1_CODEC_INVALID_RECEIVER_ADDRESS")]
+fn test_invalid_receiver_address(
+    sender: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let receiver_max = Bytes32 { value: MAX_U256 };
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver: receiver_max, guid, message: message.clone(),
+    };
+
+    // Should be able to decode the receiver address
+    let encoded = PacketV1Codec::encode(@packet);
+    PacketV1Codec::receiver_address(@encoded);
+}
+
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_decode_payload(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    let encoded = PacketV1Codec::encode(@packet);
+    let PacketPayload {
+        guid: decoded_guid, message: decoded_message,
+    } = PacketV1Codec::decode_payload(@encoded);
+
+    // Verify payload fields match
+    assert(decoded_guid == packet.guid, 'guid mismatch');
+    assert(decoded_message == message, 'message mismatch');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_decode_full_packet(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    // Roundtrip
+    let encoded = PacketV1Codec::encode(@packet);
+    let decoded = PacketV1Codec::decode(@encoded);
+
+    // Verify all fields match exactly
+    assert(decoded.nonce == packet.nonce, 'nonce mismatch');
+    assert(decoded.src_eid == packet.src_eid, 'src_eid mismatch');
+    assert(decoded.sender == packet.sender, 'sender mismatch');
+    assert(decoded.dst_eid == packet.dst_eid, 'dst_eid mismatch');
+    assert(decoded.receiver == packet.receiver, 'receiver mismatch');
+    assert(decoded.guid == packet.guid, 'guid mismatch');
+    assert(decoded.message == packet.message, 'message mismatch');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_decode_with_bytes32_sender(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    let encoded = PacketV1Codec::encode(@packet);
+    let PacketSenderBytes {
+        nonce,
+        src_eid,
+        sender: sender_bytes,
+        dst_eid,
+        receiver: receiver_bytes,
+        guid: guid_bytes,
+        message: decoded_message,
+    } = PacketV1Codec::decode_with_bytes32_sender(@encoded);
+
+    // Verify all fields match
+    assert(nonce == packet.nonce, 'nonce mismatch');
+    assert(src_eid == packet.src_eid, 'src_eid mismatch');
+    assert(dst_eid == packet.dst_eid, 'dst_eid mismatch');
+    assert(receiver_bytes == packet.receiver, 'receiver mismatch');
+    assert(guid_bytes == packet.guid, 'guid mismatch');
+    assert(decoded_message == message, 'message mismatch');
+
+    // Verify sender can be converted back
+    assert(sender_bytes.try_into().unwrap() == packet.sender, 'sender mismatch');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_encode_decode_roundtrip(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    // Roundtrip
+    let encoded = PacketV1Codec::encode(@packet);
+    let decoded = PacketV1Codec::decode(@encoded);
+
+    // Verify perfect roundtrip
+    assert(decoded.nonce == packet.nonce, 'roundtrip nonce fail');
+    assert(decoded.src_eid == packet.src_eid, 'roundtrip src_eid fail');
+    assert(decoded.sender == packet.sender, 'roundtrip sender fail');
+    assert(decoded.dst_eid == packet.dst_eid, 'roundtrip dst_eid fail');
+    assert(decoded.receiver == packet.receiver, 'roundtrip receiver fail');
+    assert(decoded.guid == packet.guid, 'roundtrip guid fail');
+    assert(decoded.message == packet.message, 'roundtrip message fail');
+}
+
+#[test]
+#[should_panic(expected: "LZ_PACKET_V1_CODEC_INVALID_PACKET_VERSION")]
+#[fuzzer(runs: 10)]
+fn test_decode_invalid_version(
+    sender: ContractAddress,
+    receiver: ContractAddress,
+    nonce: u64,
+    guid: Bytes32,
+    src_eid: Eid,
+    dst_eid: Eid,
+    message: ByteArray,
+) {
+    let src_eid = src_eid.eid;
+    let dst_eid = dst_eid.eid;
+    let receiver = receiver.into();
+    let packet = Packet {
+        nonce, src_eid, sender, dst_eid, receiver, guid, message: message.clone(),
+    };
+
+    let mut encoded = PacketV1Codec::encode(@packet);
+
+    // Corrupt the version byte (first byte should be 1, change it to 2)
+    // We need to manually modify the first byte
+    let mut corrupted_encoded: ByteArray = Default::default();
+    corrupted_encoded.append_u8(2); // Invalid version
+
+    // Append the rest of the packet (skip the first byte)
+    for i in 1..encoded.len() {
+        corrupted_encoded.append_u8(encoded.at(i).unwrap());
+    }
+
+    // This should panic with "Invalid packet version"
+    PacketV1Codec::decode(@corrupted_encoded);
+}