@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/contracts/endpoint-v2/src/tests/endpoint_v2/ttl_config.rs

@@ -2,20 +2,20 @@ use crate::tests::endpoint_setup::setup;
 use soroban_sdk::{testutils::Address as _, Address};
 use utils::{
     errors::TtlError,
-    ttl::{TtlConfig, TtlConfigData},
+    ttl::{TtlConfig, TtlConfigStorage},
 };
 
 fn ttl_defaults(env: &soroban_sdk::Env, contract: &Address) -> (TtlConfig, TtlConfig) {
     env.as_contract(contract, || {
         (
-            TtlConfigData::instance(env).expect("instance config should exist"),
-            TtlConfigData::persistent(env).expect("persistent config should exist"),
+            TtlConfigStorage::instance(env).expect("instance config should exist"),
+            TtlConfigStorage::persistent(env).expect("persistent config should exist"),
         )
     })
 }
 
 #[test]
-fn test_set_ttl_config_success() {
+fn test_set_ttl_configs_success() {
     let context = setup();
     let env = &context.env;
     let endpoint = &context.endpoint_client;
@@ -30,8 +30,8 @@ fn test_set_ttl_config_success() {
     let instance_config = Some(TtlConfig::new(instance_threshold, instance_extend_to));
     let persistent_config = Some(TtlConfig::new(persistent_threshold, persistent_extend_to));
 
-    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
-    endpoint.set_ttl_config(&instance_config, &persistent_config, &None);
+    context.mock_owner_auth("set_ttl_configs", (&instance_config, &persistent_config));
+    endpoint.set_ttl_configs(&instance_config, &persistent_config);
 
     let (stored_instance, stored_persistent) = ttl_defaults(env, &context.endpoint_client.address);
 
@@ -41,7 +41,7 @@ fn test_set_ttl_config_success() {
 
 #[test]
 #[should_panic(expected = "Error(Auth, InvalidAction)")]
-fn test_set_ttl_config_requires_owner() {
+fn test_set_ttl_configs_requires_owner() {
     let context = setup();
     let env = &context.env;
     let endpoint = &context.endpoint_client;
@@ -50,13 +50,13 @@ fn test_set_ttl_config_requires_owner() {
     let instance_config = Some(TtlConfig::new(1, 2));
     let persistent_config = Some(TtlConfig::new(1, 2));
 
-    context.mock_auth(&attacker, "set_ttl_config", (&instance_config, &persistent_config));
+    context.mock_auth(&attacker, "set_ttl_configs", (&instance_config, &persistent_config));
 
-    endpoint.set_ttl_config(&instance_config, &persistent_config, &None);
+    endpoint.set_ttl_configs(&instance_config, &persistent_config);
 }
 
 #[test]
-fn test_panic_set_ttl_config_invalid_instance_range() {
+fn test_panic_set_ttl_configs_invalid_instance_range() {
     let context = setup();
     let env = &context.env;
     let endpoint = &context.endpoint_client;
@@ -68,16 +68,16 @@ fn test_panic_set_ttl_config_invalid_instance_range() {
     let instance_config = Some(TtlConfig::new(instance_threshold, instance_extend_to));
     let persistent_config = Some(TtlConfig::new(1, 2));
 
-    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+    context.mock_owner_auth("set_ttl_configs", (&instance_config, &persistent_config));
 
     assert_eq!(
-        endpoint.try_set_ttl_config(&instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        endpoint.try_set_ttl_configs(&instance_config, &persistent_config).unwrap_err().unwrap(),
         TtlError::InvalidTtlConfig.into()
     );
 }
 
 #[test]
-fn test_panic_set_ttl_config_exceeds_max_ttl() {
+fn test_panic_set_ttl_configs_exceeds_max_ttl() {
     let context = setup();
     let env = &context.env;
     let endpoint = &context.endpoint_client;
@@ -88,10 +88,10 @@ fn test_panic_set_ttl_config_exceeds_max_ttl() {
     let instance_config = Some(TtlConfig::new(1, instance_extend_to)); // Invalid: extend_to > max_ttl
     let persistent_config = Some(TtlConfig::new(1, 2));
 
-    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+    context.mock_owner_auth("set_ttl_configs", (&instance_config, &persistent_config));
 
     assert_eq!(
-        endpoint.try_set_ttl_config(&instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        endpoint.try_set_ttl_configs(&instance_config, &persistent_config).unwrap_err().unwrap(),
         TtlError::InvalidTtlConfig.into()
     );
 }
@@ -101,102 +101,102 @@ fn test_panic_set_ttl_config_exceeds_max_ttl() {
 // ============================================================================
 
 #[test]
-fn test_is_ttl_config_frozen_default_false() {
+fn test_is_ttl_configs_frozen_default_false() {
     let context = setup();
     let endpoint = &context.endpoint_client;
 
-    assert!(!endpoint.is_ttl_config_frozen());
+    assert!(!endpoint.is_ttl_configs_frozen());
 }
 
 #[test]
-fn test_freeze_ttl_config_success() {
+fn test_freeze_ttl_configs_success() {
     let context = setup();
     let endpoint = &context.endpoint_client;
 
-    assert!(!endpoint.is_ttl_config_frozen());
+    assert!(!endpoint.is_ttl_configs_frozen());
 
-    context.mock_owner_auth("freeze_ttl_config", ());
-    endpoint.freeze_ttl_config();
+    context.mock_owner_auth("freeze_ttl_configs", ());
+    endpoint.freeze_ttl_configs();
 
-    assert!(endpoint.is_ttl_config_frozen());
+    assert!(endpoint.is_ttl_configs_frozen());
 }
 
 #[test]
 #[should_panic(expected = "Error(Auth, InvalidAction)")]
-fn test_freeze_ttl_config_requires_owner() {
+fn test_freeze_ttl_configs_requires_owner() {
     let context = setup();
     let env = &context.env;
     let endpoint = &context.endpoint_client;
     let attacker = Address::generate(env);
 
-    context.mock_auth(&attacker, "freeze_ttl_config", ());
-    endpoint.freeze_ttl_config();
+    context.mock_auth(&attacker, "freeze_ttl_configs", ());
+    endpoint.freeze_ttl_configs();
 }
 
 #[test]
-fn test_freeze_ttl_config_already_frozen() {
+fn test_freeze_ttl_configs_already_frozen() {
     let context = setup();
     let endpoint = &context.endpoint_client;
 
     // First freeze
-    context.mock_owner_auth("freeze_ttl_config", ());
-    endpoint.freeze_ttl_config();
+    context.mock_owner_auth("freeze_ttl_configs", ());
+    endpoint.freeze_ttl_configs();
 
     // Try to freeze again
-    context.mock_owner_auth("freeze_ttl_config", ());
-    assert_eq!(endpoint.try_freeze_ttl_config().unwrap_err().unwrap(), TtlError::TtlConfigAlreadyFrozen.into());
+    context.mock_owner_auth("freeze_ttl_configs", ());
+    assert_eq!(endpoint.try_freeze_ttl_configs().unwrap_err().unwrap(), TtlError::TtlConfigAlreadyFrozen.into());
 }
 
 #[test]
-fn test_set_ttl_config_fails_when_frozen() {
+fn test_set_ttl_configs_fails_when_frozen() {
     let context = setup();
     let endpoint = &context.endpoint_client;
 
     // Freeze first
-    context.mock_owner_auth("freeze_ttl_config", ());
-    endpoint.freeze_ttl_config();
+    context.mock_owner_auth("freeze_ttl_configs", ());
+    endpoint.freeze_ttl_configs();
 
-    // Try to set TTL config after freeze
+    // Try to set TTL configs after freeze
     let instance_config = Some(TtlConfig::new(1, 2));
     let persistent_config = Some(TtlConfig::new(1, 2));
 
-    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+    context.mock_owner_auth("set_ttl_configs", (&instance_config, &persistent_config));
     assert_eq!(
-        endpoint.try_set_ttl_config(&instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        endpoint.try_set_ttl_configs(&instance_config, &persistent_config).unwrap_err().unwrap(),
         TtlError::TtlConfigFrozen.into()
     );
 }
 
 #[test]
-fn test_set_ttl_config_then_freeze() {
+fn test_set_ttl_configs_then_freeze() {
     let context = setup();
     let env = &context.env;
     let endpoint = &context.endpoint_client;
 
-    // Set custom TTL config
+    // Set custom TTL configs
     let instance_config = Some(TtlConfig::new(100, 200));
     let persistent_config = Some(TtlConfig::new(300, 400));
 
-    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
-    endpoint.set_ttl_config(&instance_config, &persistent_config, &None);
+    context.mock_owner_auth("set_ttl_configs", (&instance_config, &persistent_config));
+    endpoint.set_ttl_configs(&instance_config, &persistent_config);
 
     // Freeze
-    context.mock_owner_auth("freeze_ttl_config", ());
-    endpoint.freeze_ttl_config();
+    context.mock_owner_auth("freeze_ttl_configs", ());
+    endpoint.freeze_ttl_configs();
 
-    // Verify config is preserved after freeze
+    // Verify configs are preserved after freeze
     let (stored_instance, stored_persistent) = ttl_defaults(env, &context.endpoint_client.address);
     assert_eq!(stored_instance, TtlConfig::new(100, 200));
     assert_eq!(stored_persistent, TtlConfig::new(300, 400));
 
     // Verify frozen
-    assert!(endpoint.is_ttl_config_frozen());
+    assert!(endpoint.is_ttl_configs_frozen());
 
     // Verify cannot modify after freeze
     let new_instance_config = Some(TtlConfig::new(500, 600));
-    context.mock_owner_auth("set_ttl_config", (&new_instance_config, &persistent_config, &None::<TtlConfig>));
+    context.mock_owner_auth("set_ttl_configs", (&new_instance_config, &persistent_config));
     assert_eq!(
-        endpoint.try_set_ttl_config(&new_instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        endpoint.try_set_ttl_configs(&new_instance_config, &persistent_config).unwrap_err().unwrap(),
         TtlError::TtlConfigFrozen.into()
     );
 }

package/contracts/endpoint-v2/src/tests/mock.rs

@@ -95,12 +95,12 @@ impl MockSendLib {
 
         let mut native_fee_recipients = Vec::new(&env);
         if native_fee > 0 {
-            native_fee_recipients.push_back(FeeRecipient { amount: native_fee, address: fee_recipient.clone() });
+            native_fee_recipients.push_back(FeeRecipient { amount: native_fee, to: fee_recipient.clone() });
         }
 
         let mut zro_fee_recipients = Vec::new(&env);
         if zro_fee > 0 {
-            zro_fee_recipients.push_back(FeeRecipient { amount: zro_fee, address: fee_recipient });
+            zro_fee_recipients.push_back(FeeRecipient { amount: zro_fee, to: fee_recipient });
         }
 
         // Create a simple encoded payload (just the message for simplicity)

package/contracts/endpoint-v2/src/util.rs

@@ -21,8 +21,14 @@ pub fn compute_guid(
     receiver: &BytesN<32>,
 ) -> BytesN<32> {
     let mut writer = BufferWriter::new(env);
-    writer.write_u64(nonce).write_u32(src_eid).write_address_payload(sender).write_u32(dst_eid).write_bytes_n(receiver);
-    keccak256(env, &writer.to_bytes())
+    let payload = writer
+        .write_u64(nonce)
+        .write_u32(src_eid)
+        .write_address_payload(sender)
+        .write_u32(dst_eid)
+        .write_bytes_n(receiver)
+        .to_bytes();
+    keccak256(env, &payload)
 }
 
 /// Builds a payload from a GUID and message.

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

@@ -13,6 +13,7 @@ doctest = false
 soroban-sdk = { workspace = true }
 # workspace dependencies
 endpoint-v2 = { workspace = true, features = ["library"] }
+utils = { workspace = true }
 common-macros = { workspace = true }
 
 [dev-dependencies]

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

@@ -12,12 +12,12 @@
 
 #![no_std]
 
-use common_macros::contract_error;
+use common_macros::{contract_error, contract_impl};
 use endpoint_v2::{
     FeesAndPacket, IMessageLib, ISendLib, MessageLibType, MessageLibVersion, MessagingFee, OutboundPacket,
     SetConfigParam,
 };
-use soroban_sdk::{contract, contractimpl, panic_with_error, Address, Bytes, Env, Vec};
+use soroban_sdk::{contract, panic_with_error, Address, Bytes, Env, Vec};
 
 #[contract_error]
 enum BlockMessageLibError {
@@ -26,9 +26,9 @@ enum BlockMessageLibError {
 
 /// Block Message Library contract that rejects all messaging operations.
 #[contract]
-pub struct BlockMessageLib;
+pub struct BlockMessageLib; // TODO: rename to BlockedMessageLib
 
-#[contractimpl]
+#[contract_impl]
 impl IMessageLib for BlockMessageLib {
     /// Always panics - config retrieval is not supported.
     fn get_config(env: &Env, _eid: u32, _oapp: &Address, _config_type: u32) -> Bytes {
@@ -56,7 +56,7 @@ impl IMessageLib for BlockMessageLib {
     }
 }
 
-#[contractimpl]
+#[contract_impl]
 impl ISendLib for BlockMessageLib {
     /// Always panics - quoting is blocked.
     fn quote(env: &Env, _packet: &OutboundPacket, _options: &Bytes, _pay_in_zro: bool) -> MessagingFee {

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

@@ -2,19 +2,19 @@ use common_macros::contract_error;
 
 #[contract_error]
 pub enum PacketCodecV1Error {
-    InvalidPacketVersion = 11001,
-    InvalidPacketHeader,
+    InvalidPacketHeader = 1001,
+    InvalidPacketVersion,
 }
 
 #[contract_error]
 pub enum WorkerOptionsError {
-    InvalidOptions = 11101,
-    InvalidWorkerId,
+    InvalidBytesLength = 1101,
     InvalidLegacyOptionsType1,
-    LegacyOptionsType1GasOverflow,
     InvalidLegacyOptionsType2,
-    LegacyOptionsType2GasOverflow,
-    LegacyOptionsType2AmountOverflow,
     InvalidOptionType,
-    InvalidBytesLength,
+    InvalidOptions,
+    InvalidWorkerId,
+    LegacyOptionsType1GasOverflow,
+    LegacyOptionsType2AmountOverflow,
+    LegacyOptionsType2GasOverflow,
 }

package/contracts/message-libs/message-lib-common/src/interfaces/dvn.rs

@@ -2,7 +2,6 @@ use endpoint_v2::FeeRecipient;
 use soroban_sdk::{contractclient, Address, Bytes, BytesN, Env};
 
 /// Interface for Decentralized Verifier Networks (DVNs) that verify cross-chain messages.
-#[allow(clippy::upper_case_acronyms)]
 #[contractclient(name = "LayerZeroDVNClient")]
 pub trait ILayerZeroDVN {
     /// Quotes the fee for verifying a message.

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

@@ -1,6 +1,6 @@
-pub mod dvn;
-pub mod executor;
-pub mod treasury;
+mod dvn;
+mod executor;
+mod treasury;
 
 pub use dvn::*;
 pub use executor::*;

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

@@ -5,8 +5,6 @@ pub mod interfaces;
 pub mod packet_codec_v1;
 pub mod worker_options;
 
-pub use interfaces::*;
-
 #[cfg(test)]
 mod tests;
 

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

@@ -30,10 +30,8 @@ pub struct PacketHeader {
 /// # Returns
 /// Encoded packet bytes ready for cross-chain transmission
 pub fn encode_packet(env: &Env, packet: &OutboundPacket) -> Bytes {
-    let mut result = encode_packet_header(env, packet);
-    result.extend_from_array(&packet.guid.to_array());
-    result.append(&packet.message);
-    result
+    let mut writer = BufferWriter::from_bytes(encode_packet_header(env, packet));
+    writer.write_bytes_n(&packet.guid).write_bytes(&packet.message).to_bytes()
 }
 
 /// Encodes only the packet header from an outbound packet.
@@ -59,8 +57,8 @@ pub fn encode_packet_header(env: &Env, packet: &OutboundPacket) -> Bytes {
         .write_u32(packet.src_eid)
         .write_address_payload(&packet.sender)
         .write_u32(packet.dst_eid)
-        .write_bytes_n(&packet.receiver);
-    writer.to_bytes()
+        .write_bytes_n(&packet.receiver)
+        .to_bytes()
 }
 
 /// Decodes a byte vector into a packet header and validates the format.

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

@@ -61,7 +61,7 @@ fn test_payload_functions() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11002)")] // PacketCodecV1Error::InvalidPacketHeader
+#[should_panic(expected = "Error(Contract, #1001)")] // PacketCodecV1Error::InvalidPacketHeader
 fn test_invalid_header_length() {
     let env = Env::default();
     // Create a header with wrong length (too short) - only 3 bytes instead of 81
@@ -70,7 +70,7 @@ fn test_invalid_header_length() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11001)")] // PacketCodecV1Error::InvalidPacketVersion
+#[should_panic(expected = "Error(Contract, #1002)")] // PacketCodecV1Error::InvalidPacketVersion
 fn test_invalid_packet_version() {
     let env = Env::default();
     // Create a header with correct length but wrong version

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

@@ -91,7 +91,7 @@ fn test_decode_legacy_options_type_1() {
     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);
+    assert_eq!(reader.remaining_len(), 0);
 }
 
 #[test]
@@ -218,7 +218,7 @@ fn test_get_matching_options() {
 // ============ Error tests ============
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11101)")] // WorkerOptionsError::InvalidOptions
+#[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);
@@ -227,7 +227,7 @@ fn test_decode_invalid_options_too_short() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11102)")] // WorkerOptionsError::InvalidWorkerId
+#[should_panic(expected = "Error(Contract, #1106)")] // WorkerOptionsError::InvalidWorkerId
 fn test_decode_invalid_worker_id() {
     let env = Env::default();
     let mut options = Bytes::new(&env);
@@ -237,7 +237,7 @@ fn test_decode_invalid_worker_id() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11104)")] // WorkerOptionsError::LegacyOptionsType1GasOverflow
+#[should_panic(expected = "Error(Contract, #1107)")] // WorkerOptionsError::LegacyOptionsType1GasOverflow
 fn test_legacy_type1_gas_overflow() {
     let env = Env::default();
     let mut options = Bytes::new(&env);
@@ -247,7 +247,7 @@ fn test_legacy_type1_gas_overflow() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11106)")] // WorkerOptionsError::LegacyOptionsType2GasOverflow
+#[should_panic(expected = "Error(Contract, #1109)")] // WorkerOptionsError::LegacyOptionsType2GasOverflow
 fn test_legacy_type2_gas_overflow() {
     let env = Env::default();
     let mut options = Bytes::new(&env);
@@ -257,7 +257,7 @@ fn test_legacy_type2_gas_overflow() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11107)")] // WorkerOptionsError::LegacyOptionsType2AmountOverflow
+#[should_panic(expected = "Error(Contract, #1108)")] // WorkerOptionsError::LegacyOptionsType2AmountOverflow
 fn test_legacy_type2_amount_overflow() {
     let env = Env::default();
     let mut options = Bytes::new(&env);
@@ -267,7 +267,7 @@ fn test_legacy_type2_amount_overflow() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11103)")] // WorkerOptionsError::InvalidLegacyOptionsType1
+#[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);
@@ -277,7 +277,7 @@ fn test_legacy_type1_invalid_size_too_short() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11103)")] // WorkerOptionsError::InvalidLegacyOptionsType1
+#[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);
@@ -289,7 +289,7 @@ fn test_legacy_type1_invalid_size_too_long() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11105)")] // WorkerOptionsError::InvalidLegacyOptionsType2
+#[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);
@@ -299,7 +299,7 @@ fn test_legacy_type2_invalid_size_too_short() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11105)")] // WorkerOptionsError::InvalidLegacyOptionsType2
+#[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);
@@ -309,7 +309,7 @@ fn test_legacy_type2_invalid_size_too_long() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11108)")] // WorkerOptionsError::InvalidOptionType
+#[should_panic(expected = "Error(Contract, #1104)")] // WorkerOptionsError::InvalidOptionType
 fn test_unsupported_option_type() {
     let env = Env::default();
     let mut options = Bytes::new(&env);

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

@@ -67,8 +67,7 @@ pub fn split_worker_options(env: &Env, options: &Bytes) -> (Bytes, Map<u32, Byte
 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 {
+    while options_reader.remaining_len() > 0 {
         let worker_id = options_reader.read_u8();
         let option_size = options_reader.read_u16() as u32;
 
@@ -78,11 +77,10 @@ pub fn extract_type_3_options(env: &Env, options_reader: &mut BufferReader) -> (
 
         match worker_id {
             EXECUTOR_WORKER_ID => executor_options.append(&current_option),
-            DVN_WORKER_ID => append_dvn_option(&mut dvn_options, current_option),
+            DVN_WORKER_ID => append_dvn_option(env, &mut dvn_options, current_option),
             _ => panic_with_error!(env, WorkerOptionsError::InvalidWorkerId),
         }
     }
-
     (executor_options, dvn_options)
 }
 
@@ -105,7 +103,7 @@ pub fn extract_type_3_options(env: &Env, options_reader: &mut BufferReader) -> (
 /// 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();
+    let options_size = options.remaining_len();
 
     match option_type {
         LEGACY_OPTIONS_TYPE_1 => {
@@ -113,7 +111,6 @@ pub fn convert_legacy_options(env: &Env, options: &mut BufferReader, option_type
             // 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 => {
@@ -129,7 +126,6 @@ pub fn convert_legacy_options(env: &Env, options: &mut BufferReader, option_type
                 .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);
@@ -139,7 +135,7 @@ pub fn convert_legacy_options(env: &Env, options: &mut BufferReader, option_type
     }
 
     // Ensure all bytes were consumed
-    assert_with_error!(env, options.remaining() == 0, WorkerOptionsError::InvalidOptions);
+    assert_with_error!(env, options.remaining_len() == 0, WorkerOptionsError::InvalidOptions);
     executor_options.to_bytes()
 }
 
@@ -151,15 +147,11 @@ pub fn convert_legacy_options(env: &Env, options: &mut BufferReader, option_type
 ///
 /// 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) {
+fn append_dvn_option(env: &Env, 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);
-    }
+    let mut existing = dvn_options.get(dvn_idx).unwrap_or(bytes!(env));
+    existing.append(&option_bytes);
+    dvn_options.set(dvn_idx, existing);
 }
 
 /// Appends a LzReceive option to the executor options bytes.
@@ -188,3 +180,5 @@ fn left_pad_to_bytes32(env: &Env, bytes: &Bytes) -> BytesN<32> {
     bytes.copy_into_slice(&mut buf[32 - bytes.len() as usize..]);
     BytesN::from_array(env, &buf)
 }
+
+// TODO (ethan): add more negative test cases for worker options

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

@@ -3,9 +3,5 @@ use common_macros::contract_error;
 #[contract_error]
 pub enum SimpleMessageLibError {
     NotImplemented,
-    NativeFeeNotSet,
-    ZROFeeNotSet,
-    ZROTokenNotSet,
     OnlyWhitelistedCaller,
-    UnableToConvertAddress,
 }