@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

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

@@ -1,62 +0,0 @@
-//! 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_blocked.rs

@@ -1,67 +0,0 @@
-use crate::{
-    codec::MsgType,
-    integration_tests::{setup_sml::*, utils::*},
-};
-use blocked_message_lib::{BlockedMessageLib, BlockedMessageLibError};
-use endpoint_v2::MessagingFee;
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, IntoVal,
-};
-
-#[test]
-fn test_blocked_message_lib_quote_fails() {
-    let TestSetup { env, chain_a, chain_b } = wired_setup();
-
-    // Deploy and configure BlockedMessageLib as Chain A's send library to Chain B.
-    let blocked_lib = env.register(BlockedMessageLib, ());
-    register_library(&env, &chain_a.owner, &chain_a.endpoint, &blocked_lib);
-    set_default_send_library(&env, &chain_a.owner, &chain_a.endpoint, chain_b.eid, &blocked_lib);
-
-    let options = Bytes::new(&env);
-    let msg_type = MsgType::Vanilla as u32;
-
-    let result = chain_a.counter.try_quote(&chain_b.eid, &msg_type, &options, &false);
-    assert_eq!(result.unwrap_err().unwrap(), BlockedMessageLibError::NotImplemented.into());
-}
-
-#[test]
-fn test_blocked_message_lib_send_fails() {
-    let TestSetup { env, chain_a, chain_b } = wired_setup();
-
-    // Deploy and configure BlockedMessageLib as Chain A's send library to Chain B.
-    let blocked_lib = env.register(BlockedMessageLib, ());
-    register_library(&env, &chain_a.owner, &chain_a.endpoint, &blocked_lib);
-    set_default_send_library(&env, &chain_a.owner, &chain_a.endpoint, chain_b.eid, &blocked_lib);
-
-    let sender = Address::generate(&env);
-    let options = Bytes::new(&env);
-    let msg_type = MsgType::Vanilla as u32;
-
-    // We can't quote (blocked), so pass a zero-fee payment. The send should still fail inside the send library.
-    let fee = MessagingFee { native_fee: 0, zro_fee: 0 };
-
-    env.mock_auths(&[MockAuth {
-        address: &sender,
-        invoke: &MockAuthInvoke {
-            contract: &chain_a.counter.address,
-            fn_name: "increment",
-            args: (&sender, &chain_b.eid, &msg_type, &options, &fee).into_val(&env),
-            sub_invokes: &[MockAuthInvoke {
-                contract: &chain_a.native_token,
-                fn_name: "transfer",
-                args: (&sender, &chain_a.endpoint.address, &fee.native_fee).into_val(&env),
-                sub_invokes: &[],
-            }],
-        },
-    }]);
-
-    let result = chain_a.counter.try_increment(&sender, &chain_b.eid, &msg_type, &options, &fee);
-    assert_eq!(result.unwrap_err().unwrap(), BlockedMessageLibError::NotImplemented.into());
-
-    // Ensure no packet was emitted.
-    assert!(scan_packet_sent_event(&env, &chain_a.endpoint.address).is_none());
-
-    // State should be rolled back (outbound count unchanged).
-    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 0);
-}

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

@@ -1,135 +0,0 @@
-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 } = wired_setup();
-
-    let sender = Address::generate(&env);
-    let options = Bytes::new(&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);
-
-    let executor = Address::generate(&env);
-    lz_receive(&env, &chain_b, &executor, &packet, 0);
-
-    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();
-
-    let sender = Address::generate(&env);
-    let msg_type = MsgType::ABA;
-    let options = Bytes::new(&env);
-
-    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_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 and execute lz_receive
-    let executor = Address::generate(&env);
-    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();
-    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, fee.native_fee);
-
-    // 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();
-
-    let sender = Address::generate(&env);
-    let msg_type = MsgType::Composed;
-    let options = Bytes::new(&env);
-
-    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 and execute lz_receive
-    let executor = Address::generate(&env);
-    lz_receive(&env, &chain_b, &executor, &packet, 0);
-
-    // execute lz_compose
-    lz_compose(&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);
-    assert_eq!(chain_b.counter.composed_count(), 1);
-}
-
-#[test]
-fn test_increment_composed_aba() {
-    let TestSetup { env, chain_a, chain_b } = wired_setup();
-
-    let sender = Address::generate(&env);
-    let msg_type = MsgType::ComposedABA;
-    let options = Bytes::new(&env);
-
-    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_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 and execute lz_receive
-    let executor = Address::generate(&env);
-    lz_receive(&env, &chain_b, &executor, &packet_chain_a, 0);
-    // supply native token for lz_send(inside lz_compose) on Chain B
-    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();
-    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);
-
-    // 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);
-}

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

@@ -1,314 +0,0 @@
-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);
-}