@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/mocks/receiver.cairo

@@ -0,0 +1,54 @@
+//! Mock LayerZero receiver for testing
+
+#[starknet::contract]
+pub mod MockReceiver {
+    use layerzero::common::structs::packet::Origin;
+    use layerzero::endpoint::interfaces::layerzero_receiver::ILayerZeroReceiver;
+    use lz_utils::bytes::Bytes32;
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+
+    #[storage]
+    struct Storage {
+        allow_initialize: bool,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState) {
+        self.allow_initialize.write(true);
+    }
+
+    #[abi(embed_v0)]
+    impl MockReceiverImpl of ILayerZeroReceiver<ContractState> {
+        fn lz_receive(
+            ref self: ContractState,
+            origin: Origin,
+            guid: Bytes32,
+            message: ByteArray,
+            executor: ContractAddress,
+            value: u256,
+            extra_data: ByteArray,
+        ) { // empty LzReceive implementation for now
+        }
+
+        fn allow_initialize_path(self: @ContractState, origin: Origin) -> bool {
+            self.allow_initialize.read()
+        }
+        fn next_nonce(self: @ContractState, src_eid: u32, sender: Bytes32) -> u64 {
+            0
+        }
+    }
+
+    // Helper functions for testing
+    #[abi(embed_v0)]
+    impl MockReceiverHelpers of IMockReceiverHelpers<ContractState> {
+        fn set_allow_initialize(ref self: ContractState, allow: bool) {
+            self.allow_initialize.write(allow);
+        }
+    }
+
+    #[starknet::interface]
+    pub trait IMockReceiverHelpers<TContractState> {
+        fn set_allow_initialize(ref self: TContractState, allow: bool);
+    }
+}

package/layerzero/tests/mocks/treasury/lz_token_fee_lib.cairo

@@ -0,0 +1,57 @@
+//! Mock LayerZero token fee library for testing
+
+#[starknet::interface]
+pub trait IMockLzTokenFeeLibAssertion<TContractState> {
+    fn assert_payment_count(self: @TContractState, count: felt252);
+}
+
+#[starknet::contract]
+pub mod MockLzTokenFeeLib {
+    use layerzero::treasury::interfaces::lz_token_fee_lib::ILzTokenFeeLib;
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use super::IMockLzTokenFeeLibAssertion;
+
+    #[storage]
+    struct Storage {
+        fee: u256,
+        payment_count: felt252,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, fee: u256) {
+        self.fee.write(fee);
+    }
+
+    #[abi(embed_v0)]
+    impl LzTokenFeeLibImpl of ILzTokenFeeLib<ContractState> {
+        fn get_fee(
+            self: @ContractState,
+            sender: ContractAddress,
+            dst_eid: u32,
+            worker_fee: u256,
+            native_treasury_fee: u256,
+        ) -> u256 {
+            self.fee.read()
+        }
+
+        fn pay_fee(
+            ref self: ContractState,
+            sender: ContractAddress,
+            dst_eid: u32,
+            worker_fee: u256,
+            native_treasury_fee: u256,
+        ) -> u256 {
+            self.payment_count.write(self.payment_count.read() + 1);
+
+            self.fee.read()
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl MockLzTokenFeeLibStateImpl of IMockLzTokenFeeLibAssertion<ContractState> {
+        fn assert_payment_count(self: @ContractState, count: felt252) {
+            assert!(self.payment_count.read() == count);
+        }
+    }
+}

package/layerzero/tests/mocks/treasury/treasury.cairo

@@ -0,0 +1,74 @@
+//! Mock LayerZero treasury for testing
+
+#[starknet::contract]
+pub mod MockTreasury {
+    use layerzero::treasury::interfaces::layerzero_treasury::ILayerZeroTreasury;
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+
+    #[storage]
+    struct Storage {
+        native_fee: u256,
+        lz_token_fee: Option<u256>,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, native_fee: u256) {
+        self.native_fee.write(native_fee);
+    }
+
+    #[abi(embed_v0)]
+    impl MockTreasuryImpl of ILayerZeroTreasury<ContractState> {
+        fn get_fee(
+            self: @ContractState,
+            sender: ContractAddress,
+            dst_eid: u32,
+            worker_fee: u256,
+            pay_in_lz_token: bool,
+        ) -> u256 {
+            if pay_in_lz_token {
+                self.lz_token_fee.read().expect('LZ token fee')
+            } else {
+                self.native_fee.read()
+            }
+        }
+
+        fn pay_fee(
+            ref self: ContractState,
+            sender: ContractAddress,
+            dst_eid: u32,
+            worker_fee: u256,
+            pay_in_lz_token: bool,
+        ) -> u256 {
+            self.get_fee(sender, dst_eid, worker_fee, pay_in_lz_token)
+        }
+    }
+
+    // Helper functions for testing
+    #[abi(embed_v0)]
+    impl MockTreasuryHelpers of IMockTreasuryHelpers<ContractState> {
+        fn get_native_fee(self: @ContractState) -> u256 {
+            self.native_fee.read()
+        }
+
+        fn set_native_fee(ref self: ContractState, fee: u256) {
+            self.native_fee.write(fee);
+        }
+
+        fn get_lz_token_fee(self: @ContractState) -> Option<u256> {
+            self.lz_token_fee.read()
+        }
+
+        fn set_lz_token_fee(ref self: ContractState, fee: Option<u256>) {
+            self.lz_token_fee.write(fee);
+        }
+    }
+
+    #[starknet::interface]
+    pub trait IMockTreasuryHelpers<TContractState> {
+        fn get_native_fee(self: @TContractState) -> u256;
+        fn set_native_fee(ref self: TContractState, fee: u256);
+        fn get_lz_token_fee(self: @TContractState) -> Option<u256>;
+        fn set_lz_token_fee(ref self: TContractState, fee: Option<u256>);
+    }
+}

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

@@ -0,0 +1,12 @@
+//! Mock ULN config interface for testing
+
+use layerzero::message_lib::uln::structs::uln_config::UlnConfig;
+
+/// Mock interface to test UlnConfigStorageNode functionality
+#[starknet::interface]
+pub trait IMockUlnConfig<TContractState> {
+    fn set_uln_config(ref self: TContractState, config: UlnConfig);
+    fn _clear_dvns(ref self: TContractState);
+    fn get_uln_config(self: @TContractState) -> UlnConfig;
+    fn resolve(ref self: TContractState, default: UlnConfig, custom: UlnConfig) -> UlnConfig;
+}

package/layerzero/tests/mocks/uln_config/uln_config.cairo

@@ -0,0 +1,35 @@
+//! Mock ULN config for testing
+
+/// Mock contract for testing the UlnConfigStorageNode struct
+#[starknet::contract]
+pub mod MockUlnConfig {
+    use layerzero::message_lib::uln::structs::uln_config::{UlnConfig, UlnConfigUtils};
+    use layerzero::message_lib::uln::structs::uln_config_storage_node::{
+        UlnConfigStorageNode, UlnConfigStorageNodeTrait,
+    };
+    use crate::mocks::uln_config::interface::IMockUlnConfig;
+
+    #[storage]
+    struct Storage {
+        pub uln_config_node: UlnConfigStorageNode,
+    }
+
+    #[abi(embed_v0)]
+    impl MockUlnConfigImpl of IMockUlnConfig<ContractState> {
+        fn set_uln_config(ref self: ContractState, config: UlnConfig) {
+            self.uln_config_node.set_uln_config(config);
+        }
+
+        fn _clear_dvns(ref self: ContractState) {
+            self.uln_config_node._clear_dvns();
+        }
+
+        fn get_uln_config(self: @ContractState) -> UlnConfig {
+            self.uln_config_node.get_uln_config()
+        }
+
+        fn resolve(ref self: ContractState, default: UlnConfig, custom: UlnConfig) -> UlnConfig {
+            UlnConfigUtils::resolve(@default, @custom)
+        }
+    }
+}

package/layerzero/tests/mocks/workers/base.cairo

@@ -0,0 +1,80 @@
+//! Base worker contract wrapping the base worker component for testing
+
+#[starknet::contract]
+pub mod MockBaseWorker {
+    use layerzero::workers::base::base::WorkerBaseComponent;
+    use openzeppelin::access::accesscontrol::AccessControlComponent;
+    use openzeppelin::introspection::src5::SRC5Component;
+    use openzeppelin::security::pausable::PausableComponent;
+    use openzeppelin::upgrades::upgradeable::UpgradeableComponent;
+    use starknet::ContractAddress;
+
+    ////////////////
+    // Components //
+    ////////////////
+
+    component!(path: WorkerBaseComponent, storage: worker_base, event: WorkerBaseEvent);
+    component!(path: AccessControlComponent, storage: access_control, event: AccessControlEvent);
+    component!(path: SRC5Component, storage: src5, event: SRC5Event);
+    component!(path: UpgradeableComponent, storage: upgradeable, event: UpgradeableEvent);
+    component!(path: PausableComponent, storage: pausable, event: PausableEvent);
+
+    ////////////////
+    // Embeddings //
+    ////////////////
+
+    #[abi(embed_v0)]
+    impl WorkerBaseImpl = WorkerBaseComponent::WorkerBaseImpl<ContractState>;
+    impl WorkerBaseInternalImpl = WorkerBaseComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl AccessControlImpl = WorkerBaseComponent::AccessControlImpl<ContractState>;
+    impl AccessControlInternalImpl = AccessControlComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl PausableImpl = PausableComponent::PausableImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        worker_base: WorkerBaseComponent::Storage,
+        #[substorage(v0)]
+        access_control: AccessControlComponent::Storage,
+        #[substorage(v0)]
+        src5: SRC5Component::Storage,
+        #[substorage(v0)]
+        upgradeable: UpgradeableComponent::Storage,
+        #[substorage(v0)]
+        pausable: PausableComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        WorkerBaseEvent: WorkerBaseComponent::Event,
+        #[flat]
+        AccessControlEvent: AccessControlComponent::Event,
+        #[flat]
+        SRC5Event: SRC5Component::Event,
+        #[flat]
+        UpgradeableEvent: UpgradeableComponent::Event,
+        #[flat]
+        PausableEvent: PausableComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        message_libs: Array<ContractAddress>,
+        price_feed: ContractAddress,
+        default_multiplier_bps: u16,
+        role_admin: ContractAddress,
+        admins: Array<ContractAddress>,
+    ) {
+        self.access_control.initializer();
+        self
+            .worker_base
+            .initializer(message_libs, price_feed, default_multiplier_bps, role_admin, admins);
+    }
+}

package/layerzero/tests/mocks/workers/dvn.cairo

@@ -0,0 +1,115 @@
+//! Mock DVN worker contract for testing
+
+#[starknet::contract]
+pub mod MockDVN {
+    use layerzero::workers::base::structs::QuoteParams;
+    use layerzero::workers::dvn::interface::IDvn;
+    use layerzero::workers::dvn::structs::{DstConfig, ExecuteParam, SetDstConfigParams};
+    use layerzero::workers::interface::ILayerZeroWorker;
+    use lz_utils::bytes::Bytes32;
+    use starknet::ClassHash;
+    use starknet::account::Call;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starkware_utils::errors::assert_with_byte_array;
+
+    pub(crate) const DST_CONFIG: DstConfig = DstConfig {
+        gas: 100000, multiplier_bps: 10000, floor_margin_usd: 0,
+    };
+    pub(crate) const DST_CONFIG_2: DstConfig = DstConfig {
+        gas: 200000, multiplier_bps: 20000, floor_margin_usd: 0,
+    };
+
+    #[storage]
+    struct Storage {
+        quote_result: u256,
+        should_fail: bool,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, quote_result: u256) {
+        self.quote_result.write(quote_result);
+        self.should_fail.write(false);
+    }
+
+    #[abi(embed_v0)]
+    impl MockDVNImpl of IDvn<ContractState> {
+        /// Mock implementation - do nothing
+        fn set_dst_config(ref self: ContractState, params: Array<SetDstConfigParams>) {}
+
+        /// Mock implementation - do nothing
+        fn execute(ref self: ContractState, params: Array<ExecuteParam>) {}
+
+        /// Mock implementation - do nothing
+        fn upgrade(ref self: ContractState, new_class_hash: ClassHash) {}
+
+        /// Mock implementation - do nothing
+        fn upgrade_and_call(
+            ref self: ContractState,
+            new_class_hash: ClassHash,
+            selector: felt252,
+            calldata: Span<felt252>,
+        ) -> Span<felt252> {
+            array![].span()
+        }
+
+        /// Mock implementation - do nothing
+        fn quorum_change_admin(ref self: ContractState, param: ExecuteParam) {}
+
+        /// Mock implementation - return default config
+        fn get_dst_config(self: @ContractState, dst_eid: u32) -> DstConfig {
+            if dst_eid == 0 {
+                DST_CONFIG
+            } else {
+                DST_CONFIG_2
+            }
+        }
+
+        /// Mock implementation - return dummy hash
+        fn hash_call_data(
+            self: @ContractState, vid: u32, call_data: Call, expiration: u256,
+        ) -> Bytes32 {
+            Bytes32 { value: 'mock_hash'.into() }
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl MockLayerZeroWorkerImpl of ILayerZeroWorker<ContractState> {
+        fn assign_job(ref self: ContractState, params: QuoteParams) -> u256 {
+            assert_with_byte_array(!self.should_fail.read(), "MockDVN: quote failed");
+            self.quote_result.read()
+        }
+
+        fn quote(self: @ContractState, params: QuoteParams) -> u256 {
+            assert_with_byte_array(!self.should_fail.read(), "MockDVN: quote failed");
+            self.quote_result.read()
+        }
+    }
+
+    /// Helper functions for testing
+    #[abi(embed_v0)]
+    impl MockDVNHelpers of IMockDVNHelpers<ContractState> {
+        fn set_quote_result(ref self: ContractState, quote_result: u256) {
+            self.quote_result.write(quote_result);
+        }
+
+        fn get_quote_result(self: @ContractState) -> u256 {
+            self.quote_result.read()
+        }
+
+        fn set_should_fail(ref self: ContractState, should_fail: bool) {
+            self.should_fail.write(should_fail);
+        }
+
+        fn get_should_fail(self: @ContractState) -> bool {
+            self.should_fail.read()
+        }
+    }
+
+    #[starknet::interface]
+    pub trait IMockDVNHelpers<TContractState> {
+        fn set_quote_result(ref self: TContractState, quote_result: u256);
+        fn get_quote_result(self: @TContractState) -> u256;
+        fn set_should_fail(ref self: TContractState, should_fail: bool);
+        fn get_should_fail(self: @TContractState) -> bool;
+    }
+}

package/layerzero/tests/mocks/workers/executor/decode/decode.cairo

@@ -0,0 +1,97 @@
+//! Mock ExecutorDecode interface for testing
+
+#[starknet::contract]
+mod MockExecutorDecode {
+    use core::array::Span;
+    use core::byte_array::ByteArray;
+    use layerzero::workers::common::{
+        apply_premium_and_floor_margin, convert_and_apply_premium_to_value,
+    };
+    use layerzero::workers::executor::options::{
+        ExecutorOptionsAggregated, PriceFeedParams, _aggregate_options, _decode_executor_options,
+        _parse_options_to_array, _read_lz_compose_option, _read_lz_read_option,
+        _read_lz_receive_option, _read_native_drop_option,
+    };
+    use layerzero::workers::executor::structs::{
+        ExecutorOption, LzComposeOption, LzReadOption, LzReceiveOption, NativeDropOption,
+    };
+    use crate::mocks::workers::executor::decode::interface::IMockExecutorDecode;
+
+
+    #[storage]
+    struct Storage {}
+
+    #[abi(embed_v0)]
+    impl MockExecutorDecodeImpl of IMockExecutorDecode<ContractState> {
+        fn decode_executor_options(
+            self: @ContractState,
+            is_read: bool,
+            v1_eid: bool,
+            lz_receive_base_gas: u256,
+            lz_compose_base_gas: u256,
+            native_cap: u128,
+            options: ByteArray,
+        ) -> PriceFeedParams {
+            _decode_executor_options(
+                is_read, v1_eid, lz_receive_base_gas, lz_compose_base_gas, native_cap, @options,
+            )
+        }
+
+        fn apply_premium_to_gas(
+            self: @ContractState,
+            fee: u256,
+            bps: u16,
+            default_bps: u16,
+            margin_usd: u128,
+            native_price_usd: u128,
+        ) -> u256 {
+            apply_premium_and_floor_margin(fee, bps, default_bps, margin_usd, native_price_usd)
+        }
+
+        fn convert_and_apply_premium_to_value(
+            self: @ContractState, value: u256, ratio: u128, denom: u128, bps: u16, default_bps: u16,
+        ) -> u256 {
+            convert_and_apply_premium_to_value(value, ratio, denom, bps, default_bps)
+        }
+
+        fn parse_options_to_array(
+            self: @ContractState, options_bytes: ByteArray,
+        ) -> Array<ExecutorOption> {
+            _parse_options_to_array(@options_bytes)
+        }
+
+        fn aggregate_options(
+            self: @ContractState,
+            options_span: Span<ExecutorOption>,
+            is_read: bool,
+            v1_eid: bool,
+            native_cap: u128,
+        ) -> ExecutorOptionsAggregated {
+            _aggregate_options(options_span, is_read, v1_eid, native_cap)
+        }
+
+        fn read_lz_receive_option(
+            self: @ContractState, b: ByteArray, offset: usize, len: usize,
+        ) -> LzReceiveOption {
+            _read_lz_receive_option(@b, offset, len)
+        }
+
+        fn read_native_drop_option(
+            self: @ContractState, b: ByteArray, offset: usize, len: usize,
+        ) -> NativeDropOption {
+            _read_native_drop_option(@b, offset, len)
+        }
+
+        fn read_lz_compose_option(
+            self: @ContractState, b: ByteArray, offset: usize, len: usize,
+        ) -> LzComposeOption {
+            _read_lz_compose_option(@b, offset, len)
+        }
+
+        fn read_lz_read_option(
+            self: @ContractState, b: ByteArray, offset: usize, len: usize,
+        ) -> LzReadOption {
+            _read_lz_read_option(@b, offset, len)
+        }
+    }
+}

package/layerzero/tests/mocks/workers/executor/decode/interface.cairo

@@ -0,0 +1,59 @@
+//! Mock ExecutorDecode interface for testing
+
+use core::array::Span;
+use core::byte_array::ByteArray;
+use layerzero::workers::executor::options::{ExecutorOptionsAggregated, PriceFeedParams};
+use layerzero::workers::executor::structs::{
+    ExecutorOption, LzComposeOption, LzReadOption, LzReceiveOption, NativeDropOption,
+};
+
+#[starknet::interface]
+pub trait IMockExecutorDecode<TContractState> {
+    fn decode_executor_options(
+        self: @TContractState,
+        is_read: bool,
+        v1_eid: bool,
+        lz_receive_base_gas: u256,
+        lz_compose_base_gas: u256,
+        native_cap: u128,
+        options: ByteArray,
+    ) -> PriceFeedParams;
+
+    fn apply_premium_to_gas(
+        self: @TContractState,
+        fee: u256,
+        bps: u16,
+        default_bps: u16,
+        margin_usd: u128,
+        native_price_usd: u128,
+    ) -> u256;
+
+    fn convert_and_apply_premium_to_value(
+        self: @TContractState, value: u256, ratio: u128, denom: u128, bps: u16, default_bps: u16,
+    ) -> u256;
+
+    fn parse_options_to_array(
+        self: @TContractState, options_bytes: ByteArray,
+    ) -> Array<ExecutorOption>;
+
+    fn aggregate_options(
+        self: @TContractState,
+        options_span: Span<ExecutorOption>,
+        is_read: bool,
+        v1_eid: bool,
+        native_cap: u128,
+    ) -> ExecutorOptionsAggregated;
+
+    fn read_lz_receive_option(
+        self: @TContractState, b: ByteArray, offset: usize, len: usize,
+    ) -> LzReceiveOption;
+    fn read_native_drop_option(
+        self: @TContractState, b: ByteArray, offset: usize, len: usize,
+    ) -> NativeDropOption;
+    fn read_lz_compose_option(
+        self: @TContractState, b: ByteArray, offset: usize, len: usize,
+    ) -> LzComposeOption;
+    fn read_lz_read_option(
+        self: @TContractState, b: ByteArray, offset: usize, len: usize,
+    ) -> LzReadOption;
+}