{"sources":{"src/common/libraries/Math.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.19;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10**64) {\n                value /= 10**64;\n                result += 64;\n            }\n            if (value >= 10**32) {\n                value /= 10**32;\n                result += 32;\n            }\n            if (value >= 10**16) {\n                value /= 10**16;\n                result += 16;\n            }\n            if (value >= 10**8) {\n                value /= 10**8;\n                result += 8;\n            }\n            if (value >= 10**4) {\n                value /= 10**4;\n                result += 4;\n            }\n            if (value >= 10**2) {\n                value /= 10**2;\n                result += 2;\n            }\n            if (value >= 10**1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"src/tokens/common/BaseERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"../interfaces/IERC165.sol\";\nimport \"../interfaces/erc20/IERC20Token.sol\";\nimport \"../../common/access-control/AccessControl.sol\";\nimport \"../../common/libraries/StorageSlot.sol\";\nimport \"../../tokens/interfaces/IBeacon.sol\";\n\n/**\n * @title BaseERC20\n * @dev Implementation of the basic standard ERC20 token with Access Control and upgradeability.\n */\ncontract BaseERC20 is \n    IERC165,\n    IERC20,\n    IERC20WithRoles,\n    IERC20Burnable,\n    IERC20Mintable,\n    IERC20Events,\n    AccessControl\n{\n\n    using StorageSlot for StorageSlot.AddressSlot;\n    using StorageSlot for StorageSlot.Uint256Slot;\n    using StorageSlot for StorageSlot.BooleanSlot;\n    using StorageSlot for StorageSlot.Uint8Slot;\n    using StorageSlot for StorageSlot.StringSlot;\n\n    // Beacon Address\n    bytes32 internal constant _BEACON_SLOT = keccak256(\"proxy.beacon\");\n\n    // Initialization owner address\n    bytes32 internal constant _INIT_OWNER_SLOT = keccak256(\"proxy.initializationOwnerAddress\");\n\n    // Token total supply\n    bytes32 internal constant _TOTAL_SUPPLY_SLOT = keccak256(\"proxy.totalSupply\");\n\n    // Contract initialization status\n    bytes32 internal constant _IS_INITIALIZED_SLOT = keccak256(\"proxy.isInitialized\");\n\n    // Stores number of the token decimals\n    bytes32 internal constant _DECIMALS_SLOT = keccak256(\"proxy.decimals\");\n\n    // Stores token name\n    bytes32 internal constant _NAME_SLOT = keccak256(\"proxy.name\");\n\n    // Stores token symbol\n    bytes32 internal constant _SYMBOL_SLOT = keccak256(\"proxy.symbol\");\n\n    // Stores token holders balances\n    bytes32 internal constant _BALANCES_SLOT = keccak256(\"proxy.balances\");\n\n    // Token approvals\n    bytes32 internal constant _ALLOWED_SLOT = keccak256(\"proxy.allowed\");\n\n    /**\n     * @dev Emitted when the Beacon address is changed.\n     * @param previousBeacon The address of the previous Beacon.\n     * @param newBeacon The address of the new Beacon.\n     */\n    event BeaconChanged(address indexed previousBeacon, address indexed newBeacon);\n\n\n    /**\n     * @notice Inputs verification\n     * @param addr The address to verify\n     * @param value the amount of tokens to be verified\n     */\n    modifier verifyInputs(address addr, uint256 value) {\n        require(addr != address(0x00), \"verifyInputs: Invalid address\");\n        require(value > 0x00, \"verifyInputs: Invalid value\");\n        _;\n    }\n\n    /**\n     * @notice Ensure that only the initialization owner can call certain functions.\n     */\n    modifier onlyInitializationOwner() {\n        require(msg.sender == StorageSlot.getAddressSlot(_INIT_OWNER_SLOT).value, \"initialize: Caller is not the initialization owner\");\n        _;\n    }\n\n    /**\n     * @notice Initialize the contract with the given initialization owner address and roles.\n     * @param name_ The name of the token\n     * @param symbol_ The symbol of the token\n     * @param decimals_ The number of decimals of the token\n     * @param totalSupply_ The total supply of the token\n     * @param tokensRecipient_ The address receiving the initial supply of tokens\n     * @param owner The address assigned the DEFAULT_ADMIN_ROLE\n     * @param issuer The address assigned the ISSUER_ROLE\n     * @param registrar The address assigned the REGISTRAR_ROLE\n     */\n    function initializeWithRoles(\n        string memory name_,\n        string memory symbol_,\n        uint8 decimals_,\n        uint256 totalSupply_,\n        address tokensRecipient_,\n        address owner,\n        address issuer,\n        address registrar\n    ) external onlyInitializationOwner {\n        require(owner != address(0), \"initialize: Invalid address for owner\");\n        require(issuer != address(0), \"initialize: Invalid address for issuer\");\n        require(registrar != address(0), \"initialize: Invalid address for registrar\");\n        require(!StorageSlot.getBooleanSlot(_IS_INITIALIZED_SLOT).value, \"initialize: contract already initialized\");\n\n        require(\n            (bytes(symbol_).length > 0) && (bytes(symbol_).length < 13),\n            \"Symbol length should always be between 1 & 12\"\n        );\n        require(decimals_ > 0 && decimals_ <= 18, \"Invalid decimals_ value\");\n        require(bytes(name_).length > 0, \"Empty name\");\n\n        // Set the values using storage slots\n        StorageSlot.getStringSlot(_NAME_SLOT).value = name_;\n        StorageSlot.getStringSlot(_SYMBOL_SLOT).value = symbol_;\n        StorageSlot.getUint8Slot(_DECIMALS_SLOT).value = decimals_;\n\n        if (totalSupply_ > 0) {\n            require(tokensRecipient_ != address(0x00), \"Can't mint tokens to the empty address\");\n            _mint(tokensRecipient_, totalSupply_);\n        }\n\n        _grantRole(DEFAULT_ADMIN_ROLE, owner);\n        _grantRole(ISSUER_ROLE, issuer);\n        _grantRole(REGISTRAR_ROLE, registrar);\n        _setRoleAdmin(ISSUER_ROLE, DELEGATED_ADMIN_ROLE);\n        _setRoleAdmin(REGISTRAR_ROLE, DELEGATED_ADMIN_ROLE);\n\n        // Set the initialization flag using storage slot\n        StorageSlot.getBooleanSlot(_IS_INITIALIZED_SLOT).value = true;\n\n    }\n\n    /**\n     * @notice Allows the contract's DEFAULT_ADMIN_ROLE to upgrade the Beacon and optionally execute a function on the new implementation.\n     * @param newBeacon The address of the new Beacon contract.\n     * @param callData The data to be passed to the delegate call on the new implementation.\n     *\n     * Emits a {BeaconChanged} event.\n     *\n     * Requirements:\n     * - The caller must have the `DEFAULT_ADMIN_ROLE`.\n     * - `newBeacon` cannot be the zero address.\n     */\n    function upgradeBeaconToAndCall(\n        address newBeacon,\n        bytes memory callData\n    ) \n        external \n        onlyRole(DEFAULT_ADMIN_ROLE) \n    {\n        require(newBeacon != address(0), \"Proxy: new beacon is the zero address\");\n        address previousBeacon = StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n        _setBeacon(newBeacon);\n        emit BeaconChanged(previousBeacon, newBeacon);\n        \n        if (callData.length > 0) {\n            address implementationAddress = IBeacon(StorageSlot.getAddressSlot(_BEACON_SLOT).value).implementation();\n            (bool success, ) = implementationAddress.delegatecall(callData);\n            require(success, \"Proxy: Call failed\");\n        }\n    }\n\n    /**\n     * @dev Internal function to set a new Beacon address in the contract's storage.\n     * @param newBeacon The address of the new Beacon contract.\n     *\n     */\n    function _setBeacon(address newBeacon) private {\n        require(newBeacon != address(0), \"Proxy: new beacon is the zero address\");\n        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n    }\n         \n    /**\n     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.\n     * @dev Beware that changing an allowance with this method brings the risk that someone may use both the old\n     * @dev and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this\n     * @dev race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:\n     * @dev https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     * @param spender The address which will spend the funds.\n     * @param tokens The amount of tokens to be spent.\n     */\n    function approve(address spender, uint256 tokens) external virtual override returns (bool) {\n        require(spender != address(0x00), \"approve: No spender\");\n        require(spender != msg.sender, \"approve: Same spender\");\n\n        StorageSlot.getUint256Slot(keccak256(abi.encode(_ALLOWED_SLOT, msg.sender, spender))).value = tokens;\n\n        emit Approval(msg.sender, spender, tokens);\n\n        return true;\n    }\n\n    /**\n     * @notice ERC-20-Lite transfer function.\n     * @param to The address which you want to transfer to\n     * @param value the amount of tokens to be transferred\n     * @return bool flag - true if transfer is successful\n     */\n    function transfer(address to, uint256 value) external virtual override returns (bool) {\n        require(to != address(0x00), \"transfer: Invalid address\");\n        return _transfer(msg.sender, to, value);\n    }\n\n    /**\n     * @notice ERC-20 transferFrom function.\n     * @param to The address which you want to transfer to\n     * @param tokens the amount of tokens to be transferred\n     * @param from The address from which will be transferred token\n     * @return bool flag - true if transfer is successfule\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 tokens\n    ) external virtual override returns (bool) {\n        require(to != address(0x00), \"transfer: Invalid address\");\n        return _transferFrom(from, to, tokens);\n    }\n\n    /**\n     * @notice Function to mint tokens\n     * @param to The address that will receive the minted tokens\n     * @param value The amount of tokens to mint\n     */\n    function mint(address to, uint256 value) external virtual override onlyRole(REGISTRAR_ROLE) verifyInputs(to, value) {\n        _mint(to, value);\n    }\n\n    /**\n     * @notice Burns a specific amount of tokens for selected address\n     * @notice Protected by permission module\n     * @param from Address from which tokens were burned\n     * @param value The amount of token to be burned\n     */\n    function burn(address from, uint256 value) external virtual override onlyRole(REGISTRAR_ROLE) verifyInputs(from, value) {\n        _burn(from, value);\n    }\n\n    /**\n     * @return the name of the token.\n     */\n    function name() external view override returns (string memory) {\n        return StorageSlot.getStringSlot(_NAME_SLOT).value;\n    }\n\n    /**\n     * @return the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() external view override returns (string memory) {\n        return StorageSlot.getStringSlot(_SYMBOL_SLOT).value;\n    }\n\n    /**\n     * @return the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n     * called.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() external view override returns (uint8) {\n        return StorageSlot.getUint8Slot(_DECIMALS_SLOT).value;\n    }\n\n    /**\n     * @return Total number of tokens in existence\n     */\n    function totalSupply() external view override returns (uint256) {\n        return StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value;\n\n    }\n\n    /**\n     * @param tokenHolder Token holder address\n     * @return result Token holder balance\n     */\n    function balanceOf(address tokenHolder) external view override returns (uint256 result) {\n        return StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, tokenHolder))).value;\n\n    }\n\n    /**\n     * @dev Function to check the amount of tokens that an owner allowed to a spender.\n     * @param owner address The address which owns the funds.\n     * @param spender address The address which will spend the funds.\n     * @return tokens A uint256 specifying the amount of tokens still available for the spender.\n     */\n    function allowance(address owner, address spender) external view override returns (uint256 tokens) {\n        return StorageSlot.getUint256Slot(keccak256(abi.encode(_ALLOWED_SLOT, owner, spender))).value;\n    }\n\n    /**\n     * @notice Update balances\n     * @param from Sender address\n     * @param to Recipient address\n     * @param tokens the amount of tokens to be transferred\n     */\n    function _transferFrom(\n        address from,\n        address to,\n        uint256 tokens\n    ) internal returns (bool) {\n        if (from != msg.sender) {\n            uint256 allowedTokens = StorageSlot.getUint256Slot(keccak256(abi.encode(_ALLOWED_SLOT, from, msg.sender))).value;\n            require(allowedTokens >= tokens, \"_transferFrom: Transfer not allowed\");\n\n            unchecked {\n                StorageSlot.getUint256Slot(keccak256(abi.encode(_ALLOWED_SLOT, from, msg.sender))).value = allowedTokens - tokens;\n            }\n        }\n\n        return _transfer(from, to, tokens);\n    }\n\n\n    /**\n     * @notice Transfer function.\n     * @param from The address which you want to transfer from\n     * @param to The address which you want to transfer to\n     * @param value the amount of tokens to be transferred\n     */\n    function _transfer(\n        address from,\n        address to,\n        uint256 value\n    ) internal returns (bool) {\n        require(from != to, \"_transfer: Cannot transfer to yourself\");\n\n        uint256 fromBalance = StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, from))).value;\n        require(fromBalance >= value, \"_transfer: Insufficient funds\");\n\n        if (from == address(0)) {\n            uint256 currentTotalSupply = StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value;\n            require(type(uint256).max - value >= currentTotalSupply, \"_transfer: totalSupply overflow\");\n            StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value = currentTotalSupply + value;\n        } else {\n            StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, from))).value = fromBalance - value;\n        }\n\n        if (to == address(0)) {\n            uint256 currentTotalSupply = StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value;\n            require(currentTotalSupply >= value, \"_transfer: totalSupply underflow\");\n            StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value = currentTotalSupply - value;\n        } else {\n            uint256 toBalance = StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, to))).value;\n            StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, to))).value = toBalance + value;\n        }\n\n        emit Transfer(from, to, value);\n\n        return true;\n    }\n\n\n    /**\n    * @notice Mints a specific amount of tokens.\n    * @param to Address to which tokens to be minted\n    * @param value The amount of tokens to be minted.\n    */\n    function _mint(address to, uint256 value) internal {\n        uint256 toBalance = StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, to))).value;\n        StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, to))).value = toBalance + value;\n\n        uint256 currentTotalSupply = StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value;\n        require(type(uint256).max - value >= currentTotalSupply, \"_mint: totalSupply overflow\");\n        StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value = currentTotalSupply + value;\n\n        emit Transfer(address(0), to, value);\n    }\n\n    /**\n    * @notice Burns a specific amount of tokens.\n    * @param from Address from which tokens to be burned\n    * @param value The amount of tokens to be burned.\n    */\n    function _burn(address from, uint256 value) internal {\n        uint256 fromBalance = StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, from))).value;\n        require(fromBalance >= value, \"_burn: Insufficient funds\");\n        StorageSlot.getUint256Slot(keccak256(abi.encode(_BALANCES_SLOT, from))).value = fromBalance - value;\n\n        uint256 currenttotalSupply = StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value;\n        StorageSlot.getUint256Slot(_TOTAL_SUPPLY_SLOT).value = currenttotalSupply - value;\n\n        emit Transfer(from, address(0), value);\n    }\n\n    \n\n\n    /**\n     * @notice Query if a contract implements an interface\n     * @param interfaceID The interface identifier, as specified in ERC-165\n     * @dev Interface identification is specified in ERC-165\n     * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md\n     * @return `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise\n     */\n    function supportsInterface(bytes4 interfaceID) public pure virtual override returns (bool) {\n        if (\n            interfaceID == type(IERC165).interfaceId ||\n            interfaceID == type(IERC20).interfaceId ||\n            interfaceID == type(IERC20WithRoles).interfaceId ||\n            interfaceID == type(IERC20Burnable).interfaceId ||\n            interfaceID == type(IERC20Mintable).interfaceId ||\n            interfaceID == type(IERC20Events).interfaceId ||\n            interfaceID == type(IAccessControl).interfaceId\n        ) {\n            return true;\n        }\n        return interfaceID == 0xffffffff ? false : false;\n    }\n}\n"},"src/common/libraries/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\n\npragma solidity 0.8.19;\n\nimport \"./Math.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n}"},"src/tokens/interfaces/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\ninterface IBeacon {\n    function implementation() external view returns (address);\n}\n"},"src/tokens/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"src/common/libraries/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.19;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n    \n    // New struct for Uint8Slot\n    struct Uint8Slot {\n        uint8 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint8Slot` with member `value` located at `slot`.\n     */\n    function getUint8Slot(bytes32 slot) internal pure returns (Uint8Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n}"},"src/tokens/interfaces/ICompliance.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Compliance interface for transfer validations\n * @dev Interface to define compliance rules for token transfers\n */\ninterface ICompliance {\n    /**\n     * @notice Determines if a transfer is allowed under compliance rules\n     * @dev Checks if a transfer from one address to another with a specific amount is compliant\n     * @dev Compliance rules can include, but are not limited to:\n     * @dev - Checking if both sender and receiver are whitelisted\n     * @dev - Ensuring the amount does not exceed certain limits\n     * @dev - Verifying transfer does not violate the regulatory requirements set by the contract\n     * @param from Address of the sender of the tokens\n     * @param to Address of the receiver of the tokens\n     * @param amount Amount of tokens to be transferred\n     * @return bool Returns true if the transfer is compliant, false otherwise\n     */\n    function canTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) external view returns (bool);\n}\n"},"src/tokens/interfaces/erc20/IERC20.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 token functions\n */\ninterface IERC20 {\n    /**\n     * @notice ERC-20 transfer function\n     * @param to The address receiving the transfer\n     * @param tokens the amount of tokens to be transferred\n     * @return bool flag - true if transfer is successful\n     */\n    function transfer(address to, uint256 tokens) external returns (bool);\n\n    /**\n     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.\n     * @dev Beware that changing an allowance with this method brings the risk that someone may use both the old\n     * @dev and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this\n     * @dev race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:\n     * @dev https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     * @param spender The address which will spend the funds.\n     * @param tokens The amount of tokens to be spent.\n     * @return success approve result.\n     */\n    function approve(address spender, uint256 tokens) external returns (bool success);\n\n    /**\n     * @notice ERC-20 transferFrom function.\n     * @param to The address to receive the transfer\n     * @param tokens the amount of tokens to be transferred\n     * @param from The address sending the transfer\n     * @return bool flag - true if transfer is successfule\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 tokens\n    ) external returns (bool);\n\n    /**\n     * @return the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @return the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @return the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n     * called.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() external view returns (uint8);\n\n    /**\n     * @return Total number of tokens in existence\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @param tokenHolder Token holder address\n     * @return result Token holder balance\n     */\n    function balanceOf(address tokenHolder) external view returns (uint256 result);\n\n    /**\n     * @dev Function to check the amount of tokens that an owner allowed to a spender.\n     * @param tokenOwner address The address which owns the funds.\n     * @param spender address The address which will spend the funds.\n     * @return tokens A uint256 specifying the amount of tokens still available for the spender.\n     */\n    function allowance(address tokenOwner, address spender) external view returns (uint256 tokens);\n}\n"},"src/common/access-control/AccessControl.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity ^0.8.19;\n\nimport \"./IAccessControl.sol\";\nimport \"../libraries/Strings.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * This version includes an admin cap for the `DEFAULT_ADMIN_ROLE`\n * to ensure secure role management and avoid excessive administrative power.\n */\nabstract contract AccessControl is IAccessControl {\n\n    struct RoleDataC20 {\n        mapping(address => bool) members;\n        bytes32 adminRole;\n    }\n\n    struct Delegate {\n        address from;\n        address[] delegates;\n    }\n\n    mapping(bytes32 => RoleDataC20) internal _rolesC20;\n\n    /// @notice Maximum number of accounts that can hold the `DEFAULT_ADMIN_ROLE`\n    uint256 public constant MAX_ADMINS = 3;\n\n    /// @notice Current number of accounts that hold the `DEFAULT_ADMIN_ROLE`\n    uint256 private _adminCount = 0;\n\n    /// @notice Maximum number of delegates that can be assigned the `DELEGATED_ADMIN_ROLE`\n    uint256 public constant MAX_DELEGATES = 12;\n\n    /// @notice Mapping that stores the delegation tree structure\n    mapping(address => Delegate) public delegatedAdmins;\n\n    /// @notice Cursor to track the number of delegates assigned\n    uint256 public lastDelegatedAdmin = 0;\n\n    /// @notice Predefined roles within the system\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n    bytes32 public constant ISSUER_ROLE = keccak256(\"ISSUER_ROLE\");\n    bytes32 public constant REGISTRAR_ROLE = keccak256(\"REGISTRAR_ROLE\");\n    bytes32 public constant DELEGATED_ADMIN_ROLE = keccak256(\"DELEGATED_ADMIN_ROLE\");\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with a standardized message including the required role.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev Modifier that checks that a given role is not 'DEFAULT_ADMIN_ROLE'\n     */\n    modifier notDefaultAdminRole(bytes32 role) {\n        require(\n            role != DEFAULT_ADMIN_ROLE,\n            \"AccessControl: notDefaultAdminRole, DEFAULT_ADMIN_ROLE is intransferable\"\n        );\n        _;\n    }\n\n    /**\n     * @dev Modifier that checks that a given role is not 'DELEGATED_ADMIN_ROLE'\n     */\n    modifier notDelegatedAdminRole(bytes32 role) {\n        require(\n            role != DELEGATED_ADMIN_ROLE,\n            \"AccessControl: notDelegatedAdminRole, Cannot edit DELEGATED_ADMIN_ROLE using this function\"\n        );\n        _;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted} event.\n     *\n     * Requirements:\n     * - The caller must have the admin role associated with `role`.\n     * - The role must not be `DEFAULT_ADMIN_ROLE` or `DELEGATED_ADMIN_ROLE`.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account)\n        public\n        virtual\n        override\n        onlyRole(getRoleAdmin(role))\n        notDefaultAdminRole(role)\n        notDelegatedAdminRole(role)\n    {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Grants `DEFAULT_ADMIN_ROLE` to `account`.\n     *\n     * Requirements:\n     * - The caller must have `DEFAULT_ADMIN_ROLE`.\n     * - The admin cap must not have been reached.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantDefaultAdminRole(address account) public virtual override {\n        require(\n            hasRole(DEFAULT_ADMIN_ROLE, msg.sender),\n            \"grantDefaultAdminRole: Incorrect Admin Role\"\n        );\n        require(\n\t        !hasRole(DELEGATED_ADMIN_ROLE, account),\n\t        \"grantDefaultAdminRole: DELEGATED_ADMIN_ROLE accounts cannot be assigned DEFAULT_ADMIN_ROLE\"\n        );\n        require(\n            !hasRole(DEFAULT_ADMIN_ROLE, account),\n            \"grantDefaultAdminRole: DEFAULT_ADMIN_ROLE accounts cannot be re-assigned DEFAULT_ADMIN_ROLE\"\n        );\n        require(_adminCount < MAX_ADMINS, \"grantDefaultAdminRole: Admin cap reached\");\n\n        _grantRole(DEFAULT_ADMIN_ROLE, account);\n    }\n\n    /**\n     * @dev Grants `DELEGATED_ADMIN_ROLE` to `account`.\n     *\n     * Requirements:\n     * - The caller must have `DEFAULT_ADMIN_ROLE` or `DELEGATED_ADMIN_ROLE`.\n     * - The total number of delegates must not exceed `MAX_DELEGATES`.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantDelegateAdminRole(address account) public virtual override {\n        require(\n            hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || hasRole(DELEGATED_ADMIN_ROLE, msg.sender),\n            \"grantDelegateAdminRole: Incorrect Admin Role\"\n        );\n        require(!hasRole(DELEGATED_ADMIN_ROLE, account), \"_grantDelegateAdminRole: account already has this role\");\n        require(\n            !hasRole(DEFAULT_ADMIN_ROLE, account),\n            \"grantDelegateAdminRole: DEFAULT_ADMIN_ROLE accounts cannot be assigned DELEGATED_ADMIN_ROLE\"\n        );\n        require(account != address(0x00), \"0x address\");\n        require(lastDelegatedAdmin < MAX_DELEGATES, \"grantDelegateAdminRole: Delegate cap reached\");\n\n        delegatedAdmins[msg.sender].delegates.push(account);\n        delegatedAdmins[account].from = msg.sender;\n\n        _grantRole(DELEGATED_ADMIN_ROLE, account);\n        lastDelegatedAdmin++;\n    }\n\n    /**\n     * @dev Batch grants `DELEGATED_ADMIN_ROLE` to each address in `accounts` array.\n     *\n     * Requirements:\n     * - The caller must have `DEFAULT_ADMIN_ROLE`.\n     * - The total number of delegates must not exceed `MAX_DELEGATES`.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function batchGrantDelegateAdminRole(address[] memory accounts) public virtual override {\n        require(\n            hasRole(DEFAULT_ADMIN_ROLE, msg.sender),\n            \"batchGrantDelegateAdminRole: Only DEFAULT_ADMIN_ROLE can batch delegate\"\n        );\n\n        uint256 _len = accounts.length;\n        require(lastDelegatedAdmin + _len <= MAX_DELEGATES, \"batchGrantDelegateAdminRole: Delegate cap exceeded\");\n\n        for (uint256 i; i < _len; ++i) {\n            grantDelegateAdminRole(accounts[i]);\n        }\n    }\n\n    /**\n     * @dev Revokes `DELEGATED_ADMIN_ROLE` from `account`.\n     *\n     * Requirements:\n     * - The caller must have either the `DEFAULT_ADMIN_ROLE` or be the direct delegator.\n     */\n    function revokeDelegateAdminRole(address account) public virtual override {\n        bool _isDefaultAdmin = hasRole(DEFAULT_ADMIN_ROLE, msg.sender);\n        require(hasRole(DELEGATED_ADMIN_ROLE, account), \"revokeDelegateAdminRole: Account is not a DELEGATED_ADMIN_ROLE\");\n        require(\n            _isDefaultAdmin || delegatedAdmins[account].from == msg.sender,\n            \"revokeDelegateAdminRole: Msg.sender does not have admin rights over this role for account\"\n        );\n\n        _recursiveRemoveDelegate(account, _isDefaultAdmin);\n    }\n\n    /**\n     * @dev Revokes `DEFAULT_ADMIN_ROLE` from `account`.\n     *\n     * Requirements:\n     * - The caller must have the `DEFAULT_ADMIN_ROLE`.\n     * - At least one admin must remain after the revocation.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeDefaultAdminRole(address account) public virtual override {\n        require(\n            hasRole(DEFAULT_ADMIN_ROLE, msg.sender),\n            \"revokeDefaultAdminRole: Incorrect Admin Role\"\n        );\n        require(\n            hasRole(DEFAULT_ADMIN_ROLE, account), \n            \"revokeDefaultAdminRole: Account is not a DEFAULT_ADMIN_ROLE\"\n        );\n        require(_adminCount > 1, \"revokeDefaultAdminRole: Cannot have less than one admin\");\n\n        // Revoke all delegates of this admin\n        Delegate memory delegateInfo = delegatedAdmins[account];\n        uint256 delegatesLength = delegateInfo.delegates.length;\n\n        for (uint256 i = 0; i < delegatesLength; ++i) {\n            _removeDelegate(delegateInfo.delegates[i]);\n        }\n\n        delete delegatedAdmins[account];\n\n        _revokeRole(DEFAULT_ADMIN_ROLE, account);     \n        _adminCount--;\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     * - The caller must have the admin role associated with `role`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account)\n        public\n        virtual\n        override\n        onlyRole(getRoleAdmin(role))\n        notDefaultAdminRole(role)\n        notDelegatedAdminRole(role)\n    {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * Requirements:\n     * - The caller must be `account`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role) public virtual override notDefaultAdminRole(role) notDelegatedAdminRole(role) {\n        _revokeRole(role, msg.sender);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     * @param role The role to check.\n     * @param account The account to check.\n     */\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n        return _rolesC20[role].members[account];\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     * @param role The role to check.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n        return _rolesC20[role].adminRole;\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     * @param role The role to change.\n     * @param adminRole The new admin role.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _rolesC20[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * Internal function without access restriction.\n     * @param role The role to grant.\n     * @param account The account to grant the role to.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual {\n        require(account != address(0x00), \"0x address\");\n\n        if (role == DEFAULT_ADMIN_ROLE) {\n            require(\n                !hasRole(DEFAULT_ADMIN_ROLE, account),\n                \"_grantRole: DEFAULT_ADMIN_ROLE accounts cannot be re-assigned DEFAULT_ADMIN_ROLE\"\n            );\n            _adminCount++;\n        }\n\n        if (!hasRole(role, account)) {\n            _rolesC20[role].members[account] = true;\n            emit RoleGranted(role, account, msg.sender);\n        }\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     * @param role The role to revoke.\n     * @param account The account to revoke the role from.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual {\n        require(account != address(0x00), \"0x address\");\n        if (hasRole(role, account)) {\n            _rolesC20[role].members[account] = false;\n            emit RoleRevoked(role, account, msg.sender);\n        }\n    }\n\n    /**\n     * @dev Recursively removes delegate roles from an account.\n     * @param account The account to remove delegate roles from.\n     * @param _isDefaultAdmin Boolean indicating if the caller is a default admin.\n     */\n    function _recursiveRemoveDelegate(address account, bool _isDefaultAdmin) internal virtual {\n        require(account != address(0x00), \"0x address\");\n\n        address parent = delegatedAdmins[account].from;\n        require(parent == msg.sender || _isDefaultAdmin, \"no rights to revoke\");\n\n        if (parent != address(0)) {\n            Delegate storage parentInfo = delegatedAdmins[parent];\n            uint256 delegatesLength = parentInfo.delegates.length;\n            for (uint256 i = 0; i < delegatesLength; ++i) {\n                if (parentInfo.delegates[i] == account) {\n                    parentInfo.delegates[i] = parentInfo.delegates[delegatesLength - 1];\n                    parentInfo.delegates.pop();\n                    break;\n                }\n            }\n        }\n\n        _removeDelegate(account);\n    }\n\n    function _removeDelegate(address account) internal virtual {\n        Delegate memory delegateInfo = delegatedAdmins[account];\n        uint256 delegatesLength = delegateInfo.delegates.length;\n\n        for (uint256 i = 0; i < delegatesLength; ++i) {\n            _removeDelegate(delegateInfo.delegates[i]);\n        }\n\n        delete delegatedAdmins[account];\n        _revokeRole(DELEGATED_ADMIN_ROLE, account);\n        lastDelegatedAdmin--;\n    }\n\n    /**\n     * @dev Revert with a standard message if `msg.sender` is missing `role`.\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\n     *\n     * Format of the revert message is described in {_checkRole}.\n     *\n     * _Available since v4.6._\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, msg.sender);\n    }\n\n    /**\n     * @dev Revert with a standard message if `account` is missing `role`.\n     * @param role The role to check.\n     * @param account The account to check.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account) && !hasRole(DEFAULT_ADMIN_ROLE, account)) {\n            revert(\n                string(\n                    abi.encodePacked(\n                        \"AccessControl: account \",\n                        Strings.toHexString(account),\n                        \" is missing role \",\n                        Strings.toHexString(uint256(role), 32)\n                    )\n                )\n            );\n        }\n    }\n}\n"},"src/tokens/interfaces/erc20/IERC20Token.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\nimport \"./IERC20Burnable.sol\";\nimport \"./IERC20Clawback.sol\";\nimport \"./IERC20.sol\";\nimport \"./IERC20WithRoles.sol\";\nimport \"./IERC20Mintable.sol\";\nimport \"./IERC20Pausable.sol\";\nimport \"./IERC20Freeze.sol\";\nimport \"./IERC20Events.sol\";\nimport \"./IERC20FreezeEvents.sol\";\nimport \"./IERC20PausableEvents.sol\";\nimport \"./IERC20ClawbackEvents.sol\";\nimport \"./IERC20BatchBasic.sol\";\nimport \"./IERC20BatchClawback.sol\";\nimport \"./IERC20BatchFreeze.sol\";\nimport \"../../../common/access-control/IAccessControl.sol\";\n\n/**\n * @title The comprehensive interface of ERC-20\n */\ninterface IERC20Token is\n    IERC20Burnable,\n    IERC20Clawback,\n    IERC20,\n    IERC20WithRoles,\n    IERC20Mintable,\n    IERC20Pausable,\n    IERC20Freeze,\n    IERC20Events,\n    IERC20FreezeEvents,\n    IERC20PausableEvents,\n    IERC20ClawbackEvents,\n    IERC20BatchBasic,\n    IERC20BatchClawback,\n    IERC20BatchFreeze,\n    IAccessControl\n{\n\n}\n"},"src/tokens/standards/ERC20BasicStandard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"../common/BaseERC20.sol\";\n\n/**\n * @title ERC20BasicStandard\n * @dev Implementation of a basic ERC20 token standard with Access Control and beacon-based upgradeability.\n */\ncontract ERC20BasicStandard is \n    BaseERC20, \n    IERC20BatchBasic\n{\n\n    /**\n     *  @dev See {ERC20Batch-batchTransfer}.\n     */\n    function batchTransfer(address[] calldata _toList, uint256[] calldata _amounts) external virtual override {\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length, \"batchTransfer: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchTransfer: Invalid address\");\n            require(_amounts[i] > 0, \"batchTransfer: Amount must be greater than zero\");\n            _transfer(msg.sender, _toList[i], _amounts[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchMint}.\n     */\n    function batchMint(address[] calldata _toList, uint256[] calldata _amounts)\n        external\n        virtual \n        override\n        onlyRole(REGISTRAR_ROLE)\n    {\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length, \"batchMint: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchMint: Invalid address\");\n            require(_amounts[i] > 0x00, \"batchMint: Invalid value\");\n            _mint(_toList[i], _amounts[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchBurn}.\n     */\n    function batchBurn(address[] calldata _userAddresses, uint256[] calldata _amounts)\n        external\n        virtual \n        override\n        onlyRole(REGISTRAR_ROLE)\n    {\n        uint256 len_ = _userAddresses.length;\n        require(len_ == _amounts.length, \"batchBurn: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_userAddresses[i] != address(0x00), \"batchBurn: Invalid address\");\n            require(_amounts[i] > 0x00, \"batchBurn: Invalid value\");\n            _burn(_userAddresses[i], _amounts[i]);\n        }\n    }\n    \n    /**\n     * @notice Query if a contract implements an interface\n     * @param interfaceID The interface identifier, as specified in ERC-165\n     * @dev Interface identification is specified in ERC-165\n     * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md\n     * @return `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise\n     */\n    function supportsInterface(bytes4 interfaceID) public pure virtual override returns (bool) {\n        if (\n            interfaceID == type(IERC20BatchBasic).interfaceId ||\n            super.supportsInterface(interfaceID)\n        ) {\n            return true;\n        }\n        return interfaceID == 0xffffffff ? false : false;\n    }\n}\n"},"src/common/access-control/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.19;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`.\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`).\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - The caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Grants `DEFAULT_ADMIN_ROLE` to `account`.\n     *\n     * If `account` had not been already granted `DEFAULT_ADMIN_ROLE`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - The caller must have `DEFAULT_ADMIN_ROLE`.\n     * - It will only be granted if the admin cap has not been reached.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantDefaultAdminRole(address account) external;\n\n    /**\n     * @dev Grants `DELEGATED_ADMIN_ROLE` to `account`.\n     *\n     * If `account` had not been already granted `DELEGATED_ADMIN_ROLE`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - The caller must have `DEFAULT_ADMIN_ROLE` or `DELEGATED_ADMIN_ROLE`.\n     * - The total number of delegates must not exceed the `MAX_DELEGATES`.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantDelegateAdminRole(address account) external;\n\n    /**\n     * @dev Batch grants `DELEGATED_ADMIN_ROLE` to each address in `accounts` array.\n     *\n     * If each `account` had not been already granted `DELEGATED_ADMIN_ROLE`, emits a {RoleGranted}\n     * event for each.\n     *\n     * Requirements:\n     *\n     * - The caller must have `DEFAULT_ADMIN_ROLE`.\n     * - The total number of delegates must not exceed `MAX_DELEGATES`.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function batchGrantDelegateAdminRole(address[] memory accounts) external;\n\n    /**\n     * @dev Revokes `DELEGATED_ADMIN_ROLE` from `account`.\n     *\n     * If `account` had been granted `DELEGATED_ADMIN_ROLE`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - The caller must have `DEFAULT_ADMIN_ROLE` or be the direct delegator of the role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeDelegateAdminRole(address account) external;\n\n    /**\n     * @dev Revokes `DEFAULT_ADMIN_ROLE` from `account`.\n     *\n     * If `account` had been granted `DEFAULT_ADMIN_ROLE`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - The caller must have `DEFAULT_ADMIN_ROLE`.\n     * - At least one admin must remain after the revocation.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeDefaultAdminRole(address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - The caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - The caller must be `account`.\n     */\n    function renounceRole(bytes32 role) external;\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n}\n"},"src/tokens/interfaces/erc20/IERC20Events.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\n/**\n * @title IERC20Events\n * @dev Interface for ERC20 Events\n */\ninterface IERC20Events {\n    /**\n     * @notice Write info to the log about tokens transfer\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @notice Write info to the log about approval\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"},"src/tokens/interfaces/erc20/IERC20Freeze.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 token freeze functions\n */\ninterface IERC20Freeze {\n    /**\n     * @notice Freeze the account balance\n     * @param account Account to freeze\n     */\n    function freeze(address account) external;\n\n    /**\n     * @notice Unfreeze the account balance\n     * @param account Account to unfreeze\n     */\n    function unfreeze(address account) external;\n\n    /**\n     * @return Bool flag - true if account is frozen\n     * @param account Account to check for freeze\n     */\n    function isFrozen(address account) external view returns (bool);\n}\n"},"src/tokens/interfaces/erc20/IERC20Burnable.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 token burnable functions\n */\ninterface IERC20Burnable {\n    /**\n     * @notice Burns a specific amount of tokens for selected address\n     * @notice Protected by permission module\n     * @param from Address from which tokens were burned\n     * @param value The amount of token to be burned\n     */\n    function burn(address from, uint256 value) external;\n}\n"},"src/tokens/interfaces/erc20/IERC20Clawback.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 token clawback functions\n */\ninterface IERC20Clawback {\n    /**\n     * @notice Clawback method which provides an allowance for an authorized\n     * @notice party to move tokens between any accounts\n     * @param from Address from which tokens will be removed\n     * @param to The recipient address\n     * @param tokens Value which will be transferred\n     */\n    function clawback(\n        address from,\n        address to,\n        uint256 tokens\n    ) external;\n}\n"},"src/tokens/interfaces/erc20/IERC20Mintable.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 token mint functions\n */\ninterface IERC20Mintable {\n    /**\n     * @notice Emit when tokens are minted (issued)\n     */\n    event Mint(address indexed to, uint256 amount);\n\n    /**\n     * @notice Function to mint (issue) tokens\n     * @param to The address that will receive the minted tokens\n     * @param tokens The amount of tokens to mint\n     */\n    function mint(address to, uint256 tokens) external;\n}\n"},"src/tokens/interfaces/erc20/IERC20Pausable.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 token pausable methods\n */\ninterface IERC20Pausable {\n    /**\n     * @notice Called by the registrar to pause, triggers stopped state\n     */\n    function pause() external;\n\n    /**\n     * @dev Called by the registrar to unpause, returns to normal state\n     */\n    function unpause() external;\n\n    /**\n     * @notice Show whether a token is paused or not\n     */\n    function isPaused() external view returns (bool);\n}\n"},"src/tokens/interfaces/erc20/IERC20WithRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\n/**\n * @title IERC20WithRoles\n * @dev Interface of the ERC-20 role-based access control function for initialization.\n */\ninterface IERC20WithRoles {\n\n    /**\n     * @notice Initializes the contract with the given roles and token parameters.\n     * @dev This function can only be called once, and should be called by a contract deployer or administrator.\n     * @param name_ The name of the token.\n     * @param symbol_ The symbol of the token.\n     * @param decimals_ The number of decimals the token uses.\n     * @param totalSupply_ The total supply of the token to be minted during initialization.\n     * @param tokensRecipient_ The address that will receive the initial supply of tokens.\n     * @param owner The address to be granted the `DEFAULT_ADMIN_ROLE`, which typically has the highest level of control.\n     * @param issuer The address to be granted the `ISSUER_ROLE`, which is allowed to issue/mint new tokens.\n     * @param registrar The address to be granted the `REGISTRAR_ROLE`, which is allowed to manage role assignments.\n     */\n    function initializeWithRoles(\n        string memory name_,\n        string memory symbol_,\n        uint8 decimals_,\n        uint256 totalSupply_,\n        address tokensRecipient_,\n        address owner,\n        address issuer,\n        address registrar\n    ) external;\n}"},"src/tokens/standards/ERC20RevocableStandard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"./ERC20ControlledStandard.sol\";\n\n/**\n * @title ERC20RevocableStandard\n * @dev Implementation of the revocable ERC20 token standard with additional functionalities.\n */\ncontract ERC20RevocableStandard is \n    ERC20ControlledStandard, \n    IERC20Clawback, \n    IERC20BatchClawback, \n    IERC20ClawbackEvents \n{\n\n    /**\n     * @notice Clawback method which provides an allowance for an authorized\n     * @notice party to move tokens between any accounts\n     * @param from Address from which tokens will be removed\n     * @param to The recipient address\n     * @param value Value which will be transferred\n     */\n    function clawback(\n        address from,\n        address to,\n        uint256 value\n    ) external virtual override notPaused onlyRole(REGISTRAR_ROLE) verifyInputs(to, value) notFrozen(to) {\n        require(from != address(0x00), \"clawback: Invalid address\");\n        _transfer(from, to, value);\n\n        emit Clawback(from, to, value);\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchClawback}.\n     */\n    function batchClawback(\n        address[] calldata _fromList,\n        address[] calldata _toList,\n        uint256[] calldata _amounts\n    ) external virtual override notPaused onlyRole(REGISTRAR_ROLE) {\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length && len_ == _fromList.length, \"batchClawback: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchClawback: Invalid address\");\n            require(_fromList[i] != address(0x00), \"batchClawback: Invalid address\");\n            require(_amounts[i] > 0x00, \"batchClawback: Invalid value\");\n            require(!_isFrozen(_toList[i]), \"batchClawback: Frozen\");\n            _transfer(_fromList[i], _toList[i], _amounts[i]);\n\n            emit Clawback(_fromList[i], _toList[i], _amounts[i]);\n        }\n    }\n    \n    /**\n     * @notice Query if a contract implements an interface\n     * @param interfaceID The interface identifier, as specified in ERC-165\n     * @dev Interface identification is specified in ERC-165\n     * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md\n     * @return `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise\n     */\n    function supportsInterface(bytes4 interfaceID) public pure virtual override returns (bool) {\n        if (\n            interfaceID == type(IERC20Clawback).interfaceId ||\n            interfaceID == type(IERC20BatchClawback).interfaceId ||\n            interfaceID == type(IERC20ClawbackEvents).interfaceId ||\n            super.supportsInterface(interfaceID)\n        ) {\n            return true;\n        }\n        return interfaceID == 0xffffffff ? false : false;\n    }\n}\n"},"src/tokens/interfaces/erc20/IERC20BatchBasic.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\n/**\n * @dev Batch ERC20 interface\n */\ninterface IERC20BatchBasic {\n    /**\n     *  @dev function allowing to issue transfers in batch\n     *  Require that the msg.sender and `to` addresses are not frozen.\n     *  Require that the total value should not exceed available balance.\n     *  Require that the `to` addresses are all verified addresses,\n     *  IMPORTANT : THIS TRANSACTION COULD EXCEED GAS LIMIT IF `_toList.length` IS TOO HIGH,\n     *  USE WITH CARE OR YOU COULD LOSE TX FEES WITH AN \"OUT OF GAS\" TRANSACTION\n     *  @param _toList The addresses of the receivers\n     *  @param _amounts The number of tokens to transfer to the corresponding receiver\n     *  emits _toList.length `Transfer` events\n     */\n    function batchTransfer(address[] calldata _toList, uint256[] calldata _amounts) external;\n\n    /**\n     *  @dev function allowing to mint tokens in batch\n     *  Require that the `_toList` addresses are all verified addresses\n     *  IMPORTANT : THIS TRANSACTION COULD EXCEED GAS LIMIT IF `_toList.length` IS TOO HIGH,\n     *  USE WITH CARE OR YOU COULD LOSE TX FEES WITH AN \"OUT OF GAS\" TRANSACTION\n     *  @param _toList The addresses of the receivers\n     *  @param _amounts The number of tokens to mint to the corresponding receiver\n     *  This function can only be called by a wallet set as agent of the token\n     *  emits _toList.length `Transfer` events\n     */\n    function batchMint(address[] calldata _toList, uint256[] calldata _amounts) external;\n\n    /**\n     *  @dev function allowing to burn tokens in batch\n     *  Require that the `_userAddresses` addresses are all verified addresses\n     *  IMPORTANT : THIS TRANSACTION COULD EXCEED GAS LIMIT IF `_userAddresses.length` IS TOO HIGH,\n     *  USE WITH CARE OR YOU COULD LOSE TX FEES WITH AN \"OUT OF GAS\" TRANSACTION\n     *  @param _userAddresses The addresses of the wallets concerned by the burn\n     *  @param _amounts The number of tokens to burn from the corresponding wallets\n     *  This function can only be called by a wallet set as agent of the token\n     *  emits _userAddresses.length `Transfer` events\n     */\n    function batchBurn(address[] calldata _userAddresses, uint256[] calldata _amounts) external;\n}\n"},"src/tokens/standards/ERC20ControlledStandard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"./ERC20BasicStandard.sol\";\n\n/**\n * @title ERC20ControlledStandard\n * @dev Implementation of the controlled ERC20 token standard with additional functionalities.\n */\ncontract ERC20ControlledStandard is \n    ERC20BasicStandard, \n    IERC20Freeze,\n    IERC20BatchFreeze,\n    IERC20FreezeEvents,\n    IERC20Pausable,\n    IERC20PausableEvents\n{\n    // Transfers status (paused || not paused)\n    bytes32 internal constant _PAUSED_SLOT = keccak256(\"proxy.paused\");\n    \n    // Stores accounts that are frozen\n    bytes32 internal constant _FROZEN_SLOT = keccak256(\"proxy.frozen\");\n\n     /**\n     * @notice Modifier to make a function callable only when the account is not frozen.\n     */\n    modifier notFrozen(address account) {\n        require(!_isFrozen(account), \"notFrozen: Frozen\");\n        _;\n    }\n\n    /**\n     * @notice Modifier to make a function callable only when the account is frozen.\n     */\n    modifier frozen(address account) {\n        require(_isFrozen(account), \"frozen: Not frozen\");\n        _;\n    }\n\n    /**\n    * @notice Modifier to make a function callable only when the contract is not paused.\n    */\n    modifier notPaused() {\n        require(!StorageSlot.getBooleanSlot(_PAUSED_SLOT).value, \"notPaused: Paused\");\n        _;\n    }\n\n    /**\n    * @notice Modifier to make a function callable only when the contract is paused.\n    */\n    modifier onlyPaused() {\n        require(StorageSlot.getBooleanSlot(_PAUSED_SLOT).value, \"onlyPaused: Not paused\");\n        _;\n    }\n\n    /**\n    * @notice Called by the registrar to pause, triggers stopped state\n    */\n    function pause() external override onlyRole(REGISTRAR_ROLE) notPaused {\n        StorageSlot.getBooleanSlot(_PAUSED_SLOT).value = true;\n        emit Pause();\n    }\n\n    /**\n    * @dev called by the registrar to unpause, returns to normal state\n    */\n    function unpause() external override onlyRole(REGISTRAR_ROLE) onlyPaused {\n        StorageSlot.getBooleanSlot(_PAUSED_SLOT).value = false;\n        emit Unpause();\n    }\n\n    /**\n     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.\n     * @dev Beware that changing an allowance with this method brings the risk that someone may use both the old\n     * @dev and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this\n     * @dev race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:\n     * @dev https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     * @dev Allows setting the allowance to zero for frozen addresses.\n     * @param spender The address which will spend the funds.\n     * @param tokens The amount of tokens to be spent.\n     */\n    function approve(address spender, uint256 tokens)\n        external\n        virtual\n        override\n        notPaused\n        notFrozen(msg.sender)\n        returns (bool)\n    {\n        require(spender != address(0x00), \"approve: No spender\");\n        require(spender != msg.sender, \"approve: Same spender\");\n        require(tokens==0 || !_isFrozen(spender), \"approve: Spender is frozen\");\n        \n        StorageSlot.getUint256Slot(keccak256(abi.encode(_ALLOWED_SLOT, msg.sender, spender))).value = tokens;\n        emit Approval(msg.sender, spender, tokens);\n\n        return true;\n    }\n\n\n    /**\n     * @notice ERC-20-Lite transfer function.\n     * @param to The address which you want to transfer to\n     * @param value the amount of tokens to be transferred\n     * @return bool flag - true if transfer is successful\n     */\n    function transfer(address to, uint256 value)\n        external\n        virtual\n        override\n        notPaused\n        notFrozen(msg.sender)\n        notFrozen(to)\n        returns (bool)\n    {\n        require(to != address(0x00), \"transfer: Invalid address\");\n        return _transfer(msg.sender, to, value);\n    }\n\n    /**\n     * @notice ERC-20 transferFrom function.\n     * @param to The address which you want to transfer to\n     * @param tokens the amount of tokens to be transferred\n     * @param from The address from which will be transferred token\n     * @return bool flag - true if transfer is successfule\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 tokens\n    ) external virtual override notPaused notFrozen(from) notFrozen(msg.sender) notFrozen(to) returns (bool) {\n        require(to != address(0x00), \"transfer: Invalid address\");\n        return _transferFrom(from, to, tokens);\n    }\n\n    /**\n     * @notice Function to mint tokens\n     * @param to The address that will receive the minted tokens\n     * @param value The amount of tokens to mint\n     */\n    function mint(address to, uint256 value)\n        external\n        virtual\n        override\n        notPaused\n        onlyRole(REGISTRAR_ROLE)\n        verifyInputs(to, value)\n        notFrozen(to)\n    {\n        _mint(to, value);\n    }\n\n    /**\n     * @notice Burns a specific amount of tokens for selected address\n     * @notice Protected by permission module\n     * @param from Address from which tokens were burned\n     * @param value The amount of token to be burned\n     */\n    function burn(address from, uint256 value)\n        external\n        virtual\n        override\n        notPaused\n        onlyRole(REGISTRAR_ROLE)\n        verifyInputs(from, value)\n    {\n        _burn(from, value);\n    }\n\n    /**\n     * @notice Freeze the account balance\n     * @param account Account to freeze\n     */\n    function freeze(address account) external override notFrozen(account) onlyRole(REGISTRAR_ROLE) {\n        require(account != address(0x00), \"freeze: Zero address\");\n\n        _freeze(account);\n    }\n\n    /**\n     * @notice Unfreeze the account balance\n     * @param account Account to unfreeze\n     */\n    function unfreeze(address account) external override notPaused frozen(account) onlyRole(REGISTRAR_ROLE) {\n        require(account != address(0x00), \"unfreeze: Zero address\");\n\n        _unfreeze(account);\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchTransfer}.\n     */\n    function batchTransfer(address[] calldata _toList, uint256[] calldata _amounts)\n        external\n        virtual\n        override\n        notPaused\n        notFrozen(msg.sender)\n    {\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length, \"batchTransfer: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchTransfer: Invalid address\");\n            require(_amounts[i] > 0, \"batchTransfer: Amount must be greater than zero\");\n            require(!_isFrozen(_toList[i]), \"batchTransfer: Frozen\");\n            _transfer(msg.sender, _toList[i], _amounts[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchMint}.\n     */\n    function batchMint(address[] calldata _toList, uint256[] calldata _amounts)\n        external\n        virtual\n        override\n        notPaused\n        onlyRole(REGISTRAR_ROLE)\n    {\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length, \"batchMint: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchMint: Invalid address\");\n            require(_amounts[i] > 0x00, \"batchMint: Invalid value\");\n            require(!_isFrozen(_toList[i]), \"batchMint: Frozen\");\n            _mint(_toList[i], _amounts[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchBurn}.\n     */\n    function batchBurn(address[] calldata _userAddresses, uint256[] calldata _amounts)\n        external\n        virtual\n        override\n        notPaused\n        onlyRole(REGISTRAR_ROLE)\n    {\n        uint256 len_ = _userAddresses.length;\n        require(len_ == _amounts.length, \"batchBurn: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_userAddresses[i] != address(0x00), \"batchBurn: Invalid address\");\n            require(_amounts[i] > 0x00, \"batchBurn: Invalid value\");\n            _burn(_userAddresses[i], _amounts[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchFreeze}.\n     */\n    function batchFreeze(address[] calldata _userAddresses) external override onlyRole(REGISTRAR_ROLE) {\n        for (uint256 i = 0; i < _userAddresses.length; ++i) {\n            require(_userAddresses[i] != address(0x00), \"batchFreeze: Zero address\");\n            require(!_isFrozen(_userAddresses[i]), \"batchFreeze: Frozen\");\n            _freeze(_userAddresses[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchUnfreeze}.\n     */\n    function batchUnfreeze(address[] calldata _userAddresses) external override notPaused onlyRole(REGISTRAR_ROLE) {\n        for (uint256 i = 0; i < _userAddresses.length; ++i) {\n            require(_userAddresses[i] != address(0x00), \"batchUnfreeze: Zero address\");\n            require(_isFrozen(_userAddresses[i]), \"batchUnfreeze: Not frozen\");\n            _unfreeze(_userAddresses[i]);\n        }\n    }\n\n    /**\n     * @return Bool flag - true if account is frozen\n     * @param account Account to check for freeze\n     */\n    function isFrozen(address account) external view override returns (bool) {\n        require(account != address(0x00), \"isFrozen: Zero address\");\n        return _isFrozen(account);\n    }\n\n    /**\n     * @notice Show whether a token is paused or not\n     */\n    function isPaused() external view override returns (bool) {\n        return StorageSlot.getBooleanSlot(_PAUSED_SLOT).value;\n    }\n\n\n    /**\n    * @notice Freeze the account balance\n    * @param account Account to freeze\n    */\n    function _freeze(address account) internal {\n        StorageSlot.getBooleanSlot(keccak256(abi.encode(_FROZEN_SLOT, account))).value = true;\n        emit Freeze(account);\n    }\n\n    /**\n    * @notice Unfreeze the account balance\n    * @param account Account to unfreeze\n    */\n    function _unfreeze(address account) internal {\n        StorageSlot.getBooleanSlot(keccak256(abi.encode(_FROZEN_SLOT, account))).value = false;\n        emit Unfreeze(account);\n    }\n\n    /**\n    * @return Bool flag - true if account is frozen\n    * @param account Account to check for freeze\n    */\n    function _isFrozen(address account) internal view returns (bool) {\n        return StorageSlot.getBooleanSlot(keccak256(abi.encode(_FROZEN_SLOT, account))).value;\n    }\n\n\n    /**\n     * @notice Query if a contract implements an interface\n     * @param interfaceID The interface identifier, as specified in ERC-165\n     * @dev Interface identification is specified in ERC-165\n     * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md\n     * @return `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise\n     */\n    function supportsInterface(bytes4 interfaceID) public pure virtual override returns (bool) {\n        if (\n            interfaceID == type(IERC20Freeze).interfaceId ||\n            interfaceID == type(IERC20BatchFreeze).interfaceId ||\n            interfaceID == type(IERC20FreezeEvents).interfaceId ||\n            interfaceID == type(IERC20Pausable).interfaceId ||\n            interfaceID == type(IERC20PausableEvents).interfaceId ||\n            super.supportsInterface(interfaceID)\n        ) {\n            return true;\n        }\n        return interfaceID == 0xffffffff ? false : false;\n    }\n}\n"},"src/tokens/interfaces/erc20/IERC20BatchFreeze.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\n/**\n * @dev Batch freeze ERC20 interface\n */\ninterface IERC20BatchFreeze {\n    /**\n     *  @dev function allowing to set frozen addresses as frozen in batch\n     *  IMPORTANT : THIS TRANSACTION COULD EXCEED GAS LIMIT IF `_userAddresses.length` IS TOO HIGH,\n     *  USE WITH CARE OR YOU COULD LOSE TX FEES WITH AN \"OUT OF GAS\" TRANSACTION\n     *  @param _userAddresses The addresses for which to update frozen status\n     *  This function can only be called by a wallet set as agent of the token\n     *  emits _userAddresses.length `Freeze` events\n     */\n    function batchFreeze(address[] calldata _userAddresses) external;\n\n    /**\n     *  @dev function allowing to unfreeze frozen addresses in batch\n     *  IMPORTANT : THIS TRANSACTION COULD EXCEED GAS LIMIT IF `_userAddresses.length` IS TOO HIGH,\n     *  USE WITH CARE OR YOU COULD LOSE TX FEES WITH AN \"OUT OF GAS\" TRANSACTION\n     *  @param _userAddresses The addresses for which to update frozen status\n     *  This function can only be called by a wallet set as agent of the token\n     *  emits _userAddresses.length `Unfreeze` events\n     */\n    function batchUnfreeze(address[] calldata _userAddresses) external;\n}\n"},"src/tokens/interfaces/erc20/IERC20FreezeEvents.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 freeze token events\n */\ninterface IERC20FreezeEvents {\n    /**\n     * @notice Emit when account can't send transactions\n     */\n    event Freeze(address indexed account);\n\n    /**\n     * @notice Emit when account can't send transactinos\n     */\n    event Unfreeze(address indexed account);\n}\n"},"src/tokens/interfaces/erc20/IERC20BatchClawback.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\n/**\n * @dev Batch clawback ERC20 interface\n */\ninterface IERC20BatchClawback {\n    /**\n     *  @dev function allowing to issue clawback transfers in batch\n     *  Require that `_amounts[i]` should not exceed available balance of `_fromList[i]`.\n     *  Require that the `_toList` addresses are all verified addresses\n     *  IMPORTANT : THIS TRANSACTION COULD EXCEED GAS LIMIT IF `_fromList.length` IS TOO HIGH,\n     *  USE WITH CARE OR YOU COULD LOSE TX FEES WITH AN \"OUT OF GAS\" TRANSACTION\n     *  @param _fromList The addresses of the senders\n     *  @param _toList The addresses of the receivers\n     *  @param _amounts The number of tokens to transfer to the corresponding receiver\n     *  This function can only be called by a wallet set as agent of the token\n     *  emits `TokensUnfrozen` events if `_amounts[i]` is higher than the free balance of `_fromList[i]`\n     *  emits _fromList.length `Transfer` events\n     */\n    function batchClawback(\n        address[] calldata _fromList,\n        address[] calldata _toList,\n        uint256[] calldata _amounts\n    ) external;\n}\n"},"src/tokens/interfaces/erc20/IERC20ClawbackEvents.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 clawback token events\n */\ninterface IERC20ClawbackEvents {\n    /**\n     * @notice Emit when a clawback happened\n     */\n    event Clawback(address indexed from, address indexed to, uint256 tokens);\n}\n"},"src/tokens/interfaces/erc20/IERC20PausableEvents.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title Interface of the ERC-20 pausable token events\n */\ninterface IERC20PausableEvents {\n    /**\n     * @notice Emit when transactions are stopped\n     */\n    event Pause();\n\n    /**\n     * @notice Emit when transactions are unpaused\n     */\n    event Unpause();\n}\n"},"src/tokens/interfaces/erc20/IERC20RevocableCompliance.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.19;\n\n/**\n * @title ERC-20 token compliance revocable package interface\n */\ninterface IERC20RevocableCompliance {\n    event ComplianceAdded(address indexed _context);\n    event ComplianceRemoved(address indexed _context);\n\n    /**\n     * @notice Add compliance context to token\n     * @param context address of the Context to be added\n     */\n    function setCompliance(address context) external;\n\n    /**\n     * @notice Remove compliance context from token\n     */\n    function removeCompliance() external;\n\n    /**\n     * @notice Verify that an address is whitelisted. If no whitelist is set, the check is skipped.\n     * @param from The address from which the tokens will be sent\n     * @param to The address to which the tokens will be sent\n     * @param amount The amount of tokens to be transferred\n     * @return bool True if the transfer is compliant, false otherwise.\n     */\n    function isAddressWhitelisted(address from, address to, uint256 amount) external view returns (bool);\n\n    /**\n     * @notice Returns the compliance context from token\n     */\n    function getCompliance() external view returns (address);\n}"},"src/tokens/standards/ERC20RevocableComplianceStandard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"./ERC20RevocableStandard.sol\";\nimport \"../interfaces/ICompliance.sol\";\nimport \"../interfaces/erc20/IERC20RevocableCompliance.sol\";\n\n/**\n * @title Init ERC20RevocableComplianceToken package\n */\ncontract ERC20RevocableComplianceStandard is\n    ERC20RevocableStandard,\n    IERC20RevocableCompliance\n{\n\n    // Whitelist context address\n    bytes32 internal constant _COMPLIANCE_ADDRESS_SLOT = keccak256(\"proxy.complianceAddress\");\n\n    /**\n     * @notice ERC-20-Lite transfer function.\n     * @param to The address which you want to transfer to\n     * @param value the amount of tokens to be transferred\n     * @return bool flag - true if transfer is successful\n     */\n    function transfer(address to, uint256 value)\n        external\n        virtual\n        override\n        notPaused\n        notFrozen(msg.sender)\n        notFrozen(to)\n        returns (bool)\n    {\n        require(to != address(0x00), \"transfer: Invalid address\");\n        require(isAddressWhitelisted(msg.sender, to, value), \"transfer: Address not whitelisted\");\n        return _transfer(msg.sender, to, value);\n    }\n\n    /**\n     * @notice ERC-20 transferFrom function.\n     * @param to The address which you want to transfer to\n     * @param tokens the amount of tokens to be transferred\n     * @param from The address from which will be transferred token\n     * @return bool flag - true if transfer is successfule\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 tokens\n    ) external virtual override notPaused notFrozen(from) notFrozen(msg.sender) notFrozen(to) returns (bool) {\n        require(to != address(0x00), \"transfer: Invalid address\");\n        require(isAddressWhitelisted(from, to, tokens), \"transferFrom: Address not whitelisted\");\n        return _transferFrom(from, to, tokens);\n    }\n\n    /**\n     * @notice Function to mint tokens\n     * @param to The address that will receive the minted tokens\n     * @param value The amount of tokens to mint\n     */\n    function mint(address to, uint256 value)\n        external\n        virtual\n        override\n        notPaused\n        onlyRole(REGISTRAR_ROLE)\n        verifyInputs(to, value)\n        notFrozen(to)\n    {\n        require(isAddressWhitelisted(address(0), to, value), \"mint: Address not whitelisted\");\n        _mint(to, value);\n    }\n\n    /**\n     * @notice Clawback method which provides an allowance for an authorized\n     * @notice party to move tokens between any accounts\n     * @param from Address from which tokens will be removed\n     * @param to The recipient address\n     * @param value Value which will be transferred\n     */\n    function clawback(\n        address from,\n        address to,\n        uint256 value\n    ) external virtual override notPaused onlyRole(REGISTRAR_ROLE) verifyInputs(to, value) notFrozen(to) {\n        require(isAddressWhitelisted(from, to, value), \"clawback: Address not whitelisted\");\n        require(from != address(0x00), \"clawback: Invalid address\");\n        _transfer(from, to, value);\n\n        emit Clawback(from, to, value);\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchTransfer}.\n     */\n    function batchTransfer(address[] calldata _toList, uint256[] calldata _amounts)\n        external\n        virtual\n        override\n        notPaused\n        notFrozen(msg.sender)\n    {\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length, \"batchTransfer: Inconsistent input array lengths\");\n\n        address[] memory from = new address[](_toList.length);\n        for (uint256 i = 0; i < _toList.length; ++i) {\n            from[i] = msg.sender;\n        }\n        require(_areWhitelisted(from, _toList, _amounts), \"batchTransfer: One or more addresses not whitelisted\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchTransfer: Invalid address\");\n            require(_amounts[i] > 0, \"batchTransfer: Amount must be greater than zero\");\n            require(!_isFrozen(_toList[i]), \"batchTransfer: Frozen\");\n            _transfer(msg.sender, _toList[i], _amounts[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchMint}.\n     */\n    function batchMint(address[] calldata _toList, uint256[] calldata _amounts)\n        external\n        virtual\n        override\n        notPaused\n        onlyRole(REGISTRAR_ROLE)\n    {\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length, \"batchMint: Inconsistent input array lengths\");\n\n        address[] memory from = new address[](_toList.length);\n        require(_areWhitelisted(from, _toList, _amounts), \"batchMint: One or more addresses not whitelisted\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchMint: Invalid address\");\n            require(_amounts[i] > 0x00, \"batchMint: Invalid value\");\n            require(!_isFrozen(_toList[i]), \"batchMint: Frozen\");\n            _mint(_toList[i], _amounts[i]);\n        }\n    }\n\n    /**\n     *  @dev See {ERC20Batch-batchClawback}.\n     */\n    function batchClawback(\n        address[] calldata _fromList,\n        address[] calldata _toList,\n        uint256[] calldata _amounts\n    ) external virtual override notPaused onlyRole(REGISTRAR_ROLE) {\n        require(_areWhitelisted(_fromList, _toList, _amounts), \"batchClawback: One or more addresses not whitelisted\");\n        uint256 len_ = _toList.length;\n        require(len_ == _amounts.length && len_ == _fromList.length, \"batchClawback: Inconsistent input array lengths\");\n\n        for (uint256 i = 0; i < len_; ++i) {\n            require(_toList[i] != address(0x00), \"batchClawback: Invalid address\");\n            require(_fromList[i] != address(0x00), \"batchClawback: Invalid address\");\n            require(_amounts[i] > 0x00, \"batchClawback: Invalid value\");\n            require(!_isFrozen(_toList[i]), \"batchClawback: Frozen\");\n            _transfer(_fromList[i], _toList[i], _amounts[i]);\n\n            emit Clawback(_fromList[i], _toList[i], _amounts[i]);\n        }\n    }\n\n    /**\n     * @notice Add compliance to token\n     * @param context address of the Context to be removed\n     */\n    function setCompliance(address context) external override onlyRole(DEFAULT_ADMIN_ROLE) {\n        require(context != address(0x00), \"0x address\");\n        require(\n            IERC165(context).supportsInterface(type(ICompliance).interfaceId),\n            \"Context does not support ICompliance interface\"\n        );\n        StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value = context;\n        emit ComplianceAdded(context);\n    }\n\n    /**\n     * @notice Remove compliance from token\n     */\n    function removeCompliance() external override onlyRole(DEFAULT_ADMIN_ROLE) {\n        require(StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value != address(0x00), \"compliance is already 0x\");\n        address _context = StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value;\n        StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value = address(0x00);\n        emit ComplianceRemoved(_context);\n    }\n\n    /**\n     * @notice Returns the compliance address from token\n     */\n    function getCompliance() external view override returns (address) {\n        return StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value;\n    }\n\n    /**\n     * @notice Verify that an address is whitelisted. If no whitelist is set, the check is skipped.\n     * @param from The address from which the tokens will be sent\n     * @param to The address to which the tokens will be sent\n     * @param amount The amount of tokens to be transferred\n     * @return bool True if the transfer is compliant, false otherwise.\n     */\n    function isAddressWhitelisted(address from, address to, uint256 amount) public view override returns (bool) {\n        if (StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value == address(0x00)) {\n            return true; // No whitelist set, skip the check\n        }\n\n        return ICompliance(StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value).canTransfer(from, to, amount);\n    }\n\n    /**\n     * @notice Verify that addresses are whitelisted.\n     * Returns true if there is no whitelist or if all from and to addresses are whitelisted.\n     * @param fromList The array of sender addresses to verify\n     * @param toList The array of recipient addresses to verify\n     * @param amounts The array of token amounts to verify\n     */\n    function _areWhitelisted(address[] memory fromList, address[] memory toList, uint256[] memory amounts) internal view returns (bool) {\n        if (StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value == address(0x00)) {\n            return true;\n        }\n\n        for (uint256 i = 0; i < toList.length; ++i) {\n            require(toList[i] != address(0x00), \"verifyInputs: Invalid address\");\n\n            if (!ICompliance(StorageSlot.getAddressSlot(_COMPLIANCE_ADDRESS_SLOT).value).canTransfer(fromList[i], toList[i], amounts[i])) {\n            return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @notice Query if a contract implements an interface\n     * @param interfaceID The interface identifier, as specified in ERC-165\n     * @dev Interface identification is specified in ERC-165\n     * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md\n     * @return `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise\n     */\n    function supportsInterface(bytes4 interfaceID) public pure virtual override returns (bool) {\n        if (\n            interfaceID == type(IERC20RevocableCompliance).interfaceId ||\n            super.supportsInterface(interfaceID)\n        ) {\n            return true;\n        }\n        return interfaceID == 0xffffffff ? false : false;\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.19+commit.7dd6d404","compilerSettings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris","remappings":[":forge-std/=lib/forge-std/src/"]},"name":"ERC20RevocableComplianceStandard","fullyQualifiedName":"src/tokens/standards/ERC20RevocableComplianceStandard.sol:ERC20RevocableComplianceStandard"},"matchId":"5362031","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2024-09-14T18:41:47Z","match":"exact_match","chainId":"1","address":"0xC2A8ca84BC363605c36757f9409b214b6ee710c9"}