@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/workers/executor/test_executor.cairo

@@ -0,0 +1,1472 @@
+//! Executor tests
+
+use core::num::traits::Pow;
+use layerzero::Origin;
+use layerzero::common::constants::ZERO_ADDRESS;
+use layerzero::endpoint::events as endpoint_events;
+use layerzero::endpoint::messaging_composer::events::{ComposeDelivered, LzComposeAlert};
+use layerzero::endpoint::messaging_composer::messaging_composer::MessagingComposerComponent;
+use layerzero::workers::access_control::{ADMIN_ROLE, DEFAULT_ADMIN_ROLE, MESSAGE_LIB_ROLE};
+use layerzero::workers::base::interface::IWorkerBaseDispatcherTrait;
+use layerzero::workers::executor::errors;
+use layerzero::workers::executor::events::NativeDropApplied;
+use layerzero::workers::executor::executor::Executor;
+use layerzero::workers::executor::interface::{
+    IExecutorDispatcherTrait, IExecutorSafeDispatcherTrait,
+};
+use layerzero::workers::executor::structs::{DstConfig, NativeDropParams, SetDstConfigParams};
+use layerzero::workers::interface::{
+    ILayerZeroWorkerDispatcher, ILayerZeroWorkerDispatcherTrait,
+    ILayerZeroWorkerSafeDispatcherTrait,
+};
+use layerzero::workers::price_feed::structs::GetFeeResponse;
+use openzeppelin::access::accesscontrol::AccessControlComponent::Errors::MISSING_ROLE;
+use openzeppelin::access::accesscontrol::interface::IAccessControlDispatcherTrait;
+use openzeppelin::access::ownable::OwnableComponent;
+use openzeppelin::token::erc20::interface::IERC20DispatcherTrait;
+use snforge_std::{
+    DeclareResultTrait, EventSpyAssertionsTrait, EventSpyTrait, IsEmitted, declare, get_class_hash,
+    spy_events, start_cheat_caller_address, start_mock_call, stop_cheat_caller_address,
+    stop_mock_call,
+};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::{
+    assert_panic_with_error, assert_panic_with_felt_error, cheat_caller_address_once,
+};
+use crate::endpoint::utils::{
+    EndpointMock, MessagingComposerMock, deploy_mock_endpoint, deploy_mock_messaging_composer,
+};
+use crate::fuzzable::contract_address::{
+    ContractAddressArrayList, FuzzableContractAddress, FuzzableContractAddresses,
+};
+use crate::fuzzable::dst_config::FuzzableExecutorDstConfig;
+use crate::fuzzable::eid::{Eid, FuzzableEid};
+use crate::fuzzable::origin::FuzzableOrigin;
+use crate::fuzzable::role_admin::{FuzzableRoleAdmin, RoleAdmin};
+use crate::mocks::endpoint::MockEndpoint;
+use crate::mocks::endpoint::MockEndpoint::{
+    MockEndpointHelpersDispatcher, MockEndpointHelpersDispatcherTrait,
+};
+use crate::mocks::messaging_composer::MockMessagingComposer;
+use crate::mocks::messaging_composer::MockMessagingComposer::MockMessagingComposerHelpersDispatcherTrait;
+use crate::mocks::workers::executor::executor::MockExecutor;
+use crate::workers::executor::utils::{
+    EXECUTOR_OWNER, ExecutorFeeLibTest, ExecutorMock, ExecutorOptionBytes, ExecutorTest,
+    create_mock_compose_params, create_mock_execute_params, create_mock_quote_params,
+    deploy_executor, deploy_executor_fee_lib, deploy_mock_executor, serialize_executor_options,
+    serialize_lz_receive_option,
+};
+
+//////////////////////////
+// Access control tests //
+//////////////////////////
+
+/// Initial roles are set correctly
+#[test]
+#[fuzzer(runs: 10)]
+fn sets_initial_roles(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    message_libs: ContractAddressArrayList,
+    admins: ContractAddressArrayList,
+    token_owner: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        access_control, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            message_libs.arr.span(),
+            price_feed,
+            role_admin,
+            admins.arr.span(),
+            token_owner,
+        );
+
+    // Check that role admin was set correctly
+    assert(access_control.has_role(DEFAULT_ADMIN_ROLE, role_admin), 'Role admin should be set');
+    assert(!access_control.has_role(ADMIN_ROLE, role_admin), 'Role admin should not be admin');
+    assert!(
+        !access_control.has_role(MESSAGE_LIB_ROLE, role_admin), "Role admin should not be msg lib",
+    );
+
+    // Check that admin roles were set correctly
+    for admin in admins.arr {
+        assert(access_control.has_role(ADMIN_ROLE, admin), 'Admin role should be set');
+        assert(!access_control.has_role(MESSAGE_LIB_ROLE, admin), 'Admin should not be msg lib');
+        assert(
+            !access_control.has_role(DEFAULT_ADMIN_ROLE, admin), 'Admin should not be role admin',
+        );
+    }
+
+    // Check that message lib roles were set correctly
+    for msg_lib in message_libs.arr {
+        assert(access_control.has_role(MESSAGE_LIB_ROLE, msg_lib), 'Msg lib role should be set');
+        assert(!access_control.has_role(ADMIN_ROLE, msg_lib), 'Msg lib should not be admin');
+        assert!(
+            !access_control.has_role(DEFAULT_ADMIN_ROLE, msg_lib),
+            "Msg lib should not be role admin",
+        );
+    }
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_set_dst_config_when_admin(
+    endpoint_owner: ContractAddress,
+    src_eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    admin: ContractAddress,
+    token_owner: ContractAddress,
+    dst_eid_1: Eid,
+    dst_eid_2: Eid,
+    dst_config_1: DstConfig,
+    dst_config_2: DstConfig,
+) {
+    let dst_eid_1 = dst_eid_1.eid;
+    let dst_eid_2 = dst_eid_2.eid;
+    let role_admin = role_admin.address;
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, src_eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![admin].span(), token_owner,
+        );
+
+    // Set the dst configs
+    // Caller has the admin role
+    cheat_caller_address_once(executor, admin);
+    dispatcher
+        .set_dst_config(
+            array![
+                SetDstConfigParams { dst_eid: dst_eid_1, config: dst_config_1 },
+                SetDstConfigParams { dst_eid: dst_eid_2, config: dst_config_2 },
+            ],
+        );
+
+    // Check that the configs are set correctly
+    assert(dispatcher.get_dst_config(dst_eid_1) == dst_config_1, 'Config 1 not set correctly');
+    assert(dispatcher.get_dst_config(dst_eid_2) == dst_config_2, 'Config 2 not set correctly');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_fail_to_set_dst_config_when_not_admin(
+    endpoint_owner: ContractAddress,
+    src_eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    not_admin: ContractAddress,
+    dst_eid: Eid,
+    token_owner: ContractAddress,
+    config: DstConfig,
+) {
+    let dst_eid = dst_eid.eid;
+    let role_admin = role_admin.address;
+    let params = array![SetDstConfigParams { dst_eid, config }];
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, src_eid.eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, access_control, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![].span(), token_owner,
+        );
+
+    // Check that not_admin is not an admin
+    assert(!access_control.has_role(ADMIN_ROLE, not_admin), 'Should not be an admin');
+
+    // Attempt to set dst config
+    // Caller does not have the admin role
+    cheat_caller_address_once(executor, not_admin);
+    let res = safe_dispatcher.set_dst_config(params.clone());
+
+    // Check that set dst config fails because the caller does not have the admin role
+    assert_panic_with_felt_error(res, MISSING_ROLE);
+
+    // Set the message lib role
+    // Caller is the role admin
+    start_cheat_caller_address(executor, role_admin);
+    access_control.grant_role(MESSAGE_LIB_ROLE, not_admin);
+    stop_cheat_caller_address(executor);
+
+    // Attempt to set dst config
+    // Caller has the message lib role
+    cheat_caller_address_once(executor, not_admin);
+    let res = safe_dispatcher.set_dst_config(params);
+
+    // Check that set dst config fails because the caller only has the message lib role
+    assert_panic_with_felt_error(res, MISSING_ROLE);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_fail_to_set_dst_config_when_message_lib(
+    endpoint_owner: ContractAddress,
+    src_eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    message_libs: ContractAddressArrayList,
+    dst_eid: Eid,
+    token_owner: ContractAddress,
+    config: DstConfig,
+) {
+    let dst_eid = dst_eid.eid;
+    let role_admin = role_admin.address;
+    let params = array![SetDstConfigParams { dst_eid, config }];
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, src_eid.eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, message_libs.arr.span(), price_feed, role_admin, array![].span(), token_owner,
+        );
+
+    // Attempt to set dst config with each message lib
+    for msg_lib in message_libs.arr {
+        // Caller does not have the admin role
+        cheat_caller_address_once(executor, msg_lib);
+        let res = safe_dispatcher.set_dst_config(params.clone());
+
+        // Check that set dst config fails because the caller only has the message lib role
+        assert_panic_with_felt_error(res, MISSING_ROLE);
+    }
+}
+
+/////////////////
+// Quote tests //
+/////////////////
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_fail_to_quote_when_eid_not_supported(
+    endpoint_owner: ContractAddress,
+    src_eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    admin: ContractAddress,
+    user: ContractAddress,
+    dst_eid: Eid,
+    token_owner: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, src_eid.eid);
+    let ExecutorTest {
+        executor, base_worker, safe_layer_zero_worker, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![admin].span(), token_owner,
+        );
+
+    // Deploy and set up fee lib
+    let ExecutorFeeLibTest { fee_lib, .. } = deploy_executor_fee_lib(dst_eid.eid, admin);
+
+    // Set the worker fee lib
+    start_cheat_caller_address(executor, admin);
+    base_worker.set_worker_fee_lib(fee_lib);
+    stop_cheat_caller_address(executor);
+
+    // Quote the job - should fail because EID is not supported (no dst config set)
+    // Caller can be any address
+    start_cheat_caller_address(executor, user);
+    let res = safe_layer_zero_worker
+        .quote(create_mock_quote_params(user, dst_eid.eid, Default::default()));
+    stop_cheat_caller_address(executor);
+
+    // Check that the quote fails because the EID is not supported
+    assert_panic_with_error(res, errors::err_eid_not_supported());
+}
+
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_fail_to_quote_when_price_feed_not_set(
+    endpoint_owner: ContractAddress,
+    src_eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    user: ContractAddress,
+    dst_eid: Eid,
+    token_owner: ContractAddress,
+    config: DstConfig,
+) {
+    let dst_eid = dst_eid.eid;
+    let role_admin = role_admin.address;
+    let mock_options = serialize_executor_options(
+        array![
+            ExecutorOptionBytes {
+                option_type: 1, option: serialize_lz_receive_option(100, Option::Some(50)),
+            },
+        ],
+    );
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, src_eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, safe_layer_zero_worker, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), ZERO_ADDRESS, role_admin, array![admin].span(), token_owner,
+        );
+
+    // Set the dst config - do not set the price feed
+    // Caller has admin role
+    start_cheat_caller_address(executor, admin);
+    dispatcher.set_dst_config(array![SetDstConfigParams { dst_eid, config }]);
+    stop_cheat_caller_address(executor);
+
+    // Check that the quote fails because the price feed is not set
+    let res = safe_layer_zero_worker.quote(create_mock_quote_params(user, dst_eid, mock_options));
+    assert_panic_with_error(res, errors::err_price_feed_not_set());
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_correctly_quote(
+    endpoint_owner: ContractAddress,
+    src_eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    user: ContractAddress,
+    price_feed: ContractAddress,
+    dst_eid: Eid,
+    token_owner: ContractAddress,
+    config: DstConfig,
+) {
+    let dst_eid = dst_eid.eid;
+    let role_admin = role_admin.address;
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, src_eid.eid);
+    let ExecutorTest {
+        executor, base_worker, dispatcher, layer_zero_worker, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![admin].span(), token_owner,
+        );
+
+    // User wants to send 0.01 ETH and specifies 50,000 gas for execution.
+    // 0.01 ETH = 10^16 wei
+    let lz_receive_value = 10_u128.pow(16);
+    let lz_receive_option = serialize_lz_receive_option(50000, Option::Some(lz_receive_value));
+    let mock_options = serialize_executor_options(
+        array![ExecutorOptionBytes { option_type: 1, option: lz_receive_option }],
+    );
+
+    // Let's assume ETH is the native token (18 decimals).
+    // Let's set a 10% premium (multiplier_bps = 11000).
+    // Let's set a floor margin of $1.50 USD.
+    let set_dst_config_params = SetDstConfigParams {
+        dst_eid,
+        config: DstConfig {
+            lz_receive_base_gas: 200000, // Base gas for a receive operation
+            multiplier_bps: 11000, // 110% -> 10% premium
+            floor_margin_usd: 1_500_000_000_000_000_000, // $1.50 with 18 decimals
+            native_cap: 10_u128.pow(18), // 1 ETH cap
+            lz_compose_base_gas: 0,
+        },
+    };
+
+    // Deploy and set up fee lib
+    let ExecutorFeeLibTest { fee_lib, .. } = deploy_executor_fee_lib(dst_eid, admin);
+
+    // Update the set_dst_config_params to use the v2 EID
+    let set_dst_config_params = SetDstConfigParams {
+        dst_eid, config: set_dst_config_params.config,
+    };
+
+    // Set the dst config, price feed, and worker fee lib
+    // Caller has admin role
+    start_cheat_caller_address(executor, admin);
+    dispatcher.set_dst_config(array![set_dst_config_params]);
+    base_worker.set_price_feed(price_feed);
+    base_worker.set_worker_fee_lib(fee_lib);
+    stop_cheat_caller_address(executor);
+
+    // Mock the price feed response
+    // total_gas = lz_receive_base_gas (200,000) + lz_receive_option gas (50,000) = 250,000.
+    // Let's say the price_feed determines this costs 0.00075 ETH.
+    let mock_gas_fee = 750_000_000_000_000; // 0.00075 ETH in wei
+    // 1 ETH = $3000. We send price with 18 decimals.
+    let native_price_usd = 3000_u128 * 10_u128.pow(18);
+    let mock_response = GetFeeResponse {
+        gas_fee: mock_gas_fee,
+        price_ratio: 1, // Source and dest chains use same-priced native token
+        price_ratio_denominator: 1,
+        native_price_usd,
+    };
+
+    start_mock_call(price_feed, selector!("estimate_fee_on_send"), mock_response);
+    let quote = layer_zero_worker.quote(create_mock_quote_params(user, dst_eid, mock_options));
+    stop_mock_call(price_feed, selector!("estimate_fee_on_send"));
+
+    // Expected fee calculation:
+    // 1. Gas Component
+    // multiplier = 11000 / 10000 = 1.1
+    // fee_with_multiplier = 0.00075 * 1.1 = 0.000825 ETH
+    // margin_in_native = ($1.5 * 10^18) / ($3000 * 10^18 per ETH) = 0.0005 ETH
+    // fee_with_margin = 0.00075 + 0.0005 = 0.00125 ETH
+    // gas_component = max(0.000825, 0.00125) = 0.00125 ETH
+    let gas_component = 1_250_000_000_000_000; // 0.00125 ETH in wei
+
+    // 2. Value Component
+    // total_value = 0.01 ETH from lz_receive_option
+    // converted_total_value = 0.01 ETH (since price_ratio is 1)
+    // value_component = 0.01 * 1.1 = 0.011 ETH
+    let value_component = 11_000_000_000_000_000; // 0.011 ETH in wei
+
+    // 3. Total Fee
+    // total_fee = 0.00125 + 0.011 = 0.01225 ETH
+    // Check that the quote is correct
+    assert(quote == gas_component + value_component, 'Quote should be expected fee');
+}
+
+///////////////////
+// Upgrade tests //
+///////////////////
+
+#[test]
+#[fuzzer(runs: 10)]
+fn upgrade_succeeds(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![].span(), token_owner,
+        );
+    let new_class = declare("MockBaseWorker").unwrap().contract_class().class_hash;
+
+    // Upgrade the contract
+    // Caller is the owner
+    start_cheat_caller_address(executor, EXECUTOR_OWNER);
+    dispatcher.upgrade(*new_class);
+    stop_cheat_caller_address(executor);
+
+    // Check that the upgrade succeeds
+    assert(get_class_hash(executor) == *new_class, 'Upgrade should succeed');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn upgrade_fails_when_not_owner(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    not_owner: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+) {
+    // Ensure that not_owner is not the owner
+    if not_owner == EXECUTOR_OWNER {
+        return;
+    }
+
+    let role_admin = role_admin.address;
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![].span(), token_owner,
+        );
+    let new_class = declare("MockBaseWorker").unwrap().contract_class().class_hash;
+
+    // Attempt to upgrade the contract - role admin
+    // Caller is the role admin
+    start_cheat_caller_address(executor, role_admin);
+    let res = safe_dispatcher.upgrade(*new_class);
+    stop_cheat_caller_address(executor);
+
+    // Check that the upgrade fails because role_admin does not have the admin role
+    assert_panic_with_felt_error(res, OwnableComponent::Errors::NOT_OWNER);
+
+    // Attempt to upgrade the contract - non-owner
+    // Caller is not the owner
+    start_cheat_caller_address(executor, not_owner);
+    let res = safe_dispatcher.upgrade(*new_class);
+    stop_cheat_caller_address(executor);
+
+    // Check that the upgrade fails because not_owner is not the owner
+    assert_panic_with_felt_error(res, OwnableComponent::Errors::NOT_OWNER);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn upgrade_and_call_succeeds(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![].span(), token_owner,
+        );
+
+    let new_class_hash = declare("MockExecutor").unwrap().contract_class().class_hash;
+
+    // Upgrade and call
+    // Caller is the owner
+    start_cheat_caller_address(executor, EXECUTOR_OWNER);
+    let mut serialized_res = dispatcher
+        .upgrade_and_call(
+            *new_class_hash, selector!("get_dst_config"), array![0_u32.into()].span(),
+        );
+    stop_cheat_caller_address(executor);
+
+    // Check that the function was called correctly
+    let res: DstConfig = Serde::deserialize(ref serialized_res).unwrap();
+    assert(res == MockExecutor::DST_CONFIG, 'Function should be called');
+
+    // Check that the contract was upgraded
+    assert(get_class_hash(executor) == *new_class_hash, 'Upgrade should succeed');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn upgrade_and_call_fails_when_not_owner(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    not_owner: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+) {
+    // Ensure that not_owner is not the owner
+    if not_owner == EXECUTOR_OWNER {
+        return;
+    }
+
+    let role_admin = role_admin.address;
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![].span(), token_owner,
+        );
+
+    let new_class_hash = declare("MockExecutor").unwrap().contract_class().class_hash;
+
+    // Attempt to upgrade and call
+    // Caller is not the owner
+    start_cheat_caller_address(executor, not_owner);
+    let res = safe_dispatcher.upgrade_and_call(*new_class_hash, 0, array![].span());
+    stop_cheat_caller_address(executor);
+
+    // Check that the upgrade fails because the caller is not the owner
+    assert_panic_with_felt_error(res, OwnableComponent::Errors::NOT_OWNER);
+}
+
+///////////////////
+// Execute tests //
+///////////////////
+
+#[test]
+#[fuzzer(runs: 10)]
+fn execute_should_succeed_with_packet_delivered_event(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    receiver: ContractAddress,
+) {
+    let eid = eid.eid;
+
+    // Deploy contracts
+    let EndpointMock { endpoint, token, .. } = deploy_mock_endpoint(endpoint_owner, eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            token,
+            role_admin.address,
+            array![admin].span(),
+            endpoint_owner,
+        );
+
+    // ExecuteParams - values are not important because we're mocking the endpoint
+    let params = create_mock_execute_params(eid, receiver);
+    let origin = params.origin.clone();
+
+    let mut spy = spy_events();
+
+    // Execute
+    start_cheat_caller_address(executor, admin);
+    dispatcher.execute(params);
+    stop_cheat_caller_address(executor);
+
+    // Check that endpoint event was emitted
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    endpoint,
+                    MockEndpoint::Event::PacketDelivered(
+                        endpoint_events::PacketDelivered { origin, receiver },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn execute_should_fail_with_alert_event(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    receiver: ContractAddress,
+) {
+    let eid = eid.eid;
+
+    // Deploy contracts
+    let EndpointMock { endpoint, token, .. } = deploy_mock_endpoint(endpoint_owner, eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            token,
+            role_admin.address,
+            array![admin].span(),
+            endpoint_owner,
+        );
+
+    // ExecuteParams - values are not important because we're mocking the endpoint
+    let params = create_mock_execute_params(eid, receiver);
+    let origin = params.origin.clone();
+
+    // Set the endpoint to fail on lz_receive
+    let mut endpoint_dispatcher = MockEndpointHelpersDispatcher { contract_address: endpoint };
+    endpoint_dispatcher.set_receive_should_fail(true);
+
+    let mut spy = spy_events();
+
+    // Execute
+    start_cheat_caller_address(executor, admin);
+    dispatcher.execute(params.clone());
+    stop_cheat_caller_address(executor);
+
+    // Check that endpoint event was emitted
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    endpoint,
+                    MockEndpoint::Event::LzReceiveAlert(
+                        endpoint_events::LzReceiveAlert {
+                            origin,
+                            executor,
+                            receiver,
+                            guid: params.guid,
+                            gas: 0,
+                            value: params.value,
+                            message: params.message,
+                            extra_data: params.extra_data,
+                            reason: array!['Mock receive failed'],
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn execute_should_fail_when_not_admin(
+    role_admin: RoleAdmin,
+    endpoint_owner: ContractAddress,
+    not_admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    receiver: ContractAddress,
+    eid: Eid,
+) {
+    let eid = eid.eid;
+    let role_admin = role_admin.address;
+
+    // Deploy contracts
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin, array![].span(), token_owner,
+        );
+
+    // ExecuteParams values are not important because we're mocking the endpoint
+    let params = create_mock_execute_params(eid, receiver);
+
+    // Attempt to execute
+    // Caller does not have admin role
+    start_cheat_caller_address(executor, not_admin);
+    let res = safe_dispatcher.execute(params);
+    stop_cheat_caller_address(executor);
+
+    // Check that the execute fails because the caller does not have the admin role
+    assert_panic_with_felt_error(res, MISSING_ROLE);
+}
+
+///////////////////
+// Compose tests //
+///////////////////
+
+#[test]
+#[fuzzer(runs: 10)]
+fn compose_should_succeed_with_compose_delivered_event(
+    token: ContractAddress, sender: ContractAddress, receiver: ContractAddress,
+) {
+    // Deploy mock contracts
+    let MessagingComposerMock {
+        composer, dispatcher: composer_dispatcher, ..,
+    } = deploy_mock_messaging_composer(token);
+    let ExecutorMock {
+        dispatcher, ..,
+    } = deploy_mock_executor(ZERO_ADDRESS, ZERO_ADDRESS, composer);
+
+    // Set the messaging composer to be mock
+    composer_dispatcher.set_is_real(false);
+
+    // ComposeParams values are not important because we're mocking the endpoint
+    let params = create_mock_compose_params(sender, receiver);
+
+    let mut spy = spy_events();
+
+    // Compose
+    // Mock executor does not have access control
+    dispatcher.compose(params.clone());
+
+    // Check that compose delivered event was emitted
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    composer,
+                    MockMessagingComposer::Event::MessagingComposerEvent(
+                        MessagingComposerComponent::Event::ComposeDelivered(
+                            ComposeDelivered {
+                                from: params.sender,
+                                to: params.receiver,
+                                guid: params.guid,
+                                index: params.index,
+                            },
+                        ),
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn compose_should_fail_with_lz_compose_alert_event(
+    token: ContractAddress, sender: ContractAddress, receiver: ContractAddress,
+) {
+    // Deploy mock contracts
+    let MessagingComposerMock {
+        composer, dispatcher: composer_dispatcher, ..,
+    } = deploy_mock_messaging_composer(token);
+    let ExecutorMock {
+        dispatcher, ..,
+    } = deploy_mock_executor(ZERO_ADDRESS, ZERO_ADDRESS, composer);
+
+    // Set the messaging composer to be mock and fail on lz_compose
+    composer_dispatcher.set_is_real(false);
+    composer_dispatcher.set_should_compose_fail(true);
+
+    // ComposeParams values are not important because we're mocking the endpoint
+    let params = create_mock_compose_params(sender, receiver);
+
+    let mut spy = spy_events();
+
+    // Compose
+    // Mock executor does not have access control
+    dispatcher.compose(params.clone());
+
+    // Check that compose alert event was emitted
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    composer,
+                    MockMessagingComposer::Event::MessagingComposerEvent(
+                        MessagingComposerComponent::Event::LzComposeAlert(
+                            LzComposeAlert {
+                                from: params.sender,
+                                to: params.receiver,
+                                executor: ZERO_ADDRESS,
+                                guid: params.guid,
+                                index: params.index,
+                                gas: 0,
+                                value: params.value,
+                                message: params.message,
+                                extra_data: params.extra_data,
+                                reason: array!['MockComposer: lz_compose failed'],
+                            },
+                        ),
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn compose_should_fail_when_not_admin(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    not_admin: ContractAddress,
+    token_owner: ContractAddress,
+    sender: ContractAddress,
+    receiver: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), ZERO_ADDRESS, role_admin, array![].span(), token_owner,
+        );
+
+    // ComposeParams values are not important because we're mocking the endpoint
+    let params = create_mock_compose_params(sender, receiver);
+
+    // Attempt to compose
+    // Caller does not have admin role
+    start_cheat_caller_address(executor, not_admin);
+    let res = safe_dispatcher.compose(params);
+    stop_cheat_caller_address(executor);
+
+    // Check that the compose fails because the caller does not have the admin role
+    assert_panic_with_felt_error(res, MISSING_ROLE);
+}
+
+///////////////////////
+// Native drop tests //
+///////////////////////
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_to_no_receiver(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    origin: Origin,
+    oapp: ContractAddress,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher.native_drop(origin.clone(), oapp, array![]);
+
+    // Check that native drop applied event was emitted
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    executor,
+                    Executor::Event::NativeDropApplied(
+                        NativeDropApplied {
+                            origin,
+                            dst_eid: eid.eid,
+                            oapp,
+                            native_drop_params: array![],
+                            success: array![],
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_to_single_receiver(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    origin: Origin,
+    oapp: ContractAddress,
+    token_receiver: ContractAddress,
+    token_amount: u8,
+) {
+    let token_amount = token_amount.into() + 1;
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, token_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher
+        .native_drop(
+            origin.clone(),
+            oapp,
+            array![NativeDropParams { receiver: token_receiver, amount: token_amount }],
+        );
+
+    assert(token_dispatcher.balance_of(token_receiver) == token_amount, 'Invalid token amount');
+
+    // Check that native drop applied event was emitted
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    executor,
+                    Executor::Event::NativeDropApplied(
+                        NativeDropApplied {
+                            origin,
+                            dst_eid: eid.eid,
+                            oapp,
+                            native_drop_params: array![
+                                NativeDropParams { receiver: token_receiver, amount: token_amount },
+                            ],
+                            success: array![true],
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_to_two_receivers(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    origin: Origin,
+    oapp: ContractAddress,
+    token_receiver_1: ContractAddress,
+    token_receiver_2: ContractAddress,
+    token_amount_1: u8,
+    token_amount_2: u8,
+) {
+    let token_amount_1 = token_amount_1.into();
+    let token_amount_2 = token_amount_2.into();
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, token_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher
+        .native_drop(
+            origin.clone(),
+            oapp,
+            array![
+                NativeDropParams { receiver: token_receiver_1, amount: token_amount_1 },
+                NativeDropParams { receiver: token_receiver_2, amount: token_amount_2 },
+            ],
+        );
+
+    assert(token_dispatcher.balance_of(token_receiver_1) == token_amount_1, 'Invalid token amount');
+    assert(token_dispatcher.balance_of(token_receiver_2) == token_amount_2, 'Invalid token amount');
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    executor,
+                    Executor::Event::NativeDropApplied(
+                        NativeDropApplied {
+                            origin,
+                            dst_eid: eid.eid,
+                            oapp,
+                            native_drop_params: array![
+                                NativeDropParams {
+                                    receiver: token_receiver_1, amount: token_amount_1,
+                                },
+                                NativeDropParams {
+                                    receiver: token_receiver_2, amount: token_amount_2,
+                                },
+                            ],
+                            success: array![true, true],
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_with_insufficient_balance(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    origin: Origin,
+    oapp: ContractAddress,
+    token_receiver: ContractAddress,
+    token_amount: u8,
+    sink: ContractAddress,
+) {
+    // Make the token amount always non-zero to fail the native token transfer.
+    let token_amount = token_amount.into() + 1;
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, token, token_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+
+    // Drain all tokens from the executor.
+    let balance = token_dispatcher.balance_of(executor);
+    cheat_caller_address_once(token, executor);
+    token_dispatcher.transfer(sink, balance);
+    assert(token_dispatcher.balance_of(executor) == 0, 'Non-zero balance for executor');
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher
+        .native_drop(
+            origin.clone(),
+            oapp,
+            array![NativeDropParams { receiver: token_receiver, amount: token_amount }],
+        );
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    executor,
+                    Executor::Event::NativeDropApplied(
+                        NativeDropApplied {
+                            origin,
+                            dst_eid: eid.eid,
+                            oapp,
+                            native_drop_params: array![
+                                NativeDropParams { receiver: token_receiver, amount: token_amount },
+                            ],
+                            success: array![false],
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_with_partial_transfer_success(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    origin: Origin,
+    oapp: ContractAddress,
+    token_receiver_1: ContractAddress,
+    token_receiver_2: ContractAddress,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, token_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+
+    // We transfer a little more than half of balance of the executor to two native drop receivers.
+    let token_amount = token_dispatcher.balance_of(executor) / 2 + 1;
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher
+        .native_drop(
+            origin.clone(),
+            oapp,
+            array![
+                NativeDropParams { receiver: token_receiver_1, amount: token_amount },
+                NativeDropParams { receiver: token_receiver_2, amount: token_amount },
+            ],
+        );
+
+    assert(token_dispatcher.balance_of(token_receiver_1) == token_amount, 'Invalid token amount');
+    assert(token_dispatcher.balance_of(token_receiver_2) == 0, 'Non-zero token amount');
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    executor,
+                    Executor::Event::NativeDropApplied(
+                        NativeDropApplied {
+                            origin,
+                            dst_eid: eid.eid,
+                            oapp,
+                            native_drop_params: array![
+                                NativeDropParams {
+                                    receiver: token_receiver_1, amount: token_amount,
+                                },
+                                NativeDropParams {
+                                    receiver: token_receiver_2, amount: token_amount,
+                                },
+                            ],
+                            success: array![true, false],
+                        },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_when_not_admin(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    origin: Origin,
+    oapp: ContractAddress,
+    user: ContractAddress,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin.address, array![].span(), token_owner,
+        );
+
+    cheat_caller_address_once(executor, user);
+    let result = safe_dispatcher.native_drop(origin, oapp, array![]);
+
+    assert_panic_with_felt_error(result, MISSING_ROLE);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_and_execute_with_no_native_drop_receiver(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    oapp: ContractAddress,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+    let execute_params = create_mock_execute_params(eid.eid, oapp);
+    let origin = execute_params.origin.clone();
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher.native_drop_and_execute(array![], execute_params);
+
+    let events = spy.get_events();
+
+    assert!(events.events.len() == 2);
+    assert!(
+        events
+            .is_emitted(
+                executor,
+                @Executor::Event::NativeDropApplied(
+                    NativeDropApplied {
+                        origin: origin.clone(),
+                        dst_eid: eid.eid,
+                        oapp,
+                        native_drop_params: array![],
+                        success: array![],
+                    },
+                ),
+            ),
+    );
+    assert!(
+        events
+            .is_emitted(
+                endpoint,
+                @MockEndpoint::Event::PacketDelivered(
+                    endpoint_events::PacketDelivered { origin, receiver: oapp },
+                ),
+            ),
+    );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_and_execute_with_single_native_drop_receiver(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    oapp: ContractAddress,
+    token_owner: ContractAddress,
+    token_receiver: ContractAddress,
+    token_amount: u8,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+    let execute_params = create_mock_execute_params(eid.eid, oapp);
+    let origin = execute_params.origin.clone();
+    let native_drop_params = array![
+        NativeDropParams { receiver: token_receiver, amount: token_amount.into() + 1 },
+    ];
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher.native_drop_and_execute(native_drop_params.clone(), execute_params);
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    executor,
+                    Executor::Event::NativeDropApplied(
+                        NativeDropApplied {
+                            origin: origin.clone(),
+                            dst_eid: eid.eid,
+                            oapp,
+                            native_drop_params,
+                            success: array![true],
+                        },
+                    ),
+                ),
+            ],
+        );
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    endpoint,
+                    MockEndpoint::Event::PacketDelivered(
+                        endpoint_events::PacketDelivered { origin, receiver: oapp },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_and_execute_with_insufficient_balance(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    oapp: ContractAddress,
+    token_owner: ContractAddress,
+    token_receiver: ContractAddress,
+    token_amount: u8,
+    sink: ContractAddress,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, dispatcher, token, token_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint,
+            array![].span(),
+            price_feed,
+            role_admin.address,
+            array![admin].span(),
+            token_owner,
+        );
+    let execute_params = create_mock_execute_params(eid.eid, oapp);
+    let origin = execute_params.origin.clone();
+    let native_drop_params = array![
+        NativeDropParams { receiver: token_receiver, amount: token_amount.into() + 1 },
+    ];
+
+    // Drain all tokens from the executor.
+    let balance = token_dispatcher.balance_of(executor);
+    cheat_caller_address_once(token, executor);
+    token_dispatcher.transfer(sink, balance);
+    assert(token_dispatcher.balance_of(executor) == 0, 'Non-zero balance for executor');
+
+    let mut spy = spy_events();
+
+    cheat_caller_address_once(executor, admin);
+    dispatcher.native_drop_and_execute(native_drop_params.clone(), execute_params);
+
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    executor,
+                    Executor::Event::NativeDropApplied(
+                        NativeDropApplied {
+                            origin: origin.clone(),
+                            dst_eid: eid.eid,
+                            oapp,
+                            native_drop_params,
+                            success: array![false],
+                        },
+                    ),
+                ),
+            ],
+        );
+    // Even when native drops fail, the executor is expected to execute a message and succeed the
+    // whole transaction.
+    spy
+        .assert_emitted(
+            @array![
+                (
+                    endpoint,
+                    MockEndpoint::Event::PacketDelivered(
+                        endpoint_events::PacketDelivered { origin, receiver: oapp },
+                    ),
+                ),
+            ],
+        );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn native_drop_and_execute_when_not_admin(
+    endpoint_owner: ContractAddress,
+    eid: Eid,
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    token_owner: ContractAddress,
+    receiver: ContractAddress,
+    user: ContractAddress,
+) {
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, eid.eid);
+    let ExecutorTest {
+        executor, safe_dispatcher, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), price_feed, role_admin.address, array![].span(), token_owner,
+        );
+    let execute_params = create_mock_execute_params(eid.eid, receiver);
+
+    cheat_caller_address_once(executor, user);
+    let result = safe_dispatcher.native_drop_and_execute(array![], execute_params);
+
+    assert_panic_with_felt_error(result, MISSING_ROLE);
+}
+
+//////////////////////////
+// Implementation tests //
+//////////////////////////
+
+#[test]
+fn impl_layer_zero_worker_interface() {
+    const EID: u32 = 1;
+    let endpoint_owner = 'endpoint owner'.try_into().unwrap();
+
+    let EndpointMock { endpoint, .. } = deploy_mock_endpoint(endpoint_owner, EID);
+    let ExecutorTest {
+        executor, ..,
+    } =
+        deploy_executor(
+            endpoint, array![].span(), ZERO_ADDRESS, ZERO_ADDRESS, array![].span(), endpoint_owner,
+        );
+
+    /// Runtime check that the executor implements the ILayerZeroWorker interface
+    ILayerZeroWorkerDispatcher { contract_address: executor };
+}