@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/message-libs/message-lib-common/src/tests/worker_options/convert_legacy_options.rs

@@ -0,0 +1,280 @@
+use crate::worker_options::*;
+use hex_literal::hex;
+use soroban_sdk::{Bytes, BytesN, Env};
+use utils::buffer_reader::BufferReader;
+
+#[test]
+fn test_convert_legacy_options_type2_outputs_lz_receive_and_native_drop() {
+    let env = Env::default();
+
+    // Legacy type 2: gas(u256) + amount(u256) + receiver(20 bytes)
+    // gas: 200000 (0x30d40), amount: 10000000 (0x989680)
+    let legacy_options = Bytes::from_slice(
+        &env,
+        &hex!(
+            "0000000000000000000000000000000000000000000000000000000000030d40\
+             0000000000000000000000000000000000000000000000000000000000989680\
+             f39fd6e51aad88f6f4ce6ab8827279cfffb92266"
+        ),
+    );
+    let expected_executor_options = Bytes::from_slice(&env, &hex!("0100110100000000000000000000000000030d400100310200000000000000000000000000989680000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
+
+    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+
+    assert_eq!(executor_options, expected_executor_options);
+
+    let mut reader = BufferReader::new(&executor_options);
+    // lzReceive
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
+    assert_eq!(reader.read_u16(), 17);
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE);
+    assert_eq!(reader.read_u128(), 200000);
+    // nativeDrop
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
+    assert_eq!(reader.read_u16(), 49);
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP);
+    assert_eq!(reader.read_u128(), 10000000);
+    assert_eq!(
+        reader.read_bytes_n(),
+        BytesN::from_array(&env, &hex!("000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"))
+    );
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_convert_legacy_options_type1_outputs_lz_receive() {
+    let env = Env::default();
+
+    // Legacy type 1: gas(u256)
+    // gas: 200000 (0x30d40)
+    let legacy_options =
+        Bytes::from_slice(&env, &hex!("0000000000000000000000000000000000000000000000000000000000030d40"));
+    let expected_executor_options = Bytes::from_slice(&env, &hex!("0100110100000000000000000000000000030d40"));
+
+    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_1);
+
+    assert_eq!(executor_options, expected_executor_options);
+
+    let mut reader = BufferReader::new(&executor_options);
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 17); // option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE); // option_type
+    assert_eq!(reader.read_u128(), 200000); // option_data
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_convert_legacy_options_type2_receiver_len_1_is_left_padded_to_bytes32() {
+    let env = Env::default();
+
+    // Legacy type 2: gas(u256) + amount(u256) + receiver(1 byte)
+    // gas: 200000 (0x30d40), amount: 10000000 (0x989680), receiver: 0x42
+    let legacy_options = Bytes::from_slice(
+        &env,
+        &hex!(
+            "0000000000000000000000000000000000000000000000000000000000030d40\
+             0000000000000000000000000000000000000000000000000000000000989680\
+             42"
+        ),
+    );
+
+    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+
+    let mut reader = BufferReader::new(&executor_options);
+    // lzReceive
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 17); // option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE); // option_type
+    assert_eq!(reader.read_u128(), 200000); // option_data
+                                            // nativeDrop
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 49); // option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP); // option_type
+    assert_eq!(reader.read_u128(), 10000000); // option_data
+    assert_eq!(
+        reader.read_bytes_n(),
+        BytesN::from_array(&env, &hex!("0000000000000000000000000000000000000000000000000000000000000042"))
+    ); // option value (receiver)
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_convert_legacy_options_type2_receiver_len_32_is_not_modified() {
+    let env = Env::default();
+
+    // Legacy type 2: gas(u256) + amount(u256) + receiver(32 bytes)
+    let legacy_options = Bytes::from_slice(
+        &env,
+        &hex!(
+            "0000000000000000000000000000000000000000000000000000000000030d40\
+             0000000000000000000000000000000000000000000000000000000000989680\
+             1111111111111111111111111111111111111111111111111111111111111111"
+        ),
+    );
+
+    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+
+    let mut reader = BufferReader::new(&executor_options);
+    // lzReceive
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
+    assert_eq!(reader.read_u16(), 17);
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE);
+    assert_eq!(reader.read_u128(), 200000);
+    // nativeDrop
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
+    assert_eq!(reader.read_u16(), 49);
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP);
+    assert_eq!(reader.read_u128(), 10000000);
+    assert_eq!(reader.read_bytes_n(), BytesN::from_array(&env, &[0x11u8; 32]));
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_convert_legacy_options_type1_allows_u128_max_gas() {
+    let env = Env::default();
+
+    // gas(u256) where value == u128::MAX (fits, should not overflow)
+    // u256 big-endian: 16 bytes zeros + 16 bytes 0xff
+    let legacy_options =
+        Bytes::from_slice(&env, &hex!("00000000000000000000000000000000ffffffffffffffffffffffffffffffff"));
+
+    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_1);
+
+    let expected_executor_options = Bytes::from_slice(&env, &hex!("01001101ffffffffffffffffffffffffffffffff"));
+    assert_eq!(executor_options, expected_executor_options);
+
+    let mut reader = BufferReader::new(&executor_options);
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
+    assert_eq!(reader.read_u16(), 17);
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE);
+    assert_eq!(reader.read_u128(), u128::MAX);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_convert_legacy_options_type2_allows_u128_max_gas_and_amount() {
+    let env = Env::default();
+
+    // gas(u256)=u128::MAX, amount(u256)=u128::MAX, receiver(32 bytes)=0x11...
+    let legacy_options = Bytes::from_slice(
+        &env,
+        &hex!(
+            "00000000000000000000000000000000ffffffffffffffffffffffffffffffff\
+             00000000000000000000000000000000ffffffffffffffffffffffffffffffff\
+             1111111111111111111111111111111111111111111111111111111111111111"
+        ),
+    );
+
+    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+
+    let mut reader = BufferReader::new(&executor_options);
+    // lzReceive
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
+    assert_eq!(reader.read_u16(), 17);
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE);
+    assert_eq!(reader.read_u128(), u128::MAX);
+    // nativeDrop
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
+    assert_eq!(reader.read_u16(), 49);
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP);
+    assert_eq!(reader.read_u128(), u128::MAX);
+    assert_eq!(reader.read_bytes_n(), BytesN::from_array(&env, &[0x11u8; 32]));
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1116)")] // WorkerOptionsError::LegacyOptionsType1GasOverflow
+fn test_convert_legacy_options_type1_rejects_gas_overflow() {
+    let env = Env::default();
+    // Minimal overflow value: u128::MAX + 1 == 2^128
+    // u256 big-endian: 16 bytes zeros + 0x01 + 15 bytes zeros + 16 bytes zeros
+    let legacy_options =
+        Bytes::from_slice(&env, &hex!("0000000000000000000000000000000100000000000000000000000000000000"));
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_1);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1118)")] // WorkerOptionsError::LegacyOptionsType2GasOverflow
+fn test_convert_legacy_options_type2_rejects_gas_overflow() {
+    let env = Env::default();
+    let legacy_options = Bytes::from_slice(
+        &env,
+        &hex!(
+            "0000000000000000000000000000000100000000000000000000000000000000\
+             00000000000000000000000000000000000000000000000000000000000003e8\
+             4242424242424242424242424242424242424242"
+        ),
+    );
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1117)")] // WorkerOptionsError::LegacyOptionsType2AmountOverflow
+fn test_convert_legacy_options_type2_rejects_amount_overflow() {
+    let env = Env::default();
+    let legacy_options = Bytes::from_slice(
+        &env,
+        &hex!(
+            "0000000000000000000000000000000000000000000000000000000000030d40\
+             0000000000000000000000000000000100000000000000000000000000000000\
+             4242424242424242424242424242424242424242"
+        ),
+    );
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1112)")] // WorkerOptionsError::InvalidLegacyOptionsType2
+fn test_convert_legacy_options_type2_rejects_receiver_longer_than_32_bytes() {
+    let env = Env::default();
+
+    // gas(u256) + amount(u256) + receiver(33 bytes)
+    let mut bytes = [0u8; 32 + 32 + 33];
+    bytes[31] = 1; // gas = 1
+    bytes[63] = 1; // amount = 1
+    bytes[64..].fill(0x42); // receiver bytes
+
+    let legacy_options = Bytes::from_slice(&env, &bytes);
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1113)")] // WorkerOptionsError::InvalidOptionType
+fn test_convert_legacy_options_rejects_unknown_legacy_type() {
+    let env = Env::default();
+    let legacy_options = Bytes::from_slice(&env, &[0u8; 32]);
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), 99);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1111)")] // WorkerOptionsError::InvalidLegacyOptionsType1
+fn test_convert_legacy_options_type1_rejects_invalid_size_too_short() {
+    let env = Env::default();
+    let legacy_options = Bytes::from_slice(&env, &[0u8; 31]); // 31 bytes
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_1);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1111)")] // WorkerOptionsError::InvalidLegacyOptionsType1
+fn test_convert_legacy_options_type1_rejects_invalid_size_too_long() {
+    let env = Env::default();
+    let legacy_options = Bytes::from_slice(&env, &[0u8; 33]); // 33 bytes
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_1);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1112)")] // WorkerOptionsError::InvalidLegacyOptionsType2
+fn test_convert_legacy_options_type2_rejects_invalid_size_too_short() {
+    let env = Env::default();
+    // 64 bytes (no receiver)
+    let legacy_options = Bytes::from_slice(&env, &[0u8; 64]); // 64 bytes
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1112)")] // WorkerOptionsError::InvalidLegacyOptionsType2
+fn test_convert_legacy_options_type2_rejects_invalid_size_too_long() {
+    let env = Env::default();
+    let legacy_options = Bytes::from_slice(&env, &[0u8; 97]); // 97 bytes
+    convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+}

package/contracts/message-libs/message-lib-common/src/tests/worker_options/extract_type_3_options.rs

@@ -0,0 +1,126 @@
+use crate::worker_options::extract_type_3_options;
+use hex_literal::hex;
+use soroban_sdk::map;
+use soroban_sdk::{Bytes, Env};
+use utils::buffer_reader::BufferReader;
+
+#[test]
+fn test_extract_type_3_options_returns_empty_for_empty_body() {
+    let env = Env::default();
+
+    // Empty body (reader positioned after the 2-byte options type header).
+    let body = Bytes::new(&env);
+    let mut reader = BufferReader::new(&body);
+
+    let (executor_options, dvn_options) = extract_type_3_options(&env, &mut reader);
+    assert_eq!(executor_options.len(), 0);
+    assert_eq!(dvn_options, map![&env]);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_extract_type_3_options_splits_executor_and_dvn() {
+    let env = Env::default();
+
+    // but without the 2-byte options type prefix.
+    let executor_options_raw = hex!("0100110100000000000000000000000000009470010011010000000000000000000000000000ea60");
+    let dvn_options_raw = hex!("020002000102000302ff0102000200010200020101");
+
+    let mut body = Bytes::new(&env);
+    body.extend_from_slice(&executor_options_raw);
+    body.extend_from_slice(&dvn_options_raw);
+    let mut reader = BufferReader::new(&body);
+
+    let (executor_options, dvn_options) = extract_type_3_options(&env, &mut reader);
+
+    // Executor option is preserved as-is.
+    assert_eq!(executor_options, Bytes::from_slice(&env, &executor_options_raw));
+
+    // DVN options are grouped by dvn_idx (4th byte of the option bytes).
+    assert_eq!(dvn_options.len(), 3);
+    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
+    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
+    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_extract_type_3_options_executor_only_options() {
+    let env = Env::default();
+
+    // Two executor options back-to-back.
+    let executor_options_raw = hex!("0100110100000000000000000000000000009470010011010000000000000000000000000000ea60");
+    let body = Bytes::from_slice(&env, &executor_options_raw);
+    let mut reader = BufferReader::new(&body);
+
+    let (executor_options, dvn_options) = extract_type_3_options(&env, &mut reader);
+
+    assert_eq!(executor_options, Bytes::from_slice(&env, &executor_options_raw));
+    assert_eq!(dvn_options.len(), 0);
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_extract_type_3_options_dvn_only_groups_same_idx_by_concatenation() {
+    let env = Env::default();
+
+    // Same DVN test vector as used by `split_worker_options`:
+    // - dvn_idx=0 appears twice and should be concatenated.
+    let dvn_options_raw = hex!("020002000102000302ff0102000200010200020101");
+    let body = Bytes::from_slice(&env, &dvn_options_raw);
+    let mut reader = BufferReader::new(&body);
+
+    let (executor_options, dvn_options) = extract_type_3_options(&env, &mut reader);
+
+    assert_eq!(executor_options.len(), 0);
+    assert_eq!(dvn_options.len(), 3);
+    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
+    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
+    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_extract_type_3_options_interleaved_executor_and_dvn_keeps_executor_order() {
+    let env = Env::default();
+
+    let exec_1 = hex!("0100110100000000000000000000000000009470");
+    let exec_2 = hex!("010011010000000000000000000000000000ea60");
+    let dvn_0 = hex!("0200020001");
+    let dvn_2 = hex!("02000302ff01");
+    let dvn_1 = hex!("0200020101");
+
+    // Interleave DVN and executor options; executor bytes should still be preserved
+    // and returned as the concatenation in encounter-order.
+    let mut body = Bytes::new(&env);
+    body.extend_from_slice(&dvn_0);
+    body.extend_from_slice(&exec_1);
+    body.extend_from_slice(&dvn_2);
+    body.extend_from_slice(&exec_2);
+    body.extend_from_slice(&dvn_0);
+    body.extend_from_slice(&dvn_1);
+
+    let mut reader = BufferReader::new(&body);
+    let (executor_options, dvn_options) = extract_type_3_options(&env, &mut reader);
+
+    let mut expected_executor = Bytes::new(&env);
+    expected_executor.extend_from_slice(&exec_1);
+    expected_executor.extend_from_slice(&exec_2);
+    assert_eq!(executor_options, expected_executor);
+
+    assert_eq!(dvn_options.len(), 3);
+    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
+    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
+    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1115)")] // WorkerOptionsError::InvalidWorkerId
+fn test_extract_type_3_options_rejects_unknown_worker_id() {
+    let env = Env::default();
+    // worker_id = 0 (invalid) + option_size = 5 + 5 bytes of dummy data
+    let body = Bytes::from_slice(&env, &hex!("00000501020304050607"));
+    let mut reader = BufferReader::new(&body);
+    extract_type_3_options(&env, &mut reader);
+}

package/contracts/message-libs/message-lib-common/src/tests/worker_options/left_pad_to_bytes32.rs

@@ -0,0 +1,48 @@
+use crate::worker_options::test;
+use hex_literal::hex;
+use soroban_sdk::{Bytes, BytesN, Env};
+
+#[test]
+fn test_left_pad_to_bytes32_pads_left_with_zeros() {
+    let env = Env::default();
+
+    let input_20 = Bytes::from_slice(&env, &hex!("f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
+    let out_32 = test::left_pad_to_bytes32_for_test(&env, &input_20);
+
+    assert_eq!(
+        out_32,
+        BytesN::from_array(&env, &hex!("000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"))
+    );
+
+    let empty = Bytes::new(&env);
+    let out_empty = test::left_pad_to_bytes32_for_test(&env, &empty);
+    assert_eq!(out_empty, BytesN::from_array(&env, &[0u8; 32]));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1110)")] // WorkerOptionsError::InvalidBytesLength
+fn test_left_pad_to_bytes32_rejects_len_greater_than_32() {
+    let env = Env::default();
+    let too_long = Bytes::from_slice(&env, &[0u8; 33]);
+    test::left_pad_to_bytes32_for_test(&env, &too_long);
+}
+
+#[test]
+fn test_left_pad_to_bytes32_len_32_is_unchanged() {
+    let env = Env::default();
+
+    let input = Bytes::from_slice(&env, &[0x11u8; 32]);
+    let out = test::left_pad_to_bytes32_for_test(&env, &input);
+    assert_eq!(out, BytesN::from_array(&env, &[0x11u8; 32]));
+}
+
+#[test]
+fn test_left_pad_to_bytes32_len_31_pads_single_leading_zero() {
+    let env = Env::default();
+
+    let input = Bytes::from_slice(&env, &[0x22u8; 31]);
+    let out = test::left_pad_to_bytes32_for_test(&env, &input);
+    let mut expected = [0u8; 32];
+    expected[1..].fill(0x22);
+    assert_eq!(out, BytesN::from_array(&env, &expected));
+}

package/contracts/message-libs/message-lib-common/src/tests/worker_options/mod.rs

@@ -0,0 +1,7 @@
+mod append_dvn_option;
+mod append_lz_receive_option;
+mod append_native_drop_option;
+mod convert_legacy_options;
+mod extract_type_3_options;
+mod left_pad_to_bytes32;
+mod split_worker_options;

package/contracts/message-libs/message-lib-common/src/tests/worker_options/split_worker_options.rs

@@ -0,0 +1,139 @@
+use crate::worker_options::*;
+use hex_literal::hex;
+use soroban_sdk::{Bytes, BytesN, Env};
+use utils::buffer_reader::BufferReader;
+
+#[test]
+fn test_split_worker_options_type3_dvn_only() {
+    let env = Env::default();
+
+    // Type 3, DVN options only.
+    // x"0003" + x"020002000102000302ff0102000200010200020101"
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
+    options.extend_from_slice(&hex!("020002000102000302ff0102000200010200020101"));
+
+    let (executor_options, dvn_options) = split_worker_options(&env, &options);
+
+    assert_eq!(executor_options.len(), 0);
+    assert_eq!(dvn_options.len(), 3);
+
+    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
+    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
+    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
+}
+
+#[test]
+fn test_split_worker_options_type3_executor_only() {
+    let env = Env::default();
+
+    // Type 3, executor options only.
+    let executor_options_raw = hex!("0100110100000000000000000000000000009470010011010000000000000000000000000000ea60");
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
+    options.extend_from_slice(&executor_options_raw);
+
+    let (executor_options, dvn_options) = split_worker_options(&env, &options);
+
+    assert_eq!(executor_options, Bytes::from_slice(&env, &executor_options_raw));
+    assert_eq!(dvn_options.len(), 0);
+}
+
+#[test]
+fn test_split_worker_options_type3_executor_and_dvn() {
+    let env = Env::default();
+
+    // Type 3, executor + DVN options.
+    let executor_options_raw = hex!("0100110100000000000000000000000000009470010011010000000000000000000000000000ea60");
+    let dvn_options_raw = hex!("020002000102000302ff0102000200010200020101");
+
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
+    options.extend_from_slice(&executor_options_raw);
+    options.extend_from_slice(&dvn_options_raw);
+
+    let (executor_options, dvn_options) = split_worker_options(&env, &options);
+
+    assert_eq!(executor_options, Bytes::from_slice(&env, &executor_options_raw));
+    assert_eq!(dvn_options.len(), 3);
+
+    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
+    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
+    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
+}
+
+#[test]
+fn test_split_worker_options_legacy_type1_converts_to_executor_options() {
+    let env = Env::default();
+
+    // Legacy type 1: [type][gas(u256)].
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
+    options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000030d40")); // 200_000
+
+    let (executor_options, dvn_options) = split_worker_options(&env, &options);
+
+    assert_eq!(executor_options, Bytes::from_slice(&env, &hex!("0100110100000000000000000000000000030d40")));
+    assert_eq!(dvn_options.len(), 0);
+
+    let mut reader = BufferReader::new(&executor_options);
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 17); // option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE); // option_type
+    assert_eq!(reader.read_u128(), 200000); // option_data
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+fn test_split_worker_options_legacy_type2_converts_to_executor_options() {
+    let env = Env::default();
+
+    // Legacy type 2: [type][gas(u256)][amount(u256)][receiver(20 bytes)].
+    let mut legacy_options = Bytes::new(&env);
+    legacy_options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
+    legacy_options.extend_from_slice(&hex!(
+        "0000000000000000000000000000000000000000000000000000000000030d40\
+         0000000000000000000000000000000000000000000000000000000000989680\
+         f39fd6e51aad88f6f4ce6ab8827279cfffb92266"
+    ));
+
+    let expected_executor_options = Bytes::from_slice(&env, &hex!("0100110100000000000000000000000000030d400100310200000000000000000000000000989680000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
+
+    let (executor_options, dvn_options) = split_worker_options(&env, &legacy_options);
+    assert_eq!(dvn_options.len(), 0);
+    assert_eq!(executor_options, expected_executor_options);
+
+    let mut reader = BufferReader::new(&executor_options);
+    // lzReceive
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 17); // option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE); // option_type
+    assert_eq!(reader.read_u128(), 200000); // option value (execution gas)
+                                            // nativeDrop
+    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID); // worker_id
+    assert_eq!(reader.read_u16(), 49); //option_size
+    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP); // option_type
+    assert_eq!(reader.read_u128(), 10000000); // option value (amount)
+    assert_eq!(
+        reader.read_bytes_n(),
+        BytesN::from_array(&env, &hex!("000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"))
+    ); // option value (receiver)
+    assert_eq!(reader.remaining_len(), 0);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1114)")] // WorkerOptionsError::InvalidOptions
+fn test_split_worker_options_rejects_too_short_options() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.push_back(OPTIONS_TYPE_3 as u8);
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1114)")] // WorkerOptionsError::InvalidOptions
+fn test_split_worker_options_rejects_empty_options() {
+    let env = Env::default();
+    let options = Bytes::new(&env);
+    split_worker_options(&env, &options);
+}

package/contracts/message-libs/message-lib-common/src/worker_options.rs

@@ -181,4 +181,34 @@ fn left_pad_to_bytes32(env: &Env, bytes: &Bytes) -> BytesN<32> {
     BytesN::from_array(env, &buf)
 }
 
-// TODO (ethan): add more negative test cases for worker options
+// ========================================================
+// Test-only wrappers for internal helper functions
+// ========================================================
+//
+// These allow unit tests under `src/tests/...` (a sibling module of `worker_options`)
+// to exercise internal helpers without changing their visibility in production builds.
+#[cfg(test)]
+#[allow(dead_code)]
+pub(crate) mod test {
+    use super::*;
+
+    pub fn append_dvn_option_for_test(env: &Env, dvn_options: &mut Map<u32, Bytes>, option_bytes: Bytes) {
+        super::append_dvn_option(env, dvn_options, option_bytes)
+    }
+
+    pub fn append_lz_receive_option_for_test(env: &Env, execution_gas: u128) -> Bytes {
+        let mut buf = BufferWriter::new(env);
+        super::append_lz_receive_option(&mut buf, execution_gas);
+        buf.to_bytes()
+    }
+
+    pub fn append_native_drop_option_for_test(env: &Env, amount: u128, receiver: &BytesN<32>) -> Bytes {
+        let mut buf = BufferWriter::new(env);
+        super::append_native_drop_option(&mut buf, amount, receiver);
+        buf.to_bytes()
+    }
+
+    pub fn left_pad_to_bytes32_for_test(env: &Env, bytes: &Bytes) -> BytesN<32> {
+        super::left_pad_to_bytes32(env, bytes)
+    }
+}