@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

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

@@ -0,0 +1,997 @@
+extern crate std;
+
+use crate::{
+    counter::{Counter, CounterClient},
+    integration_tests::{
+        signing::{Ed25519KeyPair, Secp256k1KeyPair},
+        utils::{address_to_bytes32, decode_packet, register_library, set_peer, set_zro, ChainSetupCommon},
+    },
+};
+use dvn::{DVNClient, DstConfig as DvnDstConfig, DstConfigParam as DvnDstConfigParam, LzDVN};
+use dvn_fee_lib::DvnFeeLib;
+use endpoint_v2::{EndpointV2, EndpointV2Client};
+use executor::{DstConfig as ExecutorDstConfig, ExecutorClient, LzExecutor, SetDstConfigParam};
+use executor_fee_lib::ExecutorFeeLib;
+use executor_helper::{ExecutorHelper, ExecutorHelperClient};
+use price_feed::{types::UpdatePrice, LzPriceFeed};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token::TokenClient,
+    vec, Address, BytesN, Env, IntoVal, Vec,
+};
+use treasury::Treasury;
+use uln302::{
+    ExecutorConfig, ReceiveUln302Client, SendUln302Client, SetDefaultExecutorConfigParam, SetDefaultUlnConfigParam,
+    Uln302, Uln302Client, UlnConfig,
+};
+use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
+use worker::Price;
+
+pub const CONFIRMATIONS: u64 = 1;
+pub const MAX_MESSAGE_SIZE: u32 = 10000;
+pub const DVN_VID: u32 = 1; // DVN Verifier ID
+
+// Price feed constants for testing
+const PRICE_RATIO_DENOMINATOR: u128 = 10_u128.pow(20);
+const DEFAULT_GAS_PRICE: u64 = 100;
+const DEFAULT_GAS_PER_BYTE: u32 = 1;
+const DEFAULT_MULTIPLIER_BPS: u32 = 10000; // 100%
+
+// Worker options constants
+const OPTIONS_TYPE_3: u16 = 3;
+const EXECUTOR_WORKER_ID: u8 = 1;
+const EXECUTOR_OPTION_TYPE_LZRECEIVE: u8 = 1;
+
+#[allow(dead_code)]
+const EXECUTOR_OPTION_TYPE_NATIVE_DROP: u8 = 2;
+
+const EXECUTOR_OPTION_TYPE_LZCOMPOSE: u8 = 3;
+
+// ============================================================================
+// Options Creation Functions
+// ============================================================================
+
+/// Creates default ULN302 options with Type 3 format and basic lzReceive gas (no lzCompose).
+/// This is required because ULN302 expects at least 2 bytes for the options type header.
+pub fn create_default_options(env: &Env) -> soroban_sdk::Bytes {
+    create_options_with_gas(env, 100000, 0)
+}
+
+/// Extracts the executor value (native token amount) from Type 3 options.
+/// Returns 0 if no value is specified in the options.
+pub fn get_executor_value_from_options(_env: &Env, options: &soroban_sdk::Bytes) -> i128 {
+    let mut reader = BufferReader::new(options);
+
+    // Skip options type header (2 bytes)
+    let _options_type = reader.read_u16();
+
+    // Parse options until we find lzReceive with value
+    while reader.remaining_len() > 0 {
+        let _worker_id = reader.read_u8();
+        let option_size = reader.read_u16();
+        let option_type = reader.read_u8();
+
+        if option_type == EXECUTOR_OPTION_TYPE_LZRECEIVE {
+            // option_size includes option_type(1) + data
+            // If data is 32 bytes (gas + value), extract value
+            // If data is 16 bytes (gas only), value is 0
+            let data_size = option_size - 1; // subtract option_type byte
+            let _gas = reader.read_u128();
+            if data_size == 32 {
+                return reader.read_u128() as i128;
+            }
+            return 0;
+        } else {
+            // Skip this option's data (option_size - 1 for option_type already read)
+            reader.skip((option_size - 1).into());
+        }
+    }
+
+    0
+}
+
+/// Extracts the lzCompose value (native token amount) from Type 3 options.
+/// Returns 0 if no lzCompose value is specified in the options.
+pub fn get_compose_value_from_options(_env: &Env, options: &soroban_sdk::Bytes) -> i128 {
+    let mut reader = BufferReader::new(options);
+
+    // Skip options type header (2 bytes)
+    let _options_type = reader.read_u16();
+
+    // Parse options until we find lzCompose with value
+    while reader.remaining_len() > 0 {
+        let _worker_id = reader.read_u8();
+        let option_size = reader.read_u16();
+        let option_type = reader.read_u8();
+
+        if option_type == EXECUTOR_OPTION_TYPE_LZCOMPOSE {
+            // option_size includes option_type(1) + data
+            // lzCompose format: [index: u16][gas: u128] (18 bytes) or [index: u16][gas: u128][value: u128] (34 bytes)
+            // So data_size is 18 or 34
+            let data_size = option_size - 1; // subtract option_type byte
+            let _index = reader.read_u16();
+            let _gas = reader.read_u128();
+            if data_size == 34 {
+                return reader.read_u128() as i128;
+            }
+            return 0;
+        } else {
+            // Skip this option's data (option_size - 1 for option_type already read)
+            reader.skip((option_size - 1).into());
+        }
+    }
+
+    0
+}
+
+/// Creates ULN302 options with lzReceive gas and optional lzCompose gas.
+/// Format: [options_type(2)][lzReceive option][lzCompose option (if lz_compose_gas > 0)]
+///
+/// # Arguments
+/// * `env` - Soroban environment
+/// * `gas` - Gas limit for lzReceive execution (always required)
+/// * `lz_compose_gas` - Gas limit for lzCompose execution (only added if > 0)
+pub fn create_options_with_gas(env: &Env, gas: u128, lz_compose_gas: u128) -> soroban_sdk::Bytes {
+    create_options_with_gas_and_value(env, gas, 0, lz_compose_gas, 0)
+}
+
+/// Creates ULN302 options with lzReceive gas/value and optional lzCompose gas/value.
+/// Format: [options_type(2)][lzReceive option][lzCompose option (if lz_compose_gas > 0)]
+///
+/// # Arguments
+/// * `env` - Soroban environment
+/// * `gas` - Gas limit for lzReceive execution (always required)
+/// * `value` - Native value for lzReceive (only added if > 0)
+/// * `lz_compose_gas` - Gas limit for lzCompose execution (only added if > 0)
+/// * `lz_compose_value` - Native value for lzCompose (only added if > 0)
+pub fn create_options_with_gas_and_value(
+    env: &Env,
+    gas: u128,
+    value: u128,
+    lz_compose_gas: u128,
+    lz_compose_value: u128,
+) -> soroban_sdk::Bytes {
+    let mut writer = BufferWriter::new(env);
+
+    // Type 3 options header
+    writer.write_u16(OPTIONS_TYPE_3);
+
+    // Add lzReceive option - include value only if > 0
+    if value > 0 {
+        writer
+            .write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+            .write_u16(33) // option_size: option_type(1) + gas(16) + value(16) = 33 bytes
+            .write_u8(EXECUTOR_OPTION_TYPE_LZRECEIVE) // option_type (1 byte)
+            .write_u128(gas) // execution gas (16 bytes)
+            .write_u128(value); // value (16 bytes)
+    } else {
+        writer
+            .write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+            .write_u16(17) // option_size: option_type(1) + gas(16) = 17 bytes
+            .write_u8(EXECUTOR_OPTION_TYPE_LZRECEIVE) // option_type (1 byte)
+            .write_u128(gas); // execution gas (16 bytes)
+    }
+
+    // Add lzCompose option only if lz_compose_gas > 0
+    if lz_compose_gas > 0 {
+        if lz_compose_value > 0 {
+            // lzCompose with gas and value: [index: u16][gas: u128][value: u128] = 34 bytes
+            writer
+                .write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+                .write_u16(35) // option_size: option_type(1) + index(2) + gas(16) + value(16) = 35 bytes
+                .write_u8(EXECUTOR_OPTION_TYPE_LZCOMPOSE) // option_type (1 byte)
+                .write_u16(0) // compose index (2 bytes)
+                .write_u128(lz_compose_gas) // compose gas (16 bytes)
+                .write_u128(lz_compose_value); // compose value (16 bytes)
+        } else {
+            // lzCompose with gas only: [index: u16][gas: u128] = 18 bytes
+            writer
+                .write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+                .write_u16(19) // option_size: option_type(1) + index(2) + gas(16) = 19 bytes
+                .write_u8(EXECUTOR_OPTION_TYPE_LZCOMPOSE) // option_type (1 byte)
+                .write_u16(0) // compose index (2 bytes)
+                .write_u128(lz_compose_gas); // compose gas (16 bytes)
+        }
+    }
+
+    writer.to_bytes()
+}
+
+/// Creates ULN302 options with lzReceive gas and value (for ABA return messages).
+/// Format: [options_type(2)][lzReceive option with gas and value]
+pub fn create_aba_return_options(env: &Env) -> soroban_sdk::Bytes {
+    let mut writer = BufferWriter::new(env);
+
+    // Type 3 options header
+    writer.write_u16(OPTIONS_TYPE_3);
+
+    // Add lzReceive option with gas=200000 and value=10 (matching Counter's ABA return)
+    writer
+        .write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+        .write_u16(33) // option_size: option_type(1) + gas(16) + value(16) = 33 bytes
+        .write_u8(EXECUTOR_OPTION_TYPE_LZRECEIVE) // option_type (1 byte)
+        .write_u128(200000) // execution gas (16 bytes)
+        .write_u128(10); // value (16 bytes)
+
+    writer.to_bytes()
+}
+
+/// Creates ULN302 options for ComposedABA return (gas=200000, no lzCompose).
+pub fn create_composed_aba_return_options(env: &Env) -> soroban_sdk::Bytes {
+    create_options_with_gas(env, 200000, 0)
+}
+
+/// Creates ULN302 options with native drop included.
+/// Format: [options_type(2)][lzReceive option][native drop option]
+#[allow(dead_code)]
+pub fn create_options_with_native_drop(env: &Env, amount: u128, receiver: &BytesN<32>) -> soroban_sdk::Bytes {
+    let mut writer = BufferWriter::new(env);
+
+    // Type 3 options header
+    writer.write_u16(OPTIONS_TYPE_3);
+
+    // Add a basic lzReceive option with default gas (100000)
+    writer
+        .write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+        .write_u16(17) // option_size: option_type(1) + data(16) = 17 bytes
+        .write_u8(EXECUTOR_OPTION_TYPE_LZRECEIVE) // option_type (1 byte)
+        .write_u128(100000); // execution gas data (16 bytes)
+
+    // Add native drop option
+    writer
+        .write_u8(EXECUTOR_WORKER_ID) // worker_id (1 byte)
+        .write_u16(49) // option_size: option_type(1) + amount(16) + receiver(32) = 49 bytes
+        .write_u8(EXECUTOR_OPTION_TYPE_NATIVE_DROP) // option_type (1 byte)
+        .write_u128(amount) // drop amount (16 bytes)
+        .write_bytes_n(receiver); // receiver address (32 bytes)
+
+    writer.to_bytes()
+}
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+/// DVN credentials for initialization (addresses for signers and admin).
+pub struct DvnCredentials {
+    /// secp256k1 addresses for DVN multisig
+    pub signers: std::vec::Vec<Secp256k1KeyPair>,
+    /// Ed25519 key pair for DVN admin address
+    pub admin_keypair: Ed25519KeyPair,
+}
+
+impl DvnCredentials {
+    /// Generate new DVN credentials with the specified number of signers.
+    pub fn generate(num_signers: usize) -> Self {
+        Self {
+            signers: (0..num_signers).map(|_| Secp256k1KeyPair::generate()).collect(),
+            admin_keypair: Ed25519KeyPair::generate(),
+        }
+    }
+
+    /// Get the signer addresses as a Soroban Vec<BytesN<20>>.
+    pub fn signer_addresses(&self, env: &Env) -> Vec<BytesN<20>> {
+        let mut addrs: Vec<BytesN<20>> = vec![env];
+        for kp in &self.signers {
+            addrs.push_back(kp.signer(env));
+        }
+        addrs
+    }
+
+    /// Get the admin address for DVN registration.
+    pub fn admin_address(&self, env: &Env) -> Address {
+        self.admin_keypair.address(env)
+    }
+}
+
+pub struct ChainSetup<'a> {
+    pub eid: u32,
+    pub owner: Address,
+    pub admin: Address, // Worker admin
+    pub native_token: Address,
+    pub endpoint: EndpointV2Client<'a>,
+    pub uln302: Uln302Client<'a>,
+    pub dvn: DVNClient<'a>,
+    pub dvn2: DVNClient<'a>, // Second DVN for multi-DVN tests
+    pub executor: ExecutorClient<'a>,
+    pub executor_helper: ExecutorHelperClient<'a>,
+    pub price_feed: Address,
+    pub counter: CounterClient<'a>,
+}
+
+impl<'a> ChainSetupCommon<'a> for ChainSetup<'a> {
+    fn counter(&self) -> &CounterClient<'a> {
+        &self.counter
+    }
+    fn endpoint(&self) -> &EndpointV2Client<'a> {
+        &self.endpoint
+    }
+    fn native_token(&self) -> &Address {
+        &self.native_token
+    }
+    fn owner(&self) -> &Address {
+        &self.owner
+    }
+    fn validate_packet(
+        &self,
+        env: &Env,
+        packet_event: &(soroban_sdk::Bytes, soroban_sdk::Bytes, Address),
+    ) -> endpoint_v2::OutboundPacket {
+        use message_lib_common::packet_codec_v1;
+
+        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);
+
+        // DVN verify with mock_auths
+        let receive_uln302 = ReceiveUln302Client::new(env, &self.uln302.address);
+
+        env.mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &self.dvn.address,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &self.uln302.address,
+                fn_name: "verify",
+                args: (&self.dvn.address, &encoded_header, &payload_hash, &CONFIRMATIONS).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        receive_uln302.verify(&self.dvn.address, &encoded_header, &payload_hash, &CONFIRMATIONS);
+
+        // Commit verification (permissionless)
+        receive_uln302.commit_verification(&encoded_header, &payload_hash);
+
+        packet
+    }
+}
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub chain_a: ChainSetup<'a>,
+    pub chain_b: ChainSetup<'a>,
+}
+
+/// Intermediate structure to hold chain infrastructure before DVN/Executor creation
+struct ChainInfra {
+    endpoint_address: Address,
+    uln302_address: Address,
+    #[allow(dead_code)]
+    treasury_address: Address,
+    price_feed_address: Address,
+    dvn_fee_lib_address: Address,
+    executor_fee_lib_address: Address,
+    zro_token: Address,
+    admin: Address,
+    deposit_address: Address,
+    /// DVN credentials (addresses for initialization)
+    dvn_credentials: DvnCredentials,
+}
+
+/// Phase 1: Create basic chain infrastructure (Endpoint, ULN302, Treasury, etc.)
+fn setup_chain_infrastructure(env: &Env, owner: &Address) -> ChainInfra {
+    // Create ZRO token
+    let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let zro_token = zro_sac.address();
+
+    // Register endpoint
+    let endpoint_address = env.register(EndpointV2, (owner,));
+
+    // Register Treasury (real)
+    let treasury_address = env.register(Treasury, (owner,));
+
+    // Register PriceFeed (real)
+    let price_updater = Address::generate(env);
+    let price_feed_address = env.register(LzPriceFeed, (owner, &price_updater));
+
+    // Register fee libs
+    let dvn_fee_lib_address = env.register(DvnFeeLib, (owner,));
+    let executor_fee_lib_address = env.register(ExecutorFeeLib, (owner,));
+
+    // Register ULN302
+    let uln302_address = env.register(Uln302, (owner, &endpoint_address, &treasury_address));
+
+    // Create admin for workers
+    let admin = Address::generate(env);
+
+    // Deposit address for fee collection
+    let deposit_address = Address::generate(env);
+
+    // Generate real DVN credentials (1 signer with threshold 1)
+    let dvn_credentials = DvnCredentials::generate(1);
+
+    ChainInfra {
+        endpoint_address,
+        uln302_address,
+        treasury_address: treasury_address.clone(),
+        price_feed_address,
+        dvn_fee_lib_address,
+        executor_fee_lib_address,
+        zro_token,
+        admin,
+        deposit_address,
+        dvn_credentials,
+    }
+}
+
+/// Phase 2: Create DVN, Executor, and ExecutorHelper with cross-chain ULN302 support
+fn setup_chain_workers<'a>(
+    env: &Env,
+    owner: &Address,
+    infra: &ChainInfra,
+    all_uln302_addresses: &Vec<Address>, // All ULN302 addresses across chains
+) -> (DVNClient<'a>, DVNClient<'a>, ExecutorClient<'a>, ExecutorHelperClient<'a>) {
+    // Use the DVN admin address from credentials, plus the worker admin
+    let admins = vec![env, infra.admin.clone(), infra.dvn_credentials.admin_address(env)];
+
+    // Use real secp256k1 signers from credentials
+    let signers = infra.dvn_credentials.signer_addresses(env);
+    let threshold: u32 = infra.dvn_credentials.signers.len() as u32;
+
+    // Register first DVN with ALL ULN302 addresses as supported message libs
+    let dvn_address = env.register(
+        LzDVN,
+        (
+            DVN_VID,                    // vid
+            &signers,                   // signers (real secp256k1 addresses)
+            threshold,                  // threshold
+            &admins,                    // admins
+            all_uln302_addresses,       // supported_msglibs - ALL chains' ULN302s
+            &infra.price_feed_address,  // price_feed
+            DEFAULT_MULTIPLIER_BPS,     // default_multiplier_bps
+            &infra.dvn_fee_lib_address, // worker_fee_lib
+            &infra.deposit_address,     // deposit_address
+        ),
+    );
+
+    // Register second DVN for multi-DVN verification tests
+    let dvn2_credentials = DvnCredentials::generate(1);
+    let admins2 = vec![env, infra.admin.clone(), dvn2_credentials.admin_address(env)];
+    let signers2 = dvn2_credentials.signer_addresses(env);
+    let dvn2_address = env.register(
+        LzDVN,
+        (
+            DVN_VID + 1, // Different vid for second DVN
+            &signers2,
+            1u32, // threshold
+            &admins2,
+            all_uln302_addresses,
+            &infra.price_feed_address,
+            DEFAULT_MULTIPLIER_BPS,
+            &infra.dvn_fee_lib_address,
+            &infra.deposit_address,
+        ),
+    );
+
+    // Register ExecutorHelper (stateless entry point for executor AA workflow)
+    let executor_helper_address = env.register(ExecutorHelper, ());
+
+    // Register real Executor with ALL ULN302 addresses as supported message libs
+    let executor_address = env.register(
+        LzExecutor,
+        (
+            &infra.endpoint_address,
+            owner,
+            &admins,
+            all_uln302_addresses, // supported_msglibs - ALL chains' ULN302s
+            &infra.price_feed_address,
+            DEFAULT_MULTIPLIER_BPS,
+            &infra.executor_fee_lib_address, // worker_fee_lib
+            &infra.deposit_address,          // deposit_address
+        ),
+    );
+
+    let dvn = DVNClient::new(env, &dvn_address);
+    let dvn2 = DVNClient::new(env, &dvn2_address);
+    let executor = ExecutorClient::new(env, &executor_address);
+    let executor_helper = ExecutorHelperClient::new(env, &executor_helper_address);
+
+    (dvn, dvn2, executor, executor_helper)
+}
+
+/// Phase 3: Complete chain setup by creating Counter and finalizing configuration
+fn finalize_chain_setup<'a>(
+    env: &Env,
+    owner: &Address,
+    infra: ChainInfra,
+    dvn: DVNClient<'a>,
+    dvn2: DVNClient<'a>,
+    executor: ExecutorClient<'a>,
+    executor_helper: ExecutorHelperClient<'a>,
+) -> ChainSetup<'a> {
+    // Register Counter OApp
+    let counter_address = env.register(Counter, (owner, &infra.endpoint_address, owner));
+
+    // Create clients
+    let endpoint = EndpointV2Client::new(env, &infra.endpoint_address);
+
+    let native_token = endpoint.native_token();
+
+    let uln302 = Uln302Client::new(env, &infra.uln302_address);
+    let counter = CounterClient::new(env, &counter_address);
+
+    set_zro(env, owner, &endpoint, &infra.zro_token);
+    register_library(env, owner, &endpoint, &uln302.address);
+
+    let eid = endpoint.eid();
+
+    // Set up price feed with initial prices for this chain's eid
+    setup_price_feed(env, owner, &infra.price_feed_address, eid);
+
+    let chain_setup = ChainSetup {
+        owner: owner.clone(),
+        admin: infra.admin,
+        endpoint,
+        uln302,
+        dvn,
+        dvn2,
+        executor,
+        executor_helper,
+        price_feed: infra.price_feed_address,
+        counter,
+        eid,
+        native_token,
+    };
+
+    // Allow executor self-spend so transfer_from succeeds in compose tests.
+    env.mock_all_auths();
+    TokenClient::new(env, &chain_setup.native_token).approve(
+        &chain_setup.executor.address,
+        &chain_setup.executor.address,
+        &i128::MAX,
+        &10_u32,
+    );
+
+    chain_setup
+}
+
+/// Set up price feed with test prices
+fn setup_price_feed(env: &Env, owner: &Address, price_feed: &Address, eid: u32) {
+    let client = price_feed::LzPriceFeedClient::new(env, price_feed);
+
+    // Set price ratio denominator
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: price_feed,
+            fn_name: "set_price_ratio_denominator",
+            args: (&PRICE_RATIO_DENOMINATOR,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    client.set_price_ratio_denominator(&PRICE_RATIO_DENOMINATOR);
+
+    // Set native token price in USD (1 XLM = 1 USD for simplicity, scaled)
+    let native_price_usd: u128 = 10_000_000; // 1 USD with 7 decimals
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: price_feed,
+            fn_name: "set_native_token_price_usd",
+            args: (owner, &native_price_usd).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    client.set_native_token_price_usd(owner, &native_price_usd);
+
+    // Set price for this eid (for testing, use 1:1 price ratio)
+    // Price feed internally uses eid % 30000 for lookups, so we need to normalize
+    let normalized_eid = eid % 30_000;
+    let price = Price {
+        price_ratio: PRICE_RATIO_DENOMINATOR,
+        gas_price_in_unit: DEFAULT_GAS_PRICE,
+        gas_per_byte: DEFAULT_GAS_PER_BYTE,
+    };
+
+    // Note: STELLAR_EID (30111) normalizes to 111, which is the Optimism mainnet EID.
+    // The Optimism fee model requires prices for BOTH L2 (111) AND L1 Ethereum (101).
+    // So we set prices for both.
+    let mut prices = vec![env, UpdatePrice { eid: normalized_eid, price: price.clone() }];
+
+    // If this is an Optimism-style chain (111, 10132, 20132), also set L1 Ethereum price
+    if normalized_eid == 111 {
+        prices.push_back(UpdatePrice { eid: 101, price: price.clone() }); // Ethereum mainnet
+    } else if normalized_eid == 10132 {
+        prices.push_back(UpdatePrice { eid: 10121, price: price.clone() }); // Ethereum Goerli
+    } else if normalized_eid == 20132 {
+        prices.push_back(UpdatePrice { eid: 20121, price: price.clone() }); // Ethereum Goerli
+    }
+
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: price_feed,
+            fn_name: "set_price",
+            args: (owner, &prices).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    client.set_price(owner, &prices);
+}
+
+pub fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+    env.mock_all_auths(); // Required for contract registration (DVN multisig init, etc.)
+    let owner = Address::generate(&env);
+
+    // Phase 1: Create basic infrastructure for both chains
+    let infra_a = setup_chain_infrastructure(&env, &owner);
+    let infra_b = setup_chain_infrastructure(&env, &owner);
+
+    // Collect all ULN302 addresses for cross-chain support
+    let all_uln302_addresses: Vec<Address> = vec![&env, infra_a.uln302_address.clone(), infra_b.uln302_address.clone()];
+
+    // Phase 2: Create workers with cross-chain ULN302 support
+    let (dvn_a, dvn2_a, executor_a, executor_helper_a) =
+        setup_chain_workers(&env, &owner, &infra_a, &all_uln302_addresses);
+    let (dvn_b, dvn2_b, executor_b, executor_helper_b) =
+        setup_chain_workers(&env, &owner, &infra_b, &all_uln302_addresses);
+
+    // Phase 3: Finalize chain setup
+    let chain_a = finalize_chain_setup(&env, &owner, infra_a, dvn_a, dvn2_a, executor_a, executor_helper_a);
+    let chain_b = finalize_chain_setup(&env, &owner, infra_b, dvn_b, dvn2_b, executor_b, executor_helper_b);
+
+    TestSetup { env, chain_a, chain_b }
+}
+
+/// DVN configuration mode for endpoint wiring.
+#[derive(Clone, Copy)]
+pub enum DvnMode {
+    /// Single DVN: required = [dvn], no optional
+    Single,
+    /// Two required DVNs: required = [dvn, dvn2], no optional
+    TwoRequired,
+    /// Duplicate DVN in optional: required = [dvn], optional = [dvn, dvn2], threshold = 1
+    DuplicateOptional,
+}
+
+/// Creates a fully wired test setup with the specified DVN mode.
+pub fn wired_setup_with_dvn_mode<'a>(mode: DvnMode) -> TestSetup<'a> {
+    let test_setup = setup();
+    wire_endpoint(&test_setup.env, &[&test_setup.chain_a, &test_setup.chain_b], mode);
+    wire_counter(&test_setup.env, &[&test_setup.chain_a, &test_setup.chain_b]);
+    test_setup
+}
+
+// ============================================================================
+// Wire functions
+// ============================================================================
+
+pub fn wire_endpoint(env: &Env, chains: &[&ChainSetup<'_>], mode: DvnMode) {
+    // First pass: Set up price feeds with cross-chain prices
+    for chain in chains {
+        for other_chain in chains {
+            if chain.endpoint.address == other_chain.endpoint.address {
+                continue;
+            }
+            setup_price_feed(env, &chain.owner, &chain.price_feed, other_chain.eid);
+        }
+    }
+
+    // Second pass: Set up DVN and Executor dst configs
+    for chain in chains {
+        for other_chain in chains {
+            if chain.endpoint.address == other_chain.endpoint.address {
+                continue;
+            }
+            set_dvn_dst_config(env, &chain.admin, &chain.dvn, other_chain.eid);
+            // For multi-DVN modes, also configure dvn2
+            if matches!(mode, DvnMode::TwoRequired | DvnMode::DuplicateOptional) {
+                set_dvn_dst_config(env, &chain.admin, &chain.dvn2, other_chain.eid);
+            }
+            set_executor_dst_config(env, &chain.admin, &chain.executor, other_chain.eid);
+        }
+    }
+
+    // Third pass: Set up ULN configs based on DVN mode
+    for chain in chains {
+        for other_chain in chains {
+            if chain.endpoint.address == other_chain.endpoint.address {
+                continue;
+            }
+
+            let (send_required, recv_required, send_optional, recv_optional, optional_threshold) = match mode {
+                DvnMode::Single => (
+                    vec![env, other_chain.dvn.address.clone()],
+                    vec![env, chain.dvn.address.clone()],
+                    vec![env],
+                    vec![env],
+                    0,
+                ),
+                DvnMode::TwoRequired => (
+                    vec![env, other_chain.dvn.address.clone(), other_chain.dvn2.address.clone()],
+                    vec![env, chain.dvn.address.clone(), chain.dvn2.address.clone()],
+                    vec![env],
+                    vec![env],
+                    0,
+                ),
+                DvnMode::DuplicateOptional => (
+                    vec![env, other_chain.dvn.address.clone()],
+                    vec![env, chain.dvn.address.clone()],
+                    vec![env, other_chain.dvn.address.clone(), other_chain.dvn2.address.clone()],
+                    vec![env, chain.dvn.address.clone(), chain.dvn2.address.clone()],
+                    1,
+                ),
+            };
+
+            set_default_send_uln_config_with_optional(
+                env,
+                &chain.owner,
+                &chain.uln302,
+                other_chain.eid,
+                &send_required,
+                &send_optional,
+                optional_threshold,
+            );
+
+            set_default_receive_uln_config_with_optional(
+                env,
+                &chain.owner,
+                &chain.uln302,
+                other_chain.eid,
+                &recv_required,
+                &recv_optional,
+                optional_threshold,
+            );
+
+            set_default_executor_config(env, &chain.owner, &chain.uln302, other_chain.eid, &chain.executor.address);
+        }
+    }
+
+    // Fourth pass: Set default send and receive libraries
+    for chain in chains {
+        for other_chain in chains {
+            if chain.endpoint.address == other_chain.endpoint.address {
+                continue;
+            }
+
+            set_default_send_library(env, &chain.owner, &chain.endpoint, other_chain.eid, &chain.uln302.address);
+            set_default_receive_library(env, &chain.owner, &chain.endpoint, other_chain.eid, &chain.uln302.address);
+        }
+    }
+}
+
+/// Set DVN destination config
+fn set_dvn_dst_config(env: &Env, admin: &Address, dvn: &DVNClient<'_>, dst_eid: u32) {
+    let config = DvnDstConfig {
+        gas: 100_000,          // Gas for verification
+        multiplier_bps: 10000, // 100%
+        floor_margin_usd: 0,   // No floor margin for tests
+    };
+    let params = vec![env, DvnDstConfigParam { dst_eid, config }];
+
+    env.mock_auths(&[MockAuth {
+        address: admin,
+        invoke: &MockAuthInvoke {
+            contract: &dvn.address,
+            fn_name: "set_dst_config",
+            args: (admin, &params).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    dvn.set_dst_config(admin, &params);
+}
+
+/// Set Executor destination config
+fn set_executor_dst_config(env: &Env, admin: &Address, executor: &ExecutorClient<'_>, dst_eid: u32) {
+    let config = ExecutorDstConfig {
+        lz_receive_base_gas: 50_000, // Base gas for lz_receive
+        multiplier_bps: 10000,       // 100%
+        floor_margin_usd: 0,         // No floor margin for tests
+        native_cap: 1_000_000_000,   // Max native drop
+        lz_compose_base_gas: 30_000, // Base gas for lz_compose
+    };
+    let params = vec![env, SetDstConfigParam { dst_eid, dst_config: config }];
+
+    env.mock_auths(&[MockAuth {
+        address: admin,
+        invoke: &MockAuthInvoke {
+            contract: &executor.address,
+            fn_name: "set_dst_config",
+            args: (admin, &params).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    executor.set_dst_config(admin, &params);
+}
+
+pub fn wire_counter(env: &Env, chains: &[&ChainSetup<'_>]) {
+    for chain in chains {
+        for other_chain in chains {
+            if chain.endpoint.address == other_chain.endpoint.address {
+                continue;
+            }
+            set_peer(
+                env,
+                &chain.owner,
+                &chain.counter,
+                other_chain.eid,
+                &address_to_bytes32(&other_chain.counter.address),
+            );
+        }
+    }
+}
+
+pub fn set_default_send_library(
+    env: &Env,
+    owner: &Address,
+    endpoint: &EndpointV2Client<'_>,
+    dst_eid: u32,
+    lib: &Address,
+) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint.address,
+            fn_name: "set_default_send_library",
+            args: (&dst_eid, lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint.set_default_send_library(&dst_eid, lib);
+}
+
+pub fn set_default_receive_library(
+    env: &Env,
+    owner: &Address,
+    endpoint: &EndpointV2Client<'_>,
+    src_eid: u32,
+    lib: &Address,
+) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint.address,
+            fn_name: "set_default_receive_library",
+            args: (&src_eid, lib, &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint.set_default_receive_library(&src_eid, lib, &0u64);
+}
+
+pub fn set_default_send_uln_config_with_optional(
+    env: &Env,
+    owner: &Address,
+    uln302: &Uln302Client<'_>,
+    dst_eid: u32,
+    required_dvns: &soroban_sdk::Vec<Address>,
+    optional_dvns: &soroban_sdk::Vec<Address>,
+    optional_dvn_threshold: u32,
+) {
+    let config = UlnConfig {
+        confirmations: CONFIRMATIONS,
+        required_dvns: required_dvns.clone(),
+        optional_dvns: optional_dvns.clone(),
+        optional_dvn_threshold,
+    };
+    let params = vec![env, SetDefaultUlnConfigParam { eid: dst_eid, config }];
+
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "set_default_send_uln_configs",
+            args: (&params,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    SendUln302Client::new(env, &uln302.address).set_default_send_uln_configs(&params);
+}
+
+pub fn set_default_receive_uln_config_with_optional(
+    env: &Env,
+    owner: &Address,
+    uln302: &Uln302Client<'_>,
+    src_eid: u32,
+    required_dvns: &soroban_sdk::Vec<Address>,
+    optional_dvns: &soroban_sdk::Vec<Address>,
+    optional_dvn_threshold: u32,
+) {
+    let config = UlnConfig {
+        confirmations: CONFIRMATIONS,
+        required_dvns: required_dvns.clone(),
+        optional_dvns: optional_dvns.clone(),
+        optional_dvn_threshold,
+    };
+    let params = vec![env, SetDefaultUlnConfigParam { eid: src_eid, config }];
+
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "set_default_receive_uln_configs",
+            args: (&params,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    ReceiveUln302Client::new(env, &uln302.address).set_default_receive_uln_configs(&params);
+}
+
+pub fn set_default_executor_config(
+    env: &Env,
+    owner: &Address,
+    uln302: &Uln302Client<'_>,
+    dst_eid: u32,
+    executor: &Address,
+) {
+    let config = ExecutorConfig { max_message_size: MAX_MESSAGE_SIZE, executor: executor.clone() };
+    let params = vec![env, SetDefaultExecutorConfigParam { dst_eid, config }];
+
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "set_default_executor_configs",
+            args: (&params,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    SendUln302Client::new(env, &uln302.address).set_default_executor_configs(&params);
+}
+
+// ============================================================================
+// Executor Helper Functions
+// ============================================================================
+
+use crate::tests::mint_to;
+use endpoint_v2::{Origin, OutboundPacket};
+use executor_helper::{ComposeParams, ExecutionParams};
+use soroban_sdk::Bytes;
+
+/// Execute lz_receive via ExecutorHelper (executor AA workflow).
+/// Automatically mints native tokens to the admin if value > 0.
+pub fn lz_receive_via_executor(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    admin: &Address,
+    packet: &OutboundPacket,
+    value: i128,
+) {
+    // Mint native tokens to admin if value > 0
+    if value > 0 {
+        mint_to(env, &chain.owner, &chain.native_token, admin, value);
+    }
+
+    let origin = Origin { src_eid: packet.src_eid, sender: address_to_bytes32(&packet.sender), nonce: packet.nonce };
+
+    let params = ExecutionParams {
+        receiver: chain.counter.address.clone(),
+        origin: origin.clone(),
+        guid: packet.guid.clone(),
+        message: packet.message.clone(),
+        extra_data: Bytes::new(env),
+        value,
+        gas_limit: 1_000_000, // Arbitrary gas limit for tests
+    };
+
+    env.mock_all_auths_allowing_non_root_auth();
+    chain.executor_helper.execute(&chain.executor.address, &params, admin);
+}
+
+/// Execute lz_compose via ExecutorHelper (executor AA workflow).
+/// Automatically mints native tokens to the admin if value > 0.
+pub fn lz_compose_via_executor(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    admin: &Address,
+    packet: &OutboundPacket,
+    value: i128,
+) {
+    // Mint native tokens to admin if value > 0
+    if value > 0 {
+        mint_to(env, &chain.owner, &chain.native_token, admin, value);
+    }
+
+    let params = ComposeParams {
+        from: chain.counter.address.clone(),
+        to: chain.counter.address.clone(),
+        guid: packet.guid.clone(),
+        index: 0,
+        message: packet.message.clone(),
+        extra_data: Bytes::new(env),
+        value,
+        gas_limit: 1_000_000, // Arbitrary gas limit for tests
+    };
+
+    env.mock_all_auths_allowing_non_root_auth();
+    chain.executor_helper.compose(&chain.executor.address, &params, admin);
+}