@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,4 +1,24 @@
-use super::*;
+use super::{Uln302, Uln302Args, Uln302Client};
+use crate::{
+    errors::Uln302Error,
+    events::{
+        DVNFeePaid, DefaultExecutorConfigsSet, DefaultSendUlnConfigsSet, ExecutorConfigSet, ExecutorFeePaid,
+        SendUlnConfigSet,
+    },
+    interfaces::{
+        ExecutorConfig, ISendUln302, OAppExecutorConfig, OAppUlnConfig, SetDefaultExecutorConfigParam,
+        SetDefaultUlnConfigParam, UlnConfig,
+    },
+    storage::UlnStorage,
+};
+use common_macros::{contract_impl, only_auth};
+use endpoint_v2::{FeeRecipient, FeesAndPacket, ISendLib, MessagingFee, OutboundPacket};
+use message_lib_common::{
+    interfaces::{LayerZeroDVNClient, LayerZeroExecutorClient, LayerZeroTreasuryClient},
+    packet_codec_v1, worker_options,
+};
+use soroban_sdk::{assert_with_error, bytes, vec, Address, Bytes, BytesN, Env, Map, Vec};
+use utils::option_ext::OptionExt;
 
 // ==============================================================================
 // ISendLib Contract Implementation
@@ -10,22 +30,21 @@ impl ISendLib for Uln302 {
     ///
     /// Calculates fees from: executor (message execution), DVNs (verification), and treasury (protocol fee).
     fn quote(env: &Env, packet: &OutboundPacket, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
-        let (executor_options, dvn_options) = worker_options::split_worker_options(env, options);
+        let (executor_options, dvn_options, packet_header, payload_hash) =
+            prepare_packet_and_options(env, packet, options);
 
         // Executor fee
         let executor_fee =
             Self::quote_executor(env, &packet.sender, packet.dst_eid, packet.message.len(), &executor_options);
 
         // DVNs fees
-        let packet_header = packet_codec_v1::encode_packet_header(env, packet);
-        let payload_hash = packet_codec_v1::payload_hash(env, packet);
         let dvns_fee =
             Self::quote_dvns(env, &packet.sender, packet.dst_eid, &packet_header, &payload_hash, &dvn_options);
 
         // Treasury fee
         let workers_fee = executor_fee + dvns_fee;
-        let treasury_fee =
-            Self::get_treasury_client(env).get_fee(&packet.sender, &packet.dst_eid, &workers_fee, &pay_in_zro);
+        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);
 
         if pay_in_zro {
             MessagingFee { native_fee: workers_fee, zro_fee: treasury_fee }
@@ -40,28 +59,41 @@ impl ISendLib for Uln302 {
     fn send(env: &Env, packet: &OutboundPacket, options: &Bytes, pay_in_zro: bool) -> FeesAndPacket {
         Self::endpoint(env).require_auth();
 
-        let mut native_fee_recipients = vec![env];
-        let mut zro_fee_recipients = vec![env];
-        let (executor_options, dvn_options) = worker_options::split_worker_options(env, options);
+        let (executor_options, dvn_options, packet_header, payload_hash) =
+            prepare_packet_and_options(env, packet, options);
 
         // Executor fee
         let executor_fee_recipient =
             Self::assign_executor(env, &packet.sender, packet.dst_eid, packet.message.len(), &executor_options);
-        native_fee_recipients.push_back(executor_fee_recipient);
 
         // DVNs fees
-        let packet_header = packet_codec_v1::encode_packet_header(env, packet);
-        let payload_hash = packet_codec_v1::payload_hash(env, packet);
         let dvns_fee_recipients =
             Self::assign_dvns(env, &packet.sender, packet.dst_eid, &packet_header, &payload_hash, &dvn_options);
+
+        // Collect all worker fees
+        let mut native_fee_recipients = vec![env, executor_fee_recipient];
         native_fee_recipients.extend(dvns_fee_recipients.iter());
 
         // Treasury fee
-        let workers_fee = native_fee_recipients.iter().map(|fee| fee.amount).sum();
-        let treasury_fee =
-            Self::get_treasury_client(env).get_fee(&packet.sender, &packet.dst_eid, &workers_fee, &pay_in_zro);
+        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,
+        );
+
+        // Handle ZRO fee recipients
+        let mut zro_fee_recipients = vec![env];
         if treasury_fee > 0 {
-            let treasury_fee_recipient = FeeRecipient { to: Self::treasury(env), amount: treasury_fee };
+            // The treasury contract address is used as the fixed fee recipient (rather than allowing
+            // the treasury admin to configure a custom receiver). This is because ZRO may be issued
+            // as a Stellar Classic Asset, which requires the recipient to have an established trustline.
+            // If an arbitrary receiver could be configured, a malicious treasury admin could set it to
+            // an address without a trustline, causing all token transfers to fail and effectively
+            // DOSing the OApp. Using the contract address ensures the recipient is always valid.
+            let treasury_fee_recipient = FeeRecipient { to: treasury_addr, amount: treasury_fee };
             if pay_in_zro {
                 zro_fee_recipients.push_back(treasury_fee_recipient);
             } else {
@@ -84,23 +116,23 @@ impl ISendLib for Uln302 {
 #[contract_impl]
 impl ISendUln302 for Uln302 {
     /// Sets default executor configurations for multiple destination endpoints.
-    #[only_owner]
+    #[only_auth]
     fn set_default_executor_configs(env: &Env, params: &Vec<SetDefaultExecutorConfigParam>) {
         for param in params {
             param.config.validate_default_config(env);
             UlnStorage::set_default_executor_configs(env, param.dst_eid, &param.config);
         }
-        DefaultExecutorConfigSet { params: params.clone() }.publish(env);
+        DefaultExecutorConfigsSet { params: params.clone() }.publish(env);
     }
 
     /// Sets default send ULN configurations for multiple destination endpoints.
-    #[only_owner]
+    #[only_auth]
     fn set_default_send_uln_configs(env: &Env, params: &Vec<SetDefaultUlnConfigParam>) {
         for param in params {
             param.config.validate_default_config(env);
             UlnStorage::set_default_send_uln_configs(env, param.eid, &param.config);
         }
-        DefaultUlnSendConfigSet { params: params.clone() }.publish(env);
+        DefaultSendUlnConfigsSet { params: params.clone() }.publish(env);
     }
 
     // ============================================================================================
@@ -109,6 +141,7 @@ impl ISendUln302 for Uln302 {
 
     /// Returns the treasury address for fee collection.
     fn treasury(env: &Env) -> Address {
+        // This is safe because the treasury is set in the constructor.
         UlnStorage::treasury(env).unwrap()
     }
 
@@ -124,7 +157,8 @@ impl ISendUln302 for Uln302 {
 
     /// Returns the effective executor configuration by merging OApp config with default.
     fn effective_executor_config(env: &Env, sender: &Address, dst_eid: u32) -> ExecutorConfig {
-        let default_config = Self::expect_default_executor_config(env, dst_eid);
+        let default_config = Self::default_executor_config(env, dst_eid)
+            .unwrap_or_panic(env, Uln302Error::DefaultExecutorConfigNotFound);
         let oapp_config = Self::oapp_executor_config(env, sender, dst_eid).unwrap_or_default();
 
         oapp_config.apply_default_config(&default_config)
@@ -142,13 +176,14 @@ impl ISendUln302 for Uln302 {
 
     /// Returns the effective send ULN configuration by merging OApp config with default.
     fn effective_send_uln_config(env: &Env, sender: &Address, dst_eid: u32) -> UlnConfig {
-        let default_config = Self::expect_default_send_uln_config(env, dst_eid);
+        let default_config =
+            Self::default_send_uln_config(env, dst_eid).unwrap_or_panic(env, Uln302Error::DefaultSendUlnConfigNotFound);
         let oapp_config = Self::oapp_send_uln_config(env, sender, dst_eid).unwrap_or(OAppUlnConfig::default(env));
 
-        let config = oapp_config.apply_default_config(&default_config);
-        config.validate_at_least_one_dvn(env); // validate the final config
+        let effective_config = oapp_config.apply_default_config(&default_config);
+        effective_config.validate_at_least_one_dvn(env); // validate the final config
 
-        config
+        effective_config
     }
 }
 
@@ -158,11 +193,6 @@ impl ISendUln302 for Uln302 {
 
 impl Uln302 {
     /// Sets OApp-specific executor configuration for a destination endpoint.
-    ///
-    /// # Arguments
-    /// * `sender` - The sender OApp address
-    /// * `dst_eid` - The destination endpoint ID
-    /// * `config` - The OApp-specific executor configuration
     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);
         ExecutorConfigSet { sender: sender.clone(), dst_eid, config: config.clone() }.publish(env);
@@ -170,12 +200,6 @@ impl Uln302 {
 
     /// Sets OApp-specific send ULN configuration for a destination endpoint.
     ///
-    /// # Arguments
-    /// * `sender` - The sender OApp address
-    /// * `dst_eid` - The destination endpoint ID
-    /// * `config` - The OApp-specific send ULN configuration
-    ///
-    /// # Panics
     /// 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);
@@ -184,7 +208,7 @@ impl Uln302 {
         // validate the config by getting the effective config
         let _ = Self::effective_send_uln_config(env, sender, dst_eid);
 
-        UlnSendConfigSet { sender: sender.clone(), dst_eid, config: config.clone() }.publish(env);
+        SendUlnConfigSet { sender: sender.clone(), dst_eid, config: config.clone() }.publish(env);
     }
 
     // ============================================================================================
@@ -192,31 +216,16 @@ impl Uln302 {
     // ============================================================================================
 
     /// Quotes the executor fee for message execution.
-    ///
-    /// # Arguments
-    /// * `sender` - The sender OApp address
-    /// * `dst_eid` - The destination endpoint ID
-    /// * `message_length` - The length of the message
-    /// * `options` - The worker options
-    ///
-    /// # Returns
-    /// The executor fee
     fn quote_executor(env: &Env, sender: &Address, dst_eid: u32, message_length: u32, options: &Bytes) -> i128 {
-        let executor = Self::get_validated_executor_client(env, sender, dst_eid, message_length);
-        executor.get_fee(&env.current_contract_address(), sender, &dst_eid, &message_length, options)
+        // 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);
+
+        let executor_client = LayerZeroExecutorClient::new(env, &executor_config.executor);
+        executor_client.get_fee(&env.current_contract_address(), sender, &dst_eid, &message_length, options)
     }
 
     /// Quotes the total DVN fees for message verification.
-    ///
-    /// # Arguments
-    /// * `sender` - The sender OApp address
-    /// * `dst_eid` - The destination endpoint ID
-    /// * `packet_header` - The raw packet header bytes
-    /// * `payload_hash` - The hash of the message payload
-    /// * `dvn_options` - The worker options for each DVN
-    ///
-    /// # Returns
-    /// The total DVN fees
     fn quote_dvns(
         env: &Env,
         sender: &Address,
@@ -228,19 +237,17 @@ impl Uln302 {
         let uln_config = Self::effective_send_uln_config(env, sender, dst_eid);
         let send_lib = env.current_contract_address();
         let confirmations = uln_config.confirmations;
-
-        let get_dvn_fee = |idx: usize, dvn_addr: Address| {
-            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)
-        };
-
         uln_config
             .required_dvns
             .iter()
             .chain(uln_config.optional_dvns.iter())
             .enumerate()
-            .fold(0_i128, |total_fee, (idx, dvn_addr)| total_fee + get_dvn_fee(idx, dvn_addr))
+            .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)
+            })
+            .sum()
     }
 
     // ============================================================================================
@@ -248,15 +255,6 @@ impl Uln302 {
     // ============================================================================================
 
     /// Assigns an executor job and returns the fee recipient.
-    ///
-    /// # Arguments
-    /// * `sender` - The sender OApp address
-    /// * `dst_eid` - The destination endpoint ID
-    /// * `message_length` - The length of the message
-    /// * `options` - The worker options
-    ///
-    /// # Returns
-    /// The fee recipient
     fn assign_executor(
         env: &Env,
         sender: &Address,
@@ -264,25 +262,19 @@ impl Uln302 {
         message_length: u32,
         options: &Bytes,
     ) -> FeeRecipient {
-        let executor = Self::get_validated_executor_client(env, sender, dst_eid, message_length);
+        // 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);
+
+        let executor_client = LayerZeroExecutorClient::new(env, &executor_config.executor);
         let recipient =
-            executor.assign_job(&env.current_contract_address(), sender, &dst_eid, &message_length, options);
+            executor_client.assign_job(&env.current_contract_address(), sender, &dst_eid, &message_length, options);
 
-        ExecutorFeePaid { executor: executor.address.clone(), fee: recipient.clone() }.publish(env);
+        ExecutorFeePaid { executor: executor_client.address.clone(), fee: recipient.clone() }.publish(env);
         recipient
     }
 
     /// Assigns DVN jobs and returns fee recipients for all DVNs.
-    ///
-    /// # Arguments
-    /// * `sender` - The sender OApp address
-    /// * `dst_eid` - The destination endpoint ID
-    /// * `packet_header` - The raw packet header bytes
-    /// * `payload_hash` - The hash of the message payload
-    /// * `dvn_options` - The worker options for each DVN
-    ///
-    /// # Returns
-    /// The fee recipients for all DVNs
     fn assign_dvns(
         env: &Env,
         sender: &Address,
@@ -295,61 +287,43 @@ impl Uln302 {
         let send_lib = env.current_contract_address();
         let confirmations = uln_config.confirmations;
 
-        let assign_dvn_job = |idx: usize, dvn_addr: &Address| -> FeeRecipient {
-            let dvn_client = LayerZeroDVNClient::new(env, dvn_addr);
+        let mut dvns = vec![env];
+        let mut fees = vec![env];
+        for (idx, dvn_addr) in uln_config.required_dvns.iter().chain(uln_config.optional_dvns.iter()).enumerate() {
+            let dvn_client = LayerZeroDVNClient::new(env, &dvn_addr);
             let dvn_opts = dvn_options.get(idx as u32).unwrap_or(bytes!(env));
-            dvn_client.assign_job(&send_lib, sender, &dst_eid, packet_header, payload_hash, &confirmations, &dvn_opts)
-        };
-
-        let (dvns, fees) = uln_config.required_dvns.iter().chain(uln_config.optional_dvns.iter()).enumerate().fold(
-            (vec![env], vec![env]),
-            |(mut dvns, mut fees), (idx, dvn_addr)| {
-                fees.push_back(assign_dvn_job(idx, &dvn_addr));
-                dvns.push_back(dvn_addr);
-                (dvns, fees)
-            },
-        );
+            let dvn_fee_recipient = dvn_client.assign_job(
+                &send_lib,
+                sender,
+                &dst_eid,
+                packet_header,
+                payload_hash,
+                &confirmations,
+                &dvn_opts,
+            );
+            fees.push_back(dvn_fee_recipient);
+            dvns.push_back(dvn_addr);
+        }
 
         DVNFeePaid { dvns, fees: fees.clone() }.publish(env);
         fees
     }
+}
 
-    // ============================================================================================
-    // Helper Functions
-    // ============================================================================================
-
-    /// Gets a validated executor client, ensuring message size is within limits.
-    ///
-    /// # Arguments
-    /// * `sender` - The sender OApp address
-    /// * `dst_eid` - The destination endpoint ID
-    /// * `message_length` - The length of the message
-    ///
-    /// # Returns
-    /// The executor client
-    fn get_validated_executor_client(
-        env: &Env,
-        sender: &Address,
-        dst_eid: u32,
-        message_length: u32,
-    ) -> LayerZeroExecutorClient<'static> {
-        let executor_config = Self::effective_executor_config(env, sender, dst_eid);
-        assert_with_error!(env, message_length <= executor_config.max_message_size, Uln302Error::InvalidMessageSize);
-        LayerZeroExecutorClient::new(env, &executor_config.executor)
-    }
-
-    /// Returns the treasury client.
-    fn get_treasury_client(env: &Env) -> LayerZeroTreasuryClient<'static> {
-        LayerZeroTreasuryClient::new(env, &Self::treasury(env))
-    }
-
-    /// Returns the default executor config or panics if not found.
-    fn expect_default_executor_config(env: &Env, dst_eid: u32) -> ExecutorConfig {
-        Self::default_executor_config(env, dst_eid).unwrap_or_panic(env, Uln302Error::DefaultExecutorConfigNotFound)
-    }
+// ==============================================================================
+// Helper Functions
+// ==============================================================================
 
-    /// Returns the default send ULN config or panics if not found.
-    fn expect_default_send_uln_config(env: &Env, dst_eid: u32) -> UlnConfig {
-        Self::default_send_uln_config(env, dst_eid).unwrap_or_panic(env, Uln302Error::DefaultSendUlnConfigNotFound)
-    }
+/// Prepares common packet and options needed for both quote and send flows.
+///
+/// Returns a tuple of (executor_options, dvn_options, packet_header, payload_hash)
+fn prepare_packet_and_options(
+    env: &Env,
+    packet: &OutboundPacket,
+    options: &Bytes,
+) -> (Bytes, Map<u32, Bytes>, Bytes, BytesN<32>) {
+    let (executor_options, dvn_options) = worker_options::split_worker_options(env, options);
+    let packet_header = packet_codec_v1::encode_packet_header(env, packet);
+    let payload_hash = packet_codec_v1::payload_hash(env, packet);
+    (executor_options, dvn_options, packet_header, payload_hash)
 }

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

@@ -25,6 +25,11 @@ pub enum UlnStorage {
     #[persistent(UlnConfig)]
     DefaultReceiveUlnConfigs { src_eid: u32 },
 
+    /// The OApp-specific executor configurations for a sender and destination endpoint
+    #[persistent(OAppExecutorConfig)]
+    #[name("oapp_executor_configs")]
+    OAppExecutorConfigs { sender: Address, dst_eid: u32 },
+
     /// The OApp-specific send ULN configurations for a sender and destination endpoint
     #[persistent(OAppUlnConfig)]
     #[name("oapp_send_uln_configs")]
@@ -35,11 +40,6 @@ pub enum UlnStorage {
     #[name("oapp_receive_uln_configs")]
     OAppReceiveUlnConfigs { receiver: Address, src_eid: u32 },
 
-    /// The OApp-specific executor configurations for a sender and destination endpoint
-    #[persistent(OAppExecutorConfig)]
-    #[name("oapp_executor_configs")]
-    OAppExecutorConfigs { sender: Address, dst_eid: u32 },
-
     /// The confirmations for a DVN for a given header hash and payload hash
     #[persistent(u64)]
     Confirmations { dvn: Address, header_hash: BytesN<32>, payload_hash: BytesN<32> },

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

@@ -1,7 +1,7 @@
 extern crate std;
 use crate::{
     errors::Uln302Error,
-    events::UlnReceiveConfigSet,
+    events::ReceiveUlnConfigSet,
     interfaces::{OAppUlnConfig, UlnConfig},
     tests::setup::{setup, TestSetup},
     uln302::CONFIG_TYPE_RECEIVE_ULN,
@@ -35,8 +35,7 @@ fn test_effective_receive_uln_config_with_custom_config() {
     let default_config = UlnConfig::generate(&setup.env, 15, 1, 2, 1);
     let eid = 101;
 
-    setup.set_default_send_uln_config(eid, default_config.clone());
-    setup.set_default_receive_uln_config(eid, default_config.clone());
+    setup.set_default_configs(eid, default_config.clone());
 
     let TestSetup { env, uln302, endpoint, .. } = setup;
 
@@ -57,11 +56,11 @@ fn test_effective_receive_uln_config_with_custom_config() {
     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);
 
-    // Assert UlnReceiveConfigSet event was published immediately after the setter
+    // Assert ReceiveUlnConfigSet event was published immediately after the setter
     assert_event(
         &env,
         &uln302.address,
-        UlnReceiveConfigSet { config: custom_config.clone(), receiver: oapp.clone(), src_eid: eid },
+        ReceiveUlnConfigSet { config: custom_config.clone(), receiver: oapp.clone(), src_eid: eid },
     );
 
     let config = uln302.effective_receive_uln_config(&oapp, &eid);
@@ -77,8 +76,7 @@ fn test_effective_receive_uln_config_must_have_at_least_one_dvn() {
     let default_config = UlnConfig::generate(&setup.env, 10, 1, 0, 0);
     let eid = 101;
 
-    setup.set_default_receive_uln_config(eid, default_config.clone());
-    setup.set_default_send_uln_config(eid, default_config);
+    setup.set_default_configs(eid, default_config.clone());
 
     let TestSetup { env, uln302, endpoint, .. } = setup;
 

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

@@ -1,7 +1,7 @@
 extern crate std;
 use crate::{
     errors::Uln302Error,
-    events::DefaultUlnReceiveConfigSet,
+    events::DefaultReceiveUlnConfigsSet,
     interfaces::{ReceiveUln302Client, SetDefaultUlnConfigParam, UlnConfig},
     tests::setup::{setup, TestSetup},
 };
@@ -32,8 +32,8 @@ fn test_set_default_receive_uln_configs() {
     }]);
     uln302.set_default_receive_uln_configs(&oapp_receive_uln_configs);
 
-    // Assert DefaultUlnReceiveConfigSet event was published with all params
-    assert_event(&env, &uln302.address, DefaultUlnReceiveConfigSet { params: oapp_receive_uln_configs.clone() });
+    // Assert DefaultReceiveUlnConfigSet event was published with all params
+    assert_event(&env, &uln302.address, DefaultReceiveUlnConfigsSet { params: oapp_receive_uln_configs.clone() });
 
     let uln302_receive_client = ReceiveUln302Client::new(&env, &uln302.address);
     for config in oapp_receive_uln_configs.clone() {

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

@@ -2,7 +2,7 @@ extern crate std;
 
 use crate::{
     errors::Uln302Error,
-    events::UlnSendConfigSet,
+    events::SendUlnConfigSet,
     interfaces::{OAppUlnConfig, UlnConfig},
     tests::setup::{setup, TestSetup},
     uln302::CONFIG_TYPE_SEND_ULN,
@@ -20,8 +20,7 @@ fn test_effective_send_uln_config_with_default_only() {
     let default_config = UlnConfig::generate(&setup.env, 10, 2, 3, 2);
     let eid = 100;
 
-    setup.set_default_send_uln_config(eid, default_config.clone());
-    setup.set_default_receive_uln_config(eid, default_config.clone());
+    setup.set_default_configs(eid, default_config.clone());
 
     let TestSetup { env, uln302, .. } = setup;
 
@@ -40,8 +39,7 @@ fn test_effective_send_uln_config_with_custom_config() {
     let default_config = UlnConfig::generate(&setup.env, 10, 2, 3, 2);
     let eid = 100;
 
-    setup.set_default_send_uln_config(eid, default_config.clone());
-    setup.set_default_receive_uln_config(eid, default_config.clone());
+    setup.set_default_configs(eid, default_config.clone());
 
     let TestSetup { env, uln302, endpoint, .. } = setup;
 
@@ -66,11 +64,11 @@ fn test_effective_send_uln_config_with_custom_config() {
     let params = vec![&env, SetConfigParam { eid, config_type: CONFIG_TYPE_SEND_ULN, config: config_bytes }];
     endpoint.set_config(&Address::generate(&env), &oapp, &uln302.address, &params);
 
-    // Assert UlnSendConfigSet event was published immediately after the setter
+    // Assert SendUlnConfigSet event was published immediately after the setter
     assert_event(
         &env,
         &uln302.address,
-        UlnSendConfigSet { config: custom_config.clone(), dst_eid: eid, sender: oapp.clone() },
+        SendUlnConfigSet { config: custom_config.clone(), dst_eid: eid, sender: oapp.clone() },
     );
 
     // Get aggregated config - should have custom confirmations but default DVNs
@@ -89,8 +87,7 @@ fn test_effective_send_uln_config_must_have_at_least_one_dvn() {
     let default_config = UlnConfig::generate(&setup.env, 10, 2, 0, 0);
     let eid = 100;
 
-    setup.set_default_send_uln_config(eid, default_config.clone());
-    setup.set_default_receive_uln_config(eid, default_config);
+    setup.set_default_configs(eid, default_config.clone());
 
     let TestSetup { env, uln302, endpoint, .. } = setup;
 

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

@@ -7,7 +7,7 @@ use utils::testing_utils::assert_event;
 
 use crate::{
     errors::Uln302Error,
-    events::DefaultExecutorConfigSet,
+    events::DefaultExecutorConfigsSet,
     interfaces::{ExecutorConfig, SendUln302Client, SetDefaultExecutorConfigParam},
     tests::setup::{setup, TestSetup},
 };
@@ -44,7 +44,7 @@ fn test_set_default_executor_configs() {
     uln302.set_default_executor_configs(&executor_configs);
 
     // Assert DefaultExecutorConfigSet event was published with all params
-    assert_event(&env, &uln302.address, DefaultExecutorConfigSet { params: executor_configs.clone() });
+    assert_event(&env, &uln302.address, DefaultExecutorConfigsSet { params: executor_configs.clone() });
 
     let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
     for config_param in executor_configs.clone() {

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

@@ -7,7 +7,7 @@ use utils::testing_utils::assert_event;
 
 use crate::{
     errors::Uln302Error,
-    events::DefaultUlnSendConfigSet,
+    events::DefaultSendUlnConfigsSet,
     interfaces::{SendUln302Client, SetDefaultUlnConfigParam, UlnConfig},
     tests::setup::{setup, TestSetup},
 };
@@ -33,8 +33,8 @@ fn test_set_default_send_uln_configs() {
     }]);
     uln302.set_default_send_uln_configs(&oapp_send_uln_configs);
 
-    // Assert DefaultUlnSendConfigSet event was published with all params
-    assert_event(&env, &uln302.address, DefaultUlnSendConfigSet { params: oapp_send_uln_configs.clone() });
+    // Assert DefaultSendUlnConfigSet event was published with all params
+    assert_event(&env, &uln302.address, DefaultSendUlnConfigsSet { params: oapp_send_uln_configs.clone() });
 
     let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
     for config in oapp_send_uln_configs.clone() {

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

@@ -253,6 +253,15 @@ impl<'a> TestSetup<'a> {
         self.uln302.set_default_executor_configs(&params);
     }
 
+    /// Sets all three default configs (executor, send ULN, receive ULN) for an EID.
+    /// This is required for `is_supported_eid` to return true.
+    pub fn set_default_configs(&self, eid: u32, uln_config: UlnConfig) {
+        let executor_config = ExecutorConfig::generate(&self.env, 10000);
+        self.set_default_executor_config(eid, executor_config);
+        self.set_default_send_uln_config(eid, uln_config.clone());
+        self.set_default_receive_uln_config(eid, uln_config);
+    }
+
     pub fn register_executor(&mut self, fee: i128) -> Address {
         let executor = self.env.register(DummyExecutor, (fee,));
         self.executors.push_back(executor.clone());

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

@@ -44,4 +44,9 @@ impl ExecutorConfig {
     pub fn new(max_message_size: u32, executor: &Address) -> Self {
         ExecutorConfig { max_message_size, executor: executor.clone() }
     }
+
+    pub fn generate(env: &Env, max_message_size: u32) -> Self {
+        use soroban_sdk::testutils::Address as _;
+        ExecutorConfig { max_message_size, executor: Address::generate(env) }
+    }
 }

package/contracts/message-libs/uln-302/src/tests/uln302/get_app_receive_uln_config.rs

@@ -15,8 +15,7 @@ fn test_get_oapp_receive_uln_config() {
     let default_config = UlnConfig::generate(&setup.env, 15, 1, 2, 1);
     let eid = 101;
 
-    setup.set_default_send_uln_config(eid, default_config.clone());
-    setup.set_default_receive_uln_config(eid, default_config);
+    setup.set_default_configs(eid, default_config);
 
     let TestSetup { env, uln302, endpoint, .. } = setup;
 

package/contracts/message-libs/uln-302/src/tests/uln302/get_app_send_uln_config.rs

@@ -15,8 +15,7 @@ fn test_get_oapp_send_uln_config() {
     let default_config = UlnConfig::generate(&setup.env, 10, 2, 3, 2);
     let eid = 100;
 
-    setup.set_default_send_uln_config(eid, default_config.clone());
-    setup.set_default_receive_uln_config(eid, default_config);
+    setup.set_default_configs(eid, default_config);
 
     let TestSetup { env, uln302, endpoint, .. } = setup;