@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

package/contracts/oapps/counter/integration_tests/signing.rs

@@ -0,0 +1,62 @@
+//! Key generation utilities for DVN initialization in integration tests.
+//!
+//! Generates secp256k1 addresses (for DVN multisig) and Ed25519 addresses (for admin).
+
+use ed25519_dalek::SigningKey as Ed25519SigningKey;
+use k256::ecdsa::{SigningKey, VerifyingKey};
+use rand::thread_rng;
+use sha3::{Digest, Keccak256};
+use soroban_sdk::{address_payload::AddressPayload, Address, BytesN, Env};
+
+/// Generates an Ethereum-style address from a secp256k1 key (for DVN multisig signer).
+#[derive(Clone)]
+pub struct Secp256k1KeyPair {
+    /// The derived Ethereum-style address (last 20 bytes of keccak256(pubkey))
+    pub eth_address: [u8; 20],
+}
+
+impl Secp256k1KeyPair {
+    /// Generate a new random secp256k1 address.
+    pub fn generate() -> Self {
+        let signing_key = SigningKey::random(&mut thread_rng());
+        let eth_address = Self::derive_eth_address(&signing_key);
+        Self { eth_address }
+    }
+
+    fn derive_eth_address(signing_key: &SigningKey) -> [u8; 20] {
+        let verifying_key: &VerifyingKey = signing_key.verifying_key();
+        let pubkey_bytes = verifying_key.to_encoded_point(false);
+        let pubkey_uncompressed = pubkey_bytes.as_bytes();
+
+        let mut hasher = Keccak256::new();
+        hasher.update(&pubkey_uncompressed[1..65]);
+        let hash = hasher.finalize();
+
+        let mut eth_address = [0u8; 20];
+        eth_address.copy_from_slice(&hash[12..32]);
+        eth_address
+    }
+
+    /// Get the signer address as BytesN<20> for use in Soroban.
+    pub fn signer(&self, env: &Env) -> BytesN<20> {
+        BytesN::from_array(env, &self.eth_address)
+    }
+}
+
+/// Generates an Ed25519 address (for DVN admin).
+pub struct Ed25519KeyPair {
+    signing_key: Ed25519SigningKey,
+}
+
+impl Ed25519KeyPair {
+    /// Generate a new random Ed25519 key pair.
+    pub fn generate() -> Self {
+        Self { signing_key: Ed25519SigningKey::generate(&mut thread_rng()) }
+    }
+
+    /// Get the public key as a Soroban Address.
+    pub fn address(&self, env: &Env) -> Address {
+        let bytes_n = BytesN::from_array(env, &self.signing_key.verifying_key().to_bytes());
+        Address::from_payload(env, AddressPayload::AccountIdPublicKeyEd25519(bytes_n))
+    }
+}

package/contracts/oapps/counter/integration_tests/test_with_sml.rs

@@ -1,35 +1,27 @@
-use crate::codec::MsgType;
-use crate::integration_tests::{setup::*, utils::*};
-use crate::tests::{approve, mint_to};
+use crate::{
+    codec::MsgType,
+    integration_tests::{setup_sml::*, utils::*},
+    tests::mint_to,
+};
 use soroban_sdk::{testutils::Address as _, Address, Bytes};
 
 #[test]
 fn test_increment_vanilla() {
-    let TestSetup { env, chain_a, chain_b } = setup();
+    let TestSetup { env, chain_a, chain_b } = wired_setup();
 
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_counter(&env, &[&chain_a, &chain_b]);
-
-    // on Chain A, quote and increment
     let sender = Address::generate(&env);
     let options = Bytes::new(&env);
-    let msg_type = MsgType::Vanilla;
-
-    let fee = quote(&chain_a, chain_b.eid, msg_type, &options);
+    let fee = quote(&chain_a, chain_b.eid, MsgType::Vanilla, &options);
 
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
-    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee);
-    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    increment(&env, &chain_a, &sender, chain_b.eid, MsgType::Vanilla, &options, &fee);
 
-    // // validate packet on Chain B
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    let packet = validate_packet(&env, &chain_b, &packet_event);
 
-    // deliver the message on Chain B
     let executor = Address::generate(&env);
-    lz_receive(&env, &chain_b, &executor, &packet, 0, false);
+    lz_receive(&env, &chain_b, &executor, &packet, 0);
 
-    // state assertion
     assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
     assert_eq!(chain_b.counter.count(), 1);
     assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
@@ -37,12 +29,8 @@ fn test_increment_vanilla() {
 
 #[test]
 fn test_increment_aba() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_counter(&env, &[&chain_a, &chain_b]);
+    let TestSetup { env, chain_a, chain_b } = wired_setup();
 
-    // on Chain A, quote and increment
     let sender = Address::generate(&env);
     let msg_type = MsgType::ABA;
     let options = Bytes::new(&env);
@@ -53,24 +41,18 @@ fn test_increment_aba() {
 
     // validate packet on Chain B
     let packet_event_chain_a = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event_chain_a);
-    let packet_chain_a = decode_packet(&env, &packet_event_chain_a.0);
+    let packet_chain_a = validate_packet(&env, &chain_b, &packet_event_chain_a);
 
     // deliver the message on Chain B and execute lz_receive
     let executor = Address::generate(&env);
-    mint_to(&env, &chain_b.owner, &chain_b.native_token, &executor, fee.native_fee);
-    approve(&env, &executor, &chain_b.native_token, fee.native_fee);
-    lz_receive(&env, &chain_b, &executor, &packet_chain_a, fee.native_fee, true);
+    lz_receive(&env, &chain_b, &executor, &packet_chain_a, fee.native_fee);
 
     // validate packet on Chain A
     let packet_event_chain_b = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
-    validate_packet(&env, &chain_a, &packet_event_chain_b);
-    let packet_chain_b = decode_packet(&env, &packet_event_chain_b.0);
+    let packet_chain_b = validate_packet(&env, &chain_a, &packet_event_chain_b);
 
-    mint_to(&env, &chain_a.owner, &chain_a.native_token, &executor, fee.native_fee);
-    approve(&env, &executor, &chain_a.native_token, fee.native_fee);
     // deliver the message on Chain A and execute lz_receive
-    lz_receive(&env, &chain_a, &executor, &packet_chain_b, fee.native_fee, false);
+    lz_receive(&env, &chain_a, &executor, &packet_chain_b, fee.native_fee);
 
     // state assertion
     assert_eq!(chain_a.counter.count(), 1);
@@ -84,12 +66,8 @@ fn test_increment_aba() {
 
 #[test]
 fn test_increment_composed() {
-    let TestSetup { env, chain_a, chain_b } = setup();
+    let TestSetup { env, chain_a, chain_b } = wired_setup();
 
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_counter(&env, &[&chain_a, &chain_b]);
-
-    // increment
     let sender = Address::generate(&env);
     let msg_type = MsgType::Composed;
     let options = Bytes::new(&env);
@@ -100,12 +78,11 @@ fn test_increment_composed() {
 
     // validate packet on Chain B
     let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event);
-    let packet = decode_packet(&env, &packet_event.0);
+    let packet = validate_packet(&env, &chain_b, &packet_event);
 
     // deliver the message on Chain B and execute lz_receive
     let executor = Address::generate(&env);
-    lz_receive(&env, &chain_b, &executor, &packet, 0, false);
+    lz_receive(&env, &chain_b, &executor, &packet, 0);
 
     // execute lz_compose
     lz_compose(&env, &chain_b, &executor, &packet, 0);
@@ -119,12 +96,8 @@ fn test_increment_composed() {
 
 #[test]
 fn test_increment_composed_aba() {
-    let TestSetup { env, chain_a, chain_b } = setup();
-
-    wire_endpoint(&env, &[&chain_a, &chain_b]);
-    wire_counter(&env, &[&chain_a, &chain_b]);
+    let TestSetup { env, chain_a, chain_b } = wired_setup();
 
-    // on Chain A, quote and increment
     let sender = Address::generate(&env);
     let msg_type = MsgType::ComposedABA;
     let options = Bytes::new(&env);
@@ -135,24 +108,20 @@ fn test_increment_composed_aba() {
 
     // validate packet on Chain B
     let packet_event_chain_a = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
-    validate_packet(&env, &chain_b, &packet_event_chain_a);
-    let packet_chain_a = decode_packet(&env, &packet_event_chain_a.0);
+    let packet_chain_a = validate_packet(&env, &chain_b, &packet_event_chain_a);
 
     // deliver the message on Chain B and execute lz_receive
     let executor = Address::generate(&env);
-    lz_receive(&env, &chain_b, &executor, &packet_chain_a, 0, false);
+    lz_receive(&env, &chain_b, &executor, &packet_chain_a, 0);
     // supply native token for lz_send(inside lz_compose) on Chain B
-    mint_to(&env, &chain_b.owner, &chain_b.native_token, &executor, fee.native_fee);
-    approve(&env, &executor, &chain_b.native_token, fee.native_fee);
     lz_compose(&env, &chain_b, &executor, &packet_chain_a, fee.native_fee);
 
     // validate packet on Chain A(packet emitted on Chain B)
     let packet_event_chain_b = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
-    validate_packet(&env, &chain_a, &packet_event_chain_b);
-    let packet_chain_b = decode_packet(&env, &packet_event_chain_b.0);
+    let packet_chain_b = validate_packet(&env, &chain_a, &packet_event_chain_b);
 
     // deliver the message on Chain A and execute lz_receive
-    lz_receive(&env, &chain_a, &executor, &packet_chain_b, 0, false);
+    lz_receive(&env, &chain_a, &executor, &packet_chain_b, 0);
 
     // state assertion
     assert_eq!(chain_a.counter.count(), 1);

package/contracts/oapps/counter/integration_tests/test_with_uln.rs

@@ -0,0 +1,314 @@
+extern crate std;
+
+use crate::{
+    codec::MsgType,
+    integration_tests::{setup_uln::*, utils::*},
+    tests::mint_to,
+};
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, IntoVal,
+};
+use uln302::ReceiveUln302Client;
+
+#[test]
+fn test_increment_vanilla() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup_with_dvn_mode(DvnMode::Single);
+
+    let sender = Address::generate(&env);
+    let options = create_default_options(&env);
+    let fee = quote(&chain_a, chain_b.eid, MsgType::Vanilla, &options);
+
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, MsgType::Vanilla, &options, &fee);
+
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    let packet = validate_packet(&env, &chain_b, &packet_event);
+
+    // Execute via executor using the packet options value.
+    let executor_value_b = get_executor_value_from_options(&env, &packet_event.1);
+    let admin = Address::generate(&env);
+    lz_receive_via_executor(&env, &chain_b, &admin, &packet, executor_value_b);
+
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+}
+
+#[test]
+fn test_increment_aba() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup_with_dvn_mode(DvnMode::Single);
+
+    let sender = Address::generate(&env);
+    let msg_type = MsgType::ABA;
+
+    // Quote return fee first, then embed it as value in the send options.
+    let return_options = create_aba_return_options(&env);
+    let fee_b_to_a = quote(&chain_b, chain_a.eid, MsgType::Vanilla, &return_options);
+    let fee_with_buffer = fee_b_to_a.native_fee + fee_b_to_a.native_fee / 100; // 1% buffer
+                                                                               // ABA message doesn't use lz_compose, so pass 0 for lz_compose params
+    let options = create_options_with_gas_and_value(&env, 100000, fee_with_buffer as u128, 0, 0);
+
+    let fee_a_to_b = quote(&chain_a, chain_b.eid, msg_type, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee_a_to_b.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee_a_to_b);
+
+    // validate packet on Chain B
+    let packet_event_chain_a = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    let packet_chain_a = validate_packet(&env, &chain_b, &packet_event_chain_a);
+
+    // Deliver the message on Chain B via executor_helper using the packet options value.
+    let executor_value_b = get_executor_value_from_options(&env, &packet_event_chain_a.1);
+    let admin = Address::generate(&env);
+    lz_receive_via_executor(&env, &chain_b, &admin, &packet_chain_a, executor_value_b);
+
+    // validate packet on Chain A
+    let packet_event_chain_b = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
+    let packet_chain_b = validate_packet(&env, &chain_a, &packet_event_chain_b);
+
+    // Extract executor value from the actual packet options
+    let executor_value = get_executor_value_from_options(&env, &packet_event_chain_b.1);
+    // deliver the message on Chain A via executor_helper
+    lz_receive_via_executor(&env, &chain_a, &admin, &packet_chain_b, executor_value);
+
+    // state assertion
+    assert_eq!(chain_a.counter.count(), 1);
+    assert_eq!(chain_a.counter.inbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+}
+
+#[test]
+fn test_increment_composed() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup_with_dvn_mode(DvnMode::Single);
+
+    let sender = Address::generate(&env);
+    let msg_type = MsgType::Composed;
+    // Composed message needs lzCompose gas for execution
+    let options = create_options_with_gas(&env, 100000, 100000);
+
+    let fee = quote(&chain_a, chain_b.eid, msg_type, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee);
+
+    // validate packet on Chain B
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    let packet = validate_packet(&env, &chain_b, &packet_event);
+
+    // deliver the message on Chain B via executor_helper
+    let executor_value_b = get_executor_value_from_options(&env, &packet_event.1);
+    let admin = Address::generate(&env);
+    lz_receive_via_executor(&env, &chain_b, &admin, &packet, executor_value_b);
+
+    // scan compose_sent event emitted by lz_receive
+    let compose_event = scan_compose_sent_event(&env, &chain_b.endpoint.address);
+    assert!(compose_event.is_some(), "compose_sent event should be emitted");
+    let (from, to, guid, index, _message) = compose_event.unwrap();
+    assert_eq!(from, chain_b.counter.address);
+    assert_eq!(to, chain_b.counter.address);
+    assert_eq!(guid, packet.guid);
+    assert_eq!(index, 0);
+
+    // execute lz_compose via executor_helper
+    let compose_value_b = get_compose_value_from_options(&env, &packet_event.1);
+    lz_compose_via_executor(&env, &chain_b, &admin, &packet, compose_value_b);
+
+    // state assertion
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_b.counter.composed_count(), 1);
+}
+
+#[test]
+fn test_increment_composed_aba() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup_with_dvn_mode(DvnMode::Single);
+
+    let sender = Address::generate(&env);
+    let msg_type = MsgType::ComposedABA;
+
+    // Quote return fee first, then embed it as value in the send options.
+    let return_options = create_composed_aba_return_options(&env);
+    let fee_b_to_a = quote(&chain_b, chain_a.eid, MsgType::Vanilla, &return_options);
+    let fee_with_buffer = fee_b_to_a.native_fee + fee_b_to_a.native_fee / 100; // 1% buffer
+                                                                               // ComposedABA uses lz_compose to send the return message, so include lzCompose gas and value
+    let options = create_options_with_gas_and_value(&env, 100000, 0, 100000, fee_with_buffer as u128);
+
+    let fee_a_to_b = quote(&chain_a, chain_b.eid, msg_type, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee_a_to_b.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, msg_type, &options, &fee_a_to_b);
+
+    // validate packet on Chain B
+    let packet_event_chain_a = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    let packet_chain_a = validate_packet(&env, &chain_b, &packet_event_chain_a);
+
+    // Deliver the message on Chain B via executor_helper using the packet options value.
+    let executor_value_b = get_executor_value_from_options(&env, &packet_event_chain_a.1);
+    let admin = Address::generate(&env);
+    lz_receive_via_executor(&env, &chain_b, &admin, &packet_chain_a, executor_value_b);
+
+    // scan compose_sent event emitted by lz_receive
+    let compose_event = scan_compose_sent_event(&env, &chain_b.endpoint.address);
+    assert!(compose_event.is_some(), "compose_sent event should be emitted");
+    let (from, to, guid, index, _message) = compose_event.unwrap();
+    assert_eq!(from, chain_b.counter.address);
+    assert_eq!(to, chain_b.counter.address);
+    assert_eq!(guid, packet_chain_a.guid);
+    assert_eq!(index, 0);
+
+    // execute lz_compose on Chain B (lz_send happens inside)
+    let compose_value_b = get_compose_value_from_options(&env, &packet_event_chain_a.1);
+    lz_compose_via_executor(&env, &chain_b, &admin, &packet_chain_a, compose_value_b);
+
+    // validate packet on Chain A (packet emitted on Chain B)
+    let packet_event_chain_b = scan_packet_sent_event(&env, &chain_b.endpoint.address).unwrap();
+    let packet_chain_b = validate_packet(&env, &chain_a, &packet_event_chain_b);
+
+    // Extract executor value from the actual packet options
+    let executor_value = get_executor_value_from_options(&env, &packet_event_chain_b.1);
+    // deliver the message on Chain A via executor_helper
+    lz_receive_via_executor(&env, &chain_a, &admin, &packet_chain_b, executor_value);
+
+    // state assertion
+    assert_eq!(chain_a.counter.count(), 1);
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_a.counter.inbound_count(&chain_b.eid), 1);
+
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_b.counter.outbound_count(&chain_a.eid), 1);
+    assert_eq!(chain_b.counter.composed_count(), 1);
+}
+
+// ============================================================================
+// Multi-DVN Verification Tests
+// ============================================================================
+
+/// Multi-DVN: both DVNs required (no optional threshold)
+#[test]
+fn test_multi_dvn_two_required() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup_with_dvn_mode(DvnMode::TwoRequired);
+
+    // Send a message A → B
+    let sender = Address::generate(&env);
+    let options = create_default_options(&env);
+    let fee = quote(&chain_a, chain_b.eid, MsgType::Vanilla, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, MsgType::Vanilla, &options, &fee);
+
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    let packet = decode_packet(&env, &packet_event.0);
+    let encoded_header = packet_codec_v1::encode_packet_header(&env, &packet);
+    let payload_hash = packet_codec_v1::payload_hash(&env, &packet);
+
+    let receive_uln302 = ReceiveUln302Client::new(&env, &chain_b.uln302.address);
+
+    // Verify with first DVN only - should NOT be verifiable yet (need 2 DVNs)
+    env.mock_auths(&[MockAuth {
+        address: &chain_b.dvn.address,
+        invoke: &MockAuthInvoke {
+            contract: &chain_b.uln302.address,
+            fn_name: "verify",
+            args: (&chain_b.dvn.address, &encoded_header, &payload_hash, &CONFIRMATIONS).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_uln302.verify(&chain_b.dvn.address, &encoded_header, &payload_hash, &CONFIRMATIONS);
+
+    // Check verifiable status - should be false (only 1 of 2 required DVNs verified)
+    let is_verifiable = receive_uln302.verifiable(&encoded_header, &payload_hash);
+    assert!(!is_verifiable, "Should NOT be verifiable with only 1 DVN");
+
+    // Verify with second DVN
+    env.mock_auths(&[MockAuth {
+        address: &chain_b.dvn2.address,
+        invoke: &MockAuthInvoke {
+            contract: &chain_b.uln302.address,
+            fn_name: "verify",
+            args: (&chain_b.dvn2.address, &encoded_header, &payload_hash, &CONFIRMATIONS).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_uln302.verify(&chain_b.dvn2.address, &encoded_header, &payload_hash, &CONFIRMATIONS);
+
+    // Now should be verifiable (both required DVNs verified)
+    let is_verifiable = receive_uln302.verifiable(&encoded_header, &payload_hash);
+    assert!(is_verifiable, "Should be verifiable with both DVNs");
+
+    // Commit and deliver
+    receive_uln302.commit_verification(&encoded_header, &payload_hash);
+
+    let executor_value_b = get_executor_value_from_options(&env, &packet_event.1);
+    let admin = Address::generate(&env);
+    lz_receive_via_executor(&env, &chain_b, &admin, &packet, executor_value_b);
+
+    // State assertions
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+}
+
+/// Multi-DVN: duplicate DVN in required+optional (optional threshold = 1)
+#[test]
+fn test_multi_dvn_duplicate_required_optional() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup_with_dvn_mode(DvnMode::DuplicateOptional);
+
+    // Send a message A → B
+    let sender = Address::generate(&env);
+    let options = create_default_options(&env);
+    let fee = quote(&chain_a, chain_b.eid, MsgType::Vanilla, &options);
+    mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, fee.native_fee);
+    increment(&env, &chain_a, &sender, chain_b.eid, MsgType::Vanilla, &options, &fee);
+
+    let packet_event = scan_packet_sent_event(&env, &chain_a.endpoint.address).unwrap();
+    let packet = decode_packet(&env, &packet_event.0);
+    let encoded_header = packet_codec_v1::encode_packet_header(&env, &packet);
+    let payload_hash = packet_codec_v1::payload_hash(&env, &packet);
+
+    let receive_uln302 = ReceiveUln302Client::new(&env, &chain_b.uln302.address);
+
+    // Verify with DVN only - because DVN is present in both required and optional lists (optional threshold = 1),
+    // this alone should satisfy verifiability.
+    env.mock_auths(&[MockAuth {
+        address: &chain_b.dvn.address,
+        invoke: &MockAuthInvoke {
+            contract: &chain_b.uln302.address,
+            fn_name: "verify",
+            args: (&chain_b.dvn.address, &encoded_header, &payload_hash, &CONFIRMATIONS).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_uln302.verify(&chain_b.dvn.address, &encoded_header, &payload_hash, &CONFIRMATIONS);
+
+    let is_verifiable = receive_uln302.verifiable(&encoded_header, &payload_hash);
+    assert!(is_verifiable, "Should be verifiable with duplicate DVN satisfying required + optional");
+
+    // Optionally verify with dvn2 (not required, but matches SUI pattern)
+    env.mock_auths(&[MockAuth {
+        address: &chain_b.dvn2.address,
+        invoke: &MockAuthInvoke {
+            contract: &chain_b.uln302.address,
+            fn_name: "verify",
+            args: (&chain_b.dvn2.address, &encoded_header, &payload_hash, &CONFIRMATIONS).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_uln302.verify(&chain_b.dvn2.address, &encoded_header, &payload_hash, &CONFIRMATIONS);
+
+    let is_verifiable = receive_uln302.verifiable(&encoded_header, &payload_hash);
+    assert!(is_verifiable, "Should be verifiable once optional threshold is met");
+
+    receive_uln302.commit_verification(&encoded_header, &payload_hash);
+
+    let executor_value_b = get_executor_value_from_options(&env, &packet_event.1);
+    let admin = Address::generate(&env);
+    lz_receive_via_executor(&env, &chain_b, &admin, &packet, executor_value_b);
+
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 1);
+    assert_eq!(chain_b.counter.count(), 1);
+    assert_eq!(chain_b.counter.inbound_count(&chain_a.eid), 1);
+}