{"constructor_args":"0x0000000000000000000000003300f198988e4c9c63f75df86de36421f06af8c4","is_partially_verified":false,"is_changed_bytecode":false,"abi":[{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"ZeroAdmin","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"allocator","type":"address"}],"name":"AllocatorRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"inputs":[],"name":"ALLOCATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FREEZER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"doCall","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"doCallWithValue","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"allocator","type":"address"}],"name":"removeAllocator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"conflicting_implementations":null,"certified":false,"additional_sources":[{"file_path":"lib/openzeppelin-contracts/contracts/access/AccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"./IAccessControl.sol\";\nimport {Context} from \"../utils/Context.sol\";\nimport {ERC165} from \"../utils/introspection/ERC165.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 * ```solidity\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 * ```solidity\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 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address account => bool) hasRole;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 role => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with an {AccessControlUnauthorizedAccount} error including the required role.\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n        return _roles[role].hasRole[account];\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n     * is missing `role`.\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert AccessControlUnauthorizedAccount(account, role);\n        }\n    }\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 {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n        return _roles[role].adminRole;\n    }\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     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\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     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\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     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n        if (callerConfirmation != _msgSender()) {\n            revert AccessControlBadConfirmation();\n        }\n\n        _revokeRole(role, callerConfirmation);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (!hasRole(role, account)) {\n            _roles[role].hasRole[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (hasRole(role, account)) {\n            _roles[role].hasRole[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/access/IAccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev The `account` is missing a role.\n     */\n    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n    /**\n     * @dev The caller of a function is not the expected one.\n     *\n     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n     */\n    error AccessControlBadConfirmation();\n\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    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     * bearer except when using {AccessControl-_setupRole}.\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 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    /**\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 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 `callerConfirmation`.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error AddressInsufficientBalance(address account);\n\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedInnerCall();\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert AddressInsufficientBalance(address(this));\n        }\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            revert FailedInnerCall();\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {FailedInnerCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert AddressInsufficientBalance(address(this));\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\n     * unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {FailedInnerCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert FailedInnerCall();\n        }\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/utils/Context.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\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"},{"file_path":"src/interfaces/IALMProxyFreezable.sol","source_code":"// SPDX-License-Identifier: AGPL-3.0-or-later\npragma solidity ^0.8.34;\n\nimport {\n    IAccessControl\n} from \"../../lib/openzeppelin-contracts/contracts/access/IAccessControl.sol\";\n\n/**\n * @title  IALMProxyFreezable\n * @notice Proxy contract with freezer and allocator roles. Allocators execute calls through the\n *         proxy, and freezers can revoke allocator access as an emergency measure.\n */\ninterface IALMProxyFreezable is IAccessControl {\n\n    /**********************************************************************************************/\n    /*** Events                                                                                 ***/\n    /**********************************************************************************************/\n\n    /**\n     * @notice Emitted when a freezer removes an allocator from the system.\n     * @param  allocator Address of the allocator that was removed.\n     */\n    event AllocatorRemoved(address indexed allocator);\n\n    /**********************************************************************************************/\n    /*** Custom Errors                                                                          ***/\n    /**********************************************************************************************/\n\n    /// @notice Thrown when the admin is the zero address.\n    error ZeroAdmin();\n\n    /**********************************************************************************************/\n    /*** Interactive Functions                                                                  ***/\n    /**********************************************************************************************/\n\n    /**\n     * @notice Performs a standard call to the specified `target` with the given `data`.\n     *         Reverts if the call fails.\n     * @param  target The address of the target contract to call.\n     * @param  data   The calldata that will be sent to the target contract.\n     * @return result The returned data from the call.\n     */\n    function doCall(address target, bytes calldata data) external returns (bytes memory result);\n\n    /**\n     * @notice This function allows for transferring `value` (ether) along with the call to the\n     *         target contract. Reverts if the call fails.\n     * @param  target The address of the target contract to call.\n     * @param  data   The calldata that will be sent to the target contract.\n     * @param  value  The amount of Ether (in wei) to send with the call.\n     * @return result The returned data from the call.\n     */\n    function doCallWithValue(address target, bytes calldata data, uint256 value)\n        external\n        payable\n        returns (bytes memory result);\n\n    /**\n     * @notice This function allows a freezer to remove an allocator.\n     * @param  allocator The address of the allocator to be removed.\n     */\n    function removeAllocator(address allocator) external;\n\n    /**********************************************************************************************/\n    /*** Variables                                                                              ***/\n    /**********************************************************************************************/\n\n    /// @notice Role identifier for freezer accounts that can remove allocators.\n    function FREEZER_ROLE() external view returns (bytes32);\n\n    /// @notice Role identifier for allocator accounts authorized to execute proxy calls.\n    function ALLOCATOR_ROLE() external view returns (bytes32);\n\n}\n"}],"is_verified_via_sourcify":true,"can_be_visualized_via_sol2uml":true,"evm_version":"cancun","language":"solidity","is_verified_via_eth_bytecode_db":true,"is_fully_verified":true,"license_type":"none","is_blueprint":false,"name":"ALMProxyFreezable","creation_bytecode":"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","external_libraries":[],"proxy_type":null,"implementations":[],"verified_at":"2026-05-13T13:54:45.138267Z","is_verified_via_verifier_alliance":false,"compiler_version":"0.8.34+commit.80d5c536","decoded_constructor_args":[["0x3300f198988e4C9C63F75dF86De36421f06af8c4",{"internalType":"address","name":"admin","type":"address"}]],"sourcify_repo_url":"https://repo.sourcify.dev/1/0xe5c6318456a7Cb6f74f93B4eee4616dB5fcef699","optimization_runs":200,"compiler_settings":{"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@ensdomains/=lib/uniswap-v4-periphery/lib/v4-core/node_modules/@ensdomains/",":@layerzerolabs/lz-evm-messagelib-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/messagelib/",":@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/",":@layerzerolabs/oft-evm/=lib/grove-xchain-helpers/lib/devtools/packages/oft-evm/",":@openzeppelin/contracts-upgradeable/=lib/oz-upgradeable/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":@uniswap/v4-core/=lib/uniswap-v4-periphery/lib/v4-core/",":LayerZero-v2/=lib/grove-xchain-helpers/lib/",":aave-v3-core/=lib/aave-v3-origin/src/core/",":aave-v3-origin/=lib/aave-v3-origin/",":aave-v3-periphery/=lib/aave-v3-origin/src/periphery/",":devtools/=lib/grove-xchain-helpers/lib/devtools/packages/toolbox-foundry/src/",":ds-test/=lib/grove-address-registry/lib/forge-std/lib/ds-test/src/",":dss-allocator/=lib/dss-allocator/",":dss-interfaces/=lib/dss-test/lib/dss-interfaces/src/",":dss-test/=lib/dss-test/src/",":erc20-helpers/=lib/grove-basin/lib/erc20-helpers/src/",":erc4626-tests/=lib/metamorpho/lib/erc4626-tests/",":forge-gas-snapshot/=lib/uniswap-v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":grove-address-registry/=lib/grove-address-registry/src/",":grove-basin/=lib/grove-basin/",":grove-xchain-helpers/=lib/grove-xchain-helpers/src/",":halmos-cheatcodes/=lib/grove-basin/lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":hardhat/=lib/uniswap-v4-periphery/lib/v4-core/node_modules/hardhat/",":layerzero-v2/=lib/layerzero-v2/",":layerzerolabs/oapp-evm/=lib/grove-xchain-helpers/lib/devtools/packages/oapp-evm/",":metamorpho/=lib/metamorpho/src/",":morpho-blue/=lib/metamorpho/lib/morpho-blue/",":murky/=lib/metamorpho/lib/universal-rewards-distributor/lib/murky/src/",":openzeppelin-contracts-upgradeable/=lib/spark-vaults-v2/lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":openzeppelin/=lib/metamorpho/lib/universal-rewards-distributor/lib/openzeppelin-contracts/contracts/",":oz-upgradeable/=lib/oz-upgradeable/",":permit2/=lib/uniswap-v4-periphery/lib/permit2/",":solidity-bytes-utils/=lib/solidity-bytes-utils/",":solidity-utils/=lib/aave-v3-origin/lib/solidity-utils/",":solmate/=lib/uniswap-v4-periphery/lib/v4-core/lib/solmate/",":spark-address-registry/=lib/spark-address-registry/src/",":spark-psm/=lib/spark-psm/",":spark-vaults-v2/=lib/spark-vaults-v2/",":sparklend-address-registry/=lib/grove-basin/lib/xchain-ssr-oracle/lib/sparklend-address-registry/",":token-tests/=lib/spark-vaults-v2/lib/token-tests/src/",":uniswap-v4-periphery/=lib/uniswap-v4-periphery/",":universal-rewards-distributor/=lib/metamorpho/lib/universal-rewards-distributor/src/",":v4-core/=lib/uniswap-v4-periphery/lib/v4-core/src/",":xchain-helpers/=lib/xchain-helpers/src/",":xchain-ssr-oracle/=lib/grove-basin/lib/xchain-ssr-oracle/"]},"is_verified":true,"verified_twin_address_hash":null,"optimization_enabled":true,"deployed_bytecode":"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","source_code":"// SPDX-License-Identifier: AGPL-3.0-or-later\npragma solidity ^0.8.34;\n\nimport { AccessControl } from \"../lib/openzeppelin-contracts/contracts/access/AccessControl.sol\";\nimport { Address }       from \"../lib/openzeppelin-contracts/contracts/utils/Address.sol\";\n\nimport { IALMProxyFreezable } from \"./interfaces/IALMProxyFreezable.sol\";\n\ncontract ALMProxyFreezable is IALMProxyFreezable, AccessControl {\n\n    using Address for address;\n\n    /**********************************************************************************************/\n    /*** Constants                                                                              ***/\n    /**********************************************************************************************/\n\n    bytes32 public constant override ALLOCATOR_ROLE = keccak256(\"ALLOCATOR_ROLE\");\n    bytes32 public constant override FREEZER_ROLE   = keccak256(\"FREEZER_ROLE\");\n\n    /**********************************************************************************************/\n    /*** Constructor                                                                            ***/\n    /**********************************************************************************************/\n\n    constructor(address admin) {\n        require(admin != address(0), ZeroAdmin());\n\n        _grantRole(DEFAULT_ADMIN_ROLE, admin);\n    }\n\n    /**********************************************************************************************/\n    /*** External Interactive Freezer Functions                                                 ***/\n    /**********************************************************************************************/\n\n    function removeAllocator(address allocator) external override onlyRole(FREEZER_ROLE) {\n        require(_revokeRole(ALLOCATOR_ROLE, allocator), \"ALMProxyFreezable/not-live-allocator\");\n\n        emit AllocatorRemoved(allocator);\n    }\n\n    /**********************************************************************************************/\n    /*** External Interactive Allocator Functions                                               ***/\n    /**********************************************************************************************/\n\n    function doCall(address target, bytes calldata data)\n        external\n        override\n        onlyRole(ALLOCATOR_ROLE)\n        returns (bytes memory result)\n    {\n        result = target.functionCall(data);\n    }\n\n    function doCallWithValue(address target, bytes calldata data, uint256 value)\n        external\n        payable\n        override\n        onlyRole(ALLOCATOR_ROLE)\n        returns (bytes memory result)\n    {\n        result = target.functionCallWithValue(data, value);\n    }\n\n    /**********************************************************************************************/\n    /*** Receive function                                                                       ***/\n    /**********************************************************************************************/\n\n    receive() external payable {}\n\n}\n","creation_status":"success","file_path":"src/ALMProxyFreezable.sol"}