@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

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

@@ -1,7 +1,4 @@
-use endpoint_v2::{
-    util::{build_payload, keccak256},
-    OutboundPacket,
-};
+use endpoint_v2::{util, OutboundPacket};
 use soroban_sdk::{assert_with_error, Bytes, BytesN, Env};
 use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
 
@@ -88,10 +85,10 @@ pub fn decode_packet_header(env: &Env, encoded_header: &Bytes) -> PacketHeader {
 
 /// Returns the payload (GUID + message) from an outbound packet.
 pub fn payload(env: &Env, packet: &OutboundPacket) -> Bytes {
-    build_payload(env, &packet.guid, &packet.message)
+    util::build_payload(env, &packet.guid, &packet.message)
 }
 
 /// Returns the keccak256 hash of the packet payload.
 pub fn payload_hash(env: &Env, packet: &OutboundPacket) -> BytesN<32> {
-    keccak256(env, &payload(env, packet))
+    util::keccak256(env, &payload(env, packet))
 }

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

@@ -115,6 +115,16 @@ fn test_extract_type_3_options_interleaved_executor_and_dvn_keeps_executor_order
     assert_eq!(reader.remaining_len(), 0);
 }
 
+#[test]
+#[should_panic(expected = "Error(Contract, #1114)")] // WorkerOptionsError::InvalidOptions
+fn test_extract_type_3_options_rejects_zero_option_size() {
+    let env = Env::default();
+    // worker_id = 1 (executor) + option_size = 0 (invalid)
+    let body = Bytes::from_slice(&env, &hex!("010000"));
+    let mut reader = BufferReader::new(&body);
+    extract_type_3_options(&env, &mut reader);
+}
+
 #[test]
 #[should_panic(expected = "Error(Contract, #1115)")] // WorkerOptionsError::InvalidWorkerId
 fn test_extract_type_3_options_rejects_unknown_worker_id() {

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

@@ -15,7 +15,7 @@ pub const DVN_WORKER_ID: u8 = 2;
 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)
+// DVN option byte offset for the dvn_idx field after the worker_id and option_size fields
 pub const DVN_IDX_OFFSET: u32 = 3;
 
 /// Splits worker options into separate executor and DVN option collections.
@@ -70,6 +70,7 @@ pub fn extract_type_3_options(env: &Env, options_reader: &mut BufferReader) -> (
     while options_reader.remaining_len() > 0 {
         let worker_id = options_reader.read_u8();
         let option_size = options_reader.read_u16() as u32;
+        assert_with_error!(env, option_size > 0, WorkerOptionsError::InvalidOptions);
 
         // Rewind to the start of the current option and read the complete option bytes
         // 3 bytes for worker_id (1) + option_size (2)
@@ -147,8 +148,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.
+///
+/// DVN option_bytes layout: `[worker_id: u8][option_size: u16][dvn_idx: u8][dvn_option_data: bytes]`
+/// The dvn_idx at byte offset 3 (DVN_IDX_OFFSET) identifies which DVN this option belongs to.
 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;
+    let dvn_idx = option_bytes.get(DVN_IDX_OFFSET).unwrap_or_panic(env, WorkerOptionsError::InvalidOptions) as u32;
     let mut existing = dvn_options.get(dvn_idx).unwrap_or(bytes!(env));
     existing.append(&option_bytes);
     dvn_options.set(dvn_idx, existing);

package/contracts/message-libs/treasury/src/interfaces/zro_fee_lib.rs

@@ -6,15 +6,15 @@ use soroban_sdk::{contractclient, Address, Env};
 /// This allows for custom fee calculation logic when users opt to pay fees in ZRO.
 #[contractclient(name = "ZroFeeLibClient")]
 pub trait IZroFeeLib {
-    /// Get the treasury fee in ZRO tokens based on the worker fee.
+    /// Get the treasury fee in ZRO tokens based on the total native fee.
     ///
     /// # Arguments
     /// * `sender` - The sender OApp address
     /// * `dst_eid` - The destination endpoint ID
-    /// * `worker_fee` - The worker fee
+    /// * `total_native_fee` - The total native fee charged to the sender
     /// * `native_treasury_fee` - The treasury fee in native tokens
     ///
     /// # Returns
     /// The amount of ZRO tokens to be paid
-    fn get_fee(env: &Env, sender: &Address, dst_eid: u32, worker_fee: i128, native_treasury_fee: i128) -> i128;
+    fn get_fee(env: &Env, sender: &Address, dst_eid: u32, total_native_fee: i128, native_treasury_fee: i128) -> i128;
 }

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

@@ -1,7 +1,8 @@
 #![no_std]
 
-mod errors;
 pub mod events;
+
+mod errors;
 mod interfaces;
 
 pub use errors::*;

package/contracts/message-libs/treasury/src/tests/setup.rs

@@ -107,7 +107,7 @@ impl<'a> TestSetup<'a> {
 
     /// Gets the token balance of an address
     pub fn get_token_balance(&self, token: &Address, address: &Address) -> i128 {
-        let token_client = token::Client::new(&self.env, token);
+        let token_client = token::TokenClient::new(&self.env, token);
         token_client.balance(address)
     }
 }

package/contracts/message-libs/treasury/src/treasury.rs

@@ -6,7 +6,7 @@ use crate::{
 };
 use common_macros::{contract_impl, lz_contract, only_auth};
 use message_lib_common::interfaces::ILayerZeroTreasury;
-use soroban_sdk::{assert_with_error, token::Client, Address, Env};
+use soroban_sdk::{assert_with_error, token::TokenClient, Address, Env};
 use utils::option_ext::OptionExt;
 
 /// Denominator for basis point calculations (10000 = 100%).
@@ -66,7 +66,7 @@ impl Treasury {
     /// * `amount` - The amount to withdraw (must be positive)
     #[only_auth]
     pub fn withdraw_token(env: &Env, token: &Address, to: &Address, amount: i128) {
-        Client::new(env, token).transfer(&env.current_contract_address(), to, &amount);
+        TokenClient::new(env, token).transfer(&env.current_contract_address(), to, &amount);
         TokenWithdrawn { token: token.clone(), to: to.clone(), amount }.publish(env);
     }
 
@@ -117,15 +117,18 @@ impl ILayerZeroTreasury for Treasury {
     fn get_fee(env: &Env, sender: &Address, dst_eid: u32, total_native_fee: i128, pay_in_zro: bool) -> i128 {
         assert_with_error!(env, total_native_fee >= 0, TreasuryError::InvalidTotalNativeFee);
 
+        // If fee collection is disabled, return 0
         if !Self::fee_enabled(env) {
             return 0;
         }
 
+        // If paying in native, calculate and return the native treasury fee
         let native_treasury_fee = Self::calculate_native_fee(env, total_native_fee);
         if !pay_in_zro {
             return native_treasury_fee;
         }
 
+        // If paying in ZRO, quote the ZRO fee from the ZRO fee library
         let zro_fee =
             Self::expect_zro_fee_lib_client(env).get_fee(sender, &dst_eid, &total_native_fee, &native_treasury_fee);
         assert_with_error!(env, zro_fee >= 0, TreasuryError::InvalidZroFee);

package/contracts/message-libs/uln-302/src/errors.rs

@@ -20,6 +20,8 @@ pub enum Uln302Error {
     InvalidConfirmations,
     /// Packet header destination EID does not match this endpoint's EID
     InvalidEID,
+    /// Fee returned by a worker or treasury is negative
+    InvalidFee,
     /// Message size exceeds executor's configured maximum
     InvalidMessageSize,
     /// Optional DVNs count exceeds maximum allowed (127)

package/contracts/message-libs/uln-302/src/events.rs

@@ -12,7 +12,7 @@ pub struct ExecutorConfigSet {
     pub sender: Address,
     #[topic]
     pub dst_eid: u32,
-    pub config: OAppExecutorConfig,
+    pub config: Option<OAppExecutorConfig>,
 }
 
 #[contractevent]
@@ -22,7 +22,7 @@ pub struct SendUlnConfigSet {
     pub sender: Address,
     #[topic]
     pub dst_eid: u32,
-    pub config: OAppUlnConfig,
+    pub config: Option<OAppUlnConfig>,
 }
 
 #[contractevent]
@@ -32,7 +32,7 @@ pub struct ReceiveUlnConfigSet {
     pub receiver: Address,
     #[topic]
     pub src_eid: u32,
-    pub config: OAppUlnConfig,
+    pub config: Option<OAppUlnConfig>,
 }
 
 #[contractevent]

package/contracts/message-libs/uln-302/src/interfaces/receive_uln.rs

@@ -6,6 +6,10 @@ use soroban_sdk::{contractclient, Address, Bytes, BytesN, Env, Vec};
 /// Handles DVN verification and message commitment on the receiving chain.
 #[contractclient(name = "ReceiveUln302Client")]
 pub trait IReceiveUln302 {
+    // ============================================================================================
+    // Verification Functions
+    // ============================================================================================
+
     /// Called by a DVN to verify a message with a specific number of confirmations.
     ///
     /// # Arguments
@@ -46,6 +50,10 @@ pub trait IReceiveUln302 {
     /// * `payload_hash` - The hash of the message payload
     fn commit_verification(env: &Env, packet_header: &Bytes, payload_hash: &BytesN<32>);
 
+    // ============================================================================================
+    // Configuration Functions
+    // ============================================================================================
+
     /// Sets default receive ULN configurations for multiple source endpoints.
     ///
     /// # Arguments

package/contracts/message-libs/uln-302/src/lib.rs

@@ -1,7 +1,8 @@
 #![no_std]
 
-mod errors;
 pub mod events;
+
+mod errors;
 mod interfaces;
 mod types;
 

package/contracts/message-libs/uln-302/src/receive_uln.rs

@@ -41,7 +41,7 @@ impl IReceiveUln302 for Uln302 {
     /// (all required DVNs + optional DVN threshold). Once verified, cleans up DVN confirmation
     /// storage and calls the endpoint to mark the message as verified and executable.
     fn commit_verification(env: &Env, packet_header: &Bytes, payload_hash: &BytesN<32>) {
-        let (header, uln_config) = Self::decode_packet_header_with_config(env, packet_header);
+        let (header, uln_config, receiver) = Self::decode_packet_header_with_config(env, packet_header);
         let header_hash = util::keccak256(env, packet_header);
 
         // check if the message is verifiable
@@ -60,7 +60,7 @@ impl IReceiveUln302 for Uln302 {
         LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).verify(
             &env.current_contract_address(),
             &Origin { src_eid: header.src_eid, sender: header.sender, nonce: header.nonce },
-            &Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver)),
+            &receiver,
             payload_hash,
         );
     }
@@ -92,7 +92,7 @@ impl IReceiveUln302 for Uln302 {
 
     /// Checks if a message has been sufficiently verified by DVNs and is ready to commit.
     fn verifiable(env: &Env, packet_header: &Bytes, payload_hash: &BytesN<32>) -> bool {
-        let (_, uln_config) = Self::decode_packet_header_with_config(env, packet_header);
+        let (_, uln_config, _) = Self::decode_packet_header_with_config(env, packet_header);
         Self::verifiable_internal(env, &uln_config, &util::keccak256(env, packet_header), payload_hash)
     }
 
@@ -124,13 +124,15 @@ impl IReceiveUln302 for Uln302 {
 // ============================================================================================
 
 impl Uln302 {
-    /// Sets OApp-specific receive ULN config.
+    /// Sets or removes OApp-specific receive ULN config.
     ///
+    /// If `config` is `None`, the OApp-specific config is removed (falling back to defaults).
     /// Panics if the final effective config is invalid.
-    pub(super) fn set_receive_uln_config(env: &Env, receiver: &Address, src_eid: u32, config: &OAppUlnConfig) {
-        config.validate_oapp_config(env);
-
-        UlnStorage::set_oapp_receive_uln_configs(env, receiver, src_eid, config);
+    pub(super) fn set_receive_uln_config(env: &Env, receiver: &Address, src_eid: u32, config: &Option<OAppUlnConfig>) {
+        if let Some(c) = config {
+            c.validate_oapp_config(env);
+        }
+        UlnStorage::set_or_remove_oapp_receive_uln_configs(env, receiver, src_eid, config);
         // validate the config by getting the effective config
         let _ = Self::effective_receive_uln_config(env, receiver, src_eid);
 
@@ -141,8 +143,8 @@ impl Uln302 {
     // Verification Helpers Functions
     // ============================================================================================
 
-    /// Decodes packet header and returns header and effective ULN config.
-    fn decode_packet_header_with_config(env: &Env, packet_header: &Bytes) -> (PacketHeader, UlnConfig) {
+    /// Decodes packet header and returns header, effective ULN config, and receiver address.
+    fn decode_packet_header_with_config(env: &Env, packet_header: &Bytes) -> (PacketHeader, UlnConfig, Address) {
         let header = packet_codec_v1::decode_packet_header(env, packet_header);
         assert_with_error!(
             env,
@@ -150,10 +152,11 @@ impl Uln302 {
             Uln302Error::InvalidEID
         );
 
+        // convert the receiver address from BytesN<32> to ContractAddress
         let receiver = Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver.clone()));
         let uln_config = Self::effective_receive_uln_config(env, &receiver, header.src_eid);
 
-        (header, uln_config)
+        (header, uln_config, receiver)
     }
 
     /// Checks if all required DVNs verified and optional DVN threshold is met.
@@ -183,8 +186,8 @@ impl Uln302 {
         dvn: &Address,
         header_hash: &BytesN<32>,
         payload_hash: &BytesN<32>,
-        confirmations: u64,
+        required_confirmations: u64,
     ) -> bool {
-        Self::confirmations(env, dvn, header_hash, payload_hash).map(|c| c >= confirmations).unwrap_or(false)
+        Self::confirmations(env, dvn, header_hash, payload_hash).map(|c| c >= required_confirmations).unwrap_or(false)
     }
 }

package/contracts/message-libs/uln-302/src/send_uln.rs

@@ -45,8 +45,7 @@ impl ISendLib for Uln302 {
 
         // Treasury fee
         let workers_fee = executor_fee + dvns_fee;
-        let treasury_client = LayerZeroTreasuryClient::new(env, &Self::treasury(env));
-        let treasury_fee = treasury_client.get_fee(&packet.sender, &packet.dst_eid, &workers_fee, &pay_in_zro);
+        let (_, treasury_fee) = Self::quote_treasury(env, &packet.sender, packet.dst_eid, &workers_fee, &pay_in_zro);
 
         if pay_in_zro {
             MessagingFee { native_fee: workers_fee, zro_fee: treasury_fee }
@@ -91,13 +90,8 @@ impl ISendLib for Uln302 {
 
         // Treasury fee
         let total_worker_fee = native_fee_recipients.iter().map(|fee| fee.amount).sum();
-        let treasury_addr = Self::treasury(env);
-        let treasury_fee = LayerZeroTreasuryClient::new(env, &treasury_addr).get_fee(
-            &packet.sender,
-            &packet.dst_eid,
-            &total_worker_fee,
-            &pay_in_zro,
-        );
+        let (treasury_addr, treasury_fee) =
+            Self::quote_treasury(env, &packet.sender, packet.dst_eid, &total_worker_fee, &pay_in_zro);
 
         // Handle ZRO fee recipients
         let mut zro_fee_recipients = vec![env];
@@ -207,19 +201,23 @@ impl ISendUln302 for Uln302 {
 // ==============================================================================
 
 impl Uln302 {
-    /// Sets OApp-specific executor configuration for a destination endpoint.
-    pub(super) fn set_executor_config(env: &Env, sender: &Address, dst_eid: u32, config: &OAppExecutorConfig) {
-        UlnStorage::set_oapp_executor_configs(env, sender, dst_eid, config);
+    /// Sets or removes OApp-specific executor configuration for a destination endpoint.
+    ///
+    /// If `config` is `None`, the OApp-specific config is removed (falling back to defaults).
+    pub(super) fn set_executor_config(env: &Env, sender: &Address, dst_eid: u32, config: &Option<OAppExecutorConfig>) {
+        UlnStorage::set_or_remove_oapp_executor_configs(env, sender, dst_eid, config);
         ExecutorConfigSet { sender: sender.clone(), dst_eid, config: config.clone() }.publish(env);
     }
 
-    /// Sets OApp-specific send ULN configuration for a destination endpoint.
+    /// Sets or removes OApp-specific send ULN configuration for a destination endpoint.
     ///
+    /// If `config` is `None`, the OApp-specific config is removed (falling back to defaults).
     /// Panics if the final effective config is invalid.
-    pub(super) fn set_send_uln_config(env: &Env, sender: &Address, dst_eid: u32, config: &OAppUlnConfig) {
-        config.validate_oapp_config(env);
-
-        UlnStorage::set_oapp_send_uln_configs(env, sender, dst_eid, config);
+    pub(super) fn set_send_uln_config(env: &Env, sender: &Address, dst_eid: u32, config: &Option<OAppUlnConfig>) {
+        if let Some(c) = config {
+            c.validate_oapp_config(env);
+        }
+        UlnStorage::set_or_remove_oapp_send_uln_configs(env, sender, dst_eid, config);
         // validate the config by getting the effective config
         let _ = Self::effective_send_uln_config(env, sender, dst_eid);
 
@@ -231,13 +229,15 @@ impl Uln302 {
     // ============================================================================================
 
     /// Quotes the executor fee for message execution.
-    fn quote_executor(env: &Env, sender: &Address, dst_eid: u32, message_length: u32, options: &Bytes) -> i128 {
+    fn quote_executor(env: &Env, sender: &Address, dst_eid: u32, message_size: u32, options: &Bytes) -> i128 {
         // Get the effective executor config and validate message size
         let executor_config = Self::effective_executor_config(env, sender, dst_eid);
-        assert_with_error!(env, message_length <= executor_config.max_message_size, Uln302Error::InvalidMessageSize);
+        assert_with_error!(env, message_size <= executor_config.max_message_size, Uln302Error::InvalidMessageSize);
 
         let executor_client = LayerZeroExecutorClient::new(env, &executor_config.executor);
-        executor_client.get_fee(&env.current_contract_address(), sender, &dst_eid, &message_length, options)
+        let fee = executor_client.get_fee(&env.current_contract_address(), sender, &dst_eid, &message_size, options);
+        assert_with_error!(env, fee >= 0, Uln302Error::InvalidFee);
+        fee
     }
 
     /// Quotes the total DVN fees for message verification.
@@ -260,11 +260,36 @@ impl Uln302 {
             .map(|(idx, dvn_addr)| {
                 let dvn_client = LayerZeroDVNClient::new(env, &dvn_addr);
                 let dvn_opts = dvn_options.get(idx as u32).unwrap_or(bytes!(env));
-                dvn_client.get_fee(&send_lib, sender, &dst_eid, packet_header, payload_hash, &confirmations, &dvn_opts)
+                let fee = dvn_client.get_fee(
+                    &send_lib,
+                    sender,
+                    &dst_eid,
+                    packet_header,
+                    payload_hash,
+                    &confirmations,
+                    &dvn_opts,
+                );
+                assert_with_error!(env, fee >= 0, Uln302Error::InvalidFee);
+                fee
             })
             .sum()
     }
 
+    /// Quotes the treasury fee for the protocol.
+    fn quote_treasury(
+        env: &Env,
+        sender: &Address,
+        dst_eid: u32,
+        workers_fee: &i128,
+        pay_in_zro: &bool,
+    ) -> (Address, i128) {
+        let treasury_addr = Self::treasury(env);
+        let treasury_fee =
+            LayerZeroTreasuryClient::new(env, &treasury_addr).get_fee(sender, &dst_eid, workers_fee, pay_in_zro);
+        assert_with_error!(env, treasury_fee >= 0, Uln302Error::InvalidFee);
+        (treasury_addr, treasury_fee)
+    }
+
     // ============================================================================================
     // Assign Job Functions
     // ============================================================================================
@@ -275,16 +300,17 @@ impl Uln302 {
         guid: &BytesN<32>,
         sender: &Address,
         dst_eid: u32,
-        message_length: u32,
+        message_size: u32,
         options: &Bytes,
     ) -> FeeRecipient {
         // Get the effective executor config and validate message size
         let executor_config = Self::effective_executor_config(env, sender, dst_eid);
-        assert_with_error!(env, message_length <= executor_config.max_message_size, Uln302Error::InvalidMessageSize);
+        assert_with_error!(env, message_size <= executor_config.max_message_size, Uln302Error::InvalidMessageSize);
 
         let executor_client = LayerZeroExecutorClient::new(env, &executor_config.executor);
         let recipient =
-            executor_client.assign_job(&env.current_contract_address(), sender, &dst_eid, &message_length, options);
+            executor_client.assign_job(&env.current_contract_address(), sender, &dst_eid, &message_size, options);
+        assert_with_error!(env, recipient.amount >= 0, Uln302Error::InvalidFee);
 
         ExecutorFeePaid { guid: guid.clone(), executor: executor_client.address.clone(), fee: recipient.clone() }
             .publish(env);
@@ -319,6 +345,7 @@ impl Uln302 {
                 &confirmations,
                 &dvn_opts,
             );
+            assert_with_error!(env, dvn_fee_recipient.amount >= 0, Uln302Error::InvalidFee);
             fees.push_back(dvn_fee_recipient);
             dvns.push_back(dvn_addr);
         }

package/contracts/message-libs/uln-302/src/storage.rs

@@ -5,11 +5,11 @@ use soroban_sdk::{Address, BytesN};
 /// Storage for the Uln302 message library.
 #[storage]
 pub enum UlnStorage {
-    /// The endpoint address (set in constructor)
+    /// The endpoint address (immutable, set once in constructor)
     #[instance(Address)]
     Endpoint,
 
-    /// The treasury address for fee collection (set in constructor)
+    /// The treasury address for fee collection (immutable, set once in constructor)
     #[instance(Address)]
     Treasury,
 

package/contracts/message-libs/uln-302/src/tests/receive_uln302/effective_receive_uln_config.rs

@@ -60,7 +60,7 @@ fn test_effective_receive_uln_config_with_custom_config() {
     assert_eq_event(
         &env,
         &uln302.address,
-        ReceiveUlnConfigSet { config: custom_config.clone(), receiver: oapp.clone(), src_eid: eid },
+        ReceiveUlnConfigSet { config: Some(custom_config.clone()), receiver: oapp.clone(), src_eid: eid },
     );
 
     let config = uln302.effective_receive_uln_config(&oapp, &eid);
@@ -100,3 +100,47 @@ fn test_effective_receive_uln_config_must_have_at_least_one_dvn() {
     let result = endpoint.try_set_config(&Address::generate(&env), &oapp, &uln302.address, &params);
     assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::UlnAtLeastOneDVN.into());
 }
+
+#[test]
+fn test_remove_receive_uln_config_by_setting_none() {
+    let setup = setup();
+
+    let default_config = UlnConfig::generate(&setup.env, 15, 1, 2, 1);
+    let eid = 101;
+
+    setup.set_default_configs(eid, default_config.clone());
+
+    let TestSetup { env, uln302, endpoint, .. } = setup;
+
+    let oapp = Address::generate(&env);
+
+    // Step 1: Set a custom receive ULN config
+    let custom_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig::generate(&env, 0, 3, 1, 1),
+    };
+
+    let config_bytes = custom_config.clone().to_xdr(&env);
+    let params = vec![&env, SetConfigParam { eid, config_type: CONFIG_TYPE_RECEIVE_ULN, config: config_bytes }];
+    endpoint.set_config(&Address::generate(&env), &oapp, &uln302.address, &params);
+
+    // Verify custom config is applied
+    assert!(uln302.oapp_receive_uln_config(&oapp, &eid).is_some());
+    let config = uln302.effective_receive_uln_config(&oapp, &eid);
+    assert_eq!(config.required_dvns, custom_config.uln_config.required_dvns);
+
+    // Step 2: Remove the custom config by setting None
+    let none_config: Option<OAppUlnConfig> = None;
+    let config_bytes = none_config.to_xdr(&env);
+    let params = vec![&env, SetConfigParam { eid, config_type: CONFIG_TYPE_RECEIVE_ULN, config: config_bytes }];
+    endpoint.set_config(&Address::generate(&env), &oapp, &uln302.address, &params);
+
+    // Verify the OApp-specific config is removed
+    assert_eq!(uln302.oapp_receive_uln_config(&oapp, &eid), None);
+
+    // Verify the effective config falls back to defaults
+    let config = uln302.effective_receive_uln_config(&oapp, &eid);
+    assert_eq!(config, default_config);
+}

package/contracts/message-libs/uln-302/src/tests/receive_uln302/verifiable.rs

@@ -461,3 +461,66 @@ fn test_verifiable_partial_optional_verification() {
     // Verifiable because threshold is met
     assert!(receive_client.verifiable(&packet_header, &payload_hash));
 }
+
+#[test]
+fn test_not_verifiable_required_verified_but_optional_threshold_not_met() {
+    let test_setup = setup();
+    let TestSetup { env, uln302, .. } = &test_setup;
+
+    let dvn1 = Address::generate(env);
+    let dvn2 = Address::generate(env);
+    let dvn3 = Address::generate(env);
+    let dvn4 = Address::generate(env);
+    let receiver = Address::generate(env);
+
+    // Set up config with 2 required DVNs and 2 optional DVNs with threshold of 2
+    let mut config = create_test_uln_config(env);
+    config.required_dvns = vec![env, dvn1.clone(), dvn2.clone()];
+    config.optional_dvns = vec![env, dvn3.clone(), dvn4.clone()];
+    config.optional_dvn_threshold = 2; // Need both optional DVNs
+    TestSetup::set_default_receive_uln_config(&test_setup, SRC_EID, config);
+
+    let packet_header = create_test_packet_header(env, &receiver);
+    let payload_hash = create_test_payload_hash(env);
+
+    let receive_client = ReceiveUln302Client::new(env, &uln302.address);
+
+    // Verify all required DVNs
+    env.mock_auths(&[MockAuth {
+        address: &dvn1,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "verify",
+            args: (&dvn1, &packet_header, &payload_hash, &CONFIRMATIONS).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_client.verify(&dvn1, &packet_header, &payload_hash, &CONFIRMATIONS);
+
+    env.mock_auths(&[MockAuth {
+        address: &dvn2,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "verify",
+            args: (&dvn2, &packet_header, &payload_hash, &CONFIRMATIONS).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_client.verify(&dvn2, &packet_header, &payload_hash, &CONFIRMATIONS);
+
+    // Verify only 1 optional DVN (need 2)
+    env.mock_auths(&[MockAuth {
+        address: &dvn3,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "verify",
+            args: (&dvn3, &packet_header, &payload_hash, &CONFIRMATIONS).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_client.verify(&dvn3, &packet_header, &payload_hash, &CONFIRMATIONS);
+    // DVN4 doesn't verify
+
+    // Not verifiable because optional threshold (2) is not met (only 1 verified)
+    assert!(!receive_client.verifiable(&packet_header, &payload_hash));
+}

package/contracts/message-libs/uln-302/src/tests/send_uln302/effective_executor_config.rs

@@ -7,7 +7,7 @@ use crate::{
     uln302::CONFIG_TYPE_EXECUTOR,
 };
 use endpoint_v2::SetConfigParam;
-use soroban_sdk::{log, testutils::Address as _, vec, xdr::ToXdr, Address, Env};
+use soroban_sdk::{log, testutils::Address as _, vec, xdr::ToXdr, Address, Bytes, Env};
 use utils::testing_utils::assert_eq_event;
 
 #[test]
@@ -60,7 +60,7 @@ fn test_effective_executor_config_with_custom_executor() {
     assert_eq_event(
         &setup.env,
         &setup.uln302.address,
-        ExecutorConfigSet { config: custom_config.clone(), dst_eid: eid, sender: oapp.clone() },
+        ExecutorConfigSet { config: Some(custom_config.clone()), dst_eid: eid, sender: oapp.clone() },
     );
 
     let config = setup.uln302.effective_executor_config(&oapp, &eid);
@@ -130,3 +130,48 @@ fn test_effective_executor_config_fully_custom() {
     assert_eq!(config.executor, custom_executor);
     assert_eq!(config.max_message_size, custom_config.max_message_size);
 }
+
+#[test]
+fn test_remove_executor_config_by_setting_none() {
+    let setup = setup();
+
+    let eid = 102;
+    let default_executor = setup.register_executable_address();
+    let default_config = ExecutorConfig { max_message_size: 5000, executor: default_executor.clone() };
+
+    let default_uln_config = UlnConfig::generate(&setup.env, 10, 2, 3, 2);
+
+    setup.set_default_executor_config(eid, default_config.clone());
+    setup.set_default_receive_uln_config(eid, default_uln_config.clone());
+    setup.set_default_send_uln_config(eid, default_uln_config.clone());
+
+    let oapp = Address::generate(&setup.env);
+
+    // Step 1: Set a custom executor config
+    let custom_executor = setup.register_executable_address();
+    let custom_config = OAppExecutorConfig { max_message_size: 8000, executor: Some(custom_executor.clone()) };
+
+    let config_bytes = custom_config.clone().to_xdr(&setup.env);
+    let params = vec![&setup.env, SetConfigParam { eid, config_type: CONFIG_TYPE_EXECUTOR, config: config_bytes }];
+    setup.endpoint.set_config(&Address::generate(&setup.env), &oapp, &setup.uln302.address, &params);
+
+    // Verify custom config is applied
+    let config = setup.uln302.effective_executor_config(&oapp, &eid);
+    assert_eq!(config.executor, custom_executor);
+    assert_eq!(config.max_message_size, 8000);
+    assert!(setup.uln302.oapp_executor_config(&oapp, &eid).is_some());
+
+    // Step 2: Remove the custom config by setting None
+    let none_config: Option<OAppExecutorConfig> = None;
+    let config_bytes = none_config.to_xdr(&setup.env);
+    assert_eq!(config_bytes, Bytes::from_array(&setup.env, &[0, 0, 0, 1])); // ScVal::Void XDR encoding
+    let params = vec![&setup.env, SetConfigParam { eid, config_type: CONFIG_TYPE_EXECUTOR, config: config_bytes }];
+    setup.endpoint.set_config(&Address::generate(&setup.env), &oapp, &setup.uln302.address, &params);
+
+    // Verify the OApp-specific config is removed
+    assert_eq!(setup.uln302.oapp_executor_config(&oapp, &eid), None);
+
+    // Verify the effective config falls back to defaults
+    let config = setup.uln302.effective_executor_config(&oapp, &eid);
+    assert_eq!(config, default_config);
+}