@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/Scarb.lock

@@ -0,0 +1,203 @@
+# Code generated by scarb DO NOT EDIT.
+version = 1
+
+[[package]]
+name = "alexandria_bytes"
+version = "0.6.0"
+source = "git+https://github.com/keep-starknet-strange/alexandria.git?rev=d45439ca26fe890f636c9b06492d075add3fcb29#d45439ca26fe890f636c9b06492d075add3fcb29"
+dependencies = [
+ "alexandria_data_structures",
+ "alexandria_math",
+]
+
+[[package]]
+name = "alexandria_data_structures"
+version = "0.6.0"
+source = "git+https://github.com/keep-starknet-strange/alexandria.git?rev=d45439ca26fe890f636c9b06492d075add3fcb29#d45439ca26fe890f636c9b06492d075add3fcb29"
+
+[[package]]
+name = "alexandria_math"
+version = "0.6.0"
+source = "git+https://github.com/keep-starknet-strange/alexandria.git?rev=d45439ca26fe890f636c9b06492d075add3fcb29#d45439ca26fe890f636c9b06492d075add3fcb29"
+
+[[package]]
+name = "enumerable_set"
+version = "0.1.0"
+
+[[package]]
+name = "layerzero"
+version = "0.1.0"
+dependencies = [
+ "alexandria_bytes",
+ "enumerable_set",
+ "lz_utils",
+ "multisig",
+ "openzeppelin",
+ "snforge_std",
+ "starkware_utils",
+ "starkware_utils_testing",
+]
+
+[[package]]
+name = "lz_utils"
+version = "0.1.0"
+
+[[package]]
+name = "multisig"
+version = "0.1.0"
+dependencies = [
+ "enumerable_set",
+ "lz_utils",
+ "starkware_utils",
+]
+
+[[package]]
+name = "openzeppelin"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:5e4fdecc957cfca7854d95912dc72d9f725517c063b116512900900add29fd77"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_finance",
+ "openzeppelin_governance",
+ "openzeppelin_introspection",
+ "openzeppelin_merkle_tree",
+ "openzeppelin_presets",
+ "openzeppelin_security",
+ "openzeppelin_token",
+ "openzeppelin_upgrades",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_access"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:511681dd26d814ee2bc996d44ff8cb4aaa5ae9d14272130def7eb901cf004850"
+dependencies = [
+ "openzeppelin_introspection",
+]
+
+[[package]]
+name = "openzeppelin_account"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:fb3381c50d68b028d3801feb43df378e2bd62137b6884844f8f60aefe796188b"
+dependencies = [
+ "openzeppelin_introspection",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_finance"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:e9456ef69502a87c4c99bf50145351b50950f8b11244847d92935c466c4ba787"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_token",
+]
+
+[[package]]
+name = "openzeppelin_governance"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:056e6d6f3d48193b53f06283884f8a9675f986fc85425f6a40e8c1aeb3b3ecfa"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_introspection",
+ "openzeppelin_token",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_introspection"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:87773ed6cd2318f169283ecbbb161890d1996260a80302d81ec45b70ee5e54c1"
+
+[[package]]
+name = "openzeppelin_merkle_tree"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:47f80c9ce59557774243214f8e75c5e866f30f3d8daa755855f6ffd01c89ca89"
+
+[[package]]
+name = "openzeppelin_presets"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:36c761ee923f1dc0887c0eab8c224b49ac242dbfe9163fbb0b08562042ab3d98"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_finance",
+ "openzeppelin_introspection",
+ "openzeppelin_token",
+ "openzeppelin_upgrades",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_security"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:902932ec296c2f400e0ac7c579edeaafd6067b6ce6d9854c1191de28e396ffe3"
+
+[[package]]
+name = "openzeppelin_token"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:6fe61f63b5a6706018265fb7373b6e5bd3ff829bdc760b2b90296b1e708d180c"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_introspection",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_upgrades"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:560d57a9c3f3ec5a476e82fec8963c93c8df63a4ff9ff134f64ab8383bde3c61"
+
+[[package]]
+name = "openzeppelin_utils"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:bf799c794139837f397975ffdf6a7ed5032d198bbf70e87a8f44f144a9dfc505"
+
+[[package]]
+name = "snforge_scarb_plugin"
+version = "0.48.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:8630dcf3fa4df36a3d45e6a2d053cf84c548ab154e829fece99373ae5852921c"
+
+[[package]]
+name = "snforge_std"
+version = "0.48.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:981139c83359089540652c44f4a1a888c77409eedaa148377927cc63a604b67b"
+dependencies = [
+ "snforge_scarb_plugin",
+]
+
+[[package]]
+name = "starkware_utils"
+version = "1.0.0"
+source = "git+https://github.com/starkware-libs/starkware-starknet-utils?rev=8a5af9509d93815542b8a701cee22a1b9ec1fe34#8a5af9509d93815542b8a701cee22a1b9ec1fe34"
+dependencies = [
+ "openzeppelin",
+]
+
+[[package]]
+name = "starkware_utils_testing"
+version = "1.0.0"
+source = "git+https://github.com/starkware-libs/starkware-starknet-utils?rev=8a5af9509d93815542b8a701cee22a1b9ec1fe34#8a5af9509d93815542b8a701cee22a1b9ec1fe34"
+dependencies = [
+ "openzeppelin",
+ "snforge_std",
+ "starkware_utils",
+]

package/layerzero/Scarb.toml

@@ -0,0 +1,30 @@
+[package]
+name = "layerzero"
+version = "0.1.0"
+edition = "2024_07"
+
+# See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
+
+[dependencies]
+starknet = "2.12.0"
+starkware_utils = { git = "https://github.com/starkware-libs/starkware-starknet-utils", rev = "8a5af9509d93815542b8a701cee22a1b9ec1fe34" }
+openzeppelin = "2.0.0"
+alexandria_bytes = { git = "https://github.com/keep-starknet-strange/alexandria.git", rev = "d45439ca26fe890f636c9b06492d075add3fcb29" }
+lz_utils = { path = "../libs/lz_utils" }
+enumerable_set = { path = "../libs/enumerable_set" }
+multisig = { path = "../libs/multisig" }
+
+[dev-dependencies]
+snforge_std = "0.48.0"
+assert_macros = "2.12.0"
+starkware_utils_testing = { git = "https://github.com/starkware-libs/starkware-starknet-utils", rev = "8a5af9509d93815542b8a701cee22a1b9ec1fe34" }
+
+[[target.starknet-contract]]
+sierra = true
+casm = true
+
+[scripts]
+test = "snforge test"
+
+[tool.scarb]
+allow-prebuilt-plugins = ["snforge_scarb_plugin", "snforge_std"]

package/layerzero/snfoundry.toml

@@ -0,0 +1,11 @@
+# Visit https://foundry-rs.github.io/starknet-foundry/appendix/snfoundry-toml.html
+# and https://foundry-rs.github.io/starknet-foundry/projects/configuration.html for more information
+
+# [sncast.default]                                         # Define a profile name
+# url = "https://free-rpc.nethermind.io/sepolia-juno/v0_7" # Url of the RPC provider
+# accounts-file = "../account-file"                        # Path to the file with the account data
+# account = "mainuser"                                     # Account from `accounts_file` or default account file that will be used for the transactions
+# keystore = "~/keystore"                                  # Path to the keystore file
+# wait-params = { timeout = 300, retry-interval = 10 }     # Wait for submitted transaction parameters
+# block-explorer = "StarkScan"                             # Block explorer service used to display links to transaction details
+# show-explorer-links = true                               # Print links pointing to pages with transaction details in the chosen block explorer

package/layerzero/src/common/constants.cairo

@@ -0,0 +1,26 @@
+//! Common constants
+
+use core::num::traits::Pow;
+use starknet::ContractAddress;
+
+/// Contract address for the ETH ERC20 token on Starknet
+pub const ETH_CONTRACT_ADDRESS: ContractAddress =
+    0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7
+    .try_into()
+    .unwrap();
+
+pub const ZERO_ADDRESS: ContractAddress = 0.try_into().unwrap();
+pub const DEAD_ADDRESS: ContractAddress = 0xdead.try_into().unwrap();
+
+/// Default basis points (100%)
+pub const DEFAULT_BPS: u256 = 10000;
+
+/// Native decimals rate
+/// - STRK has 18 decimals
+/// - https://docs.starknet.io/guides/becoming-a-validator/stake/
+/// NOTE: You might need to change this if you want to deploy and EndpointV2Alt with a different
+/// native token
+pub const NATIVE_DECIMALS_RATE: u256 = 10_u256.pow(18);
+
+/// Maximum v1 EID
+pub const MAX_V1_EID: u32 = 30_000;

package/layerzero/src/common/conversions.cairo

@@ -0,0 +1,16 @@
+//! Common conversions
+
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+
+/// Converts felt252 arrays to byte arrays in the event data
+pub impl FeltArrayIntoByteArrayImpl of Into<Array<felt252>, ByteArray> {
+    fn into(self: Array<felt252>) -> ByteArray {
+        let mut byte_array = Default::default();
+
+        for felt in self.into_iter() {
+            byte_array.append_felt252(felt);
+        }
+
+        byte_array
+    }
+}

package/layerzero/src/common/guid.cairo

@@ -0,0 +1,20 @@
+/// GUID generation library
+pub mod GUID {
+    use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+    use lz_utils::bytes::Bytes32;
+    use lz_utils::keccak::keccak256;
+
+    pub fn generate(
+        nonce: u64, src_eid: u32, sender: Bytes32, dst_eid: u32, receiver: Bytes32,
+    ) -> Bytes32 {
+        let mut bytes: ByteArray = Default::default();
+
+        bytes.append_u64(nonce);
+        bytes.append_u32(src_eid);
+        bytes.append_u256(sender.value);
+        bytes.append_u32(dst_eid);
+        bytes.append_u256(receiver.value);
+
+        keccak256(@bytes)
+    }
+}

package/layerzero/src/common/packet_v1_codec.cairo

@@ -0,0 +1,307 @@
+/// Cairo implementation of the Solidity PacketV1Codec library
+///
+/// Handles encoding and decoding of LayerZero packets
+pub mod PacketV1Codec {
+    use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+    use lz_utils::bytes::{Bytes32, ContractAddressIntoBytes32};
+    use lz_utils::error::{Error, format_error};
+    use lz_utils::keccak::keccak256;
+    use starknet::ContractAddress;
+    use starkware_utils::errors::assert_with_byte_array;
+    use crate::common::structs::packet::Packet;
+
+    // Constants
+    pub const PACKET_VERSION: u8 = 1;
+    pub const PACKET_HEADER_LENGTH: u32 = 81;
+
+    // Offsets for packet structure
+    // header (version + nonce + path)
+    pub const PACKET_VERSION_OFFSET: usize = 0;
+    pub const NONCE_OFFSET: usize = 1;
+    pub const SRC_EID_OFFSET: usize = 9;
+    pub const SENDER_OFFSET: usize = 13;
+    pub const DST_EID_OFFSET: usize = 45;
+    pub const RECEIVER_OFFSET: usize = 49;
+    // payload (guid + message)
+    pub const GUID_OFFSET: usize = 81;
+    pub const MESSAGE_OFFSET: usize = 113;
+
+    /// Struct for decoding the packet payload
+    pub struct PacketPayload {
+        pub guid: Bytes32,
+        pub message: ByteArray,
+    }
+
+    /// Same as [`Packet`] but with `Bytes32` sender
+    pub struct PacketSenderBytes {
+        pub nonce: u64,
+        pub src_eid: u32,
+        pub sender: Bytes32,
+        pub dst_eid: u32,
+        pub receiver: Bytes32,
+        pub guid: Bytes32,
+        pub message: ByteArray,
+    }
+
+    #[derive(Drop)]
+    pub enum PacketV1CodecError {
+        InvalidSenderAddress,
+        InvalidReceiverAddress,
+        InvalidPacketVersion,
+        InvalidPacketHeader,
+        InvalidEid,
+    }
+
+    impl ErrorNameImpl of Error<PacketV1CodecError> {
+        fn prefix() -> ByteArray {
+            "LZ_PACKET_V1_CODEC"
+        }
+
+        fn name(self: PacketV1CodecError) -> ByteArray {
+            match self {
+                PacketV1CodecError::InvalidSenderAddress => "INVALID_SENDER_ADDRESS",
+                PacketV1CodecError::InvalidReceiverAddress => "INVALID_RECEIVER_ADDRESS",
+                PacketV1CodecError::InvalidPacketVersion => "INVALID_PACKET_VERSION",
+                PacketV1CodecError::InvalidPacketHeader => "INVALID_PACKET_HEADER",
+                PacketV1CodecError::InvalidEid => "INVALID_EID",
+            }
+        }
+    }
+
+    pub fn err_invalid_sender_address(sender: Bytes32) -> ByteArray {
+        format_error(PacketV1CodecError::InvalidSenderAddress, format!("sender: {}", sender.value))
+    }
+
+    pub fn err_invalid_receiver_address(receiver: Bytes32) -> ByteArray {
+        format_error(
+            PacketV1CodecError::InvalidReceiverAddress, format!("receiver: {}", receiver.value),
+        )
+    }
+
+    pub fn err_invalid_packet_version(version: u8) -> ByteArray {
+        format_error(PacketV1CodecError::InvalidPacketVersion, format!("version: {}", version))
+    }
+
+    pub fn err_invalid_packet_header(expected_length: u32, actual_length: u32) -> ByteArray {
+        format_error(
+            PacketV1CodecError::InvalidPacketHeader,
+            format!("expected_length: {}, actual_length: {}", expected_length, actual_length),
+        )
+    }
+
+    pub fn err_invalid_eid(expected_eid: u32, actual_eid: u32) -> ByteArray {
+        format_error(
+            PacketV1CodecError::InvalidEid,
+            format!("expected_eid: {}, actual_eid: {}", expected_eid, actual_eid),
+        )
+    }
+
+    /// Encodes only the packet header (version + nonce + path) into a byte array
+    pub fn encode_header(packet: @Packet) -> ByteArray {
+        let sender_bytes32: Bytes32 = (*packet.sender).into();
+
+        // Packet header encoding format:
+        // 1 byte version
+        // 8 bytes nonce
+        // 4 bytes srcEid
+        // 32 bytes sender
+        // 4 bytes dstEid
+        // 32 bytes receiver
+        let mut header: ByteArray = Default::default();
+
+        header.append_u8(PACKET_VERSION);
+        header.append_u64(*packet.nonce);
+        header.append_u32(*packet.src_eid);
+        header.append_u256(sender_bytes32.value);
+        header.append_u32(*packet.dst_eid);
+        header.append_u256(*packet.receiver.value);
+
+        header
+    }
+
+    /// Encodes the packet payload (guid + message) into a byte array
+    pub fn encode_payload(packet: @Packet) -> ByteArray {
+        let mut payload: ByteArray = Default::default();
+
+        payload.append_u256(*packet.guid.value);
+        payload.append(packet.message);
+
+        payload
+    }
+
+    /// Encodes a packet struct into a byte array following the LayerZero packet format
+    pub fn encode(packet: @Packet) -> ByteArray {
+        // Packet encoding:
+        // PacketHeader + bytes32 guid + byteArray message
+        let mut encoded_header: ByteArray = encode_header(packet);
+        let mut encoded_payload: ByteArray = encode_payload(packet);
+        encoded_header.append(@encoded_payload);
+        encoded_header
+    }
+
+    /// Extracts the header from an encoded packet
+    pub fn header(packet: @ByteArray) -> ByteArray {
+        let (_, header_value) = packet.read_bytes(0, GUID_OFFSET);
+        header_value
+    }
+
+    /// Extracts the version from an encoded packet
+    pub fn version(packet: @ByteArray) -> u8 {
+        let (_, version_value) = packet.read_u8(PACKET_VERSION_OFFSET);
+        version_value
+    }
+
+    /// Extracts the nonce from an encoded packet
+    pub fn nonce(packet: @ByteArray) -> u64 {
+        let (_, nonce_value) = packet.read_u64(NONCE_OFFSET);
+        nonce_value
+    }
+
+    /// Extracts the source EID from an encoded packet
+    pub fn src_eid(packet: @ByteArray) -> u32 {
+        let (_, src_eid_value) = packet.read_u32(SRC_EID_OFFSET);
+        src_eid_value
+    }
+
+    /// Extracts the sender as Bytes32 from an encoded packet
+    pub fn sender(packet: @ByteArray) -> Bytes32 {
+        let (_, sender_value) = packet.read_u256(SENDER_OFFSET);
+        Bytes32 { value: sender_value }
+    }
+
+    /// Extracts the sender as ContractAddress from an encoded packet
+    pub fn sender_address(packet: @ByteArray) -> ContractAddress {
+        let sender_bytes32 = sender(packet);
+        let sender_address = sender_bytes32.try_into();
+        assert_with_byte_array(
+            sender_address.is_some(), err_invalid_sender_address(sender_bytes32),
+        );
+
+        sender_address.unwrap()
+    }
+
+    /// Extracts the destination EID from an encoded packet
+    pub fn dst_eid(packet: @ByteArray) -> u32 {
+        let (_, dst_eid_value) = packet.read_u32(DST_EID_OFFSET);
+        dst_eid_value
+    }
+
+    /// Extracts the receiver from an encoded packet
+    pub fn receiver(packet: @ByteArray) -> Bytes32 {
+        let (_, receiver_value) = packet.read_u256(RECEIVER_OFFSET);
+        Bytes32 { value: receiver_value }
+    }
+
+    /// Extracts the receiver as ContractAddress from an encoded packet
+    pub fn receiver_address(packet: @ByteArray) -> ContractAddress {
+        let receiver_bytes32 = receiver(packet);
+        let receiver_address = receiver_bytes32.try_into();
+        assert_with_byte_array(
+            receiver_address.is_some(), err_invalid_receiver_address(receiver_bytes32),
+        );
+
+        receiver_address.unwrap()
+    }
+
+    /// Extracts the GUID from an encoded packet
+    pub fn guid(packet: @ByteArray) -> Bytes32 {
+        let (_, guid_value) = packet.read_u256(GUID_OFFSET);
+        Bytes32 { value: guid_value }
+    }
+
+    /// Extracts the message from an encoded packet
+    /// * `ByteArray` - The message
+    pub fn message(packet: @ByteArray) -> ByteArray {
+        let message_length = packet.len() - MESSAGE_OFFSET;
+        let (_, message_value) = packet.read_bytes(MESSAGE_OFFSET, message_length);
+        message_value
+    }
+
+    /// Extracts the payload (guid + message) from an encoded packet
+    pub fn payload(packet: @ByteArray) -> ByteArray {
+        let payload_length = packet.len() - GUID_OFFSET;
+        let (_, payload_value) = packet.read_bytes(GUID_OFFSET, payload_length);
+        payload_value
+    }
+
+    /// Computes the keccak256 hash of the payload
+    pub fn payload_hash(packet: @ByteArray) -> Bytes32 {
+        let payload_bytes = payload(packet);
+        keccak256(@payload_bytes)
+    }
+
+    /// Decodes only the packet payload from a byte array into individual components
+    /// Returns: (guid, message)
+    pub fn decode_payload(encoded_packet: @ByteArray) -> PacketPayload {
+        PacketPayload { guid: guid(encoded_packet), message: message(encoded_packet) }
+    }
+
+    /// Decodes a complete encoded packet into a Packet struct
+    /// Note: This assumes the sender can be converted to ContractAddress
+    /// If conversion fails, it will panic - use decode_with_bytes32_sender for safer decoding
+    pub fn decode(encoded_packet: @ByteArray) -> Packet {
+        get_and_assert_version(encoded_packet);
+
+        let PacketSenderBytes {
+            nonce, src_eid, sender: sender_bytes32, dst_eid, receiver, guid, message,
+        } = decode_with_bytes32_sender(encoded_packet);
+
+        Packet {
+            nonce,
+            src_eid,
+            dst_eid,
+            receiver,
+            guid,
+            message,
+            sender: sender_bytes32.try_into().expect('Invalid sender address'),
+        }
+    }
+
+    /// Decodes a complete encoded packet into a Packet struct with Bytes32 sender
+    /// This is safer than decode() as it doesn't attempt address conversion
+    pub fn decode_with_bytes32_sender(encoded_packet: @ByteArray) -> PacketSenderBytes {
+        get_and_assert_version(encoded_packet);
+
+        PacketSenderBytes {
+            nonce: nonce(encoded_packet),
+            src_eid: src_eid(encoded_packet),
+            sender: sender(encoded_packet),
+            dst_eid: dst_eid(encoded_packet),
+            receiver: receiver(encoded_packet),
+            guid: guid(encoded_packet),
+            message: message(encoded_packet),
+        }
+    }
+
+    pub fn get_and_assert_version(packet_header: @ByteArray) -> u8 {
+        let header_version = version(packet_header);
+        assert_with_byte_array(
+            header_version == PACKET_VERSION, err_invalid_packet_version(header_version),
+        );
+
+        header_version
+    }
+
+    /// Asserts that a packet header is valid for the given local endpoint ID
+    /// Validates:
+    /// - Header length is exactly 81 bytes
+    /// - Packet version matches PACKET_VERSION
+    /// - Destination EID matches the local endpoint ID
+    pub fn assert_header(packet_header: @ByteArray, local_eid: u32) {
+        // Assert packet header is of right size (81 bytes)
+        let header_length = packet_header.len();
+        assert_with_byte_array(
+            header_length == PACKET_HEADER_LENGTH,
+            err_invalid_packet_header(PACKET_HEADER_LENGTH, header_length),
+        );
+
+        // Assert packet header version is the same as ULN
+        get_and_assert_version(packet_header);
+
+        // Assert the packet is for this endpoint
+        let packet_dst_eid = dst_eid(packet_header);
+        assert_with_byte_array(
+            packet_dst_eid == local_eid, err_invalid_eid(local_eid, packet_dst_eid),
+        );
+    }
+}

package/layerzero/src/common/structs/messaging.cairo

@@ -0,0 +1,40 @@
+//! Common messaging structs
+
+use lz_utils::bytes::Bytes32;
+use starknet::ContractAddress;
+
+/// Parameters required to send a message
+#[derive(Drop, Serde, Clone, PartialEq, Debug, Default)]
+pub struct MessagingParams {
+    pub dst_eid: u32,
+    pub receiver: Bytes32,
+    pub message: ByteArray,
+    pub options: ByteArray,
+    pub pay_in_lz_token: bool,
+}
+
+#[derive(Drop, Serde, Default, PartialEq, Clone, Debug)]
+pub struct MessagingFee {
+    pub native_fee: u256,
+    pub lz_token_fee: u256,
+}
+
+#[derive(Drop, Clone, Serde, PartialEq, Debug)]
+pub struct Payee {
+    pub receiver: ContractAddress,
+    pub native_amount: u256,
+    pub lz_token_amount: u256,
+}
+
+#[derive(Drop, Serde, Default, PartialEq, Clone, Debug)]
+pub struct MessageReceipt {
+    pub guid: Bytes32,
+    pub nonce: u64,
+    pub payees: Array<Payee>,
+}
+
+#[derive(Drop, Serde, PartialEq, Clone, Debug)]
+pub struct MessageLibSendResult {
+    pub message_receipt: MessageReceipt,
+    pub encoded_packet: ByteArray,
+}

package/layerzero/src/common/structs/packet.cairo

@@ -0,0 +1,31 @@
+//! Common structs - `Packet` and `Origin`
+
+use lz_utils::bytes::Bytes32;
+use starknet::ContractAddress;
+
+#[derive(Clone, Drop, Serde)]
+pub struct PacketHeader {
+    pub nonce: u64,
+    pub src_eid: u32,
+    pub sender: ContractAddress,
+    pub dst_eid: u32,
+    pub receiver: Bytes32,
+}
+
+#[derive(Clone, Drop, Serde)]
+pub struct Packet {
+    pub nonce: u64,
+    pub src_eid: u32,
+    pub sender: ContractAddress,
+    pub dst_eid: u32,
+    pub receiver: Bytes32,
+    pub guid: Bytes32,
+    pub message: ByteArray,
+}
+
+#[derive(Clone, Drop, Serde, Debug, PartialEq, Default)]
+pub struct Origin {
+    pub src_eid: u32,
+    pub sender: Bytes32,
+    pub nonce: u64,
+}