@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/src/workers/dvn/fee_lib/dvn_fee_lib.cairo

@@ -0,0 +1,152 @@
+//! DVN Fee Library contract implementation
+
+/// DVN Fee Library contract
+///
+/// This contract handles fee calculations for DVN operations, separated from the main DVN logic
+/// to provide modularity and easier maintenance of fee-related functionality.
+#[starknet::contract]
+pub mod DvnFeeLib {
+    use openzeppelin::access::ownable::OwnableComponent;
+    use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use starknet::ContractAddress;
+    use starknet::storage::StoragePointerWriteAccess;
+    use starkware_utils::errors::assert_with_byte_array;
+    use crate::workers::common::apply_premium_and_floor_margin;
+    use crate::workers::dvn::constants::{EXECUTE_FIXED_BYTES, SIGNATURE_RAW_BYTES, VERIFY_BYTES};
+    use crate::workers::dvn::errors;
+    use crate::workers::dvn::fee_lib::interface::{FeeParams, IDvnFeeLib};
+    use crate::workers::dvn::structs::DstConfig;
+    use crate::workers::price_feed::interface::{
+        ILayerZeroPriceFeedDispatcher, ILayerZeroPriceFeedDispatcherTrait,
+    };
+
+    ////////////////
+    // Components //
+    ////////////////
+
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+
+    ////////////////
+    // Embeddings //
+    ////////////////
+
+    #[abi(embed_v0)]
+    impl OwnableImpl = OwnableComponent::OwnableImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+        /// Local endpoint ID v2
+        local_eid_v2: u32,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, local_eid_v2: u32, owner: ContractAddress) {
+        // Initialize ownable component
+        self.ownable.initializer(owner);
+
+        // Set immutable values
+        self.local_eid_v2.write(local_eid_v2);
+    }
+
+    #[abi(embed_v0)]
+    impl DvnFeeLibImpl of IDvnFeeLib<ContractState> {
+        // ================================== Only Owner =====================================
+
+        fn withdraw_token(
+            ref self: ContractState,
+            token_address: ContractAddress,
+            to: ContractAddress,
+            amount: u256,
+        ) {
+            self.ownable.assert_only_owner();
+            let token_dispatcher = IERC20Dispatcher { contract_address: token_address };
+
+            // NOTE: (from https://docs.openzeppelin.com/contracts-cairo/1.0.0/erc20)
+            // transfer, transfer_from and approve will never return anything different from true
+            // because they will revert on any error.
+            token_dispatcher.transfer(to, amount);
+        }
+
+        // ================================== External =====================================
+
+        fn get_fee_on_send(
+            ref self: ContractState, params: FeeParams, dst_config: DstConfig, options: ByteArray,
+        ) -> u256 {
+            self.get_fee(params, dst_config, options)
+        }
+
+        // ================================== View =====================================
+
+        fn get_fee(
+            self: @ContractState, params: FeeParams, dst_config: DstConfig, options: ByteArray,
+        ) -> u256 {
+            // Check if destination is supported
+            assert_with_byte_array(
+                dst_config.gas > 0, errors::err_eid_not_supported(params.dst_eid),
+            );
+
+            // Validate options (currently just check it's empty like in original DVN)
+            assert_with_byte_array(options.len() == 0, errors::err_invalid_dvn_options(0));
+
+            // NOTE: Deviation from EVM spec, we don't parse the DVN options here because
+            // They're only used in pre-crime and the value is not actually used.
+            // Therefore don't currently see the value in implementing the parsing logic here.
+
+            // Calculate call data size
+            let calldata_size = self._get_calldata_size(params.quorum);
+
+            // Get price feed estimate
+            let price_feed = ILayerZeroPriceFeedDispatcher { contract_address: params.price_feed };
+            let estimated_fee = price_feed
+                .estimate_fee_on_send(params.dst_eid, calldata_size, dst_config.gas.into());
+
+            // Apply premium and return
+            apply_premium_and_floor_margin(
+                estimated_fee.gas_fee,
+                dst_config.multiplier_bps,
+                params.default_multiplier_bps,
+                dst_config.floor_margin_usd,
+                estimated_fee.native_price_usd,
+            )
+        }
+
+        fn version(self: @ContractState) -> (u64, u8) {
+            (1, 1)
+        }
+    }
+
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        /// Get the call data size for the quote function
+        ///
+        /// # Arguments
+        ///
+        /// * `quorum` - The quorum for the multisig
+        ///
+        /// # Returns
+        ///
+        /// * `u32` - The call data size given the quorum amount of signatures
+        fn _get_calldata_size(self: @ContractState, quorum: u32) -> u32 {
+            const NUM_BYTES: u32 = 32;
+            let mut total_signatures_bytes = quorum * SIGNATURE_RAW_BYTES.into();
+
+            if total_signatures_bytes % NUM_BYTES != 0 {
+                total_signatures_bytes = total_signatures_bytes
+                    - (total_signatures_bytes % NUM_BYTES)
+                    + NUM_BYTES;
+            }
+
+            EXECUTE_FIXED_BYTES + VERIFY_BYTES + total_signatures_bytes + NUM_BYTES
+        }
+    }
+}

package/layerzero/src/workers/dvn/fee_lib/interface.cairo

@@ -0,0 +1,45 @@
+//! DVN Fee Lib interface
+
+use starknet::ContractAddress;
+use crate::workers::dvn::structs::DstConfig;
+
+/// Fee parameters for DVN fee calculation
+#[derive(Drop, Clone, Serde)]
+pub struct FeeParams {
+    pub price_feed: ContractAddress,
+    pub dst_eid: u32,
+    pub confirmations: u64,
+    pub sender: ContractAddress,
+    pub quorum: u32,
+    pub default_multiplier_bps: u16,
+}
+
+/// Interface for DVN Fee Library
+#[starknet::interface]
+pub trait IDvnFeeLib<TContractState> {
+    // ================================== Only Owner =====================================
+
+    /// Withdraw tokens from the fee lib
+    /// Enables recovery of funds accidentally sent
+    fn withdraw_token(
+        ref self: TContractState, token_address: ContractAddress, to: ContractAddress, amount: u256,
+    );
+
+    // ================================== External =====================================
+
+    /// Get fee function that can change state (e.g. paying price feed)
+    fn get_fee_on_send(
+        ref self: TContractState, params: FeeParams, dst_config: DstConfig, options: ByteArray,
+    ) -> u256;
+
+    // ================================== View =====================================
+
+    /// Get fee view function
+    fn get_fee(
+        self: @TContractState, params: FeeParams, dst_config: DstConfig, options: ByteArray,
+    ) -> u256;
+
+    /// Get version
+    /// Returns (major, minor)
+    fn version(self: @TContractState) -> (u64, u8);
+}

package/layerzero/src/workers/dvn/interface.cairo

@@ -0,0 +1,131 @@
+//! DVN interface
+
+use lz_utils::bytes::Bytes32;
+use starknet::ClassHash;
+use starknet::account::Call;
+use crate::workers::dvn::structs::{DstConfig, ExecuteParam, SetDstConfigParams};
+
+/// Interface for the DVN contract
+#[starknet::interface]
+pub trait IDvn<TContractState> {
+    // ================================== Only Admin =====================================
+
+    /// Set the destination configurations for multiple EIDs
+    ///
+    /// # Arguments
+    ///
+    /// * `params` - Array of parameters for setting the destination configuration
+    ///
+    /// # Access Control
+    ///
+    /// * Only admins can call this function
+    ///
+    /// # Events
+    ///
+    /// * `DstConfigSet` - Emitted when the destination configuration is set
+    fn set_dst_config(ref self: TContractState, params: Array<SetDstConfigParams>);
+
+    /// Execute jobs
+    ///
+    /// # Arguments
+    ///
+    /// * `params` - Array of parameters for executing the jobs
+    ///
+    /// # Access Control
+    ///
+    /// * Only admins can call this function
+    ///
+    /// # Events
+    ///
+    /// * `VerifySignaturesFailed` - Emitted when the signatures verification fails
+    /// * `HashAlreadyUsed` - Emitted when the hash is already used
+    /// * `ExecuteFailed` - Emitted when the job execution fails
+    fn execute(ref self: TContractState, params: Array<ExecuteParam>);
+
+    // ================================== Only Quorum =====================================
+
+    /// Function for quorum to change the admin without going through the execute function
+    ///
+    /// # Arguments
+    ///
+    /// * `param` - Parameter for changing the admin
+    ///
+    /// # Access Control
+    ///
+    /// * Anyone can call this function, but it will only succeed with a quorum of signatures
+    ///
+    /// # Events
+    ///
+    /// * `RoleGranted` - Emitted when the admin role is granted (from OpenZeppelin's
+    /// [`AccessControlComponent`])
+    fn quorum_change_admin(ref self: TContractState, param: ExecuteParam);
+
+    // ================================== Only Self =====================================
+
+    /// Upgrade the contract
+    ///
+    /// # Arguments
+    ///
+    /// * `new_class_hash` - The new class hash to upgrade to
+    ///
+    /// # Events
+    ///
+    /// * `Upgraded` - Emitted when the contract is upgraded (from OpenZeppelin's
+    /// [`UpgradeableComponent`])
+    ///
+    /// @dev Only the contract itself can call this function (enforced by multisig)
+    fn upgrade(ref self: TContractState, new_class_hash: ClassHash);
+
+    /// Upgrade the contract and call a function
+    ///
+    /// # Arguments
+    ///
+    /// * `new_class_hash` - The new class hash to upgrade to
+    /// * `selector` - The selector to call
+    /// * `data` - The data to pass to the function
+    ///
+    /// # Returns
+    ///
+    /// * `Span<felt252>` - The response data from the function call
+    ///
+    /// # Events
+    ///
+    /// * `Upgraded` - Emitted when the contract is upgraded (from OpenZeppelin's
+    /// [`UpgradeableComponent`])
+    ///
+    /// @dev Only the contract itself can call this function (enforced by multisig)
+    fn upgrade_and_call(
+        ref self: TContractState,
+        new_class_hash: ClassHash,
+        selector: felt252,
+        calldata: Span<felt252>,
+    ) -> Span<felt252>;
+
+    // ================================== View ==========================================
+
+    /// Get the destination configuration
+    ///
+    /// # Arguments
+    ///
+    /// * `dst_eid` - The destination EID
+    ///
+    /// # Returns
+    ///
+    /// * `DstConfig` - The destination configuration
+    fn get_dst_config(self: @TContractState, dst_eid: u32) -> DstConfig;
+
+    /// Hash the call data
+    ///
+    /// # Arguments
+    ///
+    /// * `vid` - The VID of the call data
+    /// * `call_data` - The call data
+    /// * `expiration` - The expiration of the call data
+    ///
+    /// # Returns
+    ///
+    /// * `Bytes32` - The keccak hash of the arguments
+    fn hash_call_data(
+        self: @TContractState, vid: u32, call_data: Call, expiration: u256,
+    ) -> Bytes32;
+}

package/layerzero/src/workers/dvn/options.cairo

@@ -0,0 +1,125 @@
+//! DVN options
+
+use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+use core::byte_array::ByteArray;
+use core::dict::{Felt252Dict, Felt252DictEntryTrait};
+use core::nullable::{FromNullableResult, NullableTrait, match_nullable};
+use starkware_utils::errors::assert_with_byte_array;
+use crate::workers::dvn::errors::err_invalid_dvn_options;
+use crate::workers::dvn::structs::DvnOption;
+
+// Constants
+pub const DVN_WORKER_ID: u8 = 2;
+pub const OPTION_TYPE_PRECRIME: u8 = 1;
+
+/// Group DVN options by their index
+///
+/// # Arguments
+/// * `options` - The DVN options in format: [worker_id][dvn_option][worker_id][dvn_option]...
+///               where dvn_option = [option_size][dvn_idx][option_type][option]
+///               option_size = len(dvn_idx) + len(option_type) + len(option)
+///               worker_id: u8, dvn_idx: u8, option_size: u16, option_type: u8, option: bytes
+///
+/// # Returns
+/// * `Felt252Dict<Nullable<ByteArray>>` - The grouped options and their indices
+pub fn group_dvn_options_by_idx(options: @ByteArray) -> Felt252Dict<Nullable<ByteArray>> {
+    let mut ret: Felt252Dict<Nullable<ByteArray>> = Default::default();
+    if options.len() == 0 {
+        return ret;
+    }
+
+    let mut cursor: usize = 0;
+
+    while cursor != options.len() {
+        let DvnOption {
+            option_size, dvn_index, option_type, option_data, cursor: new_cursor,
+        } = next_dvn_option(options, cursor);
+        let option = post_process_option(option_size, dvn_index, option_type, @option_data);
+
+        // Get the existing entry for this dvn_index
+        let (entry, prev_value) = ret.entry(dvn_index.into());
+
+        // Combine the new option with any existing options for this dvn_index
+        let combined_options = match match_nullable(prev_value) {
+            FromNullableResult::Null => option,
+            FromNullableResult::NotNull(existing) => {
+                let mut result = existing.unbox();
+                result.append(@option);
+                result
+            },
+        };
+
+        // Store the combined options back in the dictionary
+        ret = entry.finalize(NullableTrait::new(combined_options));
+        cursor = new_cursor;
+    }
+
+    ret
+}
+
+/// Post-process the option - prefixes other args to the option data
+///
+/// # Arguments
+///
+/// * `option_size` - The size of the option
+///
+/// * `dvn_index` - The index of the DVN
+///
+/// * `option_type` - The type of the option (e.g. PRECRIME)
+///
+/// * `option_data` - The data of the option
+///
+/// # Returns
+///
+/// * [`ByteArray`] - The post-processed option
+pub fn post_process_option(
+    option_size: u16, dvn_index: u8, option_type: u8, option_data: @ByteArray,
+) -> ByteArray {
+    let mut result: ByteArray = Default::default();
+
+    result.append_byte(DVN_WORKER_ID);
+    result.append_u16(option_size);
+    result.append_byte(dvn_index);
+    result.append_byte(option_type);
+    result.append(option_data);
+
+    result
+}
+
+/// Decode the next DVN option from options starting from the specified cursor
+///
+/// # Arguments
+///
+/// * `options` - The DVN options byte array
+///
+/// * `cursor` - The cursor position to start decoding from
+///
+/// # Returns
+///
+/// * [`DvnOption`] - The decoded option type, option data, and new cursor position
+pub fn next_dvn_option(options: @ByteArray, cursor: usize) -> DvnOption {
+    // Ensure we have enough bytes to read worker id
+    assert_with_byte_array(cursor < options.len(), err_invalid_dvn_options(cursor));
+
+    // skip dvn_id, always equal to DVN_WORKER_ID here = 2;
+    let cursor = cursor + 1;
+
+    let (cursor, option_size) = options.read_u16(cursor);
+    assert_with_byte_array(option_size > 2, err_invalid_dvn_options(cursor));
+
+    let (cursor, dvn_index) = options.read_u8(cursor);
+    let (cursor, option_type) = options.read_u8(cursor);
+
+    // Calculate the length of just the option data (excluding dvn_index and option_type)
+    // option_length includes dvn_index (1 byte) + option_type (1 byte) + option data
+    let option_data_length = option_size - 2; // subtract 2 bytes for dvn_index and option_type
+
+    // Extract the option data
+    // let option = slice_byte_array(options, new_cursor, option_data_length.into());
+    let (_, option) = options.read_bytes(cursor, option_data_length.into());
+
+    // Calculate the final cursor position
+    let final_cursor = cursor + option_data_length.into();
+
+    DvnOption { option_size, dvn_index, option_type, option_data: option, cursor: final_cursor }
+}

package/layerzero/src/workers/dvn/structs.cairo

@@ -0,0 +1,51 @@
+//! DVN structs
+
+use starknet::account::Call;
+use starknet::secp256_trait::Signature;
+
+/// DVN option
+pub struct DvnOption {
+    /// Size of the option
+    pub option_size: u16,
+    /// Index of the DVN
+    pub dvn_index: u8,
+    /// Type of the option
+    pub option_type: u8,
+    /// Data of the option
+    pub option_data: ByteArray,
+    /// Cursor position
+    pub cursor: u32,
+}
+
+/// Destination config
+#[derive(Copy, Default, Drop, Serde, starknet::Store, PartialEq, Debug)]
+pub struct DstConfig {
+    /// Gas for the destination
+    pub gas: u64,
+    /// Multiplier basis points
+    pub multiplier_bps: u16,
+    /// Floor margin in USD - uses priceFeed PRICE_RATIO_DENOMINATOR
+    pub floor_margin_usd: u128,
+}
+
+/// Parameters for setting the destination config
+#[derive(Copy, Default, Drop, Serde, PartialEq, Debug)]
+pub struct SetDstConfigParams {
+    /// Destination endpoint ID
+    pub dst_eid: u32,
+    /// Destination config
+    pub config: DstConfig,
+}
+
+/// Parameters for executing a job
+#[derive(Drop, Serde, Clone)]
+pub struct ExecuteParam {
+    /// Verifier ID
+    pub vid: u32,
+    /// Call data
+    pub call_data: Call,
+    /// Expiration of the instruction
+    pub expiration: u256,
+    /// Signatures for the instruction
+    pub signatures: Span<Signature>,
+}

package/layerzero/src/workers/executor/errors.cairo

@@ -0,0 +1,159 @@
+//! Executor errors
+
+use core::byte_array::ByteArray;
+use lz_utils::error::{Error, format_error};
+
+#[derive(Drop)]
+pub enum ExecutorError {
+    /// The endpoint ID is not supported.
+    EidNotSupported,
+    /// The `lz_compose` option is invalid.
+    InvalidLzComposeOption,
+    /// The `lz_read` option is invalid.
+    InvalidLzReadOption,
+    /// The `lz_receive` option is invalid.
+    InvalidLzReceiveOption,
+    /// The native drop option is invalid.
+    InvalidNativeDropOption,
+    /// The options are invalid.
+    InvalidOptions,
+    /// The options are malformed.
+    MalformedOptions,
+    /// The native amount exceeds the cap.
+    NativeAmountExceedsCap,
+    /// No options were provided.
+    NoOptions,
+    /// The price feed is not set.
+    PriceFeedNotSet,
+    /// The `lz_compose` option is not supported.
+    UnsupportedOptionLzCompose,
+    /// The `lz_read` option is not supported.
+    UnsupportedOptionLzRead,
+    /// The `lz_receive` option is not supported.
+    UnsupportedOptionLzReceive,
+    /// The native drop option is not supported.
+    UnsupportedOptionNativeDrop,
+    /// The option type is not supported.
+    UnsupportedOptionType,
+    /// Receive with value is not supported.
+    UnsupportedReceiveWithValue,
+    /// The worker fee library is not set.
+    WorkerFeeLibNotSet,
+    /// The calldata size is zero.
+    ZeroCalldataSize,
+    /// The `lz_compose` gas is zero.
+    ZeroLzComposeGas,
+    /// The `lz_receive` gas is zero.
+    ZeroLzReceiveGas,
+}
+
+impl ErrorNameImpl of Error<ExecutorError> {
+    fn prefix() -> ByteArray {
+        "LZ_EXECUTOR"
+    }
+
+    fn name(self: ExecutorError) -> ByteArray {
+        match self {
+            ExecutorError::EidNotSupported => "EID_NOT_SUPPORTED",
+            ExecutorError::InvalidLzComposeOption => "INVALID_LZ_COMPOSE_OPTION",
+            ExecutorError::InvalidLzReadOption => "INVALID_LZ_READ_OPTION",
+            ExecutorError::InvalidLzReceiveOption => "INVALID_LZ_RECEIVE_OPTION",
+            ExecutorError::InvalidNativeDropOption => "INVALID_NATIVE_DROP_OPTION",
+            ExecutorError::InvalidOptions => "INVALID_OPTIONS",
+            ExecutorError::MalformedOptions => "MALFORMED_OPTIONS",
+            ExecutorError::NativeAmountExceedsCap => "NATIVE_AMOUNT_EXCEEDS_CAP",
+            ExecutorError::NoOptions => "NO_OPTIONS",
+            ExecutorError::PriceFeedNotSet => "PRICE_FEED_NOT_SET",
+            ExecutorError::UnsupportedOptionLzCompose => "UNSUPPORTED_OPTION_LZ_COMPOSE",
+            ExecutorError::UnsupportedOptionLzRead => "UNSUPPORTED_OPTION_LZ_READ",
+            ExecutorError::UnsupportedOptionLzReceive => "UNSUPPORTED_OPTION_LZ_RECEIVE",
+            ExecutorError::UnsupportedOptionNativeDrop => "UNSUPPORTED_OPTION_NATIVE_DROP",
+            ExecutorError::UnsupportedOptionType => "UNSUPPORTED_OPTION_TYPE",
+            ExecutorError::UnsupportedReceiveWithValue => "UNSUPPORTED_RECEIVE_WITH_VALUE",
+            ExecutorError::WorkerFeeLibNotSet => "WORKER_FEELIB_NOT_SET",
+            ExecutorError::ZeroCalldataSize => "ZERO_CALLDATA_SIZE",
+            ExecutorError::ZeroLzComposeGas => "ZERO_LZ_COMPOSE_GAS",
+            ExecutorError::ZeroLzReceiveGas => "ZERO_LZ_RECEIVE_GAS",
+        }
+    }
+}
+
+pub fn err_eid_not_supported() -> ByteArray {
+    format_error(ExecutorError::EidNotSupported, "")
+}
+
+pub fn err_price_feed_not_set() -> ByteArray {
+    format_error(ExecutorError::PriceFeedNotSet, "")
+}
+
+pub fn err_worker_fee_lib_not_set() -> ByteArray {
+    format_error(ExecutorError::WorkerFeeLibNotSet, "")
+}
+
+pub fn err_no_options() -> ByteArray {
+    format_error(ExecutorError::NoOptions, "")
+}
+
+pub fn err_malformed_options() -> ByteArray {
+    format_error(ExecutorError::MalformedOptions, "")
+}
+
+pub fn err_unsupported_option_lz_receive() -> ByteArray {
+    format_error(ExecutorError::UnsupportedOptionLzReceive, "")
+}
+
+pub fn err_unsupported_receive_with_value() -> ByteArray {
+    format_error(ExecutorError::UnsupportedReceiveWithValue, "")
+}
+
+pub fn err_unsupported_option_native_drop() -> ByteArray {
+    format_error(ExecutorError::UnsupportedOptionNativeDrop, "")
+}
+
+pub fn err_unsupported_option_lz_compose() -> ByteArray {
+    format_error(ExecutorError::UnsupportedOptionLzCompose, "")
+}
+
+pub fn err_zero_lz_compose_gas() -> ByteArray {
+    format_error(ExecutorError::ZeroLzComposeGas, "")
+}
+
+pub fn err_unsupported_option_lz_read() -> ByteArray {
+    format_error(ExecutorError::UnsupportedOptionLzRead, "")
+}
+
+pub fn err_unsupported_option_type() -> ByteArray {
+    format_error(ExecutorError::UnsupportedOptionType, "")
+}
+
+pub fn err_invalid_options() -> ByteArray {
+    format_error(ExecutorError::InvalidOptions, "")
+}
+
+pub fn err_native_amount_exceeds_cap() -> ByteArray {
+    format_error(ExecutorError::NativeAmountExceedsCap, "")
+}
+
+pub fn err_zero_lz_receive_gas() -> ByteArray {
+    format_error(ExecutorError::ZeroLzReceiveGas, "")
+}
+
+pub fn err_zero_calldata_size() -> ByteArray {
+    format_error(ExecutorError::ZeroCalldataSize, "")
+}
+
+pub fn err_invalid_lz_receive_option() -> ByteArray {
+    format_error(ExecutorError::InvalidLzReceiveOption, "")
+}
+
+pub fn err_invalid_native_drop_option() -> ByteArray {
+    format_error(ExecutorError::InvalidNativeDropOption, "")
+}
+
+pub fn err_invalid_lz_compose_option() -> ByteArray {
+    format_error(ExecutorError::InvalidLzComposeOption, "")
+}
+
+pub fn err_invalid_lz_read_option() -> ByteArray {
+    format_error(ExecutorError::InvalidLzReadOption, "")
+}