@layerzerolabs/protocol-starknet-v2 0.0.34

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

@@ -0,0 +1,173 @@
+//! ULN executor config tests
+
+use core::traits::TryInto;
+use layerzero::common::constants::ZERO_ADDRESS;
+use layerzero::message_lib::uln::structs::executor_config::{ExecutorConfig, ExecutorConfigResolver};
+use starknet::ContractAddress;
+
+// Test constants
+const EXECUTOR_1: ContractAddress = 1.try_into().unwrap();
+const EXECUTOR_2: ContractAddress = 2.try_into().unwrap();
+const EXECUTOR_3: ContractAddress = 3.try_into().unwrap();
+
+#[test]
+fn test_executor_config_default() {
+    let default_config: ExecutorConfig = Default::default();
+
+    assert(default_config.max_message_size == 0, 'default max_message_size wrong');
+    assert(default_config.executor == ZERO_ADDRESS, 'default executor wrong');
+}
+
+#[test]
+fn test_resolve_with_non_zero_custom_config() {
+    let default_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let custom_config = ExecutorConfig { max_message_size: 2000, executor: EXECUTOR_2 };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // All custom values should override default values
+    assert(resolved.max_message_size == 2000, 'max_message_size not overridden');
+    assert(resolved.executor == EXECUTOR_2, 'executor not overridden');
+}
+
+#[test]
+fn test_resolve_with_zero_custom_max_message_size() {
+    let default_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let custom_config = ExecutorConfig {
+        max_message_size: 0, // Should use default
+        executor: EXECUTOR_2,
+    };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // Default max_message_size should be kept when custom is zero
+    assert(resolved.max_message_size == 1000, 'maxMessageSize != default');
+    assert(resolved.executor == EXECUTOR_2, 'executor != custom');
+}
+
+#[test]
+fn test_resolve_with_zero_custom_executor() {
+    let default_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let custom_config = ExecutorConfig {
+        max_message_size: 2000, executor: ZERO_ADDRESS // Should use default
+    };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // Default executor should be kept when custom is zero address
+    assert(resolved.max_message_size == 2000, 'maxMessageSize != custom');
+    assert(resolved.executor == EXECUTOR_1, 'executor != default');
+}
+
+#[test]
+fn test_resolve_with_all_zero_custom_config() {
+    let default_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let custom_config = ExecutorConfig {
+        max_message_size: 0, // Should use default
+        executor: ZERO_ADDRESS // Should use default
+    };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // All default values should be kept
+    assert(resolved.max_message_size == 1000, 'maxMessageSize != default');
+    assert(resolved.executor == EXECUTOR_1, 'executor != default');
+}
+
+#[test]
+fn test_resolve_with_zero_default_config() {
+    let default_config = ExecutorConfig { max_message_size: 0, executor: ZERO_ADDRESS };
+
+    let custom_config = ExecutorConfig { max_message_size: 2000, executor: EXECUTOR_2 };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // Custom values should override zero defaults
+    assert(resolved.max_message_size == 2000, 'maxMessageSize != custom');
+    assert(resolved.executor == EXECUTOR_2, 'executor != custom');
+}
+
+#[test]
+fn test_resolve_with_both_zero_configs() {
+    let default_config = ExecutorConfig { max_message_size: 0, executor: ZERO_ADDRESS };
+
+    let custom_config = ExecutorConfig { max_message_size: 0, executor: ZERO_ADDRESS };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // Should result in zero values
+    assert(resolved.max_message_size == 0, 'maxMessageSize != zero');
+    assert(resolved.executor == ZERO_ADDRESS, 'executor != zero');
+}
+
+#[test]
+fn test_resolve_with_partial_custom_config() {
+    let default_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let custom_config = ExecutorConfig {
+        max_message_size: 2000, executor: ZERO_ADDRESS // Should use default
+    };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // Mix of custom and default values
+    assert(resolved.max_message_size == 2000, 'maxMessageSize != custom');
+    assert(resolved.executor == EXECUTOR_1, 'executor != default');
+}
+
+#[test]
+fn test_resolve_with_same_configs() {
+    let default_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let custom_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // Should result in the same values
+    assert(resolved.max_message_size == 1000, 'maxMessageSize != default');
+    assert(resolved.executor == EXECUTOR_1, 'executor != default');
+}
+
+#[test]
+fn test_resolve_with_max_values() {
+    let default_config = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let custom_config = ExecutorConfig {
+        max_message_size: 0xFFFFFFFF, // Max u32 value
+        executor: EXECUTOR_3,
+    };
+
+    let resolved = ExecutorConfigResolver::resolve(@default_config, @custom_config);
+
+    // Should handle max values correctly
+    assert(resolved.max_message_size == 0xFFFFFFFF, 'maxMessageSize != max');
+    assert(resolved.executor == EXECUTOR_3, 'executor != custom');
+}
+
+#[test]
+fn test_executor_config_clone() {
+    let original = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let cloned = original.clone();
+
+    // Verify clone works correctly
+    assert(cloned.max_message_size == 1000, 'cloned max_message_size wrong');
+    assert(cloned.executor == EXECUTOR_1, 'cloned executor wrong');
+}
+
+#[test]
+fn test_executor_config_equality() {
+    let config1 = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let config2 = ExecutorConfig { max_message_size: 1000, executor: EXECUTOR_1 };
+
+    let config3 = ExecutorConfig { max_message_size: 2000, executor: EXECUTOR_1 };
+
+    // Test equality
+    assert(config1 == config2, 'configs should be equal');
+    assert(config1 != config3, 'configs should not be equal');
+}

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

@@ -0,0 +1,329 @@
+//! ULN options tests
+
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+use core::byte_array::{ByteArray, ByteArrayTrait};
+use layerzero::message_lib::uln::options::{TYPE_3, split_options};
+use layerzero::workers::dvn::options::DVN_WORKER_ID;
+use layerzero::workers::executor::options::EXECUTOR_WORKER_ID;
+
+// Test error messages as constants (shortened to fit in felt252)
+const EXEC_EMPTY: felt252 = 'exec_options empty';
+const DVN_EMPTY: felt252 = 'dvn_options empty';
+const EXEC_NOT_EMPTY: felt252 = 'exec_options not empty';
+const DVN_NOT_EMPTY: felt252 = 'dvn_options not empty';
+const WRONG_EXEC_ID: felt252 = 'wrong exec worker id';
+const WRONG_DVN_ID: felt252 = 'wrong dvn worker id';
+const WRONG_EXEC_SIZE: felt252 = 'wrong exec option size';
+const WRONG_DVN_SIZE: felt252 = 'wrong dvn option size';
+const WRONG_EXEC_DATA: felt252 = 'wrong exec option data';
+const WRONG_DVN_DATA: felt252 = 'wrong dvn option data';
+const WRONG_FIRST_EXEC_ID: felt252 = 'wrong first exec id';
+const WRONG_SECOND_EXEC_ID: felt252 = 'wrong second exec id';
+const WRONG_FIRST_EXEC_SIZE: felt252 = 'wrong first exec size';
+const WRONG_SECOND_EXEC_SIZE: felt252 = 'wrong second exec size';
+const WRONG_FIRST_EXEC_DATA: felt252 = 'wrong first exec data';
+const WRONG_SECOND_EXEC_DATA: felt252 = 'wrong second exec data';
+const WRONG_FIRST_DVN_ID: felt252 = 'wrong first dvn id';
+const WRONG_SECOND_DVN_ID: felt252 = 'wrong second dvn id';
+const WRONG_FIRST_DVN_SIZE: felt252 = 'wrong first dvn size';
+const WRONG_SECOND_DVN_SIZE: felt252 = 'wrong second dvn size';
+
+/// Helper function to create a basic Type 3 options ByteArray
+fn create_type3_options() -> ByteArray {
+    let mut options: ByteArray = Default::default();
+    options.append_u16(TYPE_3); // Option type
+    options
+}
+
+/// Helper function to add a worker option to existing options
+fn add_worker_option(ref options: ByteArray, worker_id: u8, option_data: @ByteArray) {
+    options.append_u8(worker_id);
+    options.append_u16(option_data.len().try_into().unwrap());
+    options.append(option_data);
+}
+
+/// Helper function to create sample option data
+fn create_sample_option_data(size: usize) -> ByteArray {
+    let mut data: ByteArray = Default::default();
+    let mut i = 0;
+    while i != size.try_into().unwrap() {
+        data.append_u8(i);
+        i += 1;
+    }
+    data
+}
+
+#[test]
+fn test_decode_empty_options() {
+    let mut options = create_type3_options();
+    let (executor_options, dvn_options) = split_options(@options);
+
+    assert(executor_options.len() == 0, EXEC_EMPTY);
+    assert(dvn_options.len() == 0, DVN_EMPTY);
+}
+
+#[test]
+fn test_decode_single_executor_option() {
+    let mut options = create_type3_options();
+    let sample_data = create_sample_option_data(10);
+    add_worker_option(ref options, EXECUTOR_WORKER_ID, @sample_data);
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    // Check executor options
+    assert(executor_options.len() > 0, EXEC_NOT_EMPTY);
+    let (cursor, worker_id) = executor_options.read_u8(0);
+    assert(worker_id == EXECUTOR_WORKER_ID, WRONG_EXEC_ID);
+
+    let (cursor, option_size) = executor_options.read_u16(cursor);
+    assert(option_size == 10, WRONG_EXEC_SIZE);
+
+    let (_, option_data) = executor_options.read_bytes(cursor, 10);
+    assert(option_data == sample_data, WRONG_EXEC_DATA);
+
+    // Check DVN options are empty
+    assert(dvn_options.len() == 0, DVN_EMPTY);
+}
+
+#[test]
+fn test_decode_single_dvn_option() {
+    let mut options = create_type3_options();
+    let sample_data = create_sample_option_data(15);
+    add_worker_option(ref options, DVN_WORKER_ID, @sample_data);
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    // Check executor options are empty
+    assert(executor_options.len() == 0, EXEC_EMPTY);
+
+    // Check DVN options
+    assert(dvn_options.len() > 0, DVN_NOT_EMPTY);
+    let (cursor, worker_id) = dvn_options.read_u8(0);
+    assert(worker_id == DVN_WORKER_ID, WRONG_DVN_ID);
+
+    let (cursor, option_size) = dvn_options.read_u16(cursor);
+    assert(option_size == 15, WRONG_DVN_SIZE);
+
+    let (_, option_data) = dvn_options.read_bytes(cursor, 15);
+    assert(option_data == sample_data, WRONG_DVN_DATA);
+}
+
+#[test]
+fn test_decode_multiple_executor_options() {
+    let mut options = create_type3_options();
+    let sample_data1 = create_sample_option_data(5);
+    let sample_data2 = create_sample_option_data(8);
+
+    add_worker_option(ref options, EXECUTOR_WORKER_ID, @sample_data1);
+    add_worker_option(ref options, EXECUTOR_WORKER_ID, @sample_data2);
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    // Check executor options contain both entries
+    assert(executor_options.len() > 0, EXEC_NOT_EMPTY);
+
+    // First option
+    let (cursor, worker_id1) = executor_options.read_u8(0);
+    assert(worker_id1 == EXECUTOR_WORKER_ID, WRONG_FIRST_EXEC_ID);
+
+    let (cursor, option_size1) = executor_options.read_u16(cursor);
+    assert(option_size1 == 5, WRONG_FIRST_EXEC_SIZE);
+
+    let (cursor, option_data1) = executor_options.read_bytes(cursor, 5);
+    assert(option_data1 == sample_data1, WRONG_FIRST_EXEC_DATA);
+
+    // Second option
+    let (cursor, worker_id2) = executor_options.read_u8(cursor);
+    assert(worker_id2 == EXECUTOR_WORKER_ID, WRONG_SECOND_EXEC_ID);
+
+    let (cursor, option_size2) = executor_options.read_u16(cursor);
+    assert(option_size2 == 8, WRONG_SECOND_EXEC_SIZE);
+
+    let (_, option_data2) = executor_options.read_bytes(cursor, 8);
+    assert(option_data2 == sample_data2, WRONG_SECOND_EXEC_DATA);
+
+    // Check DVN options are empty
+    assert(dvn_options.len() == 0, DVN_EMPTY);
+}
+
+#[test]
+fn test_decode_mixed_executor_and_dvn_options() {
+    let mut options = create_type3_options();
+    let executor_data = create_sample_option_data(12);
+    let dvn_data = create_sample_option_data(7);
+
+    add_worker_option(ref options, EXECUTOR_WORKER_ID, @executor_data);
+    add_worker_option(ref options, DVN_WORKER_ID, @dvn_data);
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    // Check executor options
+    assert(executor_options.len() > 0, EXEC_NOT_EMPTY);
+    let (cursor, executor_worker_id) = executor_options.read_u8(0);
+    assert(executor_worker_id == EXECUTOR_WORKER_ID, WRONG_EXEC_ID);
+
+    let (cursor, executor_option_size) = executor_options.read_u16(cursor);
+    assert(executor_option_size == 12, WRONG_EXEC_SIZE);
+
+    let (_, executor_option_data) = executor_options.read_bytes(cursor, 12);
+    assert(executor_option_data == executor_data, WRONG_EXEC_DATA);
+
+    // Check DVN options
+    assert(dvn_options.len() > 0, DVN_NOT_EMPTY);
+    let (cursor, dvn_worker_id) = dvn_options.read_u8(0);
+    assert(dvn_worker_id == DVN_WORKER_ID, WRONG_DVN_ID);
+
+    let (cursor, dvn_option_size) = dvn_options.read_u16(cursor);
+    assert(dvn_option_size == 7, WRONG_DVN_SIZE);
+
+    let (_, dvn_option_data) = dvn_options.read_bytes(cursor, 7);
+    assert(dvn_option_data == dvn_data, WRONG_DVN_DATA);
+}
+
+#[test]
+fn test_decode_unknown_worker_id() {
+    let mut options = create_type3_options();
+    let sample_data = create_sample_option_data(5);
+    add_worker_option(ref options, 99, @sample_data); // Unknown worker ID
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    // Unknown worker options should be ignored
+    assert(executor_options.len() == 0, EXEC_EMPTY);
+    assert(dvn_options.len() == 0, DVN_EMPTY);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_options_too_short() {
+    let mut options: ByteArray = Default::default();
+    options.append_u8(1); // Only 1 byte, need at least 2
+    split_options(@options);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_unsupported_option_type() {
+    let mut options: ByteArray = Default::default();
+    options.append_u16(1); // Type 1 is not supported
+    split_options(@options);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_zero_worker_id() {
+    let mut options = create_type3_options();
+    let sample_data = create_sample_option_data(5);
+    add_worker_option(ref options, 0, @sample_data); // Worker ID 0 is invalid
+    split_options(@options);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_zero_option_size() {
+    let mut options = create_type3_options();
+    options.append_u8(EXECUTOR_WORKER_ID); // Valid worker ID
+    options.append_u16(0); // Invalid option size (0)
+    split_options(@options);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_truncated_option_data() {
+    let mut options = create_type3_options();
+    options.append_u8(EXECUTOR_WORKER_ID); // Valid worker ID
+    options.append_u16(10); // Claims 10 bytes of data
+    options.append_u8(1); // But only provides 1 byte
+    split_options(@options);
+}
+
+#[test]
+fn test_decode_minimum_valid_option() {
+    let mut options = create_type3_options();
+    let sample_data = create_sample_option_data(1); // Minimum 1 byte of data
+    add_worker_option(ref options, EXECUTOR_WORKER_ID, @sample_data);
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    assert(executor_options.len() > 0, EXEC_NOT_EMPTY);
+    assert(dvn_options.len() == 0, DVN_EMPTY);
+
+    let (cursor, worker_id) = executor_options.read_u8(0);
+    assert(worker_id == EXECUTOR_WORKER_ID, WRONG_EXEC_ID);
+
+    let (_, option_size) = executor_options.read_u16(cursor);
+    assert(option_size == 1, WRONG_EXEC_SIZE);
+}
+
+#[test]
+fn test_decode_large_option_data() {
+    let mut options = create_type3_options();
+    let sample_data = create_sample_option_data(255); // Large option data
+    add_worker_option(ref options, DVN_WORKER_ID, @sample_data);
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    assert(executor_options.len() == 0, EXEC_EMPTY);
+    assert(dvn_options.len() > 0, DVN_NOT_EMPTY);
+
+    let (cursor, worker_id) = dvn_options.read_u8(0);
+    assert(worker_id == DVN_WORKER_ID, WRONG_DVN_ID);
+
+    let (cursor, option_size) = dvn_options.read_u16(cursor);
+    assert(option_size == 255, WRONG_DVN_SIZE);
+
+    let (_, option_data) = dvn_options.read_bytes(cursor, 255);
+    assert(option_data == sample_data, WRONG_DVN_DATA);
+}
+
+#[test]
+fn test_decode_complex_mixed_scenario() {
+    let mut options = create_type3_options();
+
+    // Add multiple different options
+    let executor_data1 = create_sample_option_data(3);
+    let dvn_data1 = create_sample_option_data(6);
+    let executor_data2 = create_sample_option_data(9);
+    let dvn_data2 = create_sample_option_data(12);
+    let unknown_data = create_sample_option_data(4);
+
+    add_worker_option(ref options, EXECUTOR_WORKER_ID, @executor_data1);
+    add_worker_option(ref options, DVN_WORKER_ID, @dvn_data1);
+    add_worker_option(ref options, EXECUTOR_WORKER_ID, @executor_data2);
+    add_worker_option(ref options, 50, @unknown_data); // Unknown worker ID
+    add_worker_option(ref options, DVN_WORKER_ID, @dvn_data2);
+
+    let (executor_options, dvn_options) = split_options(@options);
+
+    // Verify executor options contain both executor entries
+    assert(executor_options.len() > 0, EXEC_NOT_EMPTY);
+
+    // First executor option
+    let (cursor, worker_id1) = executor_options.read_u8(0);
+    assert(worker_id1 == EXECUTOR_WORKER_ID, WRONG_FIRST_EXEC_ID);
+    let (cursor, option_size1) = executor_options.read_u16(cursor);
+    assert(option_size1 == 3, WRONG_FIRST_EXEC_SIZE);
+    let (cursor, _) = executor_options.read_bytes(cursor, 3);
+
+    // Second executor option
+    let (cursor, worker_id2) = executor_options.read_u8(cursor);
+    assert(worker_id2 == EXECUTOR_WORKER_ID, WRONG_SECOND_EXEC_ID);
+    let (_, option_size2) = executor_options.read_u16(cursor);
+    assert(option_size2 == 9, WRONG_SECOND_EXEC_SIZE);
+
+    // Verify DVN options contain both DVN entries
+    assert(dvn_options.len() > 0, DVN_NOT_EMPTY);
+
+    // First DVN option
+    let (cursor, dvn_worker_id1) = dvn_options.read_u8(0);
+    assert(dvn_worker_id1 == DVN_WORKER_ID, WRONG_FIRST_DVN_ID);
+    let (cursor, dvn_option_size1) = dvn_options.read_u16(cursor);
+    assert(dvn_option_size1 == 6, WRONG_FIRST_DVN_SIZE);
+    let (cursor, _) = dvn_options.read_bytes(cursor, 6);
+
+    // Second DVN option
+    let (cursor, dvn_worker_id2) = dvn_options.read_u8(cursor);
+    assert(dvn_worker_id2 == DVN_WORKER_ID, WRONG_SECOND_DVN_ID);
+    let (_, dvn_option_size2) = dvn_options.read_u16(cursor);
+    assert(dvn_option_size2 == 12, WRONG_SECOND_DVN_SIZE);
+}