@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

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

@@ -1,319 +0,0 @@
-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_len(), 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, #1105)")] // 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, #1106)")] // 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, #1107)")] // 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, #1109)")] // 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, #1108)")] // 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, #1102)")] // 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, #1102)")] // 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, #1103)")] // 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, #1103)")] // 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, #1104)")] // 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);
-}