@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

package/contracts/workers/executor-fee-lib/src/executor_fee_lib.rs

@@ -0,0 +1,215 @@
+use crate::{errors::ExecutorFeeLibError, executor_option};
+use common_macros::contract_impl;
+use soroban_sdk::{assert_with_error, contract, Address, Bytes, Env};
+use worker::{FeeParams, IExecutorFeeLib, LayerZeroPriceFeedClient};
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+/// V1 endpoint ID threshold. EIDs below this are V1 endpoints with restrictions.
+const V1_EID_THRESHOLD: u32 = 30000;
+
+/// Basis points denominator (10000 = 100%).
+const BPS_DENOMINATOR: i128 = 10000;
+
+/// Overhead percentage for ordered execution (102 = 2% overhead).
+const ORDERED_EXECUTION_OVERHEAD_PERCENT: u128 = 102;
+
+/// Native token decimal rate for XLM (10^7 stroops per XLM).
+const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
+
+/// ExecutorFeeLib contract for calculating executor fees.
+///
+/// Provides fee calculation logic based on executor options, destination configuration,
+/// and current gas prices from the price feed. Handles fee multipliers, margins, and
+/// native token value conversions.
+#[contract]
+pub struct ExecutorFeeLib;
+
+#[contract_impl]
+impl ExecutorFeeLib {
+    // ========================================================================
+    // Internal Functions
+    // ========================================================================
+
+    /// Decodes executor options and calculates total gas and native value.
+    ///
+    /// Parses encoded executor options, accumulates gas requirements (including
+    /// compose calls and ordered execution overhead), and returns the total native
+    /// value and gas needed.
+    ///
+    /// # Arguments
+    /// * `options` - Encoded executor options bytes
+    /// * `dst_eid` - Destination endpoint ID
+    /// * `lz_receive_base_gas` - Base gas for lzReceive execution
+    /// * `lz_compose_base_gas` - Base gas per lzCompose call
+    /// * `native_cap` - Maximum allowed native token value
+    ///
+    /// # Returns
+    /// Tuple of (total_native_value, total_gas).
+    fn decode_executor_options(
+        env: &Env,
+        options: &Bytes,
+        dst_eid: u32,
+        lz_receive_base_gas: u64,
+        lz_compose_base_gas: u64,
+        native_cap: u128,
+    ) -> (u128, u128) {
+        let options_agg = executor_option::parse_executor_options(env, options, Self::is_v1_eid(dst_eid), native_cap);
+
+        let mut total_gas = (lz_receive_base_gas as u128)
+            + options_agg.total_gas
+            + ((lz_compose_base_gas as u128) * (options_agg.num_lz_compose as u128));
+
+        if options_agg.ordered {
+            total_gas = (total_gas * ORDERED_EXECUTION_OVERHEAD_PERCENT) / 100;
+        }
+
+        (options_agg.total_value, total_gas)
+    }
+
+    /// Returns the effective multiplier in basis points.
+    ///
+    /// Uses destination-specific multiplier if set, otherwise falls back to default multiplier.
+    ///
+    /// # Arguments
+    /// * `params` - Fee parameters containing multiplier settings
+    ///
+    /// # Returns
+    /// Effective multiplier in basis points.
+    fn get_effective_multiplier_bps(params: &FeeParams) -> u32 {
+        if params.multiplier_bps == 0 {
+            params.default_multiplier_bps
+        } else {
+            params.multiplier_bps
+        }
+    }
+
+    /// Applies premium (multiplier and margin) to gas fee.
+    ///
+    /// Calculates fee with multiplier and floor margin, returning the maximum of both
+    /// to ensure profitability.
+    ///
+    /// # Arguments
+    /// * `fee` - Base gas fee
+    /// * `multiplier_bps` - Fee multiplier in basis points
+    /// * `margin_usd` - Minimum margin in USD (scaled)
+    /// * `native_price_usd` - Native token price in USD (scaled)
+    ///
+    /// # Returns
+    /// Fee with premium applied (max of multiplier fee and margin fee).
+    fn apply_premium_to_gas(fee: i128, multiplier_bps: u32, margin_usd: u128, native_price_usd: u128) -> i128 {
+        let fee_with_multiplier = (fee * multiplier_bps as i128) / BPS_DENOMINATOR;
+
+        if native_price_usd == 0 || margin_usd == 0 {
+            return fee_with_multiplier;
+        }
+
+        let fee_with_margin = ((margin_usd * NATIVE_DECIMALS_RATE) / native_price_usd) as i128 + fee;
+
+        fee_with_margin.max(fee_with_multiplier)
+    }
+
+    /// Converts native value and applies premium multiplier.
+    ///
+    /// Converts value using price ratio and applies multiplier in basis points.
+    ///
+    /// # Arguments
+    /// * `value` - Native value to convert
+    /// * `ratio` - Price ratio numerator
+    /// * `denom` - Price ratio denominator
+    /// * `multiplier_bps` - Fee multiplier in basis points
+    ///
+    /// # Returns
+    /// Converted and multiplied value, or 0 if input value is 0.
+    fn convert_and_apply_premium_to_value(value: u128, ratio: u128, denom: u128, multiplier_bps: u32) -> i128 {
+        if value == 0 {
+            return 0;
+        }
+        let converted = (value * ratio) / denom;
+        ((converted * multiplier_bps as u128) / BPS_DENOMINATOR as u128) as i128
+    }
+
+    /// Checks if an endpoint ID is a V1 endpoint.
+    ///
+    /// V1 endpoints (EID < 30000) have restrictions on executor options.
+    ///
+    /// # Arguments
+    /// * `eid` - Endpoint ID to check
+    ///
+    /// # Returns
+    /// `true` if the endpoint is a V1 endpoint, `false` otherwise.
+    fn is_v1_eid(eid: u32) -> bool {
+        eid < V1_EID_THRESHOLD
+    }
+}
+
+// ============================================================================
+// IExecutorFeeLib Implementation
+// ============================================================================
+
+#[contract_impl]
+impl IExecutorFeeLib for ExecutorFeeLib {
+    /// Calculates the total execution fee for a cross-chain message.
+    ///
+    /// Decodes executor options, estimates gas fees from the price feed, applies
+    /// multipliers and margins, and converts native token values. Returns the
+    /// total fee in native tokens.
+    ///
+    /// # Arguments
+    /// * `executor` - Executor contract address (unused, kept for interface compatibility)
+    /// * `params` - Fee calculation parameters
+    ///
+    /// # Returns
+    /// Total execution fee in native tokens.
+    ///
+    /// # Errors
+    /// * `EidNotSupported` - If destination endpoint is not supported (lz_receive_base_gas is 0)
+    /// * Various executor option parsing errors (see `parse_executor_options`)
+    fn get_fee(env: &Env, _executor: &Address, params: &FeeParams) -> i128 {
+        assert_with_error!(env, params.lz_receive_base_gas != 0, ExecutorFeeLibError::EidNotSupported);
+
+        let (total_value, total_gas) = Self::decode_executor_options(
+            env,
+            &params.options,
+            params.dst_eid,
+            params.lz_receive_base_gas,
+            params.lz_compose_base_gas,
+            params.native_cap,
+        );
+
+        let fee_estimate = LayerZeroPriceFeedClient::new(env, &params.price_feed).estimate_fee_by_eid(
+            &env.current_contract_address(),
+            &params.dst_eid,
+            &params.calldata_size,
+            &total_gas,
+        );
+
+        let multiplier_bps = Self::get_effective_multiplier_bps(params);
+
+        let mut fee = Self::apply_premium_to_gas(
+            fee_estimate.total_gas_fee,
+            multiplier_bps,
+            params.floor_margin_usd,
+            fee_estimate.native_price_usd,
+        );
+
+        fee += Self::convert_and_apply_premium_to_value(
+            total_value,
+            fee_estimate.price_ratio,
+            fee_estimate.price_ratio_denominator,
+            multiplier_bps,
+        );
+
+        fee
+    }
+
+    /// Returns the version of the fee library.
+    ///
+    /// # Returns
+    /// Tuple of (major_version, minor_version).
+    fn version(_env: &Env) -> (u64, u32) {
+        (1, 1)
+    }
+}

package/contracts/workers/executor-fee-lib/src/executor_option.rs

@@ -0,0 +1,203 @@
+use crate::errors::ExecutorFeeLibError;
+use message_lib_common::worker_options::{EXECUTOR_OPTION_TYPE_LZRECEIVE, EXECUTOR_OPTION_TYPE_NATIVE_DROP};
+use soroban_sdk::{assert_with_error, panic_with_error, Bytes, BytesN, Env};
+use utils::buffer_reader::BufferReader;
+
+pub const EXECUTOR_OPTION_TYPE_LZCOMPOSE: u8 = 3;
+pub const EXECUTOR_OPTION_TYPE_ORDERED_EXECUTION: u8 = 4;
+
+/// Aggregated executor options parsed from encoded option bytes.
+///
+/// Contains the accumulated values from all executor options for fee calculation.
+/// This structure is built by iterating through all encoded options and summing
+/// gas requirements and native token values.
+pub struct ExecutorOptionsAgg {
+    /// Total native token value to transfer (from lzReceive value + nativeDrop + lzCompose value).
+    pub total_value: u128,
+    /// Total gas required (from lzReceive gas + lzCompose gas).
+    pub total_gas: u128,
+    /// Whether ordered execution is requested (messages must be delivered in sequence).
+    pub ordered: bool,
+    /// Number of lzCompose calls to execute.
+    pub num_lz_compose: u64,
+}
+
+// ============================================================================
+// Main Parsing Function
+// ============================================================================
+
+/// Parses executor options from encoded bytes and returns aggregated values.
+///
+/// Iterates through all encoded options, decoding each based on its type and
+/// accumulating gas, value, and other parameters for fee calculation.
+///
+/// # Arguments
+/// * `options` - Encoded executor options bytes
+/// * `is_v1_eid` - Whether destination is a V1 endpoint (< 30000), which has restrictions
+/// * `native_cap` - Maximum allowed native token value transfer
+///
+/// # Returns
+/// `ExecutorOptionsAgg` containing accumulated gas, value, compose count, and ordered flag.
+///
+/// # Errors
+/// * `NoOptions` - If options bytes are empty
+/// * `UnsupportedOptionType` - If an unknown option type is encountered or V1 restrictions violated
+/// * `ZeroLzReceiveGasProvided` - If no lzReceive gas is specified
+/// * `ZeroLzComposeGasProvided` - If lzCompose has zero gas
+/// * `NativeAmountExceedsCap` - If total native value exceeds the cap
+pub fn parse_executor_options(env: &Env, options: &Bytes, is_v1_eid: bool, native_cap: u128) -> ExecutorOptionsAgg {
+    // Assert that options are not empty (No executor options provided)
+    assert_with_error!(env, !options.is_empty(), ExecutorFeeLibError::NoOptions);
+
+    let mut reader = BufferReader::new(options);
+
+    let mut agg_options = ExecutorOptionsAgg { total_value: 0, total_gas: 0, ordered: false, num_lz_compose: 0 };
+
+    let mut lz_receive_gas: u128 = 0;
+
+    while reader.remaining_len() > 0 {
+        let (option_type, option_data) = next_executor_option(&mut reader);
+
+        match option_type {
+            EXECUTOR_OPTION_TYPE_LZRECEIVE => {
+                let (gas, value) = decode_lz_receive_option(env, &option_data);
+                // endpoint v1 does not support lzReceive with value
+                assert_with_error!(env, !(is_v1_eid && value > 0), ExecutorFeeLibError::UnsupportedOptionType);
+                lz_receive_gas += gas;
+                agg_options.total_value += value;
+            }
+            EXECUTOR_OPTION_TYPE_NATIVE_DROP => {
+                let (amount, _) = decode_native_drop_option(env, &option_data);
+                agg_options.total_value += amount;
+            }
+            EXECUTOR_OPTION_TYPE_LZCOMPOSE => {
+                // endpoint v1 does not support lzCompose
+                assert_with_error!(env, !is_v1_eid, ExecutorFeeLibError::UnsupportedOptionType);
+                let (_, gas, value) = decode_lz_compose_option(env, &option_data);
+                assert_with_error!(env, gas != 0, ExecutorFeeLibError::ZeroLzComposeGasProvided);
+                agg_options.total_gas += gas;
+                agg_options.total_value += value;
+                agg_options.num_lz_compose += 1;
+            }
+            EXECUTOR_OPTION_TYPE_ORDERED_EXECUTION => {
+                assert_with_error!(env, option_data.is_empty(), ExecutorFeeLibError::InvalidExecutorOptions);
+                agg_options.ordered = true;
+            }
+            _ => {
+                panic_with_error!(env, ExecutorFeeLibError::UnsupportedOptionType);
+            }
+        }
+    }
+
+    // Validate
+    assert_with_error!(env, agg_options.total_value <= native_cap, ExecutorFeeLibError::NativeAmountExceedsCap);
+    assert_with_error!(env, lz_receive_gas != 0, ExecutorFeeLibError::ZeroLzReceiveGasProvided);
+
+    agg_options.total_gas += lz_receive_gas;
+    agg_options
+}
+
+// ============================================================================
+// Option Extraction
+// ============================================================================
+
+/// Extracts the next executor option from the options byte stream.
+///
+/// Option format: [worker_id: u8][option_size: u16][option_type: u8][option_data: bytes]
+///
+/// Parses the binary format to extract the option type and data, skipping the worker_id
+/// which identifies which worker this option is intended for.
+///
+/// # Arguments
+/// * `reader` - Buffer reader positioned at the start of an option
+///
+/// # Returns
+/// Tuple of (option_type, option_data) where option_data excludes the option_type byte.
+fn next_executor_option(reader: &mut BufferReader) -> (u8, Bytes) {
+    // Skip worker_id (1 byte) - identifies which worker this option is for
+    let _worker_id = reader.read_u8();
+
+    // Read option_size (2 bytes) - includes option_type + option_data
+    let option_size = reader.read_u16();
+
+    // Read option_type (1 byte)
+    let option_type = reader.read_u8();
+
+    // Read option_data (option_size - 1 bytes, since option_size includes option_type)
+    let option_data = reader.read_bytes((option_size - 1) as u32);
+
+    (option_type, option_data)
+}
+
+// ============================================================================
+// Option Decoding Functions
+// ============================================================================
+
+/// Decodes an lzReceive option.
+///
+/// Format: [gas: u128] (16 bytes) or [gas: u128][value: u128] (32 bytes)
+///
+/// # Arguments
+/// * `option` - The option data bytes (without option_type)
+///
+/// # Returns
+/// Tuple of (gas, value) where value is 0 if not specified.
+///
+/// # Errors
+/// * `InvalidLzReceiveOption` - If option length is not 16 or 32 bytes.
+fn decode_lz_receive_option(env: &Env, option: &Bytes) -> (u128, u128) {
+    let len = option.len();
+    assert_with_error!(env, len == 16 || len == 32, ExecutorFeeLibError::InvalidLzReceiveOption);
+
+    let mut reader = BufferReader::new(option);
+    let gas = reader.read_u128();
+    let value = if len == 32 { reader.read_u128() } else { 0 };
+
+    (gas, value)
+}
+
+/// Decodes a native drop option.
+///
+/// Format: [amount: u128][receiver: bytes32] (48 bytes)
+///
+/// # Arguments
+/// * `option` - The option data bytes (without option_type)
+///
+/// # Returns
+/// Tuple of (amount, receiver) for the native token transfer.
+///
+/// # Errors
+/// * `InvalidNativeDropOption` - If option length is not 48 bytes.
+fn decode_native_drop_option(env: &Env, option: &Bytes) -> (u128, BytesN<32>) {
+    assert_with_error!(env, option.len() == 48, ExecutorFeeLibError::InvalidNativeDropOption);
+
+    let mut reader = BufferReader::new(option);
+    let amount = reader.read_u128();
+    let receiver = reader.read_bytes_n::<32>();
+
+    (amount, receiver)
+}
+
+/// Decodes an lzCompose option.
+///
+/// Format: [index: u16][gas: u128] (18 bytes) or [index: u16][gas: u128][value: u128] (34 bytes)
+///
+/// # Arguments
+/// * `option` - The option data bytes (without option_type)
+///
+/// # Returns
+/// Tuple of (index, gas, value) where value is 0 if not specified.
+///
+/// # Errors
+/// * `InvalidLzComposeOption` - If option length is not 18 or 34 bytes.
+fn decode_lz_compose_option(env: &Env, option: &Bytes) -> (u16, u128, u128) {
+    let len = option.len();
+    assert_with_error!(env, len == 18 || len == 34, ExecutorFeeLibError::InvalidLzComposeOption);
+
+    let mut reader = BufferReader::new(option);
+    let index = reader.read_u16();
+    let gas = reader.read_u128();
+    let value = if len == 34 { reader.read_u128() } else { 0 };
+
+    (index, gas, value)
+}

package/contracts/workers/executor-fee-lib/src/lib.rs

@@ -0,0 +1,7 @@
+#![no_std]
+
+pub mod errors;
+pub mod executor_fee_lib;
+pub mod executor_option;
+
+pub use executor_fee_lib::{ExecutorFeeLib, ExecutorFeeLibClient};

package/contracts/workers/executor-helper/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "executor-helper"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[features]
+library = []
+testutils = []
+
+[dependencies]
+cfg-if = { workspace = true }
+soroban-sdk = { workspace = true }
+# workspace dependencies
+common-macros = { workspace = true }
+utils = { workspace = true }
+worker = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+executor = { workspace = true, features = ["library"] }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+
+

package/contracts/workers/executor-helper/src/executor_helper.rs

@@ -0,0 +1,161 @@
+//! ABA-safe entry point for cross-chain message execution on Stellar.
+//! Prevents reentry into the Executor during OApp Atomic Batch Actions.
+
+use endpoint_v2::{
+    LayerZeroComposerClient, LayerZeroEndpointV2Client, LayerZeroReceiverClient, MessagingComposerClient, Origin,
+};
+use executor::{ExecutorClient, NativeDropParams};
+use common_macros::contract_impl;
+use soroban_sdk::{contract, contracttype, token::TokenClient, Address, Bytes, BytesN, Env, Vec};
+
+/// Parameters for `lz_receive` execution.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ExecutionParams {
+    pub receiver: Address,
+    pub origin: Origin,
+    pub guid: BytesN<32>,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+    pub gas_limit: i128,
+}
+
+/// Parameters for `lz_compose` execution.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ComposeParams {
+    pub from: Address,
+    pub to: Address,
+    pub guid: BytesN<32>,
+    pub index: u32,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+    pub gas_limit: i128,
+}
+
+#[contract]
+pub struct ExecutorHelper;
+
+#[contract_impl]
+impl ExecutorHelper {
+    /// Executes `lz_receive` on the target OApp; falls back to `lz_receive_alert` on failure.
+    pub fn execute(env: &Env, executor: &Address, params: &ExecutionParams, value_payer: &Address) {
+        if params.value > 0 {
+            value_payer.require_auth();
+        }
+        Self::execute_internal(env, executor, params, value_payer);
+    }
+
+    /// Executes `lz_compose` on the target composer; falls back to `lz_compose_alert` on failure.
+    pub fn compose(env: &Env, executor: &Address, params: &ComposeParams, value_payer: &Address) {
+        executor.require_auth();
+
+        let endpoint = if params.value > 0 {
+            let ep = ExecutorClient::new(env, executor).endpoint();
+            value_payer.require_auth();
+            transfer_value(env, &ep, value_payer, executor, params.value);
+            Some(ep)
+        } else {
+            None
+        };
+
+        let result = LayerZeroComposerClient::new(env, &params.to).try_lz_compose(
+            executor,
+            &params.from,
+            &params.guid,
+            &params.index,
+            &params.message,
+            &params.extra_data,
+            &params.value,
+        );
+
+        if result.is_err() {
+            let ep = endpoint.unwrap_or_else(|| ExecutorClient::new(env, executor).endpoint());
+            MessagingComposerClient::new(env, &ep).lz_compose_alert(
+                executor,
+                &params.from,
+                &params.to,
+                &params.guid,
+                &params.index,
+                &params.gas_limit,
+                &params.value,
+                &params.message,
+                &params.extra_data,
+                &Bytes::new(env),
+            );
+        }
+    }
+
+    /// Delegates `native_drop` to the executor contract.
+    pub fn native_drop(
+        env: &Env,
+        executor: &Address,
+        admin: &Address,
+        origin: &Origin,
+        dst_eid: u32,
+        oapp: &Address,
+        params: &Vec<NativeDropParams>,
+    ) {
+        admin.require_auth();
+        ExecutorClient::new(env, executor).native_drop(admin, origin, &dst_eid, oapp, params);
+    }
+
+    /// Executes `native_drop` followed by `lz_receive`.
+    pub fn native_drop_and_execute(
+        env: &Env,
+        executor: &Address,
+        admin: &Address,
+        origin: &Origin,
+        dst_eid: u32,
+        oapp: &Address,
+        native_drop_params: &Vec<NativeDropParams>,
+        execute_params: &ExecutionParams,
+    ) {
+        Self::native_drop(env, executor, admin, origin, dst_eid, oapp, native_drop_params);
+        Self::execute_internal(env, executor, execute_params, admin); // admin already authed above
+    }
+
+    fn execute_internal(env: &Env, executor: &Address, params: &ExecutionParams, value_payer: &Address) {
+        executor.require_auth();
+
+        let endpoint = if params.value > 0 {
+            let ep = ExecutorClient::new(env, executor).endpoint();
+            transfer_value(env, &ep, value_payer, executor, params.value);
+            Some(ep)
+        } else {
+            None
+        };
+
+        let result = LayerZeroReceiverClient::new(env, &params.receiver).try_lz_receive(
+            executor,
+            &params.origin,
+            &params.guid,
+            &params.message,
+            &params.extra_data,
+            &params.value,
+        );
+
+        if result.is_err() {
+            let ep = endpoint.unwrap_or_else(|| ExecutorClient::new(env, executor).endpoint());
+            LayerZeroEndpointV2Client::new(env, &ep).lz_receive_alert(
+                executor,
+                &params.origin,
+                &params.receiver,
+                &params.guid,
+                &params.gas_limit,
+                &params.value,
+                &params.message,
+                &params.extra_data,
+                &Bytes::new(env),
+            );
+        }
+    }
+}
+
+#[inline]
+fn transfer_value(env: &Env, endpoint: &Address, payer: &Address, executor: &Address, value: i128) {
+    let native_token = LayerZeroEndpointV2Client::new(env, endpoint).native_token();
+    TokenClient::new(env, &native_token).transfer(payer, executor, &value);
+}

package/contracts/workers/executor-helper/src/lib.rs

@@ -0,0 +1,11 @@
+#![no_std]
+
+mod executor_helper;
+
+cfg_if::cfg_if! {
+    // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)
+    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
+
+        pub use executor_helper::*;
+    }
+}

package/contracts/workers/{worker-common → worker}/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "worker-common"
+name = "worker"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
@@ -13,6 +13,3 @@ doctest = false
 soroban-sdk = { workspace = true }
 utils = { workspace = true }
 common-macros = { workspace = true }
-stellar-access = { workspace = true }
-stellar-macros = { workspace = true }
-stellar-contract-utils = { workspace = true }

package/contracts/workers/worker/src/errors.rs

@@ -0,0 +1,24 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum WorkerError {
+    AdminAlreadyExists = 1200,
+    AdminNotFound,
+    AlreadyOnAllowlist,
+    AlreadyOnDenylist,
+    AttemptingToRemoveOnlyAdmin,
+    DepositAddressNotSet,
+    MessageLibAlreadySupported,
+    MessageLibNotSupported,
+    NoAdminsProvided,
+    NotAllowed,
+    NotOnAllowlist,
+    NotOnDenylist,
+    PauseStatusUnchanged,
+    PriceFeedNotSet,
+    ReInitialize,
+    Unauthorized,
+    UnsupportedMessageLib,
+    WorkerFeeLibNotSet,
+    WorkerIsPaused,
+}