@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,291 @@
+extern crate std;
+use soroban_sdk::{testutils::Address as _, vec, Address, Env};
+
+use crate::interfaces::{OAppUlnConfig, UlnConfig};
+
+fn setup_env() -> Env {
+    Env::default()
+}
+
+// ==================== Test apply_default method ====================
+
+#[test]
+fn test_apply_default_all_defaults() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    // OApp config that uses all defaults
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: true,
+        use_default_optional_dvns: true,
+        uln_config: UlnConfig {
+            confirmations: 99,                                  // Should be ignored
+            required_dvns: vec![&env, Address::generate(&env)], // Should be ignored
+            optional_dvns: vec![&env, Address::generate(&env)], // Should be ignored
+            optional_dvn_threshold: 99,                         // Should be ignored
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, default_config.confirmations);
+    assert_eq!(result.required_dvns, default_config.required_dvns);
+    assert_eq!(result.optional_dvns, default_config.optional_dvns);
+    assert_eq!(result.optional_dvn_threshold, default_config.optional_dvn_threshold);
+}
+
+#[test]
+fn test_apply_default_custom_confirmations_only() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: false, // Use custom
+        use_default_required_dvns: true,
+        use_default_optional_dvns: true,
+        uln_config: UlnConfig {
+            confirmations: 25,
+            required_dvns: vec![&env],
+            optional_dvns: vec![&env],
+            optional_dvn_threshold: 0,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, 25);
+    assert_eq!(result.required_dvns, default_config.required_dvns);
+    assert_eq!(result.optional_dvns, default_config.optional_dvns);
+    assert_eq!(result.optional_dvn_threshold, default_config.optional_dvn_threshold);
+}
+
+#[test]
+fn test_apply_default_custom_required_dvns_only() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    let custom_required_dvns = vec![&env, Address::generate(&env), Address::generate(&env), Address::generate(&env)];
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: false, // Use custom
+        use_default_optional_dvns: true,
+        uln_config: UlnConfig {
+            confirmations: 0,
+            required_dvns: custom_required_dvns.clone(),
+            optional_dvns: vec![&env],
+            optional_dvn_threshold: 0,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, default_config.confirmations);
+    assert_eq!(result.required_dvns, custom_required_dvns);
+    assert_eq!(result.optional_dvns, default_config.optional_dvns);
+    assert_eq!(result.optional_dvn_threshold, default_config.optional_dvn_threshold);
+}
+
+#[test]
+fn test_apply_default_custom_optional_dvns_only() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    let custom_optional_dvns = vec![&env, Address::generate(&env), Address::generate(&env)];
+    let custom_threshold = 1;
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: true,
+        use_default_optional_dvns: false, // Use custom
+        uln_config: UlnConfig {
+            confirmations: 0,
+            required_dvns: vec![&env],
+            optional_dvns: custom_optional_dvns.clone(),
+            optional_dvn_threshold: custom_threshold,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, default_config.confirmations);
+    assert_eq!(result.required_dvns, default_config.required_dvns);
+    assert_eq!(result.optional_dvns, custom_optional_dvns);
+    assert_eq!(result.optional_dvn_threshold, custom_threshold);
+}
+
+#[test]
+fn test_apply_default_all_custom() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    let custom_required_dvns = vec![&env, Address::generate(&env)];
+    let custom_optional_dvns = vec![&env, Address::generate(&env), Address::generate(&env), Address::generate(&env)];
+    let custom_threshold = 2;
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: false,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig {
+            confirmations: 50,
+            required_dvns: custom_required_dvns.clone(),
+            optional_dvns: custom_optional_dvns.clone(),
+            optional_dvn_threshold: custom_threshold,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, 50);
+    assert_eq!(result.required_dvns, custom_required_dvns);
+    assert_eq!(result.optional_dvns, custom_optional_dvns);
+    assert_eq!(result.optional_dvn_threshold, custom_threshold);
+}
+
+#[test]
+fn test_apply_default_mix_1() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    let custom_required_dvns = vec![&env, Address::generate(&env), Address::generate(&env), Address::generate(&env)];
+    let custom_optional_dvns = vec![&env];
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: false,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig {
+            confirmations: 30,
+            required_dvns: custom_required_dvns.clone(),
+            optional_dvns: custom_optional_dvns.clone(),
+            optional_dvn_threshold: 0,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, 30);
+    assert_eq!(result.required_dvns, custom_required_dvns);
+    assert_eq!(result.optional_dvns, custom_optional_dvns);
+    assert_eq!(result.optional_dvn_threshold, 0);
+}
+
+#[test]
+fn test_apply_default_mix_2() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    let custom_optional_dvns = vec![&env, Address::generate(&env)];
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig {
+            confirmations: 0,
+            required_dvns: vec![&env],
+            optional_dvns: custom_optional_dvns.clone(),
+            optional_dvn_threshold: 1,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, default_config.confirmations);
+    assert_eq!(result.required_dvns.len(), 0);
+    assert_eq!(result.optional_dvns, custom_optional_dvns);
+    assert_eq!(result.optional_dvn_threshold, 1);
+}
+
+#[test]
+fn test_apply_default_empty_custom_dvns() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 10, 2, 3, 2);
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: false,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig {
+            confirmations: 15,
+            required_dvns: vec![&env],
+            optional_dvns: vec![&env],
+            optional_dvn_threshold: 0,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, 15);
+    assert_eq!(result.required_dvns.len(), 0);
+    assert_eq!(result.optional_dvns.len(), 0);
+    assert_eq!(result.optional_dvn_threshold, 0);
+}
+
+#[test]
+fn test_apply_default_zero_confirmations() {
+    let env = setup_env();
+
+    let default_config = UlnConfig::generate(&env, 100, 1, 0, 0);
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: false,
+        use_default_required_dvns: true,
+        use_default_optional_dvns: true,
+        uln_config: UlnConfig {
+            confirmations: 0,
+            required_dvns: vec![&env],
+            optional_dvns: vec![&env],
+            optional_dvn_threshold: 0,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.confirmations, 0);
+    assert_eq!(result.required_dvns, default_config.required_dvns);
+}
+
+#[test]
+fn test_apply_default_preserves_dvn_addresses() {
+    let env = setup_env();
+
+    let default_dvn1 = Address::generate(&env);
+    let default_dvn2 = Address::generate(&env);
+    let custom_dvn1 = Address::generate(&env);
+    let custom_dvn2 = Address::generate(&env);
+
+    let default_config = UlnConfig {
+        confirmations: 10,
+        required_dvns: vec![&env, default_dvn1.clone(), default_dvn2.clone()],
+        optional_dvns: vec![&env],
+        optional_dvn_threshold: 0,
+    };
+
+    let oapp_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: true,
+        uln_config: UlnConfig {
+            confirmations: 0,
+            required_dvns: vec![&env, custom_dvn1.clone(), custom_dvn2.clone()],
+            optional_dvns: vec![&env],
+            optional_dvn_threshold: 0,
+        },
+    };
+
+    let result = oapp_config.apply_default_config(&default_config);
+
+    assert_eq!(result.required_dvns.get(0).unwrap(), custom_dvn1);
+    assert_eq!(result.required_dvns.get(1).unwrap(), custom_dvn2);
+}

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

@@ -0,0 +1,163 @@
+use soroban_sdk::{contract, contractimpl, Env};
+
+use crate::{errors::Uln302Error, interfaces::UlnConfig};
+
+#[contract]
+struct DummyConfig;
+
+#[contractimpl]
+impl DummyConfig {
+    pub fn validate_default_config(env: &Env, config: UlnConfig) {
+        config.validate_default_config(env);
+    }
+
+    pub fn validate_at_least_one_dvn(env: &Env, config: UlnConfig) {
+        config.validate_at_least_one_dvn(env);
+    }
+}
+
+fn setup<'a>() -> (Env, DummyConfigClient<'a>) {
+    let env = Env::default();
+
+    let config = env.register(DummyConfig, ());
+    let config_client = DummyConfigClient::new(&env, &config);
+    (env, config_client)
+}
+
+#[test]
+fn test_validate_default_config() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 1, 3, 1);
+    config_client.validate_default_config(&config);
+}
+
+#[test]
+fn test_validate_default_config_has_required_duplicates() {
+    let (env, config_client) = setup();
+    let mut config = UlnConfig::generate(&env, 1, 1, 3, 1);
+    config.required_dvns.push_back(config.required_dvns.get(0).unwrap().clone());
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::DuplicateRequiredDVNs.into());
+}
+
+#[test]
+fn test_validate_default_config_has_invalid_required_dvn_count() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 128, 3, 1);
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::InvalidRequiredDVNCount.into());
+}
+
+#[test]
+fn test_validate_default_config_has_optional_duplicates() {
+    let (env, config_client) = setup();
+    let mut config = UlnConfig::generate(&env, 1, 1, 3, 1);
+    config.optional_dvns.push_back(config.optional_dvns.get(0).unwrap().clone());
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::DuplicateOptionalDVNs.into());
+}
+
+#[test]
+fn test_validate_default_config_has_invalid_optional_dvn_count() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 1, 128, 1);
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::InvalidOptionalDVNCount.into());
+}
+
+#[test]
+fn test_validate_default_config_has_invalid_optional_dvn_threshold() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 1, 3, 0);
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::InvalidOptionalDVNThreshold.into());
+}
+
+#[test]
+fn test_validate_default_config_has_zero_threshold_with_optional_dvns() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 1, 3, 4);
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::InvalidOptionalDVNThreshold.into());
+}
+
+#[test]
+fn test_validate_default_config_zero_dvns() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 0, 0, 0);
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::UlnAtLeastOneDVN.into());
+}
+
+#[test]
+fn test_assert_beyond_max_dvns() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 128, 0, 0);
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::InvalidRequiredDVNCount.into());
+}
+
+#[test]
+fn test_assert_beyond_max_dvns_with_optional_dvns() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 0, 128, 1);
+    let result = config_client.try_validate_default_config(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::InvalidOptionalDVNCount.into());
+}
+
+#[test]
+fn test_validate_at_least_one_dvn_with_optional_dvns() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 0, 1, 1);
+    config_client.validate_at_least_one_dvn(&config);
+}
+
+#[test]
+fn test_validate_at_least_one_dvn_with_optional_dvns_and_threshold_0() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 0, 1, 0);
+    let result = config_client.try_validate_at_least_one_dvn(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::UlnAtLeastOneDVN.into());
+}
+
+#[test]
+fn test_validate_at_least_one_dvn_with_required_dvns() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 1, 0, 0);
+    config_client.validate_at_least_one_dvn(&config);
+}
+
+#[test]
+fn test_validate_at_least_one_dvn_has_no_dvns() {
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 1, 0, 0, 0);
+    let result = config_client.try_validate_at_least_one_dvn(&config);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::UlnAtLeastOneDVN.into());
+}
+
+// ==================== Boundary Tests ====================
+
+#[test]
+fn test_exactly_127_required_dvns_should_pass() {
+    // Sui equivalent: test_exactly_127_required_dvns_should_pass
+    // Test with exactly 127 required DVNs (boundary test - should pass)
+    let (env, config_client) = setup();
+    let config = UlnConfig::generate(&env, 64, 127, 0, 0);
+
+    // This should NOT abort - exactly 127 is allowed
+    config_client.validate_default_config(&config);
+}
+
+#[test]
+fn test_exactly_127_optional_dvns_should_pass() {
+    // Sui equivalent: test_exactly_127_optional_dvns_should_pass
+    // Test with exactly 127 optional DVNs (boundary test - should pass)
+    let (env, config_client) = setup();
+
+    // One required DVN to satisfy "at least one DVN" requirement
+    // 127 optional DVNs with threshold of 64 (less than or equal to optional DVN count)
+    let config = UlnConfig::generate(&env, 64, 1, 127, 64);
+
+    // This should NOT abort - exactly 127 is allowed
+    config_client.validate_default_config(&config);
+}

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

@@ -0,0 +1,7 @@
+mod setup;
+
+mod config;
+mod receive_uln302;
+mod send_uln302;
+mod testing_utils;
+mod uln302;

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

@@ -0,0 +1,183 @@
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Address, IntoVal,
+};
+
+use crate::{
+    errors::Uln302Error,
+    interfaces::{ReceiveUln302Client, UlnConfig},
+    tests::setup::{setup, TestSetup},
+};
+
+use super::{
+    create_test_packet_header, create_test_packet_header_with_eid, create_test_payload_hash, CONFIRMATIONS,
+    REMOTE_EID as SRC_EID,
+};
+
+#[test]
+fn test_commit_clears_verification_storage() {
+    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 receiver = Address::generate(env);
+
+    // Set up config with 2 required DVNs and 1 optional DVN
+    let mut config = UlnConfig::generate(env, CONFIRMATIONS, 2, 1, 1);
+    config.required_dvns = vec![env, dvn1.clone(), dvn2.clone()];
+    config.optional_dvns = vec![env, dvn3.clone()];
+    config.optional_dvn_threshold = 1;
+    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);
+
+    // All DVNs verify
+    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);
+
+    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);
+
+    // Verify that verifications exist before commit
+    let header_hash = endpoint_v2::util::keccak256(env, &packet_header);
+    // Commit verification
+    receive_client.commit_verification(&packet_header, &payload_hash);
+
+    // Verify that all verifications were cleared
+    assert!(receive_client.confirmations(&dvn1, &header_hash, &payload_hash).is_none());
+    assert!(receive_client.confirmations(&dvn2, &header_hash, &payload_hash).is_none());
+    assert!(receive_client.confirmations(&dvn3, &header_hash, &payload_hash).is_none());
+}
+
+#[test]
+fn test_commit_second_time_fails() {
+    let test_setup = setup();
+    let TestSetup { env, uln302, .. } = &test_setup;
+
+    let dvn1 = Address::generate(env);
+    let dvn2 = Address::generate(env);
+    let receiver = Address::generate(env);
+
+    // Set up config with 2 required DVNs
+    let mut config = UlnConfig::generate(env, CONFIRMATIONS, 2, 0, 0);
+    config.required_dvns = vec![env, dvn1.clone(), dvn2.clone()];
+    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);
+
+    // Both required DVNs verify
+    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);
+
+    // First commit should succeed
+    receive_client.commit_verification(&packet_header, &payload_hash);
+
+    // Second commit should fail because storage was cleared (Verifying error)
+    let result = receive_client.try_commit_verification(&packet_header, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::Verifying.into());
+}
+
+#[test]
+fn test_commit_verification_invalid_eid_should_fail() {
+    // Sui equivalent: test_commit_verification_invalid_eid_should_fail
+    // Tests that commit_verification fails when packet dst_eid doesn't match endpoint EID
+    let test_setup = setup();
+    let TestSetup { env, uln302, .. } = &test_setup;
+
+    let dvn1 = Address::generate(env);
+    let dvn2 = Address::generate(env);
+    let receiver = Address::generate(env);
+
+    // Set up config with 2 required DVNs
+    let mut config = UlnConfig::generate(env, CONFIRMATIONS, 2, 0, 0);
+    config.required_dvns = vec![env, dvn1.clone(), dvn2.clone()];
+    TestSetup::set_default_receive_uln_config(&test_setup, SRC_EID, config);
+
+    // Create packet with WRONG dst_eid (different from endpoint EID)
+    let invalid_dst_eid = 999u32;
+    let packet_header = create_test_packet_header_with_eid(env, &receiver, invalid_dst_eid);
+    let payload_hash = create_test_payload_hash(env);
+
+    let receive_client = ReceiveUln302Client::new(env, &uln302.address);
+
+    // Pre-verify the packet with DVNs (to get past the verification step)
+    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);
+
+    // This should fail with InvalidEID because packet.dst_eid (999) != endpoint.eid()
+    let result = receive_client.try_commit_verification(&packet_header, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::InvalidEID.into());
+}