@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/src/oapps/oft/structs.cairo

@@ -0,0 +1,72 @@
+use lz_utils::bytes::Bytes32;
+use crate::MessageReceipt;
+
+/// Struct representing token parameters for the OFT send() operation.
+#[derive(Clone, Drop, Serde, Default)]
+pub struct SendParam {
+    pub dst_eid: u32, // Destination endpoint ID
+    pub to: Bytes32, // Recipient address
+    pub amount_ld: u256, // Amount to send in local decimals
+    pub min_amount_ld: u256, // Minimum amount to send in local decimals
+    pub extra_options: ByteArray, // Additional options supplied by the caller
+    pub compose_msg: ByteArray, // The composed message for the send() operation
+    pub oft_cmd: ByteArray // The OFT command to be executed
+}
+
+/// Struct representing OFT limit information.
+/// These amounts can change dynamically and are up to the specific oft implementation.
+#[derive(Drop, Serde, Default)]
+pub struct OFTLimit {
+    pub min_amount_ld: u256, // Minimum amount in local decimals that can be sent
+    pub max_amount_ld: u256 // Maximum amount in local decimals that can be sent
+}
+
+/// Struct representing OFT receipt information.
+#[derive(Drop, Serde, Default)]
+pub struct OFTReceipt {
+    pub amount_sent_ld: u256, // Amount of tokens ACTUALLY debited from the sender in local decimals
+    pub amount_received_ld: u256 // Amount of tokens to be received on the remote side
+}
+
+/// Struct representing OFT fee details.
+/// Future proof mechanism to provide a standardized way to communicate fees to things like a UI.
+#[derive(Drop, Serde, Default)]
+pub struct OFTFeeDetail {
+    pub fee_amount_ld: u256, // Amount of the fee in local decimals
+    pub reward_amount_ld: u256, // Amount of the reward in local decimals
+    pub description: ByteArray // Description of the fee
+}
+
+/// Struct representing OFT version information.
+#[derive(Drop, Serde, Default)]
+pub struct OFTVersion {
+    pub interface_id: u32, // The interface ID (equivalent to Solidity's bytes4)
+    pub version: u64 // The version number
+}
+
+/// Struct representing OFT quote information.
+#[derive(Drop, Serde, Default)]
+pub struct OFTQuote {
+    pub limit: OFTLimit, // The OFT limit information
+    pub oft_fee_details: Array<OFTFeeDetail>, // The details of OFT fees
+    pub receipt: OFTReceipt // The OFT receipt information
+}
+
+/// Struct representing OFT send result.
+#[derive(Drop, Serde, Default)]
+pub struct OFTSendResult {
+    pub message_receipt: MessageReceipt, // The LayerZero messaging receipt
+    pub oft_receipt: OFTReceipt // The OFT receipt information
+}
+
+#[derive(Drop, Serde, Default)]
+pub struct OFTDebit {
+    pub amount_sent_ld: u256, // Amount of tokens ACTUALLY debited from the sender in local decimals
+    pub amount_received_ld: u256 // Amount of tokens to be received on the remote side
+}
+
+#[derive(Drop, Serde, Default)]
+pub struct OFTMsgAndOptions {
+    pub message: ByteArray, // The encoded message
+    pub options: ByteArray // The encoded options
+}

package/layerzero/src/treasury/errors.cairo

@@ -0,0 +1,22 @@
+use lz_utils::error::{Error, format_error};
+
+#[derive(Drop)]
+pub enum TreasuryError {
+    LzTokenNotEnabled,
+}
+
+impl ErrorImpl of Error<TreasuryError> {
+    fn prefix() -> ByteArray {
+        "LZ_TREASURY"
+    }
+
+    fn name(self: TreasuryError) -> ByteArray {
+        match self {
+            TreasuryError::LzTokenNotEnabled => "LZ_TOKEN_NOT_ENABLED",
+        }
+    }
+}
+
+pub fn err_lz_token_not_enabled() -> ByteArray {
+    format_error(TreasuryError::LzTokenNotEnabled, "")
+}

package/layerzero/src/treasury/events.cairo

@@ -0,0 +1,5 @@
+#[derive(Drop, starknet::Event)]
+pub struct BasisPointsUpdated {
+    pub old_bp: u256,
+    pub new_bp: u256,
+}

package/layerzero/src/treasury/interfaces/layerzero_treasury.cairo

@@ -0,0 +1,54 @@
+//! LayerZero treasury interface
+
+use starknet::ContractAddress;
+
+/// Interface for Treasury component
+///
+/// The Treasury collects treasury fees.
+#[starknet::interface]
+pub trait ILayerZeroTreasury<TContractState> {
+    /// Calculates the treasury fee based on the worker fee and whether the fee should be paid in
+    /// LZ tokens. If the fee should be paid in LZ tokens, the fee is returned in ZRO, or otherwise
+    /// in native tokens.
+    ///
+    /// # Arguments
+    /// * `sender` - The sender address
+    /// * `dst_eid` - The destination endpoint ID
+    /// * `worker_fee` - The total worker fee
+    /// * `pay_in_lz_token` - The flag indicating whether a fee is paid in LZ tokens or not
+    ///
+    /// # Returns
+    /// * `u256` - The amount of tokens to be paid
+    ///
+    /// # Panics
+    /// * If `pay_in_lz_token` is true while LZ token payment is disabled in the treasury
+    fn get_fee(
+        self: @TContractState,
+        sender: ContractAddress,
+        dst_eid: u32,
+        worker_fee: u256,
+        pay_in_lz_token: bool,
+    ) -> u256;
+
+    /// Pays the fee to the treasury. The fee is calculated based on the worker fee and whether the
+    /// fee should be paid in LZ tokens.
+    ///
+    /// # Arguments
+    /// * `sender` - The sender address
+    /// * `dst_eid` - The destination endpoint ID
+    /// * `worker_fee` - The total worker fee
+    /// * `pay_in_lz_token` - The flag indicating whether a fee is paid in LZ tokens or not
+    ///
+    /// # Returns
+    /// * `u256` - The amount of tokens to be paid
+    ///
+    /// # Panics
+    /// * If `pay_in_lz_token` is true while LZ token payment is disabled in the treasury
+    fn pay_fee(
+        ref self: TContractState,
+        sender: ContractAddress,
+        dst_eid: u32,
+        worker_fee: u256,
+        pay_in_lz_token: bool,
+    ) -> u256;
+}

package/layerzero/src/treasury/interfaces/lz_token_fee_lib.cairo

@@ -0,0 +1,45 @@
+//! LayerZero token fee library interface
+
+use starknet::ContractAddress;
+
+/// Interface for LayerZero token fee library component.
+///
+/// LayerZero token fee library calculates treasury fees.
+#[starknet::interface]
+pub trait ILzTokenFeeLib<TContractState> {
+    /// Calculates the treasury fee based on the worker fee.
+    ///
+    /// # Arguments
+    /// * `sender` - The sender address
+    /// * `dst_eid` - The destination endpoint ID
+    /// * `worker_fee` - The total worker fee
+    /// * `native_treasury_fee` - The treasury fee in native tokens
+    ///
+    /// # Returns
+    /// * `u256` - The amount of tokens to be paid in LayerZero tokens
+    fn get_fee(
+        self: @TContractState,
+        sender: ContractAddress,
+        dst_eid: u32,
+        worker_fee: u256,
+        native_treasury_fee: u256,
+    ) -> u256;
+
+    /// Calculates the treasury fee based on the worker fee for later payment.
+    ///
+    /// # Arguments
+    /// * `sender` - The sender address
+    /// * `dst_eid` - The destination endpoint ID
+    /// * `worker_fee` - The total worker fee
+    /// * `native_treasury_fee` - The treasury fee in native tokens
+    ///
+    /// # Returns
+    /// * `u256` - The amount of tokens to be paid in LayerZero tokens
+    fn pay_fee(
+        ref self: TContractState,
+        sender: ContractAddress,
+        dst_eid: u32,
+        worker_fee: u256,
+        native_treasury_fee: u256,
+    ) -> u256;
+}

package/layerzero/src/treasury/interfaces/treasury_admin.cairo

@@ -0,0 +1,39 @@
+//! Treasury admin interface
+
+use starknet::ContractAddress;
+
+/// Interface for TreasuryAdmin component
+///
+/// The TreasuryAdmin allows administrators of the treasury to manage the treasury
+/// fee configuration, and withdraw collected fees.
+#[starknet::interface]
+pub trait ITreasuryAdmin<TContractState> {
+    /// Gets the basis points of the treasury fee.
+    ///
+    /// # Returns
+    /// * `u256` - The basis points
+    fn get_fee_bp(self: @TContractState) -> u256;
+
+    /// Sets the basis points of the treasury fee.
+    ///
+    /// # Arguments
+    /// * `basis_points` - The basis points
+    fn set_fee_bp(ref self: TContractState, basis_points: u256);
+
+    /// Withdraws the collected fee of a given token address.
+    fn withdraw_tokens(
+        ref self: TContractState, token_address: ContractAddress, to: ContractAddress, amount: u256,
+    );
+
+    /// Gets the LZ token fee library.
+    ///
+    /// # Returns
+    /// * `Option<ContractAddress>` - The LZ token fee library if any
+    fn get_lz_token_fee_lib(self: @TContractState) -> Option<ContractAddress>;
+
+    /// Sets the LZ token fee library.
+    ///
+    /// # Arguments
+    /// * `library` - The LZ token fee library
+    fn set_lz_token_fee_lib(ref self: TContractState, library: Option<ContractAddress>);
+}

package/layerzero/src/treasury/treasury.cairo

@@ -0,0 +1,140 @@
+//! Treasury component implementation
+
+#[starknet::contract]
+pub mod Treasury {
+    use openzeppelin::access::ownable::OwnableComponent;
+    use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starkware_utils::errors::assert_with_byte_array;
+    use crate::common::constants::DEFAULT_BPS;
+    use crate::treasury::errors::err_lz_token_not_enabled;
+    use crate::treasury::events::BasisPointsUpdated;
+    use crate::treasury::interfaces::layerzero_treasury::ILayerZeroTreasury;
+    use crate::treasury::interfaces::lz_token_fee_lib::{
+        ILzTokenFeeLibDispatcher, ILzTokenFeeLibDispatcherTrait,
+    };
+    use crate::treasury::interfaces::treasury_admin::ITreasuryAdmin;
+
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+
+    #[abi(embed_v0)]
+    impl OwnableImpl = OwnableComponent::OwnableImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+        basis_points: u256,
+        lz_token_fee_lib: Option<ContractAddress>,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+        BasisPointsUpdated: BasisPointsUpdated,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, owner: ContractAddress) {
+        self.ownable.initializer(owner);
+    }
+
+    #[abi(embed_v0)]
+    impl TreasuryImpl of ILayerZeroTreasury<ContractState> {
+        fn get_fee(
+            self: @ContractState,
+            sender: ContractAddress,
+            dst_eid: u32,
+            worker_fee: u256,
+            pay_in_lz_token: bool,
+        ) -> u256 {
+            let native_fee = self._get_native_fee(worker_fee);
+
+            if pay_in_lz_token {
+                self
+                    ._get_lz_token_library_dispatcher()
+                    .get_fee(sender, dst_eid, worker_fee, native_fee)
+            } else {
+                native_fee
+            }
+        }
+
+        fn pay_fee(
+            ref self: ContractState,
+            sender: ContractAddress,
+            dst_eid: u32,
+            worker_fee: u256,
+            pay_in_lz_token: bool,
+        ) -> u256 {
+            let native_fee = self._get_native_fee(worker_fee);
+
+            if pay_in_lz_token {
+                self
+                    ._get_lz_token_library_dispatcher()
+                    .pay_fee(sender, dst_eid, worker_fee, native_fee)
+            } else {
+                native_fee
+            }
+        }
+    }
+
+    #[generate_trait]
+    pub impl TreasuryInternalImpl of TreasuryInternalTrait {
+        fn _get_native_fee(self: @ContractState, worker_fee: u256) -> u256 {
+            worker_fee * self.basis_points.read() / DEFAULT_BPS
+        }
+
+        fn _get_lz_token_library_dispatcher(self: @ContractState) -> ILzTokenFeeLibDispatcher {
+            let library = self.lz_token_fee_lib.read();
+            assert_with_byte_array(library.is_some(), err_lz_token_not_enabled());
+
+            ILzTokenFeeLibDispatcher {
+                contract_address: library.expect('LZ token fee library exists'),
+            }
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl TreasuryAdminImpl of ITreasuryAdmin<ContractState> {
+        fn set_fee_bp(ref self: ContractState, basis_points: u256) {
+            self.ownable.assert_only_owner();
+            let old_bp = self.basis_points.read();
+            self.basis_points.write(basis_points);
+
+            self.emit(BasisPointsUpdated { old_bp, new_bp: basis_points });
+        }
+
+        fn get_fee_bp(self: @ContractState) -> u256 {
+            self.basis_points.read()
+        }
+
+        fn withdraw_tokens(
+            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);
+        }
+
+        fn get_lz_token_fee_lib(self: @ContractState) -> Option<ContractAddress> {
+            self.lz_token_fee_lib.read()
+        }
+
+        fn set_lz_token_fee_lib(ref self: ContractState, library: Option<ContractAddress>) {
+            self.ownable.assert_only_owner();
+
+            self.lz_token_fee_lib.write(library);
+        }
+    }
+}

package/layerzero/src/workers/access_control.cairo

@@ -0,0 +1,11 @@
+//! Worker access control roles
+
+/// Default admin role
+/// - can grant and revoke all roles
+pub use openzeppelin::access::accesscontrol::DEFAULT_ADMIN_ROLE;
+
+/// Admin role
+pub const ADMIN_ROLE: felt252 = 'ADMIN_ROLE';
+
+/// Message lib role
+pub const MESSAGE_LIB_ROLE: felt252 = 'MESSAGE_LIB_ROLE';

package/layerzero/src/workers/base/base.cairo

@@ -0,0 +1,238 @@
+//! Base worker component implementation
+
+#[starknet::component]
+pub mod WorkerBaseComponent {
+    use core::panics::panic_with_byte_array;
+    use openzeppelin::access::accesscontrol::AccessControlComponent;
+    use openzeppelin::access::accesscontrol::AccessControlComponent::InternalImpl as AccessControlInternalImpl;
+    use openzeppelin::access::accesscontrol::interface::IAccessControl;
+    use openzeppelin::introspection::src5::SRC5Component;
+    use openzeppelin::security::pausable::PausableComponent;
+    use openzeppelin::security::pausable::PausableComponent::{
+        InternalImpl as PausableInternalImpl, InternalTrait as PausableInternalTrait, PausableImpl,
+    };
+    use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use starknet::ContractAddress;
+    use starknet::storage::{
+        Map, StoragePathEntry, StoragePointerReadAccess, StoragePointerWriteAccess,
+    };
+    use crate::common::constants::ZERO_ADDRESS;
+    use crate::workers::access_control::{ADMIN_ROLE, DEFAULT_ADMIN_ROLE, MESSAGE_LIB_ROLE};
+    use crate::workers::base::errors::err_role_renouncing_disabled;
+    use crate::workers::base::events::{
+        DefaultMultiplierBpsSet, FeeWithdrawn, PriceFeedSet, SupportedOptionTypeSet,
+        WorkerFeeLibSet,
+    };
+    use crate::workers::base::interface::IWorkerBase;
+
+    // =============================== Storage =================================
+
+    #[storage]
+    pub struct Storage {
+        pub WorkerBase_price_feed: ContractAddress,
+        pub WorkerBase_default_multiplier_bps: u16,
+        /// EID => option type
+        pub WorkerBase_supported_option_types: Map<u32, ByteArray>,
+        pub WorkerBase_worker_fee_lib: ContractAddress,
+    }
+
+    // =============================== Events =================================
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        PriceFeedSet: PriceFeedSet,
+        FeeWithdrawn: FeeWithdrawn,
+        SupportedOptionTypeSet: SupportedOptionTypeSet,
+        DefaultMultiplierBpsSet: DefaultMultiplierBpsSet,
+        WorkerFeeLibSet: WorkerFeeLibSet,
+    }
+
+    #[embeddable_as(WorkerBaseImpl)]
+    impl WorkerBase<
+        TContractState,
+        +HasComponent<TContractState>,
+        impl AccessControl: AccessControlComponent::HasComponent<TContractState>,
+        +SRC5Component::HasComponent<TContractState>,
+        impl Pausable: PausableComponent::HasComponent<TContractState>,
+        +Drop<TContractState>,
+    > of IWorkerBase<ComponentState<TContractState>> {
+        // ================================== Only Default Admin ===============================
+
+        /// Pause the contract (only default admin)
+        fn pause(ref self: ComponentState<TContractState>) {
+            self._assert_only_default_admin();
+            let mut pausable = get_dep_component_mut!(ref self, Pausable);
+            pausable.pause();
+        }
+
+        /// Unpause the contract (only default admin)
+        fn unpause(ref self: ComponentState<TContractState>) {
+            self._assert_only_default_admin();
+            let mut pausable = get_dep_component_mut!(ref self, Pausable);
+            pausable.unpause();
+        }
+
+        // ===================================== Only Admin =====================================
+
+        fn set_price_feed(ref self: ComponentState<TContractState>, price_feed: ContractAddress) {
+            self._assert_only_admin();
+
+            let old_price_feed = self.WorkerBase_price_feed.read();
+            self.WorkerBase_price_feed.write(price_feed);
+            self.emit(PriceFeedSet { old_price_feed, new_price_feed: price_feed });
+        }
+
+        fn set_supported_option_type(
+            ref self: ComponentState<TContractState>, eid: u32, option_type: ByteArray,
+        ) {
+            self._assert_only_admin();
+            self.WorkerBase_supported_option_types.entry(eid).write(option_type.clone());
+            self.emit(SupportedOptionTypeSet { eid, option_type });
+        }
+
+        fn set_default_multiplier_bps(
+            ref self: ComponentState<TContractState>, default_multiplier_bps: u16,
+        ) {
+            self._assert_only_admin();
+            self.WorkerBase_default_multiplier_bps.write(default_multiplier_bps);
+            self.emit(DefaultMultiplierBpsSet { default_multiplier_bps });
+        }
+
+        fn withdraw_fee(
+            ref self: ComponentState<TContractState>,
+            token_address: ContractAddress,
+            to: ContractAddress,
+            amount: u256,
+        ) {
+            self._assert_only_admin();
+            IERC20Dispatcher { contract_address: token_address }.transfer(to, amount);
+            self.emit(FeeWithdrawn { to, amount });
+        }
+
+        fn set_worker_fee_lib(
+            ref self: ComponentState<TContractState>, worker_fee_lib: ContractAddress,
+        ) {
+            self._assert_only_admin();
+
+            let old_worker_fee_lib = self.WorkerBase_worker_fee_lib.read();
+            self.WorkerBase_worker_fee_lib.write(worker_fee_lib);
+            self.emit(WorkerFeeLibSet { old_worker_fee_lib, new_worker_fee_lib: worker_fee_lib });
+        }
+
+        // ======================================= View ========================================
+
+        fn get_price_feed(self: @ComponentState<TContractState>) -> ContractAddress {
+            self.WorkerBase_price_feed.read()
+        }
+
+        fn get_supported_option_type(self: @ComponentState<TContractState>, eid: u32) -> ByteArray {
+            self.WorkerBase_supported_option_types.entry(eid).read()
+        }
+
+        fn get_default_multiplier_bps(self: @ComponentState<TContractState>) -> u16 {
+            self.WorkerBase_default_multiplier_bps.read()
+        }
+
+        fn get_worker_fee_lib(self: @ComponentState<TContractState>) -> ContractAddress {
+            self.WorkerBase_worker_fee_lib.read()
+        }
+    }
+
+    /// Access control implementation - same as OpenZeppelin except `renounce_role` is disabled
+    #[embeddable_as(AccessControlImpl)]
+    pub impl AccessControl<
+        TContractState,
+        +HasComponent<TContractState>,
+        impl OZAccessControl: AccessControlComponent::HasComponent<TContractState>,
+        +SRC5Component::HasComponent<TContractState>,
+        +Drop<TContractState>,
+    > of IAccessControl<ComponentState<TContractState>> {
+        fn has_role(
+            self: @ComponentState<TContractState>, role: felt252, account: ContractAddress,
+        ) -> bool {
+            get_dep_component!(self, OZAccessControl).has_role(role, account)
+        }
+
+        fn get_role_admin(self: @ComponentState<TContractState>, role: felt252) -> felt252 {
+            get_dep_component!(self, OZAccessControl).get_role_admin(role)
+        }
+
+        fn grant_role(
+            ref self: ComponentState<TContractState>, role: felt252, account: ContractAddress,
+        ) {
+            let mut access_control = get_dep_component_mut!(ref self, OZAccessControl);
+            access_control.grant_role(role, account)
+        }
+
+        fn revoke_role(
+            ref self: ComponentState<TContractState>, role: felt252, account: ContractAddress,
+        ) {
+            let mut access_control = get_dep_component_mut!(ref self, OZAccessControl);
+            access_control.revoke_role(role, account)
+        }
+
+        fn renounce_role(
+            ref self: ComponentState<TContractState>, role: felt252, account: ContractAddress,
+        ) {
+            panic_with_byte_array(@err_role_renouncing_disabled())
+        }
+    }
+
+    // internal
+    #[generate_trait]
+    pub impl InternalImpl<
+        TContractState,
+        +HasComponent<TContractState>,
+        impl AccessControl: AccessControlComponent::HasComponent<TContractState>,
+        +SRC5Component::HasComponent<TContractState>,
+        impl Pausable: PausableComponent::HasComponent<TContractState>,
+        +Drop<TContractState>,
+    > of InternalTrait<TContractState> {
+        /// Initialize the base worker component
+        fn initializer(
+            ref self: ComponentState<TContractState>,
+            message_libs: Array<ContractAddress>,
+            price_feed: ContractAddress,
+            default_multiplier_bps: u16,
+            role_admin: ContractAddress,
+            admins: Array<ContractAddress>,
+        ) {
+            // Set initial values
+            self.WorkerBase_default_multiplier_bps.write(default_multiplier_bps);
+            self.WorkerBase_price_feed.write(price_feed);
+
+            // Set role admin
+            let mut access_control = get_dep_component_mut!(ref self, AccessControl);
+            if role_admin != ZERO_ADDRESS {
+                access_control._grant_role(DEFAULT_ADMIN_ROLE, role_admin);
+            }
+
+            // Set message libs
+            for message_lib in message_libs {
+                access_control._grant_role(MESSAGE_LIB_ROLE, message_lib);
+            }
+
+            // Set additional admins
+            for admin in admins {
+                access_control._grant_role(ADMIN_ROLE, admin);
+            }
+        }
+
+        fn _assert_only_default_admin(self: @ComponentState<TContractState>) {
+            get_dep_component!(self, AccessControl).assert_only_role(DEFAULT_ADMIN_ROLE);
+        }
+
+        fn _assert_only_admin(self: @ComponentState<TContractState>) {
+            get_dep_component!(self, AccessControl).assert_only_role(ADMIN_ROLE);
+        }
+
+        fn _assert_only_message_lib(self: @ComponentState<TContractState>) {
+            get_dep_component!(self, AccessControl).assert_only_role(MESSAGE_LIB_ROLE);
+        }
+
+        fn _assert_not_paused(self: @ComponentState<TContractState>) {
+            get_dep_component!(self, Pausable).assert_not_paused();
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+//! Base worker errors
+
+use lz_utils::error::{Error, format_error};
+
+#[derive(Drop, Clone, Debug, PartialEq)]
+pub enum WorkerBaseError {
+    WorkerBaseRoleRenouncingDisabled,
+}
+
+impl WorkerBaseErrorImpl of Error<WorkerBaseError> {
+    fn prefix() -> ByteArray {
+        "LZ_WORKER_BASE"
+    }
+
+    fn name(self: WorkerBaseError) -> ByteArray {
+        match self {
+            WorkerBaseError::WorkerBaseRoleRenouncingDisabled => "ROLE_RENUNCING_DISABLED",
+        }
+    }
+}
+
+pub fn err_role_renouncing_disabled() -> ByteArray {
+    format_error(WorkerBaseError::WorkerBaseRoleRenouncingDisabled, "")
+}