@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,95 @@
+extern crate std;
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Address, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+use crate::{
+    errors::Uln302Error,
+    events::DefaultExecutorConfigSet,
+    interfaces::{ExecutorConfig, SendUln302Client, SetDefaultExecutorConfigParam},
+    tests::setup::{setup, TestSetup},
+};
+
+#[test]
+fn test_set_default_executor_configs() {
+    let setup = setup();
+    let executor1 = setup.register_executable_address();
+    let executor2 = setup.register_executable_address();
+
+    let TestSetup { env, uln302, owner, .. } = setup;
+
+    let executor_configs = vec![
+        &env,
+        SetDefaultExecutorConfigParam {
+            dst_eid: 100,
+            config: ExecutorConfig { max_message_size: 1000, executor: executor1.clone() },
+        },
+        SetDefaultExecutorConfigParam {
+            dst_eid: 101,
+            config: ExecutorConfig { max_message_size: 2000, executor: executor2.clone() },
+        },
+    ];
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "set_default_executor_configs",
+            args: (&executor_configs,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    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() });
+
+    let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
+    for config_param in executor_configs.clone() {
+        assert_eq!(uln302_send_client.default_executor_config(&config_param.dst_eid), Some(config_param.config));
+    }
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_default_executor_configs_authorization() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let executor = Address::generate(&env);
+    let executor_configs = vec![
+        &env,
+        SetDefaultExecutorConfigParam { dst_eid: 100, config: ExecutorConfig { max_message_size: 1000, executor } },
+    ];
+
+    uln302.set_default_executor_configs(&executor_configs);
+}
+
+#[test]
+fn test_set_default_executor_configs_zero_message_size() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let executor = Address::generate(&env);
+    let executor_configs = vec![
+        &env,
+        SetDefaultExecutorConfigParam { dst_eid: 100, config: ExecutorConfig { max_message_size: 0, executor } },
+    ];
+
+    env.mock_all_auths();
+    let result = uln302.try_set_default_executor_configs(&executor_configs);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::ZeroMessageSize.into());
+}
+
+#[test]
+fn test_default_executor_config_not_found() {
+    // Sui equivalent: test_error_no_default_executor_config
+    // Attempt to get executor config without setting it first
+    let TestSetup { env, uln302, .. } = setup();
+
+    let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
+
+    // Try to get default config for an EID that hasn't been configured
+    let config = uln302_send_client.default_executor_config(&999);
+    assert_eq!(config, None);
+}

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

@@ -0,0 +1,80 @@
+extern crate std;
+use soroban_sdk::{
+    testutils::{MockAuth, MockAuthInvoke},
+    vec, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+use crate::{
+    errors::Uln302Error,
+    events::DefaultUlnSendConfigSet,
+    interfaces::{SendUln302Client, SetDefaultUlnConfigParam, UlnConfig},
+    tests::setup::{setup, TestSetup},
+};
+
+#[test]
+fn test_set_default_send_uln_configs() {
+    let TestSetup { env, uln302, owner, .. } = setup();
+
+    let oapp_send_uln_configs = vec![
+        &env,
+        SetDefaultUlnConfigParam { dst_eid: 100, config: UlnConfig::generate(&env, 1, 1, 3, 1) },
+        SetDefaultUlnConfigParam { dst_eid: 101, config: UlnConfig::generate(&env, 2, 1, 3, 1) },
+    ];
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "set_default_send_uln_configs",
+            args: (&oapp_send_uln_configs,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    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() });
+
+    let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
+    for config in oapp_send_uln_configs.clone() {
+        assert_eq!(uln302_send_client.default_send_uln_config(&config.dst_eid), Some(config.config));
+    }
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_default_send_uln_configs_authorization() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let oapp_send_uln_configs =
+        vec![&env, SetDefaultUlnConfigParam { dst_eid: 100, config: UlnConfig::generate(&env, 1, 1, 3, 1) }];
+
+    uln302.set_default_send_uln_configs(&oapp_send_uln_configs);
+}
+
+#[test]
+fn test_set_default_send_uln_configs_assert_default_config() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let mut config = UlnConfig::generate(&env, 1, 1, 3, 1);
+    config.required_dvns.push_back(config.required_dvns.get(0).unwrap().clone());
+    let oapp_send_uln_configs = vec![&env, SetDefaultUlnConfigParam { dst_eid: 100, config }];
+
+    env.mock_all_auths();
+    let result = uln302.try_set_default_send_uln_configs(&oapp_send_uln_configs);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::DuplicateRequiredDVNs.into());
+}
+
+#[test]
+fn test_default_send_uln_config_not_found() {
+    // Sui equivalent: test_error_no_default_uln_config
+    // Attempt to get ULN config without setting it first
+    let TestSetup { env, uln302, .. } = setup();
+
+    let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
+
+    // Try to get default config for an EID that hasn't been configured
+    let config = uln302_send_client.default_send_uln_config(&999);
+    assert_eq!(config, None);
+}

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

@@ -0,0 +1,268 @@
+use endpoint_v2::{FeeRecipient, MessageLibClient, MessageLibManagerClient, Origin, SetConfigParam};
+use message_lib_common::{ILayerZeroDVN, ILayerZeroExecutor, ILayerZeroTreasury};
+use soroban_sdk::{
+    contract, contractimpl, log, symbol_short,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Address, Bytes, BytesN, Env, IntoVal, Vec,
+};
+
+use crate::{
+    interfaces::{ExecutorConfig, SetDefaultExecutorConfigParam, SetDefaultUlnConfigParam, UlnConfig},
+    Uln302, Uln302Client,
+};
+
+// endpoint is set to SRC_EID, for receiving, the dst_eid is SRC_EID sent from DST_EID
+pub const LOCAL_EID: u32 = 30010;
+pub const REMOTE_EID: u32 = 30011;
+pub const CONFIRMATIONS: u64 = 1;
+pub const MAX_MESSAGE_SIZE: u32 = 10000;
+pub const DVN_FEE: [i128; 5] = [1000, 2000, 3000, 4000, 5000];
+pub const EXECUTOR_FEE: i128 = 2000;
+pub const TREASURY_NATIVE_FEE: i128 = 50;
+pub const TREASURY_ZRO_FEE: i128 = 100;
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub owner: Address,
+    pub endpoint: MessageLibManagerClient<'a>,
+    pub uln302: Uln302Client<'a>,
+    pub executors: Vec<Address>,
+    pub dvns: Vec<Address>,
+    pub treasury: DummyTreasuryClient<'a>,
+}
+
+#[contract]
+struct DummyEndpoint;
+
+#[contractimpl]
+impl DummyEndpoint {
+    pub fn eid(_env: &Env) -> u32 {
+        LOCAL_EID
+    }
+
+    pub fn set_config(env: &Env, _caller: &Address, oapp: &Address, lib: &Address, params: &Vec<SetConfigParam>) {
+        let msglib = MessageLibClient::new(env, lib);
+        msglib.set_config(oapp, params);
+    }
+
+    pub fn verify(_env: &Env, _lib: &Address, _origin: &Origin, _receiver: &Address, _payload_hash: &BytesN<32>) {
+        // do nothing
+    }
+}
+
+#[contract]
+struct DummyDVN;
+
+#[contractimpl]
+impl DummyDVN {
+    pub fn __constructor(env: &Env, fee: i128) {
+        env.storage().persistent().set(&symbol_short!("fee"), &fee);
+        env.storage().persistent().set(&symbol_short!("recipient"), &Address::generate(env));
+    }
+
+    pub fn fee(env: &Env) -> i128 {
+        env.storage().persistent().get(&symbol_short!("fee")).unwrap()
+    }
+
+    pub fn recipient(env: &Env) -> Address {
+        env.storage().persistent().get(&symbol_short!("recipient")).unwrap()
+    }
+}
+
+#[contractimpl]
+impl ILayerZeroDVN for DummyDVN {
+    fn get_fee(
+        env: &Env,
+        _send_lib: &Address,
+        _sender: &Address,
+        _dst_eid: u32,
+        _packet_header: &Bytes,
+        _payload_hash: &BytesN<32>,
+        _confirmations: u64,
+        _options: &Bytes,
+    ) -> i128 {
+        env.storage().persistent().get(&symbol_short!("fee")).unwrap()
+    }
+
+    fn assign_job(
+        env: &Env,
+        _send_lib: &Address,
+        _sender: &Address,
+        _dst_eid: u32,
+        _packet_header: &Bytes,
+        _payload_hash: &BytesN<32>,
+        _confirmations: u64,
+        _options: &Bytes,
+    ) -> FeeRecipient {
+        FeeRecipient {
+            address: env.storage().persistent().get(&symbol_short!("recipient")).unwrap(),
+            amount: env.storage().persistent().get(&symbol_short!("fee")).unwrap(),
+        }
+    }
+}
+
+#[contract]
+struct DummyExecutor;
+
+#[contractimpl]
+impl DummyExecutor {
+    pub fn __constructor(env: &Env, fee: i128) {
+        env.storage().persistent().set(&symbol_short!("fee"), &fee);
+        env.storage().persistent().set(&symbol_short!("recipient"), &Address::generate(env));
+    }
+
+    pub fn recipient(env: &Env) -> Address {
+        env.storage().persistent().get(&symbol_short!("recipient")).unwrap()
+    }
+}
+
+#[contractimpl]
+impl ILayerZeroExecutor for DummyExecutor {
+    fn get_fee(
+        env: &Env,
+        _send_lib: &Address,
+        _sender: &Address,
+        _dst_eid: u32,
+        _calldata_size: u32,
+        _options: &Bytes,
+    ) -> i128 {
+        env.storage().persistent().get(&symbol_short!("fee")).unwrap()
+    }
+
+    fn assign_job(
+        env: &Env,
+        _send_lib: &Address,
+        _sender: &Address,
+        _dst_eid: u32,
+        _calldata_size: u32,
+        _options: &Bytes,
+    ) -> FeeRecipient {
+        FeeRecipient {
+            address: env.storage().persistent().get(&symbol_short!("recipient")).unwrap(),
+            amount: env.storage().persistent().get(&symbol_short!("fee")).unwrap(),
+        }
+    }
+}
+
+#[contract]
+struct DummyTreasury;
+
+#[contractimpl]
+impl DummyTreasury {
+    pub fn __constructor(env: &Env, native_fee: i128, zro_fee: i128) {
+        env.storage().persistent().set(&symbol_short!("nt_fee"), &native_fee);
+        env.storage().persistent().set(&symbol_short!("zro_fee"), &zro_fee);
+    }
+
+    pub fn native_fee(env: &Env) -> i128 {
+        env.storage().persistent().get(&symbol_short!("nt_fee")).unwrap()
+    }
+
+    pub fn zro_fee(env: &Env) -> i128 {
+        env.storage().persistent().get(&symbol_short!("zro_fee")).unwrap()
+    }
+
+    pub fn set_native_fee(env: &Env, native_fee: i128) {
+        env.storage().persistent().set(&symbol_short!("nt_fee"), &native_fee);
+    }
+
+    pub fn set_zro_fee(env: &Env, zro_fee: i128) {
+        env.storage().persistent().set(&symbol_short!("zro_fee"), &zro_fee);
+    }
+}
+
+#[contractimpl]
+impl ILayerZeroTreasury for DummyTreasury {
+    fn get_fee(env: &Env, _sender: &Address, _dst_eid: u32, _total_native_fee: i128, pay_in_zro: bool) -> i128 {
+        if pay_in_zro {
+            Self::zro_fee(env)
+        } else {
+            Self::native_fee(env)
+        }
+    }
+}
+
+pub fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+
+    let endpoint = env.register(DummyEndpoint, ());
+    let treasury = env.register(DummyTreasury, (&0i128, &0i128));
+
+    let uln = env.register(Uln302, (&owner, &endpoint, &treasury));
+    let executors = vec![&env];
+    let dvns = vec![&env];
+
+    let uln_client = Uln302Client::new(&env, &uln);
+    let endpoint_client = MessageLibManagerClient::new(&env, &endpoint);
+    let treasury_client = DummyTreasuryClient::new(&env, &treasury);
+
+    log!(&env, "owner: {}", owner);
+    log!(&env, "endpoint: {}", endpoint);
+    log!(&env, "uln: {}", uln);
+    log!(&env, "treasury: {}", treasury);
+
+    TestSetup { env, owner, endpoint: endpoint_client, uln302: uln_client, executors, dvns, treasury: treasury_client }
+}
+
+impl<'a> TestSetup<'a> {
+    pub fn register_executable_address(&self) -> Address {
+        self.env.register(DummyExecutor, (0i128,))
+    }
+
+    pub fn set_default_send_uln_config(&self, eid: u32, config: UlnConfig) {
+        let params = vec![&self.env, SetDefaultUlnConfigParam { dst_eid: eid, config }];
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.uln302.address,
+                fn_name: "set_default_send_uln_configs",
+                args: (&params,).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.uln302.set_default_send_uln_configs(&params);
+    }
+
+    pub fn set_default_receive_uln_config(&self, eid: u32, config: UlnConfig) {
+        let params = vec![&self.env, SetDefaultUlnConfigParam { dst_eid: eid, config }];
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.uln302.address,
+                fn_name: "set_default_receive_uln_configs",
+                args: (&params,).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.uln302.set_default_receive_uln_configs(&params);
+    }
+
+    pub fn set_default_executor_config(&self, eid: u32, config: ExecutorConfig) {
+        let params = vec![&self.env, SetDefaultExecutorConfigParam { dst_eid: eid, config }];
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.uln302.address,
+                fn_name: "set_default_executor_configs",
+                args: (&params,).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.uln302.set_default_executor_configs(&params);
+    }
+
+    pub fn register_executor(&mut self, fee: i128) -> Address {
+        let executor = self.env.register(DummyExecutor, (fee,));
+        self.executors.push_back(executor.clone());
+        log!(&self.env, "registered executor: {}", executor);
+        executor
+    }
+
+    pub fn register_dvn(&mut self, fee: i128) -> Address {
+        let dvn = self.env.register(DummyDVN, (fee,));
+        self.dvns.push_back(dvn.clone());
+        log!(&self.env, "registered dvn: {}", dvn);
+        dvn
+    }
+}

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

@@ -0,0 +1,47 @@
+use soroban_sdk::{vec, Address, Env, Vec};
+
+use crate::interfaces::{ExecutorConfig, UlnConfig};
+
+impl UlnConfig {
+    pub fn new(
+        confirmations: u64,
+        required_dvns: &Vec<Address>,
+        optional_dvns: &Vec<Address>,
+        optional_dvn_threshold: u32,
+    ) -> Self {
+        UlnConfig {
+            confirmations,
+            required_dvns: required_dvns.clone(),
+            optional_dvns: optional_dvns.clone(),
+            optional_dvn_threshold,
+        }
+    }
+
+    pub fn generate(
+        env: &Env,
+        confirmations: u64,
+        num_required_dvns: u32,
+        num_optional_dvns: u32,
+        optional_dvn_threshold: u32,
+    ) -> Self {
+        use soroban_sdk::testutils::Address as _;
+
+        let mut required_dvns = vec![env];
+        for _ in 0..num_required_dvns {
+            required_dvns.push_back(Address::generate(env));
+        }
+
+        let mut optional_dvns = vec![env];
+        for _ in 0..num_optional_dvns {
+            optional_dvns.push_back(Address::generate(env));
+        }
+
+        UlnConfig { confirmations, required_dvns, optional_dvns, optional_dvn_threshold }
+    }
+}
+
+impl ExecutorConfig {
+    pub fn new(max_message_size: u32, executor: &Address) -> Self {
+        ExecutorConfig { max_message_size, executor: executor.clone() }
+    }
+}

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

@@ -0,0 +1,51 @@
+extern crate std;
+use endpoint_v2::SetConfigParam;
+use soroban_sdk::{log, testutils::Address as _, vec, xdr::ToXdr, Address, Env};
+
+use crate::{
+    interfaces::{OAppUlnConfig, UlnConfig},
+    tests::setup::{setup, TestSetup},
+    uln302::CONFIG_TYPE_RECEIVE_ULN,
+};
+
+#[test]
+fn test_get_oapp_receive_uln_config() {
+    let setup = setup();
+
+    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);
+
+    let TestSetup { env, uln302, endpoint, .. } = setup;
+
+    let oapp = Address::generate(&env);
+    log!(&env, "oapp: {}", oapp);
+
+    let custom_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig::generate(&env, 0, 2, 1, 1),
+    };
+
+    let config_bytes = custom_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);
+
+    let oapp_config = uln302.oapp_receive_uln_config(&oapp, &eid).unwrap();
+    assert_eq!(oapp_config.use_default_confirmations, true);
+    assert_eq!(oapp_config.use_default_required_dvns, false);
+}
+
+#[test]
+fn test_get_oapp_receive_uln_config_not_found() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let oapp = Address::generate(&env);
+    log!(&env, "oapp: {}", oapp);
+
+    let config = uln302.oapp_receive_uln_config(&oapp, &101);
+    assert_eq!(config, None);
+}

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

@@ -0,0 +1,51 @@
+extern crate std;
+use endpoint_v2::SetConfigParam;
+use soroban_sdk::{log, testutils::Address as _, vec, xdr::ToXdr, Address, Env};
+
+use crate::{
+    interfaces::{OAppUlnConfig, UlnConfig},
+    tests::setup::{setup, TestSetup},
+    uln302::CONFIG_TYPE_SEND_ULN,
+};
+
+#[test]
+fn test_get_oapp_send_uln_config() {
+    let setup = setup();
+
+    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);
+
+    let TestSetup { env, uln302, endpoint, .. } = setup;
+
+    let oapp = Address::generate(&env);
+    log!(&env, "oapp: {}", oapp);
+
+    let custom_config = OAppUlnConfig {
+        use_default_confirmations: false,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: true,
+        uln_config: UlnConfig::generate(&env, 20, 1, 0, 0),
+    };
+
+    let config_bytes = custom_config.clone().to_xdr(&env);
+    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);
+
+    // Get raw oapp config
+    let oapp_config = uln302.oapp_send_uln_config(&oapp, &eid).unwrap();
+    assert_eq!(custom_config, oapp_config);
+}
+
+#[test]
+fn test_get_oapp_send_uln_config_not_found() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let oapp = Address::generate(&env);
+    log!(&env, "oapp: {}", oapp);
+
+    let config = uln302.oapp_send_uln_config(&oapp, &100);
+    assert_eq!(config, None);
+}

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

@@ -0,0 +1,48 @@
+extern crate std;
+use endpoint_v2::SetConfigParam;
+use soroban_sdk::{log, testutils::Address as _, vec, xdr::ToXdr, Address, Env};
+
+use crate::{
+    interfaces::{ExecutorConfig, OAppExecutorConfig, UlnConfig},
+    tests::setup::{setup, TestSetup},
+    uln302::CONFIG_TYPE_EXECUTOR,
+};
+
+#[test]
+fn test_get_oapp_executor_config() {
+    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);
+    log!(&setup.env, "oapp: {}", oapp);
+
+    let custom_executor = setup.register_executable_address();
+    let custom_config = OAppExecutorConfig { max_message_size: 3000, executor: Some(custom_executor.clone()) };
+
+    let config_bytes = custom_config.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);
+
+    let oapp_config = setup.uln302.oapp_executor_config(&oapp, &eid).unwrap();
+    assert_eq!(oapp_config.max_message_size, 3000);
+    assert_eq!(oapp_config.executor, Some(custom_executor));
+}
+
+#[test]
+fn test_get_oapp_executor_config_not_found() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let oapp = Address::generate(&env);
+    log!(&env, "oapp: {}", oapp);
+
+    let config = uln302.oapp_executor_config(&oapp, &102);
+    assert_eq!(config, None);
+}

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

@@ -0,0 +1,4 @@
+mod get_app_receive_uln_config;
+mod get_app_send_uln_config;
+mod get_oapp_executor_config;
+mod set_config;