@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,319 @@
+use crate::worker_options::{
+    convert_legacy_options, split_worker_options, EXECUTOR_OPTION_TYPE_LZRECEIVE, EXECUTOR_OPTION_TYPE_NATIVE_DROP,
+    EXECUTOR_WORKER_ID, LEGACY_OPTIONS_TYPE_1, LEGACY_OPTIONS_TYPE_2, OPTIONS_TYPE_3,
+};
+use hex_literal::hex;
+use soroban_sdk::{Bytes, BytesN, Env};
+use utils::buffer_reader::BufferReader;
+
+#[test]
+fn test_split_worker_options_dvn_only() {
+    let env = Env::default();
+
+    // Build TYPE_3 options with only DVN options
+    // 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);
+
+    // Check DVN options are grouped correctly by index
+    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_executor_only() {
+    let env = Env::default();
+
+    // Build TYPE_3 options with two executor options
+    // x"0003" + x"0100110100000000000000000000000000009470010011010000000000000000000000000000ea60"
+    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_options() {
+    let env = Env::default();
+
+    // Build TYPE_3 options with executor and DVN options
+    // executor: x"0100110100000000000000000000000000009470010011010000000000000000000000000000ea60"
+    // dvn: x"020002000102000302ff0102000200010200020101"
+    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);
+
+    // Check DVN options grouped by index
+    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_decode_legacy_options_type_1() {
+    let env = Env::default();
+
+    // Legacy type 1: x"0001" + gas as u256 (200000 = 0x30d40)
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
+    options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000030d40"));
+
+    let (executor_options, dvn_options) = split_worker_options(&env, &options);
+
+    // Expected: x"0100110100000000000000000000000000030d40"
+    assert_eq!(executor_options, Bytes::from_slice(&env, &hex!("0100110100000000000000000000000000030d40")));
+    assert_eq!(dvn_options.len(), 0);
+
+    // Verify by parsing
+    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(), 200000);
+    assert_eq!(reader.remaining(), 0);
+}
+
+#[test]
+fn test_decode_legacy_options_type_2() {
+    let env = Env::default();
+
+    // Legacy type 2: gas(u256) + amount(u256) + receiver(20 bytes)
+    // gas: 200000 (0x30d40), amount: 10000000 (0x989680), receiver: 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+    let legacy_options = Bytes::from_slice(&env, &hex!("0000000000000000000000000000000000000000000000000000000000030d400000000000000000000000000000000000000000000000000000000000989680f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
+    let expected_options = hex!("0100110100000000000000000000000000030d400100310200000000000000000000000000989680000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266");
+
+    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
+
+    // adapter params type 2 includes both lzReceive and nativeDrop
+    assert_eq!(executor_options, Bytes::from_slice(&env, &expected_options));
+
+    // Verify by parsing
+    let mut reader = BufferReader::new(&executor_options);
+
+    // lzReceive option
+    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 option
+    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"))
+    );
+}
+
+#[test]
+fn test_split_worker_options_using_legacy_option() {
+    let env = Env::default();
+
+    // Same as test_decode_legacy_options_type_2
+    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!("0000000000000000000000000000000000000000000000000000000000030d400000000000000000000000000000000000000000000000000000000000989680f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
+    let expected_options = hex!("0100110100000000000000000000000000030d400100310200000000000000000000000000989680000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266");
+
+    let (executor_options, _) = split_worker_options(&env, &legacy_options);
+
+    // adapter params type 2 includes both lzReceive and nativeDrop
+    assert_eq!(executor_options, Bytes::from_slice(&env, &expected_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"))
+    );
+}
+
+#[test]
+fn test_group_dvn_options_by_index() {
+    let env = Env::default();
+
+    let dvn_option_bytes = hex!("020002000102000302ff0102000200010200020101");
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
+    options.extend_from_slice(&dvn_option_bytes);
+
+    let (_, dvn_options) = split_worker_options(&env, &options);
+
+    let expected_dvn_0_options = hex!("02000200010200020001"); // 2 DVN options, id = 0
+    let expected_dvn_1_options = hex!("0200020101"); // 1 DVN option, id = 1
+    let expected_dvn_2_options = hex!("02000302ff01"); // 1 DVN option, id = 2
+
+    let mut found_0 = false;
+    let mut found_1 = false;
+    let mut found_2 = false;
+
+    // Check that DVN options are grouped correctly by index
+    for (index, option) in dvn_options.iter() {
+        if index == 0 {
+            found_0 = true;
+            assert_eq!(option, Bytes::from_slice(&env, &expected_dvn_0_options));
+        }
+        if index == 1 {
+            found_1 = true;
+            assert_eq!(option, Bytes::from_slice(&env, &expected_dvn_1_options));
+        }
+        if index == 2 {
+            found_2 = true;
+            assert_eq!(option, Bytes::from_slice(&env, &expected_dvn_2_options));
+        }
+    }
+    assert!(found_0 && found_1 && found_2);
+}
+
+#[test]
+fn test_get_matching_options() {
+    let env = Env::default();
+
+    // Same DVN options as test_split_worker_options_dvn_only
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
+    options.extend_from_slice(&hex!("020002000102000302ff0102000200010200020101"));
+
+    let (_, dvn_options) = split_worker_options(&env, &options);
+
+    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")));
+}
+
+// ============ Error tests ============
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11101)")] // WorkerOptionsError::InvalidOptions
+fn test_decode_invalid_options_too_short() {
+    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, #11102)")] // WorkerOptionsError::InvalidWorkerId
+fn test_decode_invalid_worker_id() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
+    options.extend_from_slice(&hex!("00000501020304050607")); // Invalid worker_id = 0
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11104)")] // WorkerOptionsError::LegacyOptionsType1GasOverflow
+fn test_legacy_type1_gas_overflow() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
+    options.extend_from_slice(&hex!("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); // u256 max
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11106)")] // WorkerOptionsError::LegacyOptionsType2GasOverflow
+fn test_legacy_type2_gas_overflow() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
+    options.extend_from_slice(&hex!("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000003e84242424242424242424242424242424242424242424242424242424242424242"));
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11107)")] // WorkerOptionsError::LegacyOptionsType2AmountOverflow
+fn test_legacy_type2_amount_overflow() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
+    options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000030d40ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff4242424242424242424242424242424242424242424242424242424242424242"));
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11103)")] // WorkerOptionsError::InvalidLegacyOptionsType1
+fn test_legacy_type1_invalid_size_too_short() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
+    options.extend_from_slice(&hex!("00000000000000000000000000000000")); // Only 16 bytes
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11103)")] // WorkerOptionsError::InvalidLegacyOptionsType1
+fn test_legacy_type1_invalid_size_too_long() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
+    options.extend_from_slice(&hex!(
+        "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+    )); // 48 bytes
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11105)")] // WorkerOptionsError::InvalidLegacyOptionsType2
+fn test_legacy_type2_invalid_size_too_short() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
+    options.extend_from_slice(&hex!("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")); // 64 bytes, no receiver
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11105)")] // WorkerOptionsError::InvalidLegacyOptionsType2
+fn test_legacy_type2_invalid_size_too_long() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
+    options.extend_from_slice(&[0u8; 97]); // 97 bytes, too long
+    split_worker_options(&env, &options);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11108)")] // WorkerOptionsError::InvalidOptionType
+fn test_unsupported_option_type() {
+    let env = Env::default();
+    let mut options = Bytes::new(&env);
+    options.extend_from_slice(&hex!("0063")); // Invalid type 99
+    options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000000000"));
+    split_worker_options(&env, &options);
+}

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

@@ -0,0 +1,190 @@
+use crate::errors::WorkerOptionsError;
+use soroban_sdk::{assert_with_error, bytes, map, panic_with_error, Bytes, BytesN, Env, Map};
+use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter, option_ext::OptionExt};
+
+// Option type constants
+pub const LEGACY_OPTIONS_TYPE_1: u16 = 1; // legacy options type 1
+pub const LEGACY_OPTIONS_TYPE_2: u16 = 2; // legacy options type 2
+pub const OPTIONS_TYPE_3: u16 = 3; // modern options type 3
+
+// Worker ID constants
+pub const EXECUTOR_WORKER_ID: u8 = 1;
+pub const DVN_WORKER_ID: u8 = 2;
+
+// Executor option type constants
+pub const EXECUTOR_OPTION_TYPE_LZRECEIVE: u8 = 1;
+pub const EXECUTOR_OPTION_TYPE_NATIVE_DROP: u8 = 2;
+
+// DVN option byte offset (dvn_idx is the 4th byte of the option bytes)
+pub const DVN_IDX_OFFSET: u32 = 3;
+
+/// Splits worker options into separate executor and DVN option collections.
+///
+/// This is the main entry point for processing worker options. It automatically
+/// detects the option format version and delegates to the appropriate parser.
+///
+/// Format detection:
+/// - Type 3: Modern flexible format with multiple worker types
+/// - Type 1 & 2: Legacy formats (executor options only, no DVN options)
+///
+/// # Arguments
+/// * `options` - The raw options bytes
+///
+/// # Returns
+/// A tuple of (executor_options, dvn_options_map)
+pub fn split_worker_options(env: &Env, options: &Bytes) -> (Bytes, Map<u32, Bytes>) {
+    assert_with_error!(env, options.len() >= 2, WorkerOptionsError::InvalidOptions);
+
+    let mut reader = BufferReader::new(options);
+    let options_type = reader.read_u16();
+
+    if options_type == OPTIONS_TYPE_3 {
+        extract_type_3_options(env, &mut reader)
+    } else {
+        let executor_options = convert_legacy_options(env, &mut reader, options_type);
+        (executor_options, map![env])
+    }
+}
+
+/// Extracts options from the modern Type 3 format.
+///
+/// Type 3 format supports multiple workers (executors and DVNs) with flexible
+/// option structures. Each worker option includes its own size header.
+///
+/// Format Structure:
+/// ```text
+/// [worker_option][worker_option][worker_option]...
+///
+/// Worker Option:
+/// [worker_id: u8][option_size: u16][option_data: bytes(option_size)]
+/// ```
+///
+/// # Arguments
+/// * `options_reader` - Buffer reader positioned after the options type header
+///
+/// # Returns
+/// A tuple of (executor_options, dvn_options_map)
+pub fn extract_type_3_options(env: &Env, options_reader: &mut BufferReader) -> (Bytes, Map<u32, Bytes>) {
+    let mut executor_options = bytes!(env);
+    let mut dvn_options = map![env];
+
+    while options_reader.remaining() > 0 {
+        let worker_id = options_reader.read_u8();
+        let option_size = options_reader.read_u16() as u32;
+
+        // Rewind to the start of the current option and read the complete option bytes
+        // 3 bytes for worker_id (1) + option_size (2)
+        let current_option = options_reader.rewind(3).read_bytes(3 + option_size);
+
+        match worker_id {
+            EXECUTOR_WORKER_ID => executor_options.append(&current_option),
+            DVN_WORKER_ID => append_dvn_option(&mut dvn_options, current_option),
+            _ => panic_with_error!(env, WorkerOptionsError::InvalidWorkerId),
+        }
+    }
+
+    (executor_options, dvn_options)
+}
+
+/// Converts legacy option formats (Type 1 and Type 2) to executor options in Type 3 format.
+///
+/// Legacy formats only supported executor options and did not include DVN options.
+///
+/// Legacy Format Details:
+/// - **Type 1**: `[execution_gas: u256]` (32 bytes total)
+/// - **Type 2**: `[execution_gas: u256][amount: u256][receiver: bytes(0-32)]` (64-96 bytes total)
+///
+/// Note: Legacy formats use u256 for gas/amounts, but Type 3 uses u128.
+/// The conversion will panic if values exceed u128 range.
+///
+/// # Arguments
+/// * `options` - Buffer reader positioned after the options type header
+/// * `option_type` - The legacy option type (1 or 2)
+///
+/// # Returns
+/// Executor options in Type 3 format
+pub fn convert_legacy_options(env: &Env, options: &mut BufferReader, option_type: u16) -> Bytes {
+    let mut executor_options = BufferWriter::new(env);
+    let options_size = options.remaining();
+
+    match option_type {
+        LEGACY_OPTIONS_TYPE_1 => {
+            assert_with_error!(env, options_size == 32, WorkerOptionsError::InvalidLegacyOptionsType1);
+            // Execution gas (u256 -> u128)
+            let execution_gas =
+                options.read_u256().to_u128().unwrap_or_panic(env, WorkerOptionsError::LegacyOptionsType1GasOverflow);
+
+            append_lz_receive_option(&mut executor_options, execution_gas);
+        }
+        LEGACY_OPTIONS_TYPE_2 => {
+            assert_with_error!(
+                env,
+                options_size > 64 && options_size <= 96,
+                WorkerOptionsError::InvalidLegacyOptionsType2
+            );
+            // Execution gas & amount (u256 -> u128)
+            let execution_gas =
+                options.read_u256().to_u128().unwrap_or_panic(env, WorkerOptionsError::LegacyOptionsType2GasOverflow);
+            let amount = options
+                .read_u256()
+                .to_u128()
+                .unwrap_or_panic(env, WorkerOptionsError::LegacyOptionsType2AmountOverflow);
+
+            let receiver = left_pad_to_bytes32(env, &options.read_bytes_until_end());
+
+            append_lz_receive_option(&mut executor_options, execution_gas);
+            append_native_drop_option(&mut executor_options, amount, &receiver);
+        }
+        _ => panic_with_error!(env, WorkerOptionsError::InvalidOptionType),
+    }
+
+    // Ensure all bytes were consumed
+    assert_with_error!(env, options.remaining() == 0, WorkerOptionsError::InvalidOptions);
+    executor_options.to_bytes()
+}
+
+// ========================================================
+// Internal Helper Functions
+// ========================================================
+
+/// Efficiently groups DVN options by index.
+///
+/// Searches for existing DVN options with the same index and concatenates them,
+/// or creates a new entry if this is the first option for this DVN index.
+fn append_dvn_option(dvn_options: &mut Map<u32, Bytes>, option_bytes: Bytes) {
+    let dvn_idx = option_bytes.get(DVN_IDX_OFFSET).unwrap() as u32;
+    if dvn_options.contains_key(dvn_idx) {
+        let mut existing = dvn_options.get(dvn_idx).unwrap();
+        existing.append(&option_bytes);
+        dvn_options.set(dvn_idx, existing);
+    } else {
+        dvn_options.set(dvn_idx, option_bytes);
+    }
+}
+
+/// Appends a LzReceive option to the executor options bytes.
+/// Format: [worker_id][option_size][option_type][execution_gas]
+fn append_lz_receive_option(buf: &mut BufferWriter, execution_gas: u128) {
+    buf.write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+        .write_u16(17) // option_size: option_type(1) + data(16) = 17 bytes
+        .write_u8(EXECUTOR_OPTION_TYPE_LZRECEIVE) // option_type (1 byte)
+        .write_u128(execution_gas); // execution gas data (16 bytes)
+}
+
+/// Appends a native drop option to the executor options bytes.
+/// Format: [worker_id][option_size][option_type][amount][receiver]
+fn append_native_drop_option(buf: &mut BufferWriter, amount: u128, receiver: &BytesN<32>) {
+    buf.write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+        .write_u16(49) // option_size: option_type(1) + amount(16) + receiver(32) = 49 bytes
+        .write_u8(EXECUTOR_OPTION_TYPE_NATIVE_DROP) // option_type (1 byte)
+        .write_u128(amount) // drop amount (16 bytes)
+        .write_bytes_n(receiver); // receiver address (32 bytes)
+}
+
+/// Converts Bytes to BytesN<32> with left-padding (zeros at the beginning)
+fn left_pad_to_bytes32(env: &Env, bytes: &Bytes) -> BytesN<32> {
+    assert_with_error!(env, bytes.len() <= 32, WorkerOptionsError::InvalidBytesLength);
+    let mut buf = [0u8; 32];
+    bytes.copy_into_slice(&mut buf[32 - bytes.len() as usize..]);
+    BytesN::from_array(env, &buf)
+}

package/contracts/message-libs/simple-message-lib/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "simple-message-lib"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+doctest = false
+
+[features]
+library = []
+testutils = []
+
+[dependencies]
+cfg-if = { workspace = true }
+soroban-sdk = { workspace = true }
+# workspace dependencies
+common-macros = { workspace = true }
+utils = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+message-lib-common = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }

package/contracts/message-libs/simple-message-lib/src/errors.rs

@@ -0,0 +1,11 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum SimpleMessageLibError {
+    NotImplemented,
+    NativeFeeNotSet,
+    ZROFeeNotSet,
+    ZROTokenNotSet,
+    OnlyWhitelistedCaller,
+    UnableToConvertAddress,
+}

package/contracts/message-libs/simple-message-lib/src/lib.rs

@@ -0,0 +1,14 @@
+#![no_std]
+
+cfg_if::cfg_if! {
+    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
+        mod errors;
+        mod simple_message_lib;
+        mod storage;
+
+        pub use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
+    }
+}
+
+#[cfg(test)]
+mod test;