@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/e2e/utils.cairo

@@ -0,0 +1,490 @@
+//! Shared helpers for E2E tests
+
+use core::panic_with_felt252;
+use layerzero::common::constants::{DEFAULT_BPS, MAX_V1_EID};
+use layerzero::endpoint::endpoint::Endpoint;
+use layerzero::endpoint::interfaces::endpoint::IEndpointDispatcher;
+use layerzero::endpoint::message_lib_manager::interface::{
+    IMessageLibManagerDispatcher, IMessageLibManagerDispatcherTrait,
+};
+use layerzero::message_lib::interface::{IMessageLibDispatcher, IMessageLibSafeDispatcher};
+use layerzero::message_lib::sml::simple_message_lib::SimpleMessageLib::{
+    ISimpleMessageLibHelpersDispatcher, ISimpleMessageLibHelpersDispatcherTrait,
+};
+use layerzero::message_lib::uln::interface::{
+    IUltraLightNodeAdminDispatcher, IUltraLightNodeAdminDispatcherTrait,
+};
+use layerzero::message_lib::uln::structs::executor_config::ExecutorConfig;
+use layerzero::message_lib::uln::structs::uln_config::{SetDefaultUlnConfigParam, UlnConfig};
+use layerzero::oapps::counter::interface::IOmniCounterDispatcher;
+use layerzero::oapps::oapp::interface::IOAppDispatcher;
+use layerzero::treasury::interfaces::treasury_admin::{
+    ITreasuryAdminDispatcher, ITreasuryAdminDispatcherTrait,
+};
+use layerzero::workers::base::interface::{IWorkerBaseDispatcher, IWorkerBaseDispatcherTrait};
+use layerzero::workers::dvn::interface::{IDvnDispatcher, IDvnDispatcherTrait};
+use layerzero::workers::dvn::structs::{
+    DstConfig as DvnDstConfig, SetDstConfigParams as DvnSetDstConfigParams,
+};
+use layerzero::workers::executor;
+use layerzero::workers::executor::interface::{IExecutorDispatcher, IExecutorDispatcherTrait};
+use layerzero::workers::executor::structs::{
+    DstConfig as ExecutorDstConfig, ExecutorOption, LzComposeOption, LzReceiveOption,
+    SetDstConfigParams as ExecutorSetDstConfigParams,
+};
+use layerzero::workers::price_feed::interface::{
+    ILayerZeroPriceFeedDispatcher, ILayerZeroPriceFeedDispatcherTrait, IPriceFeedDispatcher,
+    IPriceFeedDispatcherTrait,
+};
+use openzeppelin::token::erc20::interface::IERC20Dispatcher;
+use snforge_std::{
+    ContractClassTrait, DeclareResultTrait, declare, start_cheat_caller_address,
+    stop_cheat_caller_address,
+};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::cheat_caller_address_once;
+use crate::fuzzable::blockchain_config::BlockchainConfig;
+use crate::mocks::composer_target::MockComposerTarget::IMockComposerTargetInspectDispatcher;
+use crate::mocks::erc20::interface::IMockERC20Dispatcher;
+use crate::workers::dvn::fee_lib::test_dvn_fee_lib::deploy_dvn_fee_lib;
+use crate::workers::dvn::utils::{KeyPair, deploy_dvn_with_all_data};
+use crate::workers::executor::fee_lib::test_executor_fee_lib::deploy_executor_fee_lib;
+
+pub const DEFAULT_MULTIPLIER_BPS: u16 = DEFAULT_BPS.try_into().unwrap();
+
+pub const DEFAULT_EXECUTOR_DST_CONFIG: ExecutorDstConfig = ExecutorDstConfig {
+    lz_receive_base_gas: 100_000,
+    lz_compose_base_gas: 100_000,
+    multiplier_bps: DEFAULT_MULTIPLIER_BPS,
+    floor_margin_usd: 0,
+    native_cap: 10_000_000_000_000_000_000 // 10 STRK
+};
+
+pub const DEFAULT_DVN_DST_CONFIG: DvnDstConfig = DvnDstConfig {
+    gas: 100_000, multiplier_bps: DEFAULT_MULTIPLIER_BPS, floor_margin_usd: 0,
+};
+
+pub fn deploy_blocked_message_lib() -> ContractAddress {
+    let contract = declare("BlockedMessageLib").unwrap().contract_class();
+    let (contract_address, _) = contract.deploy(@array![]).unwrap();
+    contract_address
+}
+
+#[derive(Drop)]
+pub struct ERC20Helper {
+    pub address: ContractAddress,
+    pub erc20: IERC20Dispatcher,
+    pub mock_erc20: IMockERC20Dispatcher,
+}
+
+pub fn deploy_erc20(supply: u256, owner: ContractAddress) -> ERC20Helper {
+    let contract = declare("MockERC20").unwrap().contract_class();
+    let mut params = array![];
+    supply.serialize(ref params);
+    owner.serialize(ref params);
+
+    let (address, _) = contract.deploy(@params).unwrap();
+
+    ERC20Helper {
+        address,
+        erc20: IERC20Dispatcher { contract_address: address },
+        mock_erc20: IMockERC20Dispatcher { contract_address: address },
+    }
+}
+
+#[derive(Drop)]
+pub struct EndpointHelper {
+    pub address: ContractAddress,
+    pub endpoint: IEndpointDispatcher,
+    pub message_lib_manager: IMessageLibManagerDispatcher,
+}
+
+pub fn deploy_endpoint(
+    owner: ContractAddress, eid: u32, native_token: ContractAddress,
+) -> EndpointHelper {
+    let blocked_library = deploy_blocked_message_lib();
+    let contract = declare("Endpoint").unwrap().contract_class();
+    let (address, _) = contract
+        .deploy(@array![owner.into(), eid.into(), native_token.into(), blocked_library.into()])
+        .unwrap();
+
+    EndpointHelper {
+        address,
+        endpoint: IEndpointDispatcher { contract_address: address },
+        message_lib_manager: IMessageLibManagerDispatcher { contract_address: address },
+    }
+}
+
+#[derive(Drop)]
+pub struct SimpleMessageLibHelper {
+    pub address: ContractAddress,
+    pub message_lib: IMessageLibDispatcher,
+    pub simple_message_lib_helpers: ISimpleMessageLibHelpersDispatcher,
+}
+
+pub fn deploy_simple_message_lib(endpoint: ContractAddress) -> SimpleMessageLibHelper {
+    let contract = declare("SimpleMessageLib").unwrap().contract_class();
+    let (address, _) = contract.deploy(@array![endpoint.into()]).unwrap();
+    let simple_message_lib_helpers = ISimpleMessageLibHelpersDispatcher {
+        contract_address: address,
+    };
+
+    simple_message_lib_helpers.set_use_mock_payees();
+
+    SimpleMessageLibHelper {
+        address,
+        message_lib: IMessageLibDispatcher { contract_address: address },
+        simple_message_lib_helpers,
+    }
+}
+
+#[derive(Drop)]
+pub struct OmniCounterHelper {
+    pub address: ContractAddress,
+    pub oapp: IOAppDispatcher,
+    pub omni_counter: IOmniCounterDispatcher,
+}
+
+pub fn deploy_omni_counter(
+    endpoint: ContractAddress, owner: ContractAddress, token: ContractAddress,
+) -> OmniCounterHelper {
+    let contract = declare("OmniCounter").unwrap().contract_class();
+    let (address, _) = contract
+        .deploy(@array![endpoint.into(), owner.into(), token.into()])
+        .unwrap();
+
+    OmniCounterHelper {
+        address,
+        oapp: IOAppDispatcher { contract_address: address },
+        omni_counter: IOmniCounterDispatcher { contract_address: address },
+    }
+}
+
+#[derive(Drop)]
+pub struct TreasuryHelper {
+    pub address: ContractAddress,
+    pub treasury_admin: ITreasuryAdminDispatcher,
+}
+
+pub fn deploy_treasury(owner: ContractAddress, native_fee_bp: u256) -> TreasuryHelper {
+    let contract = declare("Treasury").unwrap().contract_class();
+    let (address, _) = contract.deploy(@array![owner.into()]).unwrap();
+    let dispatcher = layerzero::treasury::interfaces::treasury_admin::ITreasuryAdminDispatcher {
+        contract_address: address,
+    };
+
+    cheat_caller_address_once(address, owner);
+    dispatcher.set_fee_bp(native_fee_bp);
+
+    TreasuryHelper {
+        address, treasury_admin: ITreasuryAdminDispatcher { contract_address: address },
+    }
+}
+
+#[derive(Drop)]
+pub struct ExecutorHelper {
+    pub address: ContractAddress,
+    pub executor: IExecutorDispatcher,
+    pub worker_base: IWorkerBaseDispatcher,
+}
+
+pub fn deploy_executor(
+    endpoint: ContractAddress,
+    message_lib: ContractAddress,
+    price_feed: ContractAddress,
+    role_admin: ContractAddress,
+    admins: Array<ContractAddress>,
+    native_token: ContractAddress,
+    owner: ContractAddress,
+    dst_config: ExecutorDstConfig,
+    remote_eid: u32,
+) -> ExecutorHelper {
+    let mut calldata = array![];
+    endpoint.serialize(ref calldata);
+    array![message_lib].span().serialize(ref calldata);
+    price_feed.serialize(ref calldata);
+    DEFAULT_MULTIPLIER_BPS.serialize(ref calldata);
+    role_admin.serialize(ref calldata);
+    admins.serialize(ref calldata);
+    native_token.serialize(ref calldata);
+    owner.serialize(ref calldata);
+
+    let contract = declare("Executor").unwrap().contract_class();
+    let (address, _) = contract.deploy(@calldata).unwrap();
+
+    let fee_lib = deploy_executor_fee_lib(remote_eid, owner).fee_lib;
+    let worker_base = IWorkerBaseDispatcher { contract_address: address };
+    let executor = IExecutorDispatcher { contract_address: address };
+
+    cheat_caller_address_once(address, *admins[0]);
+    worker_base.set_worker_fee_lib(fee_lib);
+    cheat_caller_address_once(address, *admins[0]);
+    executor
+        .set_dst_config(
+            array![ExecutorSetDstConfigParams { dst_eid: remote_eid, config: dst_config }],
+        );
+
+    ExecutorHelper { address, executor, worker_base }
+}
+
+#[derive(Drop)]
+pub struct DvnHelper {
+    pub address: ContractAddress,
+    pub dvn: IDvnDispatcher,
+    pub worker_base: IWorkerBaseDispatcher,
+    pub vid: u32,
+}
+
+pub fn deploy_dvn(
+    message_lib: ContractAddress,
+    price_feed: ContractAddress,
+    vid: u32,
+    signers: @Array<KeyPair>,
+    role_admin: ContractAddress,
+    admins: Span<ContractAddress>,
+    owner: ContractAddress,
+    dst_config: DvnDstConfig,
+    remote_eid: u32,
+) -> DvnHelper {
+    let multisig_threshold = signers.len();
+    let address = deploy_dvn_with_all_data(
+        vid,
+        array![message_lib].span(),
+        price_feed,
+        DEFAULT_MULTIPLIER_BPS,
+        signers.span().into_iter().map(|pair| *pair.public_address).collect(),
+        multisig_threshold,
+        role_admin,
+        admins,
+    )
+        .dvn;
+    let fee_lib = deploy_dvn_fee_lib(remote_eid, owner).fee_lib;
+    let worker_base = IWorkerBaseDispatcher { contract_address: address };
+    let dvn = IDvnDispatcher { contract_address: address };
+
+    cheat_caller_address_once(address, *admins[0]);
+    worker_base.set_worker_fee_lib(fee_lib);
+    cheat_caller_address_once(address, *admins[0]);
+    dvn.set_dst_config(array![DvnSetDstConfigParams { dst_eid: remote_eid, config: dst_config }]);
+
+    DvnHelper { address, dvn, worker_base, vid }
+}
+
+#[derive(Drop)]
+pub struct UltraLightNodeHelper {
+    pub address: ContractAddress,
+    pub message_lib: IMessageLibDispatcher,
+    pub safe_message_lib: IMessageLibSafeDispatcher,
+    pub ultra_light_node_admin: IUltraLightNodeAdminDispatcher,
+}
+
+pub fn deploy_ultra_light_node(
+    owner: ContractAddress,
+    treasury: ContractAddress,
+    endpoint: ContractAddress,
+    treasury_native_fee_cap: u256,
+) -> UltraLightNodeHelper {
+    let contract = declare("UltraLightNode").unwrap().contract_class();
+    let mut calldata = array![owner.into(), treasury.into(), endpoint.into()];
+    treasury_native_fee_cap.serialize(ref calldata);
+    let (address, _) = contract.deploy(@calldata).unwrap();
+
+    UltraLightNodeHelper {
+        address,
+        message_lib: IMessageLibDispatcher { contract_address: address },
+        safe_message_lib: IMessageLibSafeDispatcher { contract_address: address },
+        ultra_light_node_admin: IUltraLightNodeAdminDispatcher { contract_address: address },
+    }
+}
+
+/// Deploy and initialize a minimal price feed used by DVN/Executor fee libs
+pub fn deploy_price_feed(owner: ContractAddress, remote_eid: u32) -> ContractAddress {
+    use layerzero::workers::price_feed::structs::{
+        ModelType, Price, SetEidToModelTypeParam, SetPriceParam,
+    };
+
+    let remote_eid = remote_eid % MAX_V1_EID;
+
+    let contract = declare("PriceFeed").unwrap().contract_class();
+    let (address, _) = contract.deploy(@array![owner.into(), owner.into()]).unwrap();
+
+    let price_ratio_denominator = ILayerZeroPriceFeedDispatcher { contract_address: address }
+        .get_price_ratio_denominator();
+
+    let price_feed = IPriceFeedDispatcher { contract_address: address };
+    start_cheat_caller_address(address, owner);
+    price_feed.set_native_price_usd(1);
+    price_feed
+        .set_eid_to_model_type(
+            array![SetEidToModelTypeParam { eid: remote_eid, model_type: ModelType::DEFAULT }],
+        );
+    price_feed
+        .set_price(
+            array![
+                SetPriceParam {
+                    eid: remote_eid,
+                    price: Price {
+                        price_ratio: price_ratio_denominator, gas_price_in_unit: 1, gas_per_byte: 1,
+                    },
+                },
+            ],
+        );
+    stop_cheat_caller_address(address);
+
+    address
+}
+
+#[derive(Drop)]
+pub struct MockComposerTargetHelper {
+    pub address: ContractAddress,
+    pub composer_target_inspect: IMockComposerTargetInspectDispatcher,
+}
+
+pub fn deploy_mock_composer_target() -> MockComposerTargetHelper {
+    let target = declare("MockComposerTarget").unwrap().contract_class();
+    let (address, _) = target.deploy(@array![]).unwrap();
+
+    MockComposerTargetHelper {
+        address,
+        composer_target_inspect: IMockComposerTargetInspectDispatcher { contract_address: address },
+    }
+}
+
+pub fn wire_ultra_light_node(
+    uln_owner: ContractAddress,
+    message_lib: @UltraLightNodeHelper,
+    remote_eid: u32,
+    uln_config: UlnConfig,
+    executor_config: ExecutorConfig,
+) {
+    start_cheat_caller_address(*message_lib.address, uln_owner);
+
+    message_lib
+        .ultra_light_node_admin
+        .set_default_uln_send_config(
+            array![SetDefaultUlnConfigParam { eid: remote_eid, config: uln_config.clone() }],
+        );
+    message_lib
+        .ultra_light_node_admin
+        .set_default_uln_receive_config(
+            array![SetDefaultUlnConfigParam { eid: remote_eid, config: uln_config }],
+        );
+
+    message_lib.ultra_light_node_admin.set_default_executor_config(remote_eid, executor_config);
+
+    stop_cheat_caller_address(*message_lib.address);
+}
+
+pub fn decode_packet_on_endpoint(event: @snforge_std::Event) -> (ByteArray, ByteArray) {
+    let mut keys = event.keys.span();
+    let mut data = event.data.span();
+    let event: Endpoint::Event = starknet::Event::deserialize(ref keys, ref data).unwrap();
+
+    match event {
+        Endpoint::Event::PacketSent(event) => (event.encoded_packet, event.options),
+        _ => panic_with_felt252('unexpected event on endpoint'),
+    }
+}
+
+#[derive(Drop)]
+pub struct BlockchainOptions {
+    pub dvn_dst_config: DvnDstConfig,
+    pub treasury_native_fee_cap: u256,
+}
+
+#[derive(Drop)]
+pub struct Blockchain {
+    pub native_token: ERC20Helper,
+    pub endpoint: EndpointHelper,
+    pub message_lib: UltraLightNodeHelper,
+    pub treasury: TreasuryHelper,
+    pub executor: ExecutorHelper,
+    pub dvn: DvnHelper,
+    pub price_feed: ContractAddress,
+}
+
+pub fn setup_layer_zero(
+    config: @BlockchainConfig, options: BlockchainOptions, remote_eid: u32,
+) -> Blockchain {
+    let native_token = deploy_erc20(*config.native_token_supply, *config.native_token_owner);
+    let endpoint = deploy_endpoint(*config.endpoint_owner, *config.eid.eid, native_token.address);
+    let treasury = deploy_treasury(*config.treasury_owner, DEFAULT_BPS);
+    let message_lib = deploy_ultra_light_node(
+        *config.message_lib_owner,
+        treasury.address,
+        endpoint.address,
+        options.treasury_native_fee_cap,
+    );
+
+    cheat_caller_address_once(endpoint.address, *config.endpoint_owner);
+    endpoint.message_lib_manager.register_library(message_lib.address);
+
+    let price_feed = deploy_price_feed(*config.price_feed_owner, remote_eid);
+
+    let executor = deploy_executor(
+        endpoint.address,
+        message_lib.address,
+        price_feed,
+        *config.executor_role_admin,
+        array![*config.executor_admin],
+        native_token.address,
+        *config.executor_owner,
+        DEFAULT_EXECUTOR_DST_CONFIG,
+        remote_eid,
+    );
+    let dvn = deploy_dvn(
+        message_lib.address,
+        price_feed,
+        *config.dvn_vid,
+        config.dvn_signers,
+        *config.dvn_role_admin,
+        array![*config.dvn_admin].span(),
+        *config.dvn_owner,
+        options.dvn_dst_config,
+        remote_eid,
+    );
+
+    Blockchain { native_token, endpoint, message_lib, treasury, executor, dvn, price_feed }
+}
+
+#[derive(Debug, Drop)]
+pub struct DecodedExecutorOptions {
+    pub receive: @LzReceiveOption,
+    pub compose: Array<@LzComposeOption>,
+}
+
+pub fn decode_executor_options(options: @ByteArray) -> DecodedExecutorOptions {
+    let options = executor::options::_parse_options_to_array(options);
+
+    DecodedExecutorOptions {
+        receive: {
+            let mut options = options.span().into_iter();
+            let mut options = options
+                .map(
+                    |option| if let ExecutorOption::LzReceive(option) = option {
+                        Some(option)
+                    } else {
+                        None
+                    },
+                )
+                .filter(|option| option.is_some());
+
+            options.next().unwrap().unwrap()
+        },
+        compose: {
+            let mut options = options.span().into_iter();
+
+            options
+                .map(
+                    |option| if let ExecutorOption::LzCompose(option) = option {
+                        Some(option)
+                    } else {
+                        None
+                    },
+                )
+                .filter(|option| option.is_some())
+                .map(|option| option.unwrap())
+                .collect()
+        },
+    }
+}