@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/common/utils.cairo

@@ -0,0 +1,23 @@
+//! Common utils for testing
+
+use layerzero::common::structs::messaging::MessageReceipt;
+
+pub fn total_native_fee_from_receipt(receipt: @MessageReceipt) -> u256 {
+    let mut total_native_fee: u256 = 0;
+
+    for payee in receipt.payees {
+        total_native_fee += *payee.native_amount;
+    }
+
+    total_native_fee
+}
+
+pub fn total_lz_fee_from_receipt(receipt: @MessageReceipt) -> u256 {
+    let mut total_lz_fee: u256 = 0;
+
+    for payee in receipt.payees {
+        total_lz_fee += *payee.lz_token_amount;
+    }
+
+    total_lz_fee
+}

package/layerzero/tests/e2e/oft_utils.cairo

@@ -0,0 +1,121 @@
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+use core::num::traits::Pow;
+use layerzero::common::structs::packet::Origin;
+use layerzero::endpoint::interfaces::layerzero_receiver::{
+    ILayerZeroReceiverDispatcher, ILayerZeroReceiverDispatcherTrait,
+};
+use layerzero::oapps::oapp::interface::{IOAppDispatcher, IOAppDispatcherTrait};
+use layerzero::oapps::oft::interface::IOFTDispatcher;
+use lz_utils::bytes::{Bytes32, ContractAddressIntoBytes32};
+use openzeppelin::token::erc20::interface::IERC20Dispatcher;
+use snforge_std::{ContractClassTrait, DeclareResultTrait, declare};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::cheat_caller_address_once;
+use crate::e2e::utils::{
+    BlockchainOptions, DEFAULT_DVN_DST_CONFIG, DvnHelper, ERC20Helper, EndpointHelper,
+    ExecutorHelper, TreasuryHelper, UltraLightNodeHelper, setup_layer_zero,
+};
+use crate::fuzzable::blockchain_config::BlockchainConfig;
+use crate::fuzzable::contract_address::FuzzableContractAddress;
+use crate::fuzzable::eid::FuzzableEid;
+
+pub const SHARED_DECIMALS: u8 = 6;
+pub const LOCAL_DECIMALS: u8 = 18;
+const DECIMAL_DIFF: u8 = LOCAL_DECIMALS - SHARED_DECIMALS;
+pub const DIFF_DECIMALS: u256 = 10_u256.pow(DECIMAL_DIFF.into());
+
+pub const TREASURY_NATIVE_FEE_CAP: u256 = 42;
+const MOCK_GUID: Bytes32 = Bytes32 { value: 0xabcdef123456789 };
+
+#[derive(Drop)]
+pub struct OFTHelper {
+    pub address: ContractAddress,
+    pub oft: IOFTDispatcher,
+    pub oapp: IOAppDispatcher,
+    pub erc20: IERC20Dispatcher,
+}
+
+pub fn deploy_oft(
+    name: @ByteArray,
+    symbol: @ByteArray,
+    endpoint: ContractAddress,
+    owner: ContractAddress,
+    native_token: ContractAddress,
+) -> OFTHelper {
+    let contract = declare("OFT").unwrap().contract_class();
+    let mut params = array![];
+
+    name.serialize(ref params);
+    symbol.serialize(ref params);
+    endpoint.serialize(ref params);
+    owner.serialize(ref params);
+    native_token.serialize(ref params);
+
+    let (address, _) = contract.deploy(@params).unwrap();
+
+    OFTHelper {
+        address,
+        oft: IOFTDispatcher { contract_address: address },
+        oapp: IOAppDispatcher { contract_address: address },
+        erc20: IERC20Dispatcher { contract_address: address },
+    }
+}
+
+#[derive(Drop)]
+pub struct Blockchain {
+    pub native_token: ERC20Helper,
+    pub endpoint: EndpointHelper,
+    pub message_lib: UltraLightNodeHelper,
+    pub treasury: TreasuryHelper,
+    pub oft: OFTHelper,
+    pub executor: ExecutorHelper,
+    pub dvn: DvnHelper,
+}
+
+pub fn setup_blockchain(config: @BlockchainConfig, remote_eid: u32) -> Blockchain {
+    let chain = setup_layer_zero(
+        config,
+        BlockchainOptions {
+            dvn_dst_config: DEFAULT_DVN_DST_CONFIG,
+            treasury_native_fee_cap: TREASURY_NATIVE_FEE_CAP,
+        },
+        remote_eid,
+    );
+
+    let oft = deploy_oft(
+        config.oft_name,
+        config.oft_symbol,
+        chain.endpoint.address,
+        *config.oapp_owner,
+        chain.native_token.address,
+    );
+    cheat_caller_address_once(oft.address, *config.oapp_owner);
+    oft.oapp.set_delegate(*config.oapp_owner);
+
+    Blockchain {
+        native_token: chain.native_token,
+        endpoint: chain.endpoint,
+        message_lib: chain.message_lib,
+        treasury: chain.treasury,
+        executor: chain.executor,
+        dvn: chain.dvn,
+        oft,
+    }
+}
+
+pub fn mint_tokens(
+    oft: ContractAddress,
+    user: ContractAddress,
+    amount_sd: u64,
+    endpoint: ContractAddress,
+    origin: Origin,
+) {
+    let mut message: ByteArray = Default::default();
+    let bytes: Bytes32 = user.into();
+    message.append_u256(bytes.value);
+    message.append_u64(amount_sd);
+
+    cheat_caller_address_once(oft, endpoint);
+    ILayerZeroReceiverDispatcher { contract_address: oft }
+        .lz_receive(origin, MOCK_GUID, message, user, 0, Default::default());
+}

package/layerzero/tests/e2e/test_counter_with_sml.cairo

@@ -0,0 +1,194 @@
+//! E2E test for Counter with SimpleMessageLib
+
+use layerzero::common::packet_v1_codec::PacketV1Codec;
+use layerzero::common::structs::messaging::MessagingFee;
+use layerzero::common::structs::packet::{Origin, Packet};
+use layerzero::endpoint::interfaces::endpoint::IEndpointDispatcherTrait;
+use layerzero::endpoint::message_lib_manager::interface::IMessageLibManagerDispatcherTrait;
+use layerzero::message_lib::interface::IMessageLibDispatcherTrait;
+use layerzero::message_lib::sml::simple_message_lib::SimpleMessageLib::ISimpleMessageLibHelpersDispatcherTrait;
+use layerzero::oapps::counter::constants::INCREMENT_TYPE_A_B;
+use layerzero::oapps::counter::counter::OmniCounter;
+use layerzero::oapps::counter::interface::IOmniCounterDispatcherTrait;
+use layerzero::oapps::counter::structs::{IncrementReceived, IncrementSent};
+use layerzero::oapps::oapp::interface::IOAppDispatcherTrait;
+use lz_utils::bytes::{Bytes32, ContractAddressIntoBytes32};
+use openzeppelin::token::erc20::interface::IERC20DispatcherTrait;
+use snforge_std::{EventSpyAssertionsTrait, spy_events};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::cheat_caller_address_once;
+use crate::e2e::utils::{
+    SimpleMessageLibHelper, deploy_endpoint, deploy_erc20, deploy_simple_message_lib,
+};
+use super::utils::{ERC20Helper, EndpointHelper, OmniCounterHelper, deploy_omni_counter};
+
+// Test constants
+const OWNER: ContractAddress = 'owner'.try_into().unwrap();
+const SENDER: ContractAddress = 'sender'.try_into().unwrap();
+const EXECUTOR: ContractAddress = 'executor'.try_into().unwrap();
+const OAPP_OWNER: ContractAddress = 'oapp_owner'.try_into().unwrap();
+const BLOCKED_LIBRARY: ContractAddress = 'blocked_library'.try_into().unwrap();
+
+// Endpoint IDs
+const LOCAL_EID: u32 = 1;
+const REMOTE_EID: u32 = 2;
+
+// Token amounts
+const INITIAL_SUPPLY: u256 = 1000000; // 1M tokens
+
+// Test values
+const SENDER_FUNDING_AMOUNT: u256 = 10000;
+const TEST_NONCE: u64 = 1;
+const TEST_GUID_VALUE: u256 = 0x123456789abcdef;
+const EXECUTE_VALUE: u256 = 100;
+
+struct TestSetup {
+    native_token: ERC20Helper,
+    endpoint: EndpointHelper,
+    sml: SimpleMessageLibHelper,
+    counter: OmniCounterHelper,
+}
+
+fn setup() -> TestSetup {
+    let native_token = deploy_erc20(INITIAL_SUPPLY, OWNER);
+    let endpoint = deploy_endpoint(OWNER, LOCAL_EID, native_token.address);
+    let sml = deploy_simple_message_lib(endpoint.address);
+    let counter = deploy_omni_counter(endpoint.address, OAPP_OWNER, native_token.address);
+
+    // Register SimpleMessageLib
+    // Satisfy registration-time type check
+    cheat_caller_address_once(endpoint.address, OWNER);
+    endpoint.message_lib_manager.register_library(sml.address);
+
+    // Set delegate for endpoint
+    cheat_caller_address_once(counter.address, OAPP_OWNER);
+    counter.oapp.set_delegate(OAPP_OWNER);
+
+    TestSetup { native_token, endpoint, sml, counter }
+}
+
+#[test]
+fn test_send_message_with_sml() {
+    // This test simulates the following scenario:
+    // OApp OWNER sets the send library for the counter
+    // OApp OWNER sets the peer for the counter
+    // SENDER has tokens to send
+    // SENDER sends an increment message to the counter
+    // Endpoint confirms the message
+
+    let TestSetup { native_token, endpoint, sml, counter, .. } = setup();
+
+    // OWNER gives tokens to SENDER
+    cheat_caller_address_once(native_token.address, OWNER);
+    native_token.erc20.transfer(SENDER, SENDER_FUNDING_AMOUNT);
+
+    // Set send library and peer for counter
+    cheat_caller_address_once(endpoint.address, OAPP_OWNER);
+    endpoint.message_lib_manager.set_send_library(counter.address, REMOTE_EID, sml.address);
+
+    cheat_caller_address_once(counter.address, OAPP_OWNER);
+    counter.oapp.set_peer(REMOTE_EID, counter.address.into());
+
+    cheat_caller_address_once(native_token.address, SENDER);
+    native_token.erc20.approve(counter.address, SENDER_FUNDING_AMOUNT);
+
+    // Start spying on events
+    let mut spy = spy_events();
+
+    // Send increment message
+    let fee = MessagingFee { native_fee: SENDER_FUNDING_AMOUNT, lz_token_fee: 0 };
+
+    cheat_caller_address_once(counter.address, SENDER);
+    let receipt = counter
+        .omni_counter
+        .increment(REMOTE_EID, INCREMENT_TYPE_A_B, "test options", fee, SENDER);
+
+    // Verify receipt
+    assert(receipt.nonce == 1, 'First nonce should be 1');
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    counter.address,
+                    OmniCounter::Event::IncrementSent(
+                        IncrementSent {
+                            sender: SENDER, dst_eid: REMOTE_EID, increment_type: INCREMENT_TYPE_A_B,
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+fn test_receive_message_with_sml() {
+    let TestSetup { native_token, endpoint, sml, counter } = setup();
+
+    // Set receive library and peer for counter
+    cheat_caller_address_once(endpoint.address, OAPP_OWNER);
+    endpoint.message_lib_manager.set_receive_library(counter.address, REMOTE_EID, sml.address, 0);
+
+    cheat_caller_address_once(counter.address, OAPP_OWNER);
+    counter.oapp.set_peer(REMOTE_EID, SENDER.into());
+
+    // Start spying on events
+    let mut spy = spy_events();
+
+    // Create a packet for the message
+    let nonce = TEST_NONCE;
+    let guid = Bytes32 { value: TEST_GUID_VALUE };
+    let mut message: ByteArray = "";
+    message.append_byte(INCREMENT_TYPE_A_B);
+
+    let packet = Packet {
+        nonce,
+        src_eid: REMOTE_EID,
+        sender: SENDER,
+        dst_eid: LOCAL_EID,
+        receiver: counter.address.into(),
+        guid,
+        message: message.clone(),
+    };
+
+    // Encode the packet to get header and payload hash
+    let encoded_packet = PacketV1Codec::encode(@packet);
+    let packet_header = PacketV1Codec::header(@encoded_packet);
+    let payload_hash = PacketV1Codec::payload_hash(@encoded_packet);
+
+    // OWNER gives tokens to EXECUTOR
+    cheat_caller_address_once(native_token.address, OWNER);
+    native_token.erc20.transfer(EXECUTOR, SENDER_FUNDING_AMOUNT);
+
+    // Executor calls commit on message library
+    sml.simple_message_lib_helpers.set_whitelist_caller(EXECUTOR);
+    cheat_caller_address_once(sml.address, EXECUTOR);
+    sml.message_lib.commit(packet_header, payload_hash);
+
+    // Create origin for lz_receive
+    let origin = Origin { src_eid: REMOTE_EID, sender: SENDER.into(), nonce };
+    let value = EXECUTE_VALUE;
+
+    // As executor give value as allowance to endpoint
+    cheat_caller_address_once(native_token.address, EXECUTOR);
+    native_token.erc20.approve(endpoint.address, value);
+
+    // Executor calls lz_receive on endpoint
+    cheat_caller_address_once(endpoint.address, EXECUTOR);
+    endpoint.endpoint.lz_receive(origin, counter.address, guid, message, value, "");
+
+    // Verify counter was incremented
+    assert(counter.omni_counter.get_counter(REMOTE_EID) == 1, 'Counter not incremented');
+
+    // Verify IncrementReceived event
+    let expected_increment_received = OmniCounter::Event::IncrementReceived(
+        IncrementReceived {
+            src_eid: REMOTE_EID,
+            old_value: 0,
+            new_value: 1,
+            increment_type: INCREMENT_TYPE_A_B,
+            value,
+        },
+    );
+    spy.assert_emitted(@array![(counter.address, expected_increment_received)]);
+}

package/layerzero/tests/e2e/test_counter_with_uln.cairo

@@ -0,0 +1,352 @@
+//! E2E test for Counter with UltraLightNode (ULN + DVN + Executor)
+
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+use core::num::traits::Bounded;
+use layerzero::common::guid::GUID;
+use layerzero::common::packet_v1_codec::PacketV1Codec;
+use layerzero::common::structs::packet::Origin;
+use layerzero::endpoint::message_lib_manager::interface::IMessageLibManagerDispatcherTrait;
+use layerzero::message_lib::interface::IMessageLibDispatcherTrait;
+use layerzero::message_lib::uln;
+use layerzero::message_lib::uln::options::TYPE_3;
+use layerzero::message_lib::uln::structs::executor_config::ExecutorConfig;
+use layerzero::message_lib::uln::structs::uln_config::UlnConfig;
+use layerzero::oapps::counter::constants::INCREMENT_TYPE_A_B;
+use layerzero::oapps::counter::counter::OmniCounter;
+use layerzero::oapps::counter::interface::IOmniCounterDispatcherTrait;
+use layerzero::oapps::counter::structs::{IncrementReceived, IncrementSent};
+use layerzero::oapps::oapp::interface::IOAppDispatcherTrait;
+use layerzero::treasury::interfaces::treasury_admin::ITreasuryAdminDispatcherTrait;
+use layerzero::workers::base::interface::IWorkerBaseDispatcherTrait;
+use layerzero::workers::dvn::interface::IDvnDispatcherTrait;
+use layerzero::workers::dvn::structs::ExecuteParam as DvnExecuteParam;
+use layerzero::workers::executor::interface::IExecutorDispatcherTrait;
+use layerzero::workers::executor::options::OPTION_TYPE_LZRECEIVE;
+use layerzero::workers::executor::structs::ExecuteParams;
+use lz_utils::bytes::ContractAddressIntoBytes32;
+use openzeppelin::token::erc20::interface::IERC20DispatcherTrait;
+use snforge_std::{EventSpyAssertionsTrait, EventSpyTrait, EventsFilterTrait, spy_events};
+use starknet::ContractAddress;
+use starknet::account::Call;
+use starkware_utils_testing::test_utils::cheat_caller_address_once;
+use utils::{
+    BlockchainOptions, DEFAULT_DVN_DST_CONFIG, DEFAULT_EXECUTOR_DST_CONFIG, DvnHelper,
+    EndpointHelper, ExecutorHelper, OmniCounterHelper, TreasuryHelper, UltraLightNodeHelper,
+    decode_executor_options, decode_packet_on_endpoint, deploy_omni_counter, setup_layer_zero,
+    wire_ultra_light_node,
+};
+use crate::e2e::utils;
+use crate::e2e::utils::ERC20Helper;
+use crate::fuzzable::blockchain_config::BlockchainConfig;
+use crate::fuzzable::contract_address::FuzzableContractAddress;
+use crate::fuzzable::eid::FuzzableEid;
+use crate::fuzzable::keys::FuzzableKeyPair;
+use crate::mocks::erc20::interface::IMockERC20DispatcherTrait;
+use crate::workers::dvn::utils::sort_signatures;
+use crate::workers::executor::utils::{
+    ExecutorOptionBytes, serialize_executor_options, serialize_lz_receive_option,
+};
+
+const DVN_CONFIRMATIONS: u64 = 1;
+const MAX_MESSAGE_SIZE: u32 = 1024;
+const LZ_RECEIVE_USER_GAS: u128 = 100_000;
+const TREASURY_NATIVE_FEE_CAP: u256 = 0;
+
+#[derive(Drop)]
+struct Blockchain {
+    native_token: ERC20Helper,
+    endpoint: EndpointHelper,
+    message_lib: UltraLightNodeHelper,
+    treasury: TreasuryHelper,
+    executor: ExecutorHelper,
+    dvn: DvnHelper,
+    counter: OmniCounterHelper,
+}
+
+fn setup_blockchain(config: @BlockchainConfig, remote_eid: u32) -> Blockchain {
+    let chain = setup_layer_zero(
+        config,
+        BlockchainOptions {
+            dvn_dst_config: DEFAULT_DVN_DST_CONFIG,
+            treasury_native_fee_cap: TREASURY_NATIVE_FEE_CAP,
+        },
+        remote_eid,
+    );
+
+    let counter = deploy_omni_counter(
+        chain.endpoint.address, *config.oapp_owner, chain.native_token.address,
+    );
+    cheat_caller_address_once(counter.address, *config.oapp_owner);
+    counter.oapp.set_delegate(*config.oapp_owner);
+
+    Blockchain {
+        native_token: chain.native_token,
+        endpoint: chain.endpoint,
+        message_lib: chain.message_lib,
+        treasury: chain.treasury,
+        executor: chain.executor,
+        dvn: chain.dvn,
+        counter,
+    }
+}
+
+fn create_uln_config(confirmations: u64, dvn: ContractAddress) -> UlnConfig {
+    UlnConfig {
+        confirmations,
+        has_confirmations: true,
+        required_dvns: array![dvn],
+        has_required_dvns: true,
+        optional_dvns: array![],
+        optional_dvn_threshold: 0,
+        has_optional_dvns: true,
+    }
+}
+
+fn create_message_options() -> ByteArray {
+    let executor_options = serialize_executor_options(
+        array![
+            ExecutorOptionBytes {
+                option_type: OPTION_TYPE_LZRECEIVE,
+                option: serialize_lz_receive_option(LZ_RECEIVE_USER_GAS, None),
+            },
+        ],
+    );
+
+    let mut options: ByteArray = Default::default();
+    options.append_u16(TYPE_3);
+    options.append(@executor_options);
+    options
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn test_send_and_receive(src_config: BlockchainConfig, dst_config: BlockchainConfig) {
+    let src = setup_blockchain(@src_config, dst_config.eid.eid);
+    let dst = setup_blockchain(@dst_config, src_config.eid.eid);
+
+    // =============================== Wiring =================================
+
+    wire_ultra_light_node(
+        src_config.message_lib_owner,
+        @src.message_lib,
+        dst_config.eid.eid,
+        create_uln_config(DVN_CONFIRMATIONS, src.dvn.address),
+        ExecutorConfig { executor: src.executor.address, max_message_size: MAX_MESSAGE_SIZE },
+    );
+
+    wire_ultra_light_node(
+        dst_config.message_lib_owner,
+        @dst.message_lib,
+        src_config.eid.eid,
+        create_uln_config(DVN_CONFIRMATIONS, dst.dvn.address),
+        ExecutorConfig { executor: dst.executor.address, max_message_size: MAX_MESSAGE_SIZE },
+    );
+
+    cheat_caller_address_once(src.endpoint.address, src_config.oapp_owner);
+    src
+        .endpoint
+        .message_lib_manager
+        .set_send_library(src.counter.address, dst_config.eid.eid, src.message_lib.address);
+    cheat_caller_address_once(src.counter.address, src_config.oapp_owner);
+    src.counter.oapp.set_peer(dst_config.eid.eid, dst.counter.address.into());
+
+    cheat_caller_address_once(dst.endpoint.address, dst_config.oapp_owner);
+    dst
+        .endpoint
+        .message_lib_manager
+        .set_receive_library(dst.counter.address, src_config.eid.eid, dst.message_lib.address, 0);
+    cheat_caller_address_once(dst.counter.address, dst_config.oapp_owner);
+    dst.counter.oapp.set_peer(src_config.eid.eid, src.counter.address.into());
+
+    // =============================== Send a message =================================
+
+    let options = create_message_options();
+    let fee = src
+        .counter
+        .omni_counter
+        .quote(dst_config.eid.eid, INCREMENT_TYPE_A_B, options.clone(), false);
+
+    assert_gt!(fee.native_fee, 0);
+    assert_eq!(fee.lz_token_fee, 0);
+
+    cheat_caller_address_once(src.native_token.address, src_config.native_token_owner);
+    src.native_token.mock_erc20.mint(src_config.user, fee.native_fee);
+
+    assert_eq!(src.native_token.erc20.balance_of(src_config.user), fee.native_fee);
+
+    cheat_caller_address_once(src.native_token.address, src_config.user);
+    src.native_token.erc20.approve(src.counter.address, fee.native_fee);
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(src.counter.address, src_config.user);
+    src
+        .counter
+        .omni_counter
+        .increment(dst_config.eid.eid, INCREMENT_TYPE_A_B, options, fee.clone(), src_config.user);
+
+    assert_eq!(src.native_token.erc20.balance_of(src_config.user), 0);
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    src.counter.address,
+                    OmniCounter::Event::IncrementSent(
+                        IncrementSent {
+                            sender: src_config.user,
+                            dst_eid: dst_config.eid.eid,
+                            increment_type: INCREMENT_TYPE_A_B,
+                        },
+                    ),
+                ),
+            ],
+        );
+
+    cheat_caller_address_once(src.dvn.address, src_config.dvn_admin);
+    src
+        .dvn
+        .worker_base
+        .withdraw_fee(
+            src.native_token.address,
+            src_config.dvn_owner,
+            src.native_token.erc20.balance_of(src.dvn.address),
+        );
+
+    assert_gt!(src.native_token.erc20.balance_of(src_config.dvn_owner), 0);
+
+    cheat_caller_address_once(src.executor.address, src_config.executor_admin);
+    src
+        .executor
+        .worker_base
+        .withdraw_fee(
+            src.native_token.address,
+            src_config.executor_owner,
+            src.native_token.erc20.balance_of(src.executor.address),
+        );
+
+    assert_gt!(src.native_token.erc20.balance_of(src_config.executor_owner), 0);
+
+    cheat_caller_address_once(src.treasury.address, src_config.treasury_owner);
+    src
+        .treasury
+        .treasury_admin
+        .withdraw_tokens(
+            src.native_token.address,
+            src_config.treasury_owner,
+            src.native_token.erc20.balance_of(src.treasury.address),
+        );
+
+    assert_eq!(src.native_token.erc20.balance_of(src_config.treasury_owner), fee.native_fee / 2);
+
+    // =============================== DVN emulation =================================
+
+    let events = spy.get_events().emitted_by(src.endpoint.address).events;
+
+    assert_eq!(events.len(), 1);
+
+    let (_, event) = events.at(0);
+    let (encoded_packet, options) = decode_packet_on_endpoint(event);
+    let packet = PacketV1Codec::decode(@encoded_packet);
+    let (executor_options, _) = uln::options::split_options(@options);
+
+    assert_eq!(packet.nonce, 1);
+    assert_eq!(packet.src_eid, src_config.eid.eid);
+    assert_eq!(packet.sender, src.counter.address);
+    assert_eq!(packet.dst_eid, dst_config.eid.eid);
+    assert_eq!(packet.receiver, dst.counter.address.into());
+    assert_eq!(
+        packet.guid,
+        GUID::generate(
+            packet.nonce,
+            packet.src_eid,
+            packet.sender.into(),
+            packet.dst_eid.into(),
+            packet.receiver.into(),
+        ),
+    );
+    assert_eq!(
+        packet.message,
+        {
+            let mut message: ByteArray = Default::default();
+            message.append_u8(INCREMENT_TYPE_A_B);
+            message
+        },
+    );
+
+    let mut calldata = array![];
+    PacketV1Codec::header(@encoded_packet).serialize(ref calldata);
+    PacketV1Codec::payload_hash(@encoded_packet).serialize(ref calldata);
+    DVN_CONFIRMATIONS.serialize(ref calldata);
+
+    let call_data = Call {
+        to: dst.message_lib.address, selector: selector!("verify"), calldata: calldata.span(),
+    };
+    let expiration = Bounded::<u256>::MAX;
+    let hash = dst.dvn.dvn.hash_call_data(dst_config.dvn_vid, call_data, expiration);
+    let signatures = sort_signatures(
+        dst_config.dvn_signers[0].clone(), dst_config.dvn_signers[1].clone(), hash,
+    );
+
+    cheat_caller_address_once(dst.dvn.address, dst_config.dvn_admin);
+    dst
+        .dvn
+        .dvn
+        .execute(
+            array![
+                DvnExecuteParam {
+                    vid: dst_config.dvn_vid, call_data, expiration, signatures: signatures.span(),
+                },
+            ],
+        );
+
+    // =============================== Receive a message =================================
+
+    dst
+        .message_lib
+        .message_lib
+        .commit(
+            PacketV1Codec::header(@encoded_packet), PacketV1Codec::payload_hash(@encoded_packet),
+        );
+
+    let executor_options = decode_executor_options(@executor_options);
+
+    cheat_caller_address_once(dst.executor.address, dst_config.executor_admin);
+    dst
+        .executor
+        .executor
+        .execute(
+            ExecuteParams {
+                receiver: packet.receiver.try_into().unwrap(),
+                origin: Origin {
+                    src_eid: packet.src_eid, sender: packet.sender.into(), nonce: packet.nonce,
+                },
+                guid: packet.guid,
+                message: packet.message,
+                gas_limit: (*executor_options.receive.gas).into()
+                    + DEFAULT_EXECUTOR_DST_CONFIG.lz_receive_base_gas.into(),
+                value: (*executor_options.receive.value).into(),
+                extra_data: "",
+            },
+        );
+
+    assert_eq!(dst.counter.omni_counter.get_counter(src_config.eid.eid), 1);
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    dst.counter.address,
+                    OmniCounter::Event::IncrementReceived(
+                        IncrementReceived {
+                            src_eid: src_config.eid.eid,
+                            old_value: 0,
+                            new_value: 1,
+                            increment_type: INCREMENT_TYPE_A_B,
+                            value: 0,
+                        },
+                    ),
+                ),
+            ],
+        );
+}