@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/endpoint/messaging_channel/utils.cairo

@@ -0,0 +1,96 @@
+// use crate::mocks::messaging_channel::interface::IMockMessagingChannelSafeDispatcherTrait;
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+use layerzero::Origin;
+//! Message lib manager test utils
+use layerzero::endpoint::messaging_channel::interface::IMessagingChannelSafeDispatcher;
+use layerzero::endpoint::messaging_channel::interface::{
+    IMessagingChannelDispatcher, IMessagingChannelDispatcherTrait,
+};
+use lz_utils::bytes::Bytes32;
+use lz_utils::keccak::keccak256;
+use snforge_std::{ContractClassTrait, DeclareResultTrait, declare};
+use starknet::ContractAddress;
+use crate::mocks::messaging_channel::interface::{
+    IMockMessagingChannelDispatcher, IMockMessagingChannelDispatcherTrait,
+    IMockMessagingChannelSafeDispatcher,
+};
+
+// Constants
+pub(crate) const TEN_GWEI: u64 = 10_000_000_000;
+
+/// Messaging channel mock for testing
+pub(crate) struct MessagingChannelMock {
+    pub messaging_channel: ContractAddress,
+    pub dispatcher: IMessagingChannelDispatcher,
+    pub safe_dispatcher: IMessagingChannelSafeDispatcher,
+    pub helper_dispatcher: IMockMessagingChannelDispatcher,
+    pub helper_safe_dispatcher: IMockMessagingChannelSafeDispatcher,
+}
+
+
+/// Deploy the messaging channel contract and return the messaging channel mock
+pub(crate) fn deploy_messaging_channel(eid: u32) -> MessagingChannelMock {
+    let contract = declare("MockMessagingChannel").unwrap().contract_class();
+    let constructor_args = array![eid.into()];
+    let (contract_address, _) = contract.deploy(@constructor_args).unwrap();
+
+    MessagingChannelMock {
+        messaging_channel: contract_address,
+        dispatcher: IMessagingChannelDispatcher { contract_address },
+        safe_dispatcher: IMessagingChannelSafeDispatcher { contract_address },
+        helper_dispatcher: IMockMessagingChannelDispatcher { contract_address },
+        helper_safe_dispatcher: IMockMessagingChannelSafeDispatcher { contract_address },
+    }
+}
+
+// Controls initial inbound state.
+// - executed_until: all nonces [1..=executed_until] will be executed (cleared)
+// - committed_until: all nonces (executed_until..=committed_until) will be verified (committed)
+// Invariant: executed_until <= committed_until
+#[derive(Copy, Drop, Debug, Serde)]
+pub struct InboundSetupParams {
+    pub executed_until: u64,
+    pub committed_until: u64,
+}
+
+// Deterministic payload builder so keccak(payload) matches what we commit
+pub(crate) fn _build_payload(eid: u32, sender: Bytes32, nonce: u64) -> ByteArray {
+    let mut p: ByteArray = Default::default();
+    p.append_u32(eid);
+    p.append_u256(sender.value);
+    p.append_u64(nonce);
+    p
+}
+
+
+// Deploys a fresh mock and pre-populates inbound state.
+// Returns the same `MessagingChannelMock` you’re used to.
+pub(crate) fn setup_inbound_state(
+    eid: u32, oapp: ContractAddress, sender: Bytes32, params: InboundSetupParams,
+) -> MessagingChannelMock {
+    let mock = deploy_messaging_channel(eid);
+    let helper_dispatcher = IMockMessagingChannelDispatcher {
+        contract_address: mock.messaging_channel,
+    };
+    let dispatcher = IMessagingChannelDispatcher { contract_address: mock.messaging_channel };
+
+    let InboundSetupParams { executed_until, committed_until } = params;
+
+    // 1) Commit [1..=committed_until] so they are considered verified
+    for i in 1..=committed_until {
+        let payload = _build_payload(eid, sender, i);
+        let payload_hash = keccak256(@payload);
+        let origin = Origin { src_eid: eid, sender, nonce: i };
+        helper_dispatcher.fake_commit(oapp, origin.clone(), payload_hash);
+        // clear payloads up to executed_until
+        if i <= executed_until {
+            helper_dispatcher.test_clear_payload(oapp, origin, payload);
+        }
+    }
+
+    // 3) Optional sanity: inbound_nonce should equal committed_until
+    let inbound = dispatcher.inbound_nonce(oapp, eid, sender);
+    assert(inbound == committed_until, 'bad inbound');
+
+    mock
+}

package/layerzero/tests/endpoint/messaging_composer/test_messaging_composer.cairo

@@ -0,0 +1,456 @@
+//! Messaging composer tests
+
+use layerzero::endpoint::constants::EMPTY_PAYLOAD_HASH;
+use layerzero::endpoint::messaging_composer::errors::{
+    err_lz_compose_already_exists, err_lz_compose_not_found, err_lz_compose_value_exceeds_allowance,
+};
+use layerzero::endpoint::messaging_composer::events::{
+    ComposeDelivered, ComposeSent, LzComposeAlert,
+};
+use layerzero::endpoint::messaging_composer::interface::{
+    IMessagingComposerDispatcherTrait, IMessagingComposerSafeDispatcher,
+    IMessagingComposerSafeDispatcherTrait,
+};
+use layerzero::endpoint::messaging_composer::messaging_composer::MessagingComposerComponent;
+use lz_utils::bytes::Bytes32;
+use lz_utils::keccak::keccak256;
+use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+use snforge_std::{
+    EventSpyAssertionsTrait, spy_events, start_cheat_caller_address, stop_cheat_caller_address,
+};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::assert_panic_with_error;
+use crate::endpoint::messaging_composer::utils::{
+    MessagingComposerMock, deploy_messaging_composer, mint_and_approve_for_executor,
+};
+use crate::fuzzable::bytes32::FuzzableBytes32;
+use crate::fuzzable::contract_address::FuzzableContractAddress;
+use crate::fuzzable::felt_array::{Felt252ArrayList, FuzzableFelt252ArrayList};
+use crate::mocks::composer_target::MockComposerTarget::IMockComposerTargetInspectDispatcherTrait;
+use crate::mocks::messaging_composer::MockMessagingComposer;
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_send_compose_and_emit_event(
+    sender: ContractAddress, to: ContractAddress, guid: Bytes32, index: u16, msg: ByteArray,
+) {
+    let MessagingComposerMock { messaging_composer, dispatcher, .. } = deploy_messaging_composer();
+    let message: ByteArray = msg.clone();
+
+    start_cheat_caller_address(messaging_composer, sender);
+    let mut spy = spy_events();
+    dispatcher.send_compose(to, guid, index, message.clone());
+    stop_cheat_caller_address(messaging_composer);
+
+    let expected_event = MockMessagingComposer::Event::MessagingComposerEvent(
+        MessagingComposerComponent::Event::ComposeSent(
+            ComposeSent { from: sender, to, guid, index, message },
+        ),
+    );
+    spy.assert_emitted(@array![(messaging_composer, expected_event)]);
+
+    // get_compose_queue should return stored hash (non-zero)
+    let stored: Bytes32 = dispatcher.get_compose_queue(sender, to, guid, index);
+    assert(stored != EMPTY_PAYLOAD_HASH, 'non-zero hash');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn should_fail_when_send_compose_twice_same_key(
+    sender: ContractAddress, to: ContractAddress, guid: Bytes32, index: u16, msg: ByteArray,
+) {
+    let MessagingComposerMock { messaging_composer, dispatcher, .. } = deploy_messaging_composer();
+    let message: ByteArray = msg.clone();
+
+    start_cheat_caller_address(messaging_composer, sender);
+    dispatcher.send_compose(to, guid, index, message.clone());
+    use layerzero::endpoint::messaging_composer::interface::IMessagingComposerSafeDispatcher;
+    let safe = IMessagingComposerSafeDispatcher { contract_address: messaging_composer };
+    let res = safe.send_compose(to, guid, index, message);
+    stop_cheat_caller_address(messaging_composer);
+
+    assert_panic_with_error(res, err_lz_compose_already_exists());
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_lz_compose_success_and_transfer_value(
+    from: ContractAddress,
+    executor: ContractAddress,
+    _to: ContractAddress,
+    guid: Bytes32,
+    index: u16,
+    msg: ByteArray,
+    value: u256,
+) {
+    let MessagingComposerMock {
+        messaging_composer, dispatcher, token_dispatcher, target_address, target_inspect, ..,
+    } = deploy_messaging_composer();
+    let message: ByteArray = msg.clone();
+    let extra_data: ByteArray = Default::default();
+    let value: u256 = (value % 1_000_000_u256) + 1_u256;
+
+    // sender sends compose
+    start_cheat_caller_address(messaging_composer, from);
+    dispatcher.send_compose(target_address, guid, index, message.clone());
+    stop_cheat_caller_address(messaging_composer);
+
+    // mint and approve value to composer contract as `executor` (the caller)
+    mint_and_approve_for_executor(token_dispatcher, executor, messaging_composer, value);
+
+    // record balances before compose
+    let token = IERC20Dispatcher { contract_address: token_dispatcher.contract_address };
+    let to_balance_before = token.balance_of(target_address);
+    let exec_balance_before = token.balance_of(executor);
+
+    // call lz_compose from an executor/caller with allowance of "from"
+    start_cheat_caller_address(messaging_composer, executor);
+    let mut spy = spy_events();
+    dispatcher.lz_compose(from, target_address, guid, index, message, extra_data, value);
+    stop_cheat_caller_address(messaging_composer);
+
+    // expect delivered event
+    let expected_event = MockMessagingComposer::Event::MessagingComposerEvent(
+        MessagingComposerComponent::Event::ComposeDelivered(
+            ComposeDelivered { from, to: target_address, guid, index },
+        ),
+    );
+    spy.assert_emitted(@array![(messaging_composer, expected_event)]);
+
+    // validate target side effects
+    let received = target_inspect.received_count();
+    assert(received > 0, 'target should receive compose');
+
+    // validate token transfer effects
+    let to_balance_after = token.balance_of(target_address);
+    let exec_balance_after = token.balance_of(executor);
+    assert(to_balance_after == to_balance_before + value, 'to recv value');
+    assert(exec_balance_after + value == exec_balance_before, 'exec paid value');
+
+    // target should record last_value
+    let last_v = target_inspect.last_value();
+    assert(last_v == value, 'last_value == value');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn should_fail_lz_compose_when_message_hash_mismatch(
+    from: ContractAddress,
+    _to: ContractAddress,
+    guid: Bytes32,
+    index: u16,
+    m1: ByteArray,
+    m2: ByteArray,
+) {
+    let MessagingComposerMock {
+        messaging_composer, dispatcher, target_address, ..,
+    } = deploy_messaging_composer();
+
+    start_cheat_caller_address(messaging_composer, from);
+    dispatcher.send_compose(target_address, guid, index, m1.clone());
+    stop_cheat_caller_address(messaging_composer);
+
+    let safe = IMessagingComposerSafeDispatcher { contract_address: messaging_composer };
+    let m2_copy: ByteArray = m2.clone();
+    let res = safe
+        .lz_compose(from, target_address, guid, index, m2_copy, Default::default(), 0_u256);
+
+    let expected_hash = keccak256(@m1);
+    let actual_hash = keccak256(@m2);
+    assert_panic_with_error(res, err_lz_compose_not_found(expected_hash, actual_hash));
+
+    // queue should remain the same (not marked as received)
+    let stored = dispatcher.get_compose_queue(from, target_address, guid, index);
+    let received_sentinel = Bytes32 { value: 0x1 };
+    assert(stored != received_sentinel, 'not received');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn should_fail_lz_compose_when_value_exceeds_allowance(
+    from: ContractAddress, _to: ContractAddress, guid: Bytes32, index: u16, msg: ByteArray,
+) {
+    let MessagingComposerMock {
+        messaging_composer, dispatcher, token_dispatcher, target_address, ..,
+    } = deploy_messaging_composer();
+    let value: u256 = 1000_u256;
+
+    // send compose
+    start_cheat_caller_address(messaging_composer, from);
+    dispatcher.send_compose(target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(messaging_composer);
+
+    // approve less than value as the executor; set executor == from
+    start_cheat_caller_address(token_dispatcher.contract_address, from);
+    token_dispatcher.approve(messaging_composer, 100_u256);
+    stop_cheat_caller_address(token_dispatcher.contract_address);
+
+    // mock target composer lz_compose (won't be reached)
+    // mock not needed; failure occurs before external call
+
+    use layerzero::endpoint::messaging_composer::interface::IMessagingComposerSafeDispatcher;
+    let safe = IMessagingComposerSafeDispatcher { contract_address: messaging_composer };
+    // ensure executor == from for this call
+    start_cheat_caller_address(messaging_composer, from);
+    let res = safe.lz_compose(from, target_address, guid, index, msg, Default::default(), value);
+    stop_cheat_caller_address(messaging_composer);
+    assert_panic_with_error(res, err_lz_compose_value_exceeds_allowance(value, 100_u256));
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn should_emit_compose_alert(
+    from: ContractAddress,
+    to: ContractAddress,
+    executor: ContractAddress,
+    guid: Bytes32,
+    index: u16,
+    gas: u256,
+    value: u256,
+    message: ByteArray,
+    extra_data: ByteArray,
+    reason: Felt252ArrayList,
+) {
+    let MessagingComposerMock { messaging_composer, dispatcher, .. } = deploy_messaging_composer();
+    let gas: u256 = gas % 10_000_u256;
+    let value: u256 = value % 1_000_000_u256;
+
+    start_cheat_caller_address(messaging_composer, executor);
+    let mut spy = spy_events();
+    dispatcher
+        .lz_compose_alert(
+            from,
+            to,
+            guid,
+            index,
+            gas,
+            value,
+            message.clone(),
+            extra_data.clone(),
+            reason.arr.clone(),
+        );
+    stop_cheat_caller_address(messaging_composer);
+
+    let expected_event = MockMessagingComposer::Event::MessagingComposerEvent(
+        MessagingComposerComponent::Event::LzComposeAlert(
+            LzComposeAlert {
+                from,
+                to,
+                executor,
+                guid,
+                index,
+                gas,
+                value,
+                message,
+                extra_data,
+                reason: reason.arr,
+            },
+        ),
+    );
+    spy.assert_emitted(@array![(messaging_composer, expected_event)]);
+
+    // also ensure no state mutation occurs in queue for alert
+    let queue: Bytes32 = dispatcher.get_compose_queue(from, to, guid, index);
+    assert(queue == EMPTY_PAYLOAD_HASH, 'no alert queue change');
+    // do not invoke lz_compose here since `to` is arbitrary and may not be deployed
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn queued_hash_matches_keccak(from: ContractAddress, guid: Bytes32, index: u16, msg: ByteArray) {
+    let m = deploy_messaging_composer();
+
+    start_cheat_caller_address(m.messaging_composer, from);
+    m.dispatcher.send_compose(m.target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(m.messaging_composer);
+
+    let stored = m.dispatcher.get_compose_queue(from, m.target_address, guid, index);
+    let expected = keccak256(@msg);
+    assert(stored == expected, 'hash mismatch');
+
+    // default read for unknown key should be zero
+    let unknown: Bytes32 = m
+        .dispatcher
+        .get_compose_queue(from, m.target_address, guid, index + 1_u16);
+    assert(unknown == EMPTY_PAYLOAD_HASH, 'unknown key should return 0');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn lz_compose_without_prior_send_fails(
+    from: ContractAddress, guid: Bytes32, index: u16, msg: ByteArray,
+) {
+    let m = deploy_messaging_composer();
+    use layerzero::endpoint::messaging_composer::interface::IMessagingComposerSafeDispatcher;
+    let safe = IMessagingComposerSafeDispatcher { contract_address: m.messaging_composer };
+
+    let res = safe
+        .lz_compose(from, m.target_address, guid, index, msg.clone(), Default::default(), 0_u256);
+    let expected_hash = EMPTY_PAYLOAD_HASH;
+    let actual_hash = keccak256(@msg);
+    assert_panic_with_error(res, err_lz_compose_not_found(expected_hash, actual_hash));
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn zero_value_requires_no_allowance(
+    from: ContractAddress, executor: ContractAddress, guid: Bytes32, index: u16, msg: ByteArray,
+) {
+    let m = deploy_messaging_composer();
+
+    start_cheat_caller_address(m.messaging_composer, from);
+    m.dispatcher.send_compose(m.target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(m.messaging_composer);
+
+    start_cheat_caller_address(m.messaging_composer, executor);
+    let mut spy = spy_events();
+    m
+        .dispatcher
+        .lz_compose(from, m.target_address, guid, index, msg.clone(), Default::default(), 0_u256);
+    stop_cheat_caller_address(m.messaging_composer);
+
+    // queue should now be RECEIVED_MESSAGE_HASH (1)
+    let q = m.dispatcher.get_compose_queue(from, m.target_address, guid, index);
+    let received_sentinel = Bytes32 { value: 0x1 };
+    assert(q == received_sentinel, 'expected received sentinel');
+
+    // delivered event should be emitted
+    let expected_event = MockMessagingComposer::Event::MessagingComposerEvent(
+        MessagingComposerComponent::Event::ComposeDelivered(
+            ComposeDelivered { from, to: m.target_address, guid, index },
+        ),
+    );
+    spy.assert_emitted(@array![(m.messaging_composer, expected_event)]);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn value_equals_allowance_succeeds(
+    from: ContractAddress,
+    executor: ContractAddress,
+    guid: Bytes32,
+    index: u16,
+    msg: ByteArray,
+    value: u256,
+) {
+    let v: u256 = (value % 1_000_000_u256) + 1_u256;
+    let m = deploy_messaging_composer();
+
+    start_cheat_caller_address(m.messaging_composer, from);
+    m.dispatcher.send_compose(m.target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(m.messaging_composer);
+
+    // mint and approve from executor (caller)
+    mint_and_approve_for_executor(m.token_dispatcher, executor, m.messaging_composer, v);
+
+    // record balances
+    let token = IERC20Dispatcher { contract_address: m.token_dispatcher.contract_address };
+    let to_before = token.balance_of(m.target_address);
+    let exec_before = token.balance_of(executor);
+
+    start_cheat_caller_address(m.messaging_composer, executor);
+    m
+        .dispatcher
+        .lz_compose(from, m.target_address, guid, index, msg.clone(), Default::default(), v);
+    stop_cheat_caller_address(m.messaging_composer);
+
+    let q = m.dispatcher.get_compose_queue(from, m.target_address, guid, index);
+    let received_sentinel = Bytes32 { value: 0x1 };
+    assert(q == received_sentinel, 'expected received sentinel');
+
+    // verify balances and target last_value
+    let to_after = token.balance_of(m.target_address);
+    let exec_after = token.balance_of(executor);
+    assert(to_after == to_before + v, 'to recv value');
+    assert(exec_after + v == exec_before, 'exec paid value');
+    let last_v = m.target_inspect.last_value();
+    assert(last_v == v, 'last_value == value');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn lz_compose_cannot_be_replayed(
+    from: ContractAddress,
+    executor: ContractAddress,
+    guid: Bytes32,
+    index: u16,
+    msg: ByteArray,
+    value: u256,
+) {
+    let v: u256 = (value % 1_000_000_u256) + 1_u256;
+    let m = deploy_messaging_composer();
+
+    // initial send
+    start_cheat_caller_address(m.messaging_composer, from);
+    m.dispatcher.send_compose(m.target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(m.messaging_composer);
+
+    // mint and approve exact value from executor (caller)
+    mint_and_approve_for_executor(m.token_dispatcher, executor, m.messaging_composer, v);
+
+    // deliver once
+    start_cheat_caller_address(m.messaging_composer, executor);
+    m
+        .dispatcher
+        .lz_compose(from, m.target_address, guid, index, msg.clone(), Default::default(), v);
+    stop_cheat_caller_address(m.messaging_composer);
+
+    // queue must be sentinel
+    let q = m.dispatcher.get_compose_queue(from, m.target_address, guid, index);
+    let received_sentinel = Bytes32 { value: 0x1 };
+    assert(q == received_sentinel, 'expected received sentinel');
+
+    // replay fails with not found
+    let safe = IMessagingComposerSafeDispatcher { contract_address: m.messaging_composer };
+    let res = safe
+        .lz_compose(from, m.target_address, guid, index, msg.clone(), Default::default(), v);
+    let expected_hash = received_sentinel;
+    let actual_hash = keccak256(@msg);
+    assert_panic_with_error(res, err_lz_compose_not_found(expected_hash, actual_hash));
+
+    // re-sending compose with same key should fail (exists)
+    start_cheat_caller_address(m.messaging_composer, from);
+    let res2 = safe.send_compose(m.target_address, guid, index, Default::default());
+    stop_cheat_caller_address(m.messaging_composer);
+    assert_panic_with_error(res2, err_lz_compose_already_exists());
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn different_senders_and_targets_are_isolated(
+    from1: ContractAddress, from2: ContractAddress, guid: Bytes32, index: u16, msg: ByteArray,
+) {
+    let m = deploy_messaging_composer();
+
+    // sender 1 queues to target A
+    start_cheat_caller_address(m.messaging_composer, from1);
+    m.dispatcher.send_compose(m.target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(m.messaging_composer);
+
+    // sender 2 can queue same key independently
+    start_cheat_caller_address(m.messaging_composer, from2);
+    m.dispatcher.send_compose(m.target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(m.messaging_composer);
+
+    // different target isolation: same from/guid/index but new target
+    let m2 = deploy_messaging_composer();
+    start_cheat_caller_address(m2.messaging_composer, from1);
+    m2.dispatcher.send_compose(m2.target_address, guid, index, msg.clone());
+    stop_cheat_caller_address(m2.messaging_composer);
+
+    // all queues should be non-zero and independent
+    let q1: Bytes32 = m.dispatcher.get_compose_queue(from1, m.target_address, guid, index);
+    let q2: Bytes32 = m.dispatcher.get_compose_queue(from2, m.target_address, guid, index);
+    let q3: Bytes32 = m2.dispatcher.get_compose_queue(from1, m2.target_address, guid, index);
+    assert(
+        q1 != EMPTY_PAYLOAD_HASH && q2 != EMPTY_PAYLOAD_HASH && q3 != EMPTY_PAYLOAD_HASH,
+        'queues should be populated',
+    );
+    assert(q1 == q2 && q1 == q3, 'hashes match');
+}
+

package/layerzero/tests/endpoint/messaging_composer/utils.cairo

@@ -0,0 +1,75 @@
+//! Messaging composer test utils
+
+use layerzero::endpoint::messaging_composer::interface::{
+    IMessagingComposerDispatcher, IMessagingComposerSafeDispatcher,
+};
+use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+use snforge_std::{
+    ContractClassTrait, DeclareResultTrait, declare, start_cheat_caller_address,
+    stop_cheat_caller_address,
+};
+use starknet::ContractAddress;
+use crate::mocks::composer_target::MockComposerTarget::IMockComposerTargetInspectDispatcher;
+use crate::mocks::erc20::interface::{IMockERC20Dispatcher, IMockERC20DispatcherTrait};
+
+pub(crate) struct MessagingComposerMock {
+    pub messaging_composer: ContractAddress,
+    pub dispatcher: IMessagingComposerDispatcher,
+    pub safe_dispatcher: IMessagingComposerSafeDispatcher,
+    pub token_dispatcher: IERC20Dispatcher,
+    pub target_address: ContractAddress,
+    pub target_inspect: IMockComposerTargetInspectDispatcher,
+}
+
+pub(crate) fn deploy_mock_erc20() -> (IERC20Dispatcher, ContractAddress) {
+    let contract = declare("MockERC20").unwrap().contract_class();
+    let initial_supply: u256 = 1_000_000_000_000_000_000_u256;
+    let recipient: ContractAddress = 0x111.try_into().unwrap();
+    let mut calldata = array![];
+    initial_supply.serialize(ref calldata);
+    recipient.serialize(ref calldata);
+    let (contract_address, _) = contract.deploy(@calldata).unwrap();
+    (IERC20Dispatcher { contract_address }, contract_address)
+}
+
+pub(crate) fn deploy_messaging_composer() -> MessagingComposerMock {
+    let (token_dispatcher, token_address) = deploy_mock_erc20();
+
+    // Deploy a mock composer target to receive lz_compose calls, though tests can also mock it.
+    let target = declare("MockComposerTarget").unwrap().contract_class();
+    let (target_address, _) = target.deploy(@array![]).unwrap();
+
+    let contract = declare("MockMessagingComposer").unwrap().contract_class();
+    let constructor_args = array![token_address.into()];
+    let (contract_address, _) = contract.deploy(@constructor_args).unwrap();
+
+    MessagingComposerMock {
+        messaging_composer: contract_address,
+        dispatcher: IMessagingComposerDispatcher { contract_address },
+        safe_dispatcher: IMessagingComposerSafeDispatcher { contract_address },
+        token_dispatcher,
+        target_address,
+        target_inspect: IMockComposerTargetInspectDispatcher { contract_address: target_address },
+    }
+}
+
+/// Mint `amount` tokens to `executor` and approve `spender` to spend `amount` from `executor`.
+///
+/// This helper mirrors the repeated test setup where the executor funds itself and
+/// grants allowance to the messaging composer before calling `lz_compose`.
+pub(crate) fn mint_and_approve_for_executor(
+    token_dispatcher: IERC20Dispatcher,
+    executor: ContractAddress,
+    spender: ContractAddress,
+    amount: u256,
+) {
+    let mock_token = IMockERC20Dispatcher { contract_address: token_dispatcher.contract_address };
+    start_cheat_caller_address(mock_token.contract_address, executor);
+    mock_token.mint(executor, amount);
+    stop_cheat_caller_address(mock_token.contract_address);
+
+    start_cheat_caller_address(token_dispatcher.contract_address, executor);
+    token_dispatcher.approve(spender, amount);
+    stop_cheat_caller_address(token_dispatcher.contract_address);
+}
+