@layerzerolabs/oft-mint-burn-starknet 0.2.9

package/Scarb.lock

@@ -0,0 +1,190 @@
+# Code generated by scarb DO NOT EDIT.
+version = 1
+
+[[package]]
+name = "enumerable_set"
+version = "0.1.0"
+
+[[package]]
+name = "layerzero"
+version = "0.1.0"
+dependencies = [
+ "enumerable_set",
+ "lz_utils",
+ "multisig",
+ "openzeppelin",
+]
+
+[[package]]
+name = "lz_utils"
+version = "0.1.0"
+
+[[package]]
+name = "multisig"
+version = "0.1.0"
+dependencies = [
+ "enumerable_set",
+ "lz_utils",
+]
+
+[[package]]
+name = "oft_mint_burn"
+version = "0.1.0"
+dependencies = [
+ "layerzero",
+ "lz_utils",
+ "openzeppelin",
+ "snforge_std",
+ "starkware_utils_testing",
+]
+
+[[package]]
+name = "openzeppelin"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:5e4fdecc957cfca7854d95912dc72d9f725517c063b116512900900add29fd77"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_finance",
+ "openzeppelin_governance",
+ "openzeppelin_introspection",
+ "openzeppelin_merkle_tree",
+ "openzeppelin_presets",
+ "openzeppelin_security",
+ "openzeppelin_token",
+ "openzeppelin_upgrades",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_access"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:511681dd26d814ee2bc996d44ff8cb4aaa5ae9d14272130def7eb901cf004850"
+dependencies = [
+ "openzeppelin_introspection",
+]
+
+[[package]]
+name = "openzeppelin_account"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:fb3381c50d68b028d3801feb43df378e2bd62137b6884844f8f60aefe796188b"
+dependencies = [
+ "openzeppelin_introspection",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_finance"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:e9456ef69502a87c4c99bf50145351b50950f8b11244847d92935c466c4ba787"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_token",
+]
+
+[[package]]
+name = "openzeppelin_governance"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:056e6d6f3d48193b53f06283884f8a9675f986fc85425f6a40e8c1aeb3b3ecfa"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_introspection",
+ "openzeppelin_token",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_introspection"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:87773ed6cd2318f169283ecbbb161890d1996260a80302d81ec45b70ee5e54c1"
+
+[[package]]
+name = "openzeppelin_merkle_tree"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:47f80c9ce59557774243214f8e75c5e866f30f3d8daa755855f6ffd01c89ca89"
+
+[[package]]
+name = "openzeppelin_presets"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:36c761ee923f1dc0887c0eab8c224b49ac242dbfe9163fbb0b08562042ab3d98"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_finance",
+ "openzeppelin_introspection",
+ "openzeppelin_token",
+ "openzeppelin_upgrades",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_security"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:902932ec296c2f400e0ac7c579edeaafd6067b6ce6d9854c1191de28e396ffe3"
+
+[[package]]
+name = "openzeppelin_token"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:6fe61f63b5a6706018265fb7373b6e5bd3ff829bdc760b2b90296b1e708d180c"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_introspection",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_upgrades"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:560d57a9c3f3ec5a476e82fec8963c93c8df63a4ff9ff134f64ab8383bde3c61"
+
+[[package]]
+name = "openzeppelin_utils"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:bf799c794139837f397975ffdf6a7ed5032d198bbf70e87a8f44f144a9dfc505"
+
+[[package]]
+name = "snforge_scarb_plugin"
+version = "0.49.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:903150f0e9542e4277d417029eea4c03af0db398b581f9f7ae3ebbdac9afc657"
+
+[[package]]
+name = "snforge_std"
+version = "0.49.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:73d73653cc4356ec51b92a6bec9d8385b20318170c2f2ade7891e5185a0e7e64"
+dependencies = [
+ "snforge_scarb_plugin",
+]
+
+[[package]]
+name = "starkware_utils"
+version = "1.0.0"
+source = "git+https://github.com/starkware-libs/starkware-starknet-utils?rev=e1955423808045de868987b8fb0b43f5cbdf5699#e1955423808045de868987b8fb0b43f5cbdf5699"
+dependencies = [
+ "openzeppelin",
+]
+
+[[package]]
+name = "starkware_utils_testing"
+version = "1.0.0"
+source = "git+https://github.com/starkware-libs/starkware-starknet-utils?rev=e1955423808045de868987b8fb0b43f5cbdf5699#e1955423808045de868987b8fb0b43f5cbdf5699"
+dependencies = [
+ "openzeppelin",
+ "snforge_std",
+ "starkware_utils",
+]

package/Scarb.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["contracts/*"]
+

package/contracts/oft_mint_burn/Scarb.toml

@@ -0,0 +1,29 @@
+[package]
+name = "oft_mint_burn"
+version = "0.1.0"
+edition = "2024_07"
+
+# See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
+
+[dependencies]
+starknet = "2.14.0"
+openzeppelin = "2.0.0"
+lz_utils = { path = "../../node_modules/@layerzerolabs/protocol-starknet-v2/libs/lz_utils" }
+layerzero = { path = "../../node_modules/@layerzerolabs/protocol-starknet-v2/layerzero" }
+
+[dev-dependencies]
+snforge_std = "0.49.0"
+assert_macros = "2.12.0"
+starkware_utils_testing = { git = "https://github.com/starkware-libs/starkware-starknet-utils", rev = "e1955423808045de868987b8fb0b43f5cbdf5699" }
+
+[[target.starknet-contract]]
+sierra = true
+casm = true
+
+
+[scripts]
+test = "snforge test"
+
+[tool.scarb]
+allow-prebuilt-plugins = ["snforge_scarb_plugin", "snforge_std"]
+

package/contracts/oft_mint_burn/src/constants.cairo

@@ -0,0 +1,11 @@
+/// Role identifier for addresses that can manage fees
+pub const FEE_MANAGER_ROLE: felt252 = 'FEE_MANAGER_ROLE';
+
+/// Role identifier for addresses that can manage rate limits
+pub const RATE_LIMITER_MANAGER_ROLE: felt252 = 'RATE_LIMITER_MANAGER_ROLE';
+
+/// Role identifier for addresses that can upgrade the contract
+pub const UPGRADE_MANAGER_ROLE: felt252 = 'UPGRADE_MANAGER_ROLE';
+
+/// Role identifier for addresses that can pause the contract
+pub const PAUSE_MANAGER_ROLE: felt252 = 'PAUSE_MANAGER_ROLE';

package/contracts/oft_mint_burn/src/erc20_mint_burn_upgradeable/constants.cairo

@@ -0,0 +1,17 @@
+/// Role identifier for addresses that can mint new tokens
+/// In Solidity, this would be: bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE")
+pub const MINTER_ROLE: felt252 = 'MINTER_ROLE';
+
+/// Role identifier for addresses that can burn tokens without approval
+/// In Solidity, this would be: bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE")
+pub const BURNER_ROLE: felt252 = 'BURNER_ROLE';
+
+/// Role identifier for addresses that can pause the contract
+/// In Solidity, this would be: bytes32 public constant PAUSE_MANAGER_ROLE =
+/// keccak256("PAUSE_MANAGER_ROLE")
+pub const PAUSE_MANAGER_ROLE: felt252 = 'PAUSE_MANAGER_ROLE';
+
+/// Role identifier for addresses that can manage the allowlist
+/// In Solidity, this would be: bytes32 public constant ALLOWLIST_MANAGER_ROLE =
+/// keccak256("ALLOWLIST_MANAGER_ROLE")
+pub const ALLOWLIST_MANAGER_ROLE: felt252 = 'ALLOWLIST_MANAGER_ROLE';

package/contracts/oft_mint_burn/src/erc20_mint_burn_upgradeable/erc20_mint_burn_upgradeable.cairo

@@ -0,0 +1,309 @@
+/// ERC20MintBurnUpgradeable
+///
+/// Upgradeable ERC20 token with permissioned mint/burn functionality
+/// This contract provides a standard ERC20 token that allows permissioned minters and burners
+/// to mint and burn tokens through the IMintableToken interface.
+///
+/// Key features:
+/// - MINTER_ROLE: Addresses with this role can mint tokens via permissioned_mint
+/// - BURNER_ROLE: Addresses with this role can burn tokens via permissioned_burn
+/// - ALLOWLIST_MANAGER_ROLE: Addresses with this role can manage the allowlist
+/// - DEFAULT_ADMIN_ROLE: Can grant/revoke roles
+/// - Upgradeable for future improvements
+/// - Allowlist support with Open/Blacklist/Whitelist modes
+#[starknet::contract]
+pub mod ERC20MintBurnUpgradeable {
+    use AccessControlComponent::DEFAULT_ADMIN_ROLE;
+    use layerzero::common::constants::ZERO_ADDRESS;
+    use layerzero::oapps::common::allow_list::allow_list::AllowlistComponent;
+    use layerzero::oapps::common::allow_list::errors::err_not_allowed;
+    use layerzero::oapps::common::allow_list::interface::AllowlistMode;
+    use lz_utils::error::assert_with_byte_array;
+    use openzeppelin::access::accesscontrol::AccessControlComponent;
+    use openzeppelin::introspection::src5::SRC5Component;
+    use openzeppelin::security::pausable::PausableComponent;
+    use openzeppelin::token::erc20::ERC20Component;
+    use openzeppelin::token::erc20::interface::IERC20Metadata;
+    use openzeppelin::upgrades::UpgradeableComponent;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ClassHash, ContractAddress, get_caller_address};
+    use crate::erc20_mint_burn_upgradeable::constants::{
+        ALLOWLIST_MANAGER_ROLE, BURNER_ROLE, MINTER_ROLE, PAUSE_MANAGER_ROLE,
+    };
+    use crate::erc20_mint_burn_upgradeable::interface::IERC20MintBurnUpgradeable;
+    use crate::interface::IMintableToken;
+
+    // =============================== Components ===============================
+
+    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
+    component!(path: UpgradeableComponent, storage: upgradeable, event: UpgradeableEvent);
+    component!(path: PausableComponent, storage: pausable, event: PausableEvent);
+    component!(path: AccessControlComponent, storage: access_control, event: AccessControlEvent);
+    component!(path: SRC5Component, storage: src5, event: SRC5Event);
+    component!(path: AllowlistComponent, storage: allowlist, event: AllowlistEvent);
+
+
+    // Use individual embeds instead of Mixin to allow custom decimals override
+    #[abi(embed_v0)]
+    impl ERC20Impl = ERC20Component::ERC20Impl<ContractState>;
+    #[abi(embed_v0)]
+    impl ERC20CamelOnlyImpl = ERC20Component::ERC20CamelOnlyImpl<ContractState>;
+    impl ERC20InternalImpl = ERC20Component::InternalImpl<ContractState>;
+
+    impl UpgradeableInternalImpl = UpgradeableComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl AccessControlImpl =
+        AccessControlComponent::AccessControlImpl<ContractState>;
+    impl AccessControlInternalImpl = AccessControlComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl PausableImpl = PausableComponent::PausableImpl<ContractState>;
+    impl PausableInternalImpl = PausableComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl AllowlistImpl = AllowlistComponent::AllowlistImpl<ContractState>;
+    impl AllowlistInternalImpl = AllowlistComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        erc20: ERC20Component::Storage,
+        #[substorage(v0)]
+        upgradeable: UpgradeableComponent::Storage,
+        #[substorage(v0)]
+        access_control: AccessControlComponent::Storage,
+        #[substorage(v0)]
+        src5: SRC5Component::Storage,
+        #[substorage(v0)]
+        pausable: PausableComponent::Storage,
+        #[substorage(v0)]
+        allowlist: AllowlistComponent::Storage,
+        /// Token decimals (configurable via constructor)
+        decimals: u8,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        ERC20Event: ERC20Component::Event,
+        #[flat]
+        UpgradeableEvent: UpgradeableComponent::Event,
+        #[flat]
+        AccessControlEvent: AccessControlComponent::Event,
+        #[flat]
+        SRC5Event: SRC5Component::Event,
+        #[flat]
+        PausableEvent: PausableComponent::Event,
+        #[flat]
+        AllowlistEvent: AllowlistComponent::Event,
+    }
+
+    /// Initializes the ERC20 token with mint/burn capabilities
+    ///
+    /// # Arguments
+    /// * `name` - Token name
+    /// * `symbol` - Token symbol
+    /// * `decimals` - Token decimals
+    /// * `default_admin` - Address that will receive DEFAULT_ADMIN_ROLE
+    ///
+    /// # Notes
+    /// The default admin can grant MINTER_ROLE, BURNER_ROLE, and ALLOWLIST_MANAGER_ROLE to other
+    /// addresses. The allowlist is initialized in Open mode (all users allowed).
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        name: ByteArray,
+        symbol: ByteArray,
+        decimals: u8,
+        default_admin: ContractAddress,
+    ) {
+        assert(default_admin != ZERO_ADDRESS, 'Invalid admin: zero address');
+
+        // Initialize ERC20 with name and symbol
+        self.erc20.initializer(name, symbol);
+
+        // Store decimals in contract storage
+        self.decimals.write(decimals);
+
+        // Initialize access control
+        self.access_control.initializer();
+
+        // Initialize allowlist in Open mode (all users allowed by default)
+        self.allowlist.initializer(AllowlistMode::Open);
+
+        // Grant admin role to the specified address
+        // Admin can then grant MINTER_ROLE, BURNER_ROLE, and ALLOWLIST_MANAGER_ROLE as needed
+        self.access_control._grant_role(DEFAULT_ADMIN_ROLE, default_admin);
+    }
+
+    // Override ERC20Metadata to read decimals from storage
+    #[abi(embed_v0)]
+    impl ERC20MetadataImpl of IERC20Metadata<ContractState> {
+        fn name(self: @ContractState) -> ByteArray {
+            self.erc20.ERC20_name.read()
+        }
+
+        fn symbol(self: @ContractState) -> ByteArray {
+            self.erc20.ERC20_symbol.read()
+        }
+
+        fn decimals(self: @ContractState) -> u8 {
+            self.decimals.read()
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl MintableTokenImpl of IMintableToken<ContractState> {
+        /// Mints tokens to address using permitted minter pattern
+        ///
+        /// # Arguments
+        /// * `account` - Address to mint tokens to
+        /// * `amount` - Amount of tokens to mint
+        ///
+        /// # Access Control
+        /// Only callable by accounts with MINTER_ROLE
+        fn permissioned_mint(ref self: ContractState, account: ContractAddress, amount: u256) {
+            self._assert_only_minter();
+            self.erc20.mint(account, amount);
+        }
+
+        /// Burns tokens from address using permitted burner pattern
+        ///
+        /// # Arguments
+        /// * `account` - Address to burn tokens from
+        /// * `amount` - Amount of tokens to burn
+        ///
+        /// # Access Control
+        /// Only callable by accounts with BURNER_ROLE
+        ///
+        /// # Notes
+        /// Unlike standard burn, this doesn't require approval from token holder
+        fn permissioned_burn(ref self: ContractState, account: ContractAddress, amount: u256) {
+            self._assert_only_burner();
+            self.erc20.burn(account, amount);
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl ERC20MintBurnUpgradeableImpl of IERC20MintBurnUpgradeable<ContractState> {
+        fn upgrade(ref self: ContractState, new_class_hash: ClassHash) {
+            self._assert_only_default_admin();
+            self.upgradeable.upgrade(new_class_hash);
+        }
+
+        fn upgrade_and_call(
+            ref self: ContractState,
+            new_class_hash: ClassHash,
+            selector: felt252,
+            calldata: Span<felt252>,
+        ) -> Span<felt252> {
+            self._assert_only_default_admin();
+            self.upgradeable.upgrade_and_call(new_class_hash, selector, calldata)
+        }
+
+        fn pause(ref self: ContractState) {
+            self._assert_only_pause_manager();
+            self.pausable.pause();
+        }
+
+        fn unpause(ref self: ContractState) {
+            self._assert_only_pause_manager();
+            self.pausable.unpause();
+        }
+
+        fn set_allowlist_mode(ref self: ContractState, mode: AllowlistMode) {
+            self._assert_only_allowlist_manager();
+            self.allowlist._set_allowlist_mode(mode);
+        }
+
+        fn set_whitelisted(ref self: ContractState, users: Span<ContractAddress>, status: bool) {
+            self._assert_only_allowlist_manager();
+            self.allowlist._set_whitelisted(users, status);
+        }
+
+        fn set_blacklisted(ref self: ContractState, users: Span<ContractAddress>, status: bool) {
+            self._assert_only_allowlist_manager();
+            self.allowlist._set_blacklisted(users, status);
+        }
+    }
+
+    // =============================== ERC20 Hooks ===============================
+
+    // Overrides the default implementation of `ERC20Component::InternalTrait::update`
+    // - Mint (from == zero): NO pause check, NO allowlist check - can always mint
+    // - Burn (to == zero): Check pause AND allowlist on `from`
+    // - Transfer (both non-zero): Check pause AND allowlist on `from`, `to`,
+    // - Transfer from: caller if caller != from
+    impl ERC20Hooks of ERC20Component::ERC20HooksTrait<ContractState> {
+        fn before_update(
+            ref self: ERC20Component::ComponentState<ContractState>,
+            from: ContractAddress,
+            recipient: ContractAddress,
+            amount: u256,
+        ) {
+            // Mint: from == ZERO_ADDRESS - no checks, can always mint
+            if from == ZERO_ADDRESS {
+                return;
+            }
+
+            let contract = self.get_contract();
+
+            // For burn and transfer: check pause
+            contract.pausable.assert_not_paused();
+
+            // For burn (to == ZERO_ADDRESS): check allowlist on `from` only
+            if recipient == ZERO_ADDRESS {
+                assert_with_byte_array(
+                    contract.allowlist.is_user_allowlisted(from), err_not_allowed(),
+                );
+                return;
+            }
+
+            // For transfer: check allowlist on `from`, `recipient`, AND caller
+            assert_with_byte_array(
+                contract.allowlist.is_user_allowlisted(from)
+                    && contract.allowlist.is_user_allowlisted(recipient),
+                err_not_allowed(),
+            );
+
+            // handle transfer_from where caller != from
+            let caller = get_caller_address();
+            if caller != from {
+                assert_with_byte_array(
+                    contract.allowlist.is_user_allowlisted(caller), err_not_allowed(),
+                );
+            }
+        }
+    }
+
+    /// Internal functions for role validation
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        /// Validates caller has DEFAULT_ADMIN_ROLE
+        fn _assert_only_default_admin(self: @ContractState) {
+            self.access_control.assert_only_role(DEFAULT_ADMIN_ROLE);
+        }
+
+        /// Validates caller has MINTER_ROLE
+        fn _assert_only_minter(self: @ContractState) {
+            self.access_control.assert_only_role(MINTER_ROLE);
+        }
+
+        /// Validates caller has BURNER_ROLE
+        fn _assert_only_burner(self: @ContractState) {
+            self.access_control.assert_only_role(BURNER_ROLE);
+        }
+
+        /// Validates caller has PAUSE_MANAGER_ROLE
+        fn _assert_only_pause_manager(self: @ContractState) {
+            self.access_control.assert_only_role(PAUSE_MANAGER_ROLE);
+        }
+
+        /// Validates caller has ALLOWLIST_MANAGER_ROLE
+        fn _assert_only_allowlist_manager(self: @ContractState) {
+            self.access_control.assert_only_role(ALLOWLIST_MANAGER_ROLE);
+        }
+    }
+}

package/contracts/oft_mint_burn/src/erc20_mint_burn_upgradeable/interface.cairo

@@ -0,0 +1,86 @@
+use layerzero::oapps::common::allow_list::interface::AllowlistMode;
+use starknet::{ClassHash, ContractAddress};
+
+#[starknet::interface]
+pub trait IERC20MintBurnUpgradeable<TContractState> {
+    /// Upgrades 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 This function is only callable by the default admin.
+    fn upgrade(ref self: TContractState, new_class_hash: ClassHash);
+
+    /// Upgrades the contract and calls 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 This function is only callable by the default admin.
+    fn upgrade_and_call(
+        ref self: TContractState,
+        new_class_hash: ClassHash,
+        selector: felt252,
+        calldata: Span<felt252>,
+    ) -> Span<felt252>;
+
+    // =============================== Pause ===============================
+
+    /// Pauses the contract
+    ///
+    /// # Events
+    /// * `Paused` - Emitted when the contract is paused (from OpenZeppelin's
+    /// [`PausableComponent`])
+    fn pause(ref self: TContractState);
+
+    /// Unpauses the contract
+    ///
+    /// # Events
+    /// * `Unpaused` - Emitted when the contract is unpaused (from OpenZeppelin's
+    /// [`PausableComponent`])
+    fn unpause(ref self: TContractState);
+
+    // =============================== Allowlist ===============================
+
+    /// Sets the allowlist mode
+    ///
+    /// # Arguments
+    /// * `mode` - The new allowlist mode (Open, Blacklist, or Whitelist)
+    ///
+    /// # Access Control
+    /// Only callable by accounts with ALLOWLIST_MANAGER_ROLE
+    fn set_allowlist_mode(ref self: TContractState, mode: AllowlistMode);
+
+    /// Sets the whitelist status for multiple users
+    ///
+    /// # Arguments
+    /// * `users` - Array of user addresses
+    /// * `status` - Whether to whitelist (true) or unwhitelist (false)
+    ///
+    /// # Access Control
+    /// Only callable by accounts with ALLOWLIST_MANAGER_ROLE
+    fn set_whitelisted(ref self: TContractState, users: Span<ContractAddress>, status: bool);
+
+    /// Sets the blacklist status for multiple users
+    ///
+    /// # Arguments
+    /// * `users` - Array of user addresses
+    /// * `status` - Whether to blacklist (true) or unblacklist (false)
+    ///
+    /// # Access Control
+    /// Only callable by accounts with ALLOWLIST_MANAGER_ROLE
+    fn set_blacklisted(ref self: TContractState, users: Span<ContractAddress>, status: bool);
+}

package/contracts/oft_mint_burn/src/errors.cairo

@@ -0,0 +1,39 @@
+//! OFT Mint Burn Adapter errors
+
+use lz_utils::error::{Error, format_error};
+use starknet::ContractAddress;
+
+#[derive(Drop)]
+pub enum OFTMintBurnAdapterError {
+    NoFeesToWithdraw,
+    TransferFailed,
+    CallerNotOwnerOrMissingRole,
+}
+
+impl OFTMintBurnAdapterErrorImpl of Error<OFTMintBurnAdapterError> {
+    fn prefix() -> ByteArray {
+        "OFT_MINT_BURN_ADAPTER"
+    }
+
+    fn name(self: OFTMintBurnAdapterError) -> ByteArray {
+        match self {
+            OFTMintBurnAdapterError::NoFeesToWithdraw => "NO_FEES_TO_WITHDRAW",
+            OFTMintBurnAdapterError::TransferFailed => "TRANSFER_FAILED",
+            OFTMintBurnAdapterError::CallerNotOwnerOrMissingRole => "CALLER_NOT_OWNER_OR_MISSING_ROLE",
+        }
+    }
+}
+
+pub fn err_no_fees_to_withdraw() -> ByteArray {
+    format_error(OFTMintBurnAdapterError::NoFeesToWithdraw, "")
+}
+
+pub fn err_transfer_failed(to: ContractAddress, amount: u256) -> ByteArray {
+    format_error(
+        OFTMintBurnAdapterError::TransferFailed, format!("to: {:?}, amount: {:?}", to, amount),
+    )
+}
+
+pub fn err_caller_not_owner_or_missing_role(role: felt252) -> ByteArray {
+    format_error(OFTMintBurnAdapterError::CallerNotOwnerOrMissingRole, format!("role: {:?}", role))
+}