@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/message_lib/uln/utils.cairo

@@ -0,0 +1,59 @@
+//! ULN test utilities
+
+use layerzero::message_lib::interface::{IMessageLibDispatcher, IMessageLibDispatcherTrait};
+use layerzero::message_lib::structs::SetConfigParam;
+use layerzero::message_lib::uln::structs::executor_config::ExecutorConfig;
+use layerzero::message_lib::uln::structs::uln_config::UlnConfig;
+use layerzero::message_lib::uln::ultra_light_node::UltraLightNode::{
+    CONFIG_TYPE_EXECUTOR, CONFIG_TYPE_ULN,
+};
+use starknet::ContractAddress;
+
+// Helper functions for MessageLib interface
+pub fn create_uln_send_config_param(
+    eid: u32, oapp: ContractAddress, config: UlnConfig,
+) -> SetConfigParam {
+    let mut serialized_config = array![];
+    Serde::serialize(@config, ref serialized_config);
+    SetConfigParam { eid, oapp, config_type: CONFIG_TYPE_ULN, config: serialized_config }
+}
+
+pub fn create_executor_send_config_param(
+    eid: u32, oapp: ContractAddress, config: ExecutorConfig,
+) -> SetConfigParam {
+    let mut serialized_config = array![];
+    Serde::serialize(@config, ref serialized_config);
+    SetConfigParam { eid, oapp, config_type: CONFIG_TYPE_EXECUTOR, config: serialized_config }
+}
+
+pub fn create_uln_receive_config_param(
+    eid: u32, oapp: ContractAddress, config: UlnConfig,
+) -> SetConfigParam {
+    let mut serialized_config = array![];
+    Serde::serialize(@config, ref serialized_config);
+    SetConfigParam { eid, oapp, config_type: CONFIG_TYPE_ULN, config: serialized_config }
+}
+
+pub fn set_oapp_uln_send_config_via_message_lib(
+    contract_address: ContractAddress, oapp: ContractAddress, eid: u32, config: UlnConfig,
+) {
+    let message_lib = IMessageLibDispatcher { contract_address };
+    let param = create_uln_send_config_param(eid, oapp, config);
+    message_lib.set_send_config(oapp, array![param]);
+}
+
+pub fn set_oapp_executor_send_config_via_message_lib(
+    contract_address: ContractAddress, oapp: ContractAddress, eid: u32, config: ExecutorConfig,
+) {
+    let message_lib = IMessageLibDispatcher { contract_address };
+    let param = create_executor_send_config_param(eid, oapp, config);
+    message_lib.set_send_config(oapp, array![param]);
+}
+
+pub fn set_oapp_uln_receive_config_via_message_lib(
+    contract_address: ContractAddress, oapp: ContractAddress, eid: u32, config: UlnConfig,
+) {
+    let message_lib = IMessageLibDispatcher { contract_address };
+    let param = create_uln_receive_config_param(eid, oapp, config);
+    message_lib.set_receive_config(oapp, array![param]);
+}

package/layerzero/tests/mocks/composer_target.cairo

@@ -0,0 +1,76 @@
+#[starknet::contract]
+pub mod MockComposerTarget {
+    use layerzero::endpoint::interfaces::layerzero_composer::ILayerZeroComposer;
+    use layerzero::oapps::oft::oft_compose_msg_codec::OFTComposeMsgCodec;
+    use lz_utils::bytes::Bytes32;
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+
+    #[storage]
+    struct Storage {
+        last_from: ContractAddress,
+        last_guid: Bytes32,
+        last_message: ByteArray,
+        last_value: u256,
+        received_count: u32,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {}
+
+    #[constructor]
+    fn constructor(ref self: ContractState) {}
+
+    #[abi(embed_v0)]
+    impl ComposerImpl of ILayerZeroComposer<ContractState> {
+        fn lz_compose(
+            ref self: ContractState,
+            from: ContractAddress,
+            guid: Bytes32,
+            message: ByteArray,
+            executor: ContractAddress,
+            extra_data: ByteArray,
+            value: u256,
+        ) {
+            self.last_from.write(from);
+            self.last_guid.write(guid);
+            self.last_message.write(OFTComposeMsgCodec::compose_msg(@message));
+            self.last_value.write(value);
+            let count = self.received_count.read();
+            self.received_count.write(count + 1);
+        }
+    }
+
+    #[starknet::interface]
+    pub trait IMockComposerTargetInspect<TContractState> {
+        fn last_from(self: @TContractState) -> ContractAddress;
+        fn last_guid(self: @TContractState) -> Bytes32;
+        fn last_message(self: @TContractState) -> ByteArray;
+        fn last_value(self: @TContractState) -> u256;
+        fn received_count(self: @TContractState) -> u32;
+    }
+
+    #[abi(embed_v0)]
+    impl InspectImpl of IMockComposerTargetInspect<ContractState> {
+        fn last_from(self: @ContractState) -> ContractAddress {
+            self.last_from.read()
+        }
+
+        fn last_guid(self: @ContractState) -> Bytes32 {
+            self.last_guid.read()
+        }
+
+        fn last_message(self: @ContractState) -> ByteArray {
+            self.last_message.read()
+        }
+
+        fn last_value(self: @ContractState) -> u256 {
+            self.last_value.read()
+        }
+
+        fn received_count(self: @ContractState) -> u32 {
+            self.received_count.read()
+        }
+    }
+}

package/layerzero/tests/mocks/endpoint.cairo

@@ -0,0 +1,199 @@
+//! Mock endpoint component for testing
+
+#[starknet::contract]
+pub mod MockEndpoint {
+    use layerzero::MessagingFee;
+    use layerzero::common::structs::messaging::{MessageReceipt, MessagingParams, Payee};
+    use layerzero::common::structs::packet::Origin;
+    use layerzero::endpoint::events::{LzReceiveAlert, PacketDelivered};
+    use layerzero::endpoint::interfaces::endpoint::{ExecutionState, IEndpoint};
+    use lz_utils::bytes::Bytes32;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ContractAddress, get_caller_address};
+
+    #[storage]
+    struct Storage {
+        message_count: u64,
+        eid: u32,
+        receive_should_fail: bool,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        LzReceiveAlert: LzReceiveAlert,
+        PacketDelivered: PacketDelivered,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, eid: u32) {
+        self.message_count.write(0);
+        self.eid.write(eid);
+        self.receive_should_fail.write(false);
+    }
+
+    #[abi(embed_v0)]
+    impl MockEndpointImpl of IEndpoint<ContractState> {
+        fn send(
+            ref self: ContractState, params: MessagingParams, refund_address: ContractAddress,
+        ) -> MessageReceipt {
+            // Just increment the counter
+            let count = self.message_count.read();
+            self.message_count.write(count + 1);
+
+            // Return a mock receipt
+            MessageReceipt {
+                guid: Bytes32 { value: count.into() }, nonce: count, payees: self.get_mock_payees(),
+            }
+        }
+
+        /// Mock implementation
+        ///
+        /// - if `receive_should_fail` is false, emit PacketDelivered event
+        ///
+        /// - otherwise emit LzReceiveAlert event with empty reason
+        fn lz_receive(
+            ref self: ContractState,
+            origin: Origin,
+            receiver: ContractAddress,
+            guid: Bytes32,
+            message: ByteArray,
+            value: u256,
+            extra_data: ByteArray,
+        ) {
+            if self.receive_should_fail.read() {
+                self
+                    .lz_receive_alert(
+                        origin,
+                        receiver,
+                        guid,
+                        0,
+                        value,
+                        message,
+                        extra_data,
+                        array!['Mock receive failed'],
+                    );
+            } else {
+                self.emit(PacketDelivered { origin, receiver });
+            }
+        }
+
+        /// Mock implementation - emit LzReceiveAlert event
+        fn lz_receive_alert(
+            ref self: ContractState,
+            origin: Origin,
+            receiver: ContractAddress,
+            guid: Bytes32,
+            gas: u256,
+            value: u256,
+            message: ByteArray,
+            extra_data: ByteArray,
+            reason: Array<felt252>,
+        ) {
+            let executor = get_caller_address();
+            self
+                .emit(
+                    LzReceiveAlert {
+                        origin, receiver, executor, guid, gas, value, message, extra_data, reason,
+                    },
+                );
+        }
+
+        /// Mock implementation - do nothing
+        fn clear(
+            ref self: ContractState,
+            origin: Origin,
+            receiver: ContractAddress,
+            guid: Bytes32,
+            message: ByteArray,
+        ) {}
+
+        /// Mock implementation - do nothing
+        fn commit(
+            ref self: ContractState,
+            origin: Origin,
+            receiver: ContractAddress,
+            payload_hash: Bytes32,
+        ) {}
+
+        fn quote(
+            self: @ContractState, params: MessagingParams, sender: ContractAddress,
+        ) -> MessagingFee {
+            Default::default()
+        }
+
+        fn get_lz_token(self: @ContractState) -> ContractAddress {
+            'lz_token'.try_into().unwrap()
+        }
+
+        /// Mock implementation - do nothing
+        fn set_lz_token(ref self: ContractState, lz_token_address: ContractAddress) {}
+
+        fn get_eid(self: @ContractState) -> u32 {
+            self.eid.read()
+        }
+
+        fn set_delegate(ref self: ContractState, delegate: ContractAddress) {}
+
+        fn get_delegate(self: @ContractState, oapp: ContractAddress) -> ContractAddress {
+            'delegate'.try_into().unwrap()
+        }
+
+        fn initializable(self: @ContractState, origin: Origin, receiver: ContractAddress) -> bool {
+            true
+        }
+
+        fn committable(self: @ContractState, origin: Origin, receiver: ContractAddress) -> bool {
+            true
+        }
+
+        fn committable_with_receive_lib(
+            self: @ContractState,
+            origin: Origin,
+            receiver: ContractAddress,
+            receive_lib: ContractAddress,
+        ) -> bool {
+            true
+        }
+
+        fn executable(
+            self: @ContractState, origin: Origin, receiver: ContractAddress,
+        ) -> ExecutionState {
+            ExecutionState::Executable
+        }
+    }
+
+    #[starknet::interface]
+    pub trait MockEndpointHelpers<TContractState> {
+        fn set_receive_should_fail(ref self: TContractState, receive_should_fail: bool);
+        fn get_message_count(self: @TContractState) -> u64;
+        fn get_mock_payees(self: @TContractState) -> Array<Payee>;
+        fn get_mock_native_fee(self: @TContractState) -> u256;
+    }
+
+    // Helper functions for testing
+    #[abi(embed_v0)]
+    pub impl MockEndpointHelpersImpl of MockEndpointHelpers<ContractState> {
+        fn set_receive_should_fail(ref self: ContractState, receive_should_fail: bool) {
+            self.receive_should_fail.write(receive_should_fail);
+        }
+
+        fn get_message_count(self: @ContractState) -> u64 {
+            self.message_count.read()
+        }
+
+        fn get_mock_payees(self: @ContractState) -> Array<Payee> {
+            array![
+                Payee {
+                    receiver: 0x1.try_into().unwrap(),
+                    native_amount: self.get_mock_native_fee(),
+                    lz_token_amount: 0,
+                },
+            ]
+        }
+
+        fn get_mock_native_fee(self: @ContractState) -> u256 {
+            1000
+        }
+    }
+}

package/layerzero/tests/mocks/erc20/erc20.cairo

@@ -0,0 +1,50 @@
+//! Mock ERC20 component for testing
+
+#[starknet::contract]
+pub mod MockERC20 {
+    use openzeppelin::token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
+    use starknet::ContractAddress;
+    use crate::mocks::erc20::interface::IMockERC20;
+
+    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
+
+    impl ERC20ImmutableConfig of ERC20Component::ImmutableConfig {
+        const DECIMALS: u8 = 18;
+    }
+
+    // ERC20 Mixin
+    #[abi(embed_v0)]
+    impl ERC20MixinImpl = ERC20Component::ERC20MixinImpl<ContractState>;
+    impl ERC20InternalImpl = ERC20Component::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        erc20: ERC20Component::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        ERC20Event: ERC20Component::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, initial_supply: u256, recipient: ContractAddress) {
+        let name = "MyToken";
+        let symbol = "MTK";
+
+        self.erc20.initializer(name, symbol);
+        self.erc20.mint(recipient, initial_supply);
+    }
+
+    #[abi(embed_v0)]
+    impl MockERC20Impl of IMockERC20<ContractState> {
+        fn mint(ref self: ContractState, recipient: ContractAddress, amount: u256) {
+            // This function is NOT protected which means
+            // ANYONE can mint tokens
+            self.erc20.mint(recipient, amount);
+        }
+    }
+}

package/layerzero/tests/mocks/erc20/interface.cairo

@@ -0,0 +1,8 @@
+//! Mock ERC20 interface for testing
+
+use starknet::ContractAddress;
+
+#[starknet::interface]
+pub trait IMockERC20<TContractState> {
+    fn mint(ref self: TContractState, recipient: ContractAddress, amount: u256);
+}

package/layerzero/tests/mocks/message_inspector/message_inspector.cairo

@@ -0,0 +1,17 @@
+//! Mock Message Inspector component for testing
+
+#[starknet::contract]
+pub mod MockMessageInspector {
+    use core::panics::panic_with_byte_array;
+    use layerzero::oapps::message_inspector::interface::IMessageInspector;
+
+    #[storage]
+    struct Storage {}
+
+    #[abi(embed_v0)]
+    impl MockMessageInspectorImpl of IMessageInspector<ContractState> {
+        fn inspect_msg(self: @ContractState, message: ByteArray, options: ByteArray) -> bool {
+            panic_with_byte_array(@"Invalid message or options")
+        }
+    }
+}

package/layerzero/tests/mocks/message_lib_manager.cairo

@@ -0,0 +1,98 @@
+#[starknet::contract]
+pub mod MockMessageLibManager {
+    use layerzero::endpoint::message_lib_manager::message_lib_manager::MessageLibManagerComponent;
+    use lz_utils::error::{Error, format_error};
+    use openzeppelin::access::ownable::OwnableComponent;
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starkware_utils::errors::assert_with_byte_array;
+
+    // === Error Definitions ===
+    #[derive(Drop)]
+    pub enum MockMessageLibManagerError {
+        NotAuthorized,
+    }
+
+    impl ErrorNameImpl of Error<MockMessageLibManagerError> {
+        fn prefix() -> ByteArray {
+            "MOCK_MESSAGE_LIB_MANAGER"
+        }
+
+        fn name(self: MockMessageLibManagerError) -> ByteArray {
+            match self {
+                MockMessageLibManagerError::NotAuthorized => "NOT_AUTHORIZED",
+            }
+        }
+    }
+
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+    component!(
+        path: MessageLibManagerComponent,
+        storage: message_lib_manager,
+        event: MessageLibManagerEvent,
+    );
+
+    // Ownable
+    #[abi(embed_v0)]
+    impl OwnableImpl = OwnableComponent::OwnableImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    // MessageLibManager
+    #[abi(embed_v0)]
+    impl MessageLibManagerImpl =
+        MessageLibManagerComponent::MessageLibManagerImpl<ContractState>;
+    impl MessageLibManagerInternalImpl = MessageLibManagerComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        throw_on_authorize: bool,
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+        #[substorage(v0)]
+        message_lib_manager: MessageLibManagerComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+        #[flat]
+        MessageLibManagerEvent: MessageLibManagerComponent::Event,
+    }
+
+    pub fn err_not_authorized() -> ByteArray {
+        format_error(MockMessageLibManagerError::NotAuthorized, "")
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState, owner: ContractAddress, blocked_library: ContractAddress,
+    ) {
+        self.ownable.initializer(owner);
+        self.message_lib_manager.initializer(blocked_library);
+    }
+
+    #[abi(embed_v0)]
+    impl MockManagerHelpers of IMockManagerHelpers<ContractState> {
+        fn set_throw_on_authorize(ref self: ContractState, throw: bool) {
+            self.throw_on_authorize.write(throw);
+        }
+    }
+
+    #[starknet::interface]
+    pub trait IMockManagerHelpers<TContractState> {
+        fn set_throw_on_authorize(ref self: TContractState, throw: bool);
+    }
+
+    impl MessageLibManagerHooks<
+        ContractState,
+    > of MessageLibManagerComponent::IMessageLibManagerHooks<ContractState> {
+        fn _assert_authorized(
+            self: @MessageLibManagerComponent::ComponentState<ContractState>, oapp: ContractAddress,
+        ) {
+            let mut contract_state = unsafe_new_contract_state();
+            assert_with_byte_array(!contract_state.throw_on_authorize.read(), err_not_authorized());
+        }
+    }
+}

package/layerzero/tests/mocks/messaging_channel/interface.cairo

@@ -0,0 +1,23 @@
+use layerzero::Origin;
+use lz_utils::bytes::Bytes32;
+use starknet::ContractAddress;
+
+#[starknet::interface]
+pub trait IMockMessagingChannel<TContractState> {
+    fn fake_commit(
+        ref self: TContractState, receiver: ContractAddress, origin: Origin, payload_hash: Bytes32,
+    );
+    fn fake_send(
+        ref self: TContractState, sender: ContractAddress, dst_eid: u32, receiver: Bytes32,
+    );
+    fn test_clear_payload(
+        ref self: TContractState, receiver: ContractAddress, origin: Origin, payload: ByteArray,
+    );
+    fn test_skip(ref self: TContractState, receiver: ContractAddress, origin: Origin);
+    fn test_nilify(
+        ref self: TContractState, receiver: ContractAddress, origin: Origin, payload_hash: Bytes32,
+    );
+    fn test_burn(
+        ref self: TContractState, receiver: ContractAddress, origin: Origin, payload_hash: Bytes32,
+    );
+}

package/layerzero/tests/mocks/messaging_channel/messaging_channel.cairo

@@ -0,0 +1,138 @@
+//! Mock MessagingChannel contract for testing
+
+#[starknet::contract]
+pub mod MockMessagingChannel {
+    use layerzero::Origin;
+    use layerzero::endpoint::messaging_channel::messaging_channel::MessagingChannelComponent;
+    use lz_utils::bytes::Bytes32;
+    use lz_utils::error::{Error, format_error};
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starkware_utils::errors::assert_with_byte_array;
+    use crate::mocks::messaging_channel::interface::IMockMessagingChannel;
+
+    // === Error Definitions ===
+    #[derive(Drop)]
+    pub enum MockMessagingChannelError {
+        NotAuthorized,
+    }
+
+    impl ErrorNameImpl of Error<MockMessagingChannelError> {
+        fn prefix() -> ByteArray {
+            "MOCK_MESSAGING_CHANNEL"
+        }
+
+        fn name(self: MockMessagingChannelError) -> ByteArray {
+            match self {
+                MockMessagingChannelError::NotAuthorized => "NOT_AUTHORIZED",
+            }
+        }
+    }
+
+    component!(
+        path: MessagingChannelComponent, storage: messaging_channel, event: MessagingChannelEvent,
+    );
+
+    // MessagingChannel
+    #[abi(embed_v0)]
+    impl MessagingChannelImpl =
+        MessagingChannelComponent::MessagingChannel<ContractState>;
+    impl MessagingChannelInternalImpl = MessagingChannelComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        throw_on_authorize: bool,
+        #[substorage(v0)]
+        messaging_channel: MessagingChannelComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        MessagingChannelEvent: MessagingChannelComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, eid: u32) {
+        self.messaging_channel.initializer(eid);
+    }
+
+    pub fn err_not_authorized() -> ByteArray {
+        format_error(MockMessagingChannelError::NotAuthorized, "")
+    }
+
+    impl MockMessagingChannelHooks<
+        ContractState,
+    > of MessagingChannelComponent::IMessagingChannelHooks<ContractState> {
+        fn _assert_authorized(
+            self: @MessagingChannelComponent::ComponentState<ContractState>,
+            receiver: ContractAddress,
+        ) {
+            let mut contract_state = unsafe_new_contract_state();
+            assert_with_byte_array(!contract_state.throw_on_authorize.read(), err_not_authorized());
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl MockMessagingChannelHelpers of IMockMessagingChannelHelpers<ContractState> {
+        fn set_throw_on_authorize(ref self: ContractState, throw: bool) {
+            self.throw_on_authorize.write(throw);
+        }
+    }
+
+    #[starknet::interface]
+    pub trait IMockMessagingChannelHelpers<TContractState> {
+        fn set_throw_on_authorize(ref self: TContractState, throw: bool);
+    }
+
+    #[abi(embed_v0)]
+    impl MockMessagingChannelImpl of IMockMessagingChannel<ContractState> {
+        fn fake_commit(
+            ref self: ContractState,
+            receiver: ContractAddress,
+            origin: Origin,
+            payload_hash: Bytes32,
+        ) {
+            self
+                .messaging_channel
+                ._inbound_payload_hash_entry(receiver, origin.src_eid, origin.sender, origin.nonce)
+                .write(payload_hash);
+        }
+
+        fn fake_send(
+            ref self: ContractState, sender: ContractAddress, dst_eid: u32, receiver: Bytes32,
+        ) {
+            let entry = self.messaging_channel._outbound_nonce_entry(sender, dst_eid, receiver);
+            entry.write(entry.read() + 1);
+        }
+
+        fn test_clear_payload(
+            ref self: ContractState, receiver: ContractAddress, origin: Origin, payload: ByteArray,
+        ) {
+            self.messaging_channel._clear_payload(receiver, @origin, @payload);
+        }
+
+        fn test_skip(ref self: ContractState, receiver: ContractAddress, origin: Origin) {
+            self.messaging_channel.skip(receiver, origin);
+        }
+
+        fn test_nilify(
+            ref self: ContractState,
+            receiver: ContractAddress,
+            origin: Origin,
+            payload_hash: Bytes32,
+        ) {
+            self.messaging_channel.nilify(receiver, origin, payload_hash);
+        }
+
+        fn test_burn(
+            ref self: ContractState,
+            receiver: ContractAddress,
+            origin: Origin,
+            payload_hash: Bytes32,
+        ) {
+            self.messaging_channel.burn(receiver, origin, payload_hash);
+        }
+    }
+}