@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,199 @@
+// ================================================
+// IReceiveUln302 Contract Implementation
+// ================================================
+
+#[contractimpl]
+impl IReceiveUln302 for Uln302 {
+    /// Called by a DVN to verify a message with a specific number of block confirmations.
+    ///
+    /// Stores the DVN's verification attestation which will be checked during commit_verification.
+    fn verify(env: &Env, dvn: &Address, packet_header: &Bytes, payload_hash: &BytesN<32>, confirmations: u64) {
+        dvn.require_auth();
+
+        let header_hash = util::keccak256(env, packet_header);
+        UlnStorage::set_confirmations(env, dvn, &header_hash, payload_hash, &confirmations);
+
+        PayloadVerified {
+            dvn: dvn.clone(),
+            header: packet_header.clone(),
+            proof_hash: payload_hash.clone(),
+            confirmations,
+        }
+        .publish(env);
+    }
+
+    /// Permissonless to commit a verified message to the endpoint after sufficient DVN verification.
+    ///
+    /// Validates the packet header and checks that enough DVNs have verified the message
+    /// (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, header_hash, uln_config) = Self::validate_and_extract_param(env, packet_header);
+
+        // check if the message is verifiable
+        assert_with_error!(
+            env,
+            Self::verifiable_internal(env, &uln_config, &header_hash, payload_hash),
+            Uln302Error::Verifying
+        );
+
+        // clean up confirmations storage for all DVNs
+        uln_config.required_dvns.iter().chain(uln_config.optional_dvns.iter()).for_each(|dvn| {
+            UlnStorage::remove_confirmations(env, &dvn, &header_hash, payload_hash);
+        });
+
+        // commit verification to the endpoint
+        let send_lib = env.current_contract_address();
+        let origin = Origin { src_eid: header.src_eid, sender: header.sender, nonce: header.nonce };
+        let receiver = Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver));
+        LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).verify(&send_lib, &origin, &receiver, payload_hash);
+    }
+
+    // === Owner Set Config Functions ===
+
+    /// Sets default receive ULN configurations for multiple source endpoints.
+    ///
+    /// Validates each config and stores it as the default for the specified source EID.
+    #[only_owner]
+    fn set_default_receive_uln_configs(env: &Env, params: &Vec<SetDefaultUlnConfigParam>) {
+        for param in params {
+            param.config.validate_default_config(env);
+            UlnStorage::set_default_receive_uln_configs(env, param.dst_eid, &param.config);
+        }
+
+        DefaultUlnReceiveConfigSet { params: params.clone() }.publish(env);
+    }
+
+    // === View Functions ===
+
+    /// Returns the number of block confirmations a DVN has submitted for a specific message.
+    fn confirmations(env: &Env, dvn: &Address, header_hash: &BytesN<32>, payload_hash: &BytesN<32>) -> Option<u64> {
+        UlnStorage::confirmations(env, dvn, header_hash, payload_hash)
+    }
+
+    /// 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 (_, header_hash, uln_config) = Self::validate_and_extract_param(env, packet_header);
+        Self::verifiable_internal(env, &uln_config, &header_hash, payload_hash)
+    }
+
+    /// Returns the default receive ULN configuration for a source endpoint.
+    fn default_receive_uln_config(env: &Env, src_eid: u32) -> Option<UlnConfig> {
+        UlnStorage::default_receive_uln_configs(env, src_eid)
+    }
+
+    /// Returns the OApp-specific receive ULN configuration override for a source endpoint.
+    fn oapp_receive_uln_config(env: &Env, receiver: &Address, src_eid: u32) -> Option<OAppUlnConfig> {
+        UlnStorage::oapp_receive_uln_configs(env, receiver, src_eid)
+    }
+
+    /// Returns the effective receive ULN configuration by merging OApp config with defaults.
+    fn effective_receive_uln_config(env: &Env, receiver: &Address, src_eid: u32) -> UlnConfig {
+        let default_config = Self::expect_default_receive_uln_config(env, src_eid);
+        let oapp_config = Self::oapp_receive_uln_config(env, receiver, src_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
+
+        config
+    }
+}
+
+// ================================================
+// Internal Functions
+// ================================================
+
+impl Uln302 {
+    // === OApp Set Config Functions ===
+
+    /// Sets OApp-specific receive ULN config.
+    ///
+    /// # Arguments
+    /// * `receiver` - The receiver OApp address
+    /// * `src_eid` - The source endpoint ID
+    /// * `config` - The OApp-specific receive ULN configuration
+    ///
+    /// # Panics
+    /// Panics if the final effective config is invalid.
+    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);
+        // validate the config by getting the effective config
+        let _ = Self::effective_receive_uln_config(env, receiver, src_eid);
+
+        UlnReceiveConfigSet { receiver: receiver.clone(), src_eid, config: config.clone() }.publish(env);
+    }
+
+    // === Verification Helpers Functions ===
+
+    /// Validates packet header and extracts header, header hash, and effective ULN config.
+    fn validate_and_extract_param(env: &Env, packet_header: &Bytes) -> (PacketHeader, BytesN<32>, UlnConfig) {
+        let header = packet_codec_v1::decode_packet_header(env, packet_header);
+        assert_with_error!(
+            env,
+            header.dst_eid == LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).eid(),
+            Uln302Error::InvalidEID
+        );
+
+        let header_hash = util::keccak256(env, packet_header);
+        let uln_config = Self::effective_receive_uln_config(
+            env,
+            &Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver.clone())),
+            header.src_eid,
+        );
+
+        (header, header_hash, uln_config)
+    }
+
+    /// Checks if all required DVNs verified and optional DVN threshold is met.
+    ///
+    /// # Arguments
+    /// * `uln_config` - The effective ULN configuration
+    /// * `header_hash` - The hash of the packet header
+    /// * `payload_hash` - The hash of the message payload
+    ///
+    /// # Returns
+    /// True if the message has been verified by enough DVNs to be committed, false otherwise
+    fn verifiable_internal(
+        env: &Env,
+        uln_config: &UlnConfig,
+        header_hash: &BytesN<32>,
+        payload_hash: &BytesN<32>,
+    ) -> bool {
+        let threshold = uln_config.optional_dvn_threshold as usize;
+        let is_verified = |dvn: &Address| Self::verified(env, dvn, header_hash, payload_hash, uln_config.confirmations);
+
+        // check if all required DVNs are verified and the optional DVNs threshold is met
+        uln_config.required_dvns.iter().all(|dvn| is_verified(&dvn))
+            && uln_config.optional_dvns.iter().filter(is_verified).take(threshold).count() == threshold
+    }
+
+    /// Checks if a DVN has submitted enough confirmations for the message.
+    ///
+    /// # Arguments
+    /// * `dvn` - The DVN address
+    /// * `header_hash` - The hash of the packet header
+    /// * `payload_hash` - The hash of the message payload
+    /// * `confirmations` - The number of block confirmations the DVN has observed
+    ///
+    /// # Returns
+    /// True if the DVN has submitted enough confirmations for the message, false otherwise
+    fn verified(
+        env: &Env,
+        dvn: &Address,
+        header_hash: &BytesN<32>,
+        payload_hash: &BytesN<32>,
+        confirmations: u64,
+    ) -> bool {
+        Self::confirmations(env, dvn, header_hash, payload_hash).map(|c| c >= confirmations).unwrap_or(false)
+    }
+
+    // === Helper Functions ===
+
+    /// Returns default receive ULN config or panics if not found.
+    fn expect_default_receive_uln_config(env: &Env, src_eid: u32) -> UlnConfig {
+        Self::default_receive_uln_config(env, src_eid)
+            .unwrap_or_panic(env, Uln302Error::DefaultReceiveUlnConfigNotFound)
+    }
+}

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

@@ -0,0 +1,349 @@
+// ==============================================================================
+// ISendLib Contract Implementation
+// ==============================================================================
+
+#[contractimpl]
+impl ISendLib for Uln302 {
+    /// Quotes the total fee for sending a cross-chain message.
+    ///
+    /// 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);
+
+        // 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);
+
+        if pay_in_zro {
+            MessagingFee { native_fee: workers_fee, zro_fee: treasury_fee }
+        } else {
+            MessagingFee { native_fee: workers_fee + treasury_fee, zro_fee: 0 }
+        }
+    }
+
+    /// Sends a cross-chain message and returns fee recipients for payment.
+    ///
+    /// Assigns executor and DVNs, calculates fees, and encodes the packet for transmission.
+    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);
+
+        // 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);
+        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);
+        if treasury_fee > 0 {
+            let treasury_fee_recipient = FeeRecipient { address: Self::treasury(env), amount: treasury_fee };
+            if pay_in_zro {
+                zro_fee_recipients.push_back(treasury_fee_recipient);
+            } else {
+                native_fee_recipients.push_back(treasury_fee_recipient);
+            }
+        }
+
+        FeesAndPacket {
+            native_fee_recipients,
+            zro_fee_recipients,
+            encoded_packet: packet_codec_v1::encode_packet(env, packet),
+        }
+    }
+}
+
+// ==============================================================================
+// ISendUln302 Contract Implementation
+// ==============================================================================
+
+#[contractimpl]
+impl ISendUln302 for Uln302 {
+    // === Owner Set Config Functions ===
+
+    /// Sets default executor configurations for multiple destination endpoints.
+    #[only_owner]
+    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);
+    }
+
+    /// Sets default send ULN configurations for multiple destination endpoints.
+    #[only_owner]
+    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.dst_eid, &param.config);
+        }
+        DefaultUlnSendConfigSet { params: params.clone() }.publish(env);
+    }
+
+    // ===== View Functions =====
+
+    /// Returns the treasury address for fee collection.
+    fn treasury(env: &Env) -> Address {
+        UlnStorage::treasury(env).unwrap()
+    }
+
+    /// Returns the default executor configuration for a destination endpoint.
+    fn default_executor_config(env: &Env, dst_eid: u32) -> Option<ExecutorConfig> {
+        UlnStorage::default_executor_configs(env, dst_eid)
+    }
+
+    /// Returns the OApp-specific executor configuration for a destination endpoint.
+    fn oapp_executor_config(env: &Env, sender: &Address, dst_eid: u32) -> Option<OAppExecutorConfig> {
+        UlnStorage::oapp_executor_configs(env, sender, dst_eid)
+    }
+
+    /// 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 oapp_config = Self::oapp_executor_config(env, sender, dst_eid).unwrap_or_default();
+
+        oapp_config.apply_default_config(&default_config)
+    }
+
+    /// Returns the default send ULN configuration for a destination endpoint.
+    fn default_send_uln_config(env: &Env, dst_eid: u32) -> Option<UlnConfig> {
+        UlnStorage::default_send_uln_configs(env, dst_eid)
+    }
+
+    /// Returns the OApp-specific send ULN configuration for a destination endpoint.
+    fn oapp_send_uln_config(env: &Env, sender: &Address, dst_eid: u32) -> Option<OAppUlnConfig> {
+        UlnStorage::oapp_send_uln_configs(env, sender, dst_eid)
+    }
+
+    /// 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 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
+
+        config
+    }
+}
+
+// ==============================================================================
+// Internal Functions
+// ==============================================================================
+
+impl Uln302 {
+    // === OApp Set Config Functions ===
+
+    /// 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
+    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);
+    }
+
+    /// 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.
+    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);
+        // 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);
+    }
+
+    // === Quote Fee Functions ===
+
+    /// 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)
+    }
+
+    /// 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,
+        dst_eid: u32,
+        packet_header: &Bytes,
+        payload_hash: &BytesN<32>,
+        dvn_options: &Map<u32, Bytes>,
+    ) -> i128 {
+        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))
+    }
+
+    // === Assign Job Functions ===
+
+    /// 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,
+        dst_eid: u32,
+        message_length: u32,
+        options: &Bytes,
+    ) -> FeeRecipient {
+        let executor = Self::get_validated_executor_client(env, sender, dst_eid, message_length);
+        let recipient =
+            executor.assign_job(&env.current_contract_address(), sender, &dst_eid, &message_length, options);
+
+        ExecutorFeePaid { executor: executor.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,
+        dst_eid: u32,
+        packet_header: &Bytes,
+        payload_hash: &BytesN<32>,
+        dvn_options: &Map<u32, Bytes>,
+    ) -> Vec<FeeRecipient> {
+        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 assign_dvn_job = |idx: usize, dvn_addr: &Address| -> FeeRecipient {
+            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)
+            },
+        );
+
+        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)
+    }
+
+    /// 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)
+    }
+}

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

@@ -0,0 +1,47 @@
+use crate::interfaces::{ExecutorConfig, OAppExecutorConfig, OAppUlnConfig, UlnConfig};
+use common_macros::storage;
+use soroban_sdk::{Address, BytesN};
+use utils::ttl::DefaultTtlConfigProvider;
+
+/// Storage for the Uln302 message library.
+#[storage(DefaultTtlConfigProvider)]
+pub enum UlnStorage {
+    /// The endpoint address
+    #[instance(Address)]
+    Endpoint,
+
+    /// The treasury address
+    #[instance(Address)]
+    Treasury,
+
+    /// The default executor configurations for a destination endpoint
+    #[persistent(ExecutorConfig)]
+    DefaultExecutorConfigs { dst_eid: u32 },
+
+    /// The default send ULN configurations for a destination endpoint
+    #[persistent(UlnConfig)]
+    DefaultSendUlnConfigs { dst_eid: u32 },
+
+    /// The default receive ULN configurations for a source endpoint
+    #[persistent(UlnConfig)]
+    DefaultReceiveUlnConfigs { src_eid: u32 },
+
+    /// The OApp-specific send ULN configurations for a sender and destination endpoint
+    #[persistent(OAppUlnConfig)]
+    #[name("oapp_send_uln_configs")]
+    OAppSendUlnConfigs { sender: Address, dst_eid: u32 },
+
+    /// The OApp-specific receive ULN configurations for a receiver and source endpoint
+    #[persistent(OAppUlnConfig)]
+    #[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/config/mod.rs

@@ -0,0 +1,2 @@
+mod oapp_uln_config;
+mod uln_config;