@layerzerolabs/protocol-starknet-v2 0.0.34

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

@@ -0,0 +1,176 @@
+//! Mock Executor worker for testing
+
+#[starknet::contract]
+pub mod MockExecutor {
+    use layerzero::Origin;
+    use layerzero::common::conversions::FeltArrayIntoByteArrayImpl;
+    use layerzero::endpoint::events;
+    use layerzero::endpoint::interfaces::endpoint::{IEndpointDispatcher, IEndpointDispatcherTrait};
+    use layerzero::endpoint::messaging_composer::interface::{
+        IMessagingComposerDispatcher, IMessagingComposerDispatcherTrait,
+    };
+    use layerzero::workers::base::structs::QuoteParams;
+    use layerzero::workers::executor::interface::IExecutor;
+    use layerzero::workers::executor::structs::{
+        ComposeParams, DstConfig, ExecuteParams, NativeDropParams, SetDstConfigParams,
+    };
+    use layerzero::workers::interface::ILayerZeroWorker;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ClassHash, ContractAddress};
+    use starkware_utils::errors::assert_with_byte_array;
+
+    pub(crate) const DST_CONFIG: DstConfig = DstConfig {
+        lz_receive_base_gas: 100000,
+        multiplier_bps: 10000,
+        floor_margin_usd: 0,
+        native_cap: 1000000000000000000, // 1 ETH
+        lz_compose_base_gas: 50000,
+    };
+
+    #[storage]
+    struct Storage {
+        quote_result: u256,
+        should_fail: bool,
+        endpoint: ContractAddress,
+        token_address: ContractAddress,
+        composer: ContractAddress,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        PacketDelivered: events::PacketDelivered,
+        LzReceiveAlert: events::LzReceiveAlert,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        quote_result: u256,
+        endpoint: ContractAddress,
+        token_address: ContractAddress,
+        composer: ContractAddress,
+    ) {
+        self.quote_result.write(quote_result);
+        self.should_fail.write(false);
+        self.endpoint.write(endpoint);
+        self.token_address.write(token_address);
+        self.composer.write(composer);
+    }
+
+    #[abi(embed_v0)]
+    impl MockExecutorImpl of IExecutor<ContractState> {
+        /// Mock implementation - do nothing
+        fn set_dst_config(ref self: ContractState, params: Array<SetDstConfigParams>) {}
+
+        /// Mock implementation - return default config
+        fn get_dst_config(self: @ContractState, dst_eid: u32) -> DstConfig {
+            DST_CONFIG
+        }
+
+        /// Mock implementation - `lz_receive` on endpoint
+        fn execute(ref self: ContractState, params: ExecuteParams) {
+            IEndpointDispatcher { contract_address: self.endpoint.read() }
+                .lz_receive(
+                    params.origin,
+                    params.receiver,
+                    params.guid,
+                    params.message,
+                    params.value,
+                    params.extra_data,
+                );
+        }
+
+        /// Mock implementation - `lz_compose` on messaging composer
+        fn compose(ref self: ContractState, params: ComposeParams) {
+            IMessagingComposerDispatcher { contract_address: self.composer.read() }
+                .lz_compose(
+                    params.sender,
+                    params.receiver,
+                    params.guid,
+                    params.index,
+                    params.message,
+                    params.extra_data,
+                    params.value,
+                );
+        }
+
+        /// 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 native_drop(
+            ref self: ContractState,
+            origin: Origin,
+            oapp: ContractAddress,
+            native_drop_params: Array<NativeDropParams>,
+        ) {}
+
+        /// Reference implementation - call the native drop and then execute functions.
+        fn native_drop_and_execute(
+            ref self: ContractState,
+            native_drop_params: Array<NativeDropParams>,
+            execute_params: ExecuteParams,
+        ) {
+            self
+                .native_drop(
+                    execute_params.origin.clone(), execute_params.receiver, native_drop_params,
+                );
+            self.execute(execute_params);
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl LayerZeroWorkerImpl of ILayerZeroWorker<ContractState> {
+        /// Mock implementation - return quote result
+        fn assign_job(ref self: ContractState, params: QuoteParams) -> u256 {
+            assert_with_byte_array(!self.should_fail.read(), "MockExecutor: quote failed");
+
+            self.quote_result.read()
+        }
+
+        fn quote(self: @ContractState, params: QuoteParams) -> u256 {
+            assert_with_byte_array(!self.should_fail.read(), "MockExecutor: quote failed");
+
+            self.quote_result.read()
+        }
+    }
+
+    // Helper functions for testing
+    #[abi(embed_v0)]
+    impl MockExecutorHelpers of IMockExecutorHelpers<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 IMockExecutorHelpers<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/oapps/common/test_oapp_options_type_3.cairo

@@ -0,0 +1,279 @@
+//! OApp options type 3 tests
+
+use layerzero::oapps::common::oapp_options_type_3::interface::{
+    IOAppOptionsType3Dispatcher, IOAppOptionsType3DispatcherTrait,
+};
+use layerzero::oapps::common::oapp_options_type_3::structs::EnforcedOptionParam;
+use snforge_std::{
+    ContractClassTrait, DeclareResultTrait, declare, start_cheat_caller_address,
+    stop_cheat_caller_address,
+};
+use starknet::ContractAddress;
+
+// Helpers
+fn setup() -> (ContractAddress, IOAppOptionsType3Dispatcher, ContractAddress) {
+    let owner: ContractAddress = 0x123.try_into().unwrap();
+    let contract = declare("MockOAppOptionsType3").unwrap().contract_class();
+    let constructor_calldata = array![owner.into()];
+    let (contract_address, _) = contract.deploy(@constructor_calldata).unwrap();
+    let dispatcher = IOAppOptionsType3Dispatcher { contract_address };
+    (contract_address, dispatcher, owner)
+}
+
+fn create_type3_options() -> ByteArray {
+    let mut options: ByteArray = Default::default();
+    // Type 3 prefix (2 bytes)
+    options.append_byte(0x00);
+    options.append_byte(0x03);
+    // Some example option data
+    options.append_byte(0x01); // worker id
+    options.append_byte(0x00); // option size high byte
+    options.append_byte(0x05); // option size low byte (5 bytes)
+    options.append_byte(0x01); // option type
+    options.append_byte(0x00); // gas high byte
+    options.append_byte(0x00); // gas mid-high byte
+    options.append_byte(0x03); // gas mid-low byte  
+    options.append_byte(0xe8); // gas low byte (1000 in decimal)
+    options
+}
+
+fn create_invalid_type2_options() -> ByteArray {
+    let mut options: ByteArray = Default::default();
+    // Type 2 prefix (invalid for enforced options)
+    options.append_byte(0x00);
+    options.append_byte(0x02);
+    // Some option data
+    options.append_byte(0x01);
+    options.append_byte(0x02);
+    options
+}
+
+fn create_exactly_two_byte_type3_options() -> ByteArray {
+    let mut options: ByteArray = Default::default();
+    options.append_byte(0x00);
+    options.append_byte(0x03);
+    options
+}
+
+#[test]
+fn test_set_enforced_options_success() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    let options = create_type3_options();
+    let enforced_options = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: options.clone() },
+        EnforcedOptionParam { eid: 2, msg_type: 2, options: options.clone() },
+    ];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    // Verify the options were set
+    let retrieved_options = dispatcher.get_enforced_options(1, 1);
+    assert!(retrieved_options == options, "Options should match");
+
+    let retrieved_options2 = dispatcher.get_enforced_options(2, 2);
+    assert!(retrieved_options2 == options, "Options should match");
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+#[should_panic(expected: ('Caller is not the owner',))]
+fn test_set_enforced_options_only_owner() {
+    let (contract_address, dispatcher, _owner) = setup();
+
+    let non_owner: ContractAddress = 0x456.try_into().unwrap();
+    start_cheat_caller_address(contract_address, non_owner);
+
+    let options = create_type3_options();
+    let enforced_options = array![EnforcedOptionParam { eid: 1, msg_type: 1, options }];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+#[should_panic]
+fn test_set_enforced_options_invalid_type() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    let invalid_options = create_invalid_type2_options();
+    let enforced_options = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: invalid_options },
+    ];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+fn test_set_enforced_options_overwrite() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    // Set initial options
+    let initial_options = create_type3_options();
+    let enforced_options1 = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: initial_options.clone() },
+    ];
+    dispatcher.set_enforced_options(enforced_options1);
+
+    // Verify initial options are set
+    let retrieved_options = dispatcher.get_enforced_options(1, 1);
+    assert!(retrieved_options == initial_options, "Initial options should match");
+
+    // Overwrite with new options
+    let new_options = create_exactly_two_byte_type3_options();
+    let enforced_options2 = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: new_options.clone() },
+    ];
+    dispatcher.set_enforced_options(enforced_options2);
+
+    // Verify options were overwritten
+    let retrieved_options = dispatcher.get_enforced_options(1, 1);
+    assert!(retrieved_options == new_options, "Options should be overwritten");
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+fn test_combine_options_no_enforced() {
+    let (_contract_address, dispatcher, _owner) = setup();
+
+    let extra_options = create_type3_options();
+    let result = dispatcher.combine_options(1, 1, extra_options.clone());
+
+    assert!(result == extra_options, "Should return extra options when no enforced options");
+}
+
+#[test]
+fn test_combine_options_no_extra() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    let enforced_options_data = create_type3_options();
+    let enforced_options = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: enforced_options_data.clone() },
+    ];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    let empty_extra: ByteArray = Default::default();
+    let result = dispatcher.combine_options(1, 1, empty_extra);
+
+    assert!(
+        result == enforced_options_data, "Should return enforced options when no extra options",
+    );
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+fn test_combine_options_both_present() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    let enforced_options_data = create_type3_options();
+    let enforced_options = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: enforced_options_data.clone() },
+    ];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    let extra_options = create_type3_options();
+    let result = dispatcher.combine_options(1, 1, extra_options.clone());
+
+    // Result should be enforced + extra (without the type prefix from extra)
+    let mut expected = enforced_options_data.clone();
+    let mut i = 2; // Skip the first 2 bytes (type prefix) from extra options
+    while i < extra_options.len() {
+        if let Option::Some(byte) = extra_options.at(i) {
+            expected.append_byte(byte);
+        }
+        i += 1;
+    }
+
+    assert!(result == expected, "Should combine enforced and extra options");
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+#[should_panic]
+fn test_combine_options_invalid_extra_options() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    let enforced_options_data = create_type3_options();
+    let enforced_options = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: enforced_options_data },
+    ];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    let invalid_extra = create_invalid_type2_options();
+    dispatcher.combine_options(1, 1, invalid_extra);
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+fn test_combine_options_extra_exactly_two_bytes() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    let enforced_options_data = create_type3_options();
+    let enforced_options = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: enforced_options_data.clone() },
+    ];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    let two_byte_extra = create_exactly_two_byte_type3_options();
+    let result = dispatcher.combine_options(1, 1, two_byte_extra);
+
+    // Should return just enforced options since extra has no data after type prefix
+    assert!(result == enforced_options_data, "Should return only enforced options");
+
+    stop_cheat_caller_address(contract_address);
+}
+
+#[test]
+fn test_get_enforced_options_empty() {
+    let (_contract_address, dispatcher, _owner) = setup();
+
+    let result = dispatcher.get_enforced_options(999, 999);
+    let empty: ByteArray = Default::default();
+
+    assert!(result == empty, "Should return empty for non-existent options");
+}
+
+#[test]
+fn test_get_enforced_options_existing() {
+    let (contract_address, dispatcher, owner) = setup();
+
+    start_cheat_caller_address(contract_address, owner);
+
+    let options = create_type3_options();
+    let enforced_options = array![
+        EnforcedOptionParam { eid: 1, msg_type: 1, options: options.clone() },
+    ];
+
+    dispatcher.set_enforced_options(enforced_options);
+
+    let retrieved = dispatcher.get_enforced_options(1, 1);
+    assert!(retrieved == options, "Should retrieve correct options");
+
+    stop_cheat_caller_address(contract_address);
+}