{"file_path":"Timelock.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n// lib/solady/src/auth/EnumerableRoles.sol\n\n/// @notice Enumerable multiroles authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/EnumerableRoles.sol)\n///\n/// @dev Note:\n/// This implementation is agnostic to the Ownable that the contract inherits from.\n/// It performs a self-staticcall to the `owner()` function to determine the owner.\n/// This is useful for situations where the contract inherits from\n/// OpenZeppelin's Ownable, such as in LayerZero's OApp contracts.\n///\n/// This implementation performs a self-staticcall to `MAX_ROLE()` to determine\n/// the maximum role that can be set/unset. If the inheriting contract does not\n/// have `MAX_ROLE()`, then any role can be set/unset.\n///\n/// This implementation allows for any uint256 role,\n/// it does NOT take in a bitmask of roles.\n/// This is to accommodate teams that are allergic to bitwise flags.\n///\n/// By default, the `owner()` is the only account that is authorized to set roles.\n/// This behavior can be changed via overrides.\n///\n/// This implementation is compatible with any Ownable.\n/// This implementation is NOT compatible with OwnableRoles.\nabstract contract EnumerableRoles {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The status of `role` for `holder` has been set to `active`.\n    event RoleSet(address indexed holder, uint256 indexed role, bool indexed active);\n\n    /// @dev `keccak256(bytes(\"RoleSet(address,uint256,bool)\"))`.\n    uint256 private constant _ROLE_SET_EVENT_SIGNATURE =\n        0xaddc47d7e02c95c00ec667676636d772a589ffbf0663cfd7cd4dd3d4758201b8;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The index is out of bounds of the role holders array.\n    error RoleHoldersIndexOutOfBounds();\n\n    /// @dev Cannot set the role of the zero address.\n    error RoleHolderIsZeroAddress();\n\n    /// @dev The role has exceeded the maximum role.\n    error InvalidRole();\n\n    /// @dev Unauthorized to perform the action.\n    error EnumerableRolesUnauthorized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage layout of the holders enumerable mapping is given by:\n    /// ```\n    ///     mstore(0x18, holder)\n    ///     mstore(0x04, _ENUMERABLE_ROLES_SLOT_SEED)\n    ///     mstore(0x00, role)\n    ///     let rootSlot := keccak256(0x00, 0x24)\n    ///     let positionSlot := keccak256(0x00, 0x38)\n    ///     let holderSlot := add(rootSlot, sload(positionSlot))\n    ///     let holderInStorage := shr(96, sload(holderSlot))\n    ///     let length := shr(160, shl(160, sload(rootSlot)))\n    /// ```\n    uint256 private constant _ENUMERABLE_ROLES_SLOT_SEED = 0xee9853bb;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Sets the status of `role` of `holder` to `active`.\n    function setRole(address holder, uint256 role, bool active) public payable virtual {\n        _authorizeSetRole(holder, role, active);\n        _setRole(holder, role, active);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns if `holder` has active `role`.\n    function hasRole(address holder, uint256 role) public view virtual returns (bool result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x18, holder)\n            mstore(0x04, _ENUMERABLE_ROLES_SLOT_SEED)\n            mstore(0x00, role)\n            result := iszero(iszero(sload(keccak256(0x00, 0x38))))\n        }\n    }\n\n    /// @dev Returns an array of the holders of `role`.\n    function roleHolders(uint256 role) public view virtual returns (address[] memory result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := mload(0x40)\n            mstore(0x04, _ENUMERABLE_ROLES_SLOT_SEED)\n            mstore(0x00, role)\n            let rootSlot := keccak256(0x00, 0x24)\n            let rootPacked := sload(rootSlot)\n            let n := shr(160, shl(160, rootPacked))\n            let o := add(0x20, result)\n            mstore(o, shr(96, rootPacked))\n            for { let i := 1 } lt(i, n) { i := add(i, 1) } {\n                mstore(add(o, shl(5, i)), shr(96, sload(add(rootSlot, i))))\n            }\n            mstore(result, n)\n            mstore(0x40, add(o, shl(5, n)))\n        }\n    }\n\n    /// @dev Returns the total number of holders of `role`.\n    function roleHolderCount(uint256 role) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ENUMERABLE_ROLES_SLOT_SEED)\n            mstore(0x00, role)\n            result := shr(160, shl(160, sload(keccak256(0x00, 0x24))))\n        }\n    }\n\n    /// @dev Returns the holder of `role` at the index `i`.\n    function roleHolderAt(uint256 role, uint256 i) public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ENUMERABLE_ROLES_SLOT_SEED)\n            mstore(0x00, role)\n            let rootSlot := keccak256(0x00, 0x24)\n            let rootPacked := sload(rootSlot)\n            if iszero(lt(i, shr(160, shl(160, rootPacked)))) {\n                mstore(0x00, 0x5694da8e) // `RoleHoldersIndexOutOfBounds()`.\n                revert(0x1c, 0x04)\n            }\n            result := shr(96, rootPacked)\n            if i { result := shr(96, sload(add(rootSlot, i))) }\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Set the role for holder directly without authorization guard.\n    function _setRole(address holder, uint256 role, bool active) internal virtual {\n        _validateRole(role);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let holder_ := shl(96, holder)\n            if iszero(holder_) {\n                mstore(0x00, 0x82550143) // `RoleHolderIsZeroAddress()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x18, holder)\n            mstore(0x04, _ENUMERABLE_ROLES_SLOT_SEED)\n            mstore(0x00, role)\n            let rootSlot := keccak256(0x00, 0x24)\n            let n := shr(160, shl(160, sload(rootSlot)))\n            let positionSlot := keccak256(0x00, 0x38)\n            let position := sload(positionSlot)\n            for {} 1 {} {\n                if iszero(active) {\n                    if iszero(position) { break }\n                    let nSub := sub(n, 1)\n                    if iszero(eq(sub(position, 1), nSub)) {\n                        let lastHolder_ := shl(96, shr(96, sload(add(rootSlot, nSub))))\n                        sstore(add(rootSlot, sub(position, 1)), lastHolder_)\n                        sstore(add(rootSlot, nSub), 0)\n                        mstore(0x24, lastHolder_)\n                        sstore(keccak256(0x00, 0x38), position)\n                    }\n                    sstore(rootSlot, or(shl(96, shr(96, sload(rootSlot))), nSub))\n                    sstore(positionSlot, 0)\n                    break\n                }\n                if iszero(position) {\n                    sstore(add(rootSlot, n), holder_)\n                    sstore(positionSlot, add(n, 1))\n                    sstore(rootSlot, add(sload(rootSlot), 1))\n                }\n                break\n            }\n            // forgefmt: disable-next-item\n            log4(0x00, 0x00, _ROLE_SET_EVENT_SIGNATURE, shr(96, holder_), role, iszero(iszero(active)))\n        }\n    }\n\n    /// @dev Requires the role is not greater than `MAX_ROLE()`.\n    /// If `MAX_ROLE()` is not implemented, this is an no-op.\n    function _validateRole(uint256 role) internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0xd24f19d5) // `MAX_ROLE()`.\n            if and(\n                and(gt(role, mload(0x00)), gt(returndatasize(), 0x1f)),\n                staticcall(gas(), address(), 0x1c, 0x04, 0x00, 0x20)\n            ) {\n                mstore(0x00, 0xd954416a) // `InvalidRole()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Checks that the caller is authorized to set the role.\n    function _authorizeSetRole(address holder, uint256 role, bool active) internal virtual {\n        if (!_enumerableRolesSenderIsContractOwner()) _revertEnumerableRolesUnauthorized();\n        // Silence compiler warning on unused variables.\n        (holder, role, active) = (holder, role, active);\n    }\n\n    /// @dev Returns if `holder` has any roles in `encodedRoles`.\n    /// `encodedRoles` is `abi.encode(SAMPLE_ROLE_0, SAMPLE_ROLE_1, ...)`.\n    function _hasAnyRoles(address holder, bytes memory encodedRoles)\n        internal\n        view\n        virtual\n        returns (bool result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x18, holder)\n            mstore(0x04, _ENUMERABLE_ROLES_SLOT_SEED)\n            let end := add(encodedRoles, shl(5, shr(5, mload(encodedRoles))))\n            for {} lt(result, lt(encodedRoles, end)) {} {\n                encodedRoles := add(0x20, encodedRoles)\n                mstore(0x00, mload(encodedRoles))\n                result := sload(keccak256(0x00, 0x38))\n            }\n            result := iszero(iszero(result))\n        }\n    }\n\n    /// @dev Reverts if `msg.sender` does not have `role`.\n    function _checkRole(uint256 role) internal view virtual {\n        if (!hasRole(msg.sender, role)) _revertEnumerableRolesUnauthorized();\n    }\n\n    /// @dev Reverts if `msg.sender` does not have any role in `encodedRoles`.\n    function _checkRoles(bytes memory encodedRoles) internal view virtual {\n        if (!_hasAnyRoles(msg.sender, encodedRoles)) _revertEnumerableRolesUnauthorized();\n    }\n\n    /// @dev Reverts if `msg.sender` is not the contract owner and does not have `role`.\n    function _checkOwnerOrRole(uint256 role) internal view virtual {\n        if (!_enumerableRolesSenderIsContractOwner()) _checkRole(role);\n    }\n\n    /// @dev Reverts if `msg.sender` is not the contract owner and\n    /// does not have any role in `encodedRoles`.\n    function _checkOwnerOrRoles(bytes memory encodedRoles) internal view virtual {\n        if (!_enumerableRolesSenderIsContractOwner()) _checkRoles(encodedRoles);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by an account with `role`.\n    modifier onlyRole(uint256 role) virtual {\n        _checkRole(role);\n        _;\n    }\n\n    /// @dev Marks a function as only callable by an account with any role in `encodedRoles`.\n    /// `encodedRoles` is `abi.encode(SAMPLE_ROLE_0, SAMPLE_ROLE_1, ...)`.\n    modifier onlyRoles(bytes memory encodedRoles) virtual {\n        _checkRoles(encodedRoles);\n        _;\n    }\n\n    /// @dev Marks a function as only callable by the owner or by an account with `role`.\n    modifier onlyOwnerOrRole(uint256 role) virtual {\n        _checkOwnerOrRole(role);\n        _;\n    }\n\n    /// @dev Marks a function as only callable by the owner or\n    /// by an account with any role in `encodedRoles`.\n    /// Checks for ownership first, then checks for roles.\n    /// `encodedRoles` is `abi.encode(SAMPLE_ROLE_0, SAMPLE_ROLE_1, ...)`.\n    modifier onlyOwnerOrRoles(bytes memory encodedRoles) virtual {\n        _checkOwnerOrRoles(encodedRoles);\n        _;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns if the `msg.sender` is equal to `owner()` on this contract.\n    /// If the contract does not have `owner()` implemented, returns false.\n    function _enumerableRolesSenderIsContractOwner() private view returns (bool result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x8da5cb5b) // `owner()`.\n            result :=\n                and(\n                    and(eq(caller(), mload(0x00)), gt(returndatasize(), 0x1f)),\n                    staticcall(gas(), address(), 0x1c, 0x04, 0x00, 0x20)\n                )\n        }\n    }\n\n    /// @dev Reverts with `EnumerableRolesUnauthorized()`.\n    function _revertEnumerableRolesUnauthorized() private pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x99152cca) // `EnumerableRolesUnauthorized()`.\n            revert(0x1c, 0x04)\n        }\n    }\n}\n\n// lib/solady/src/accounts/LibERC7579.sol\n\n/// @notice Library for handling ERC7579 mode and execution data.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/accounts/LibERC7579.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/main/contracts/account/utils/draft-ERC7579Utils.sol)\nlibrary LibERC7579 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Cannot decode `executionData`.\n    error DecodingError();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev A single execution.\n    bytes1 internal constant CALLTYPE_SINGLE = 0x00;\n\n    /// @dev A batch of executions.\n    bytes1 internal constant CALLTYPE_BATCH = 0x01;\n\n    /// @dev A single `staticcall` execution.\n    bytes1 internal constant CALLTYPE_STATICCALL = 0xfe;\n\n    /// @dev A `delegatecall` execution.\n    bytes1 internal constant CALLTYPE_DELEGATECALL = 0xff;\n\n    /// @dev Default execution type that reverts on failure.\n    bytes1 internal constant EXECTYPE_DEFAULT = 0x00;\n\n    /// @dev Execution type that does not revert on failure.\n    bytes1 internal constant EXECTYPE_TRY = 0x01;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      MODE OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Encodes the fields into a mode.\n    function encodeMode(bytes1 callType, bytes1 execType, bytes4 selector, bytes22 payload)\n        internal\n        pure\n        returns (bytes32 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := or(shl(8, byte(0, callType)), byte(0, execType))\n            result := or(shr(224, selector), shl(64, result))\n            result := or(shr(80, payload), shl(176, result))\n        }\n    }\n\n    /// @dev Returns the call type of the mode.\n    function getCallType(bytes32 mode) internal pure returns (bytes1) {\n        return bytes1(mode);\n    }\n\n    /// @dev Returns the call type of the mode.\n    function getExecType(bytes32 mode) internal pure returns (bytes1) {\n        return mode[1];\n    }\n\n    /// @dev Returns the selector of the mode.\n    function getSelector(bytes32 mode) internal pure returns (bytes4) {\n        return bytes4(bytes32(uint256(mode) << 48));\n    }\n\n    /// @dev Returns the payload stored in the mode.\n    function getPayload(bytes32 mode) internal pure returns (bytes22) {\n        return bytes22(bytes32(uint256(mode) << 80));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                 EXECUTION DATA OPERATIONS                  */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Decodes a single call execution.\n    /// Reverts if `executionData` is not correctly encoded.\n    function decodeSingle(bytes calldata executionData)\n        internal\n        pure\n        returns (address target, uint256 value, bytes calldata data)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(gt(executionData.length, 0x33)) {\n                mstore(0x00, 0xba597e7e) // `DecodingError()`.\n                revert(0x1c, 0x04)\n            }\n            target := shr(96, calldataload(executionData.offset))\n            value := calldataload(add(executionData.offset, 0x14))\n            data.offset := add(executionData.offset, 0x34)\n            data.length := sub(executionData.length, 0x34)\n        }\n    }\n\n    /// @dev Decodes a single call execution without bounds checks.\n    function decodeSingleUnchecked(bytes calldata executionData)\n        internal\n        pure\n        returns (address target, uint256 value, bytes calldata data)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            target := shr(96, calldataload(executionData.offset))\n            value := calldataload(add(executionData.offset, 0x14))\n            data.offset := add(executionData.offset, 0x34)\n            data.length := sub(executionData.length, 0x34)\n        }\n    }\n\n    /// @dev Decodes a single delegate execution.\n    /// Reverts if `executionData` is not correctly encoded.\n    function decodeDelegate(bytes calldata executionData)\n        internal\n        pure\n        returns (address target, bytes calldata data)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(gt(executionData.length, 0x13)) {\n                mstore(0x00, 0xba597e7e) // `DecodingError()`.\n                revert(0x1c, 0x04)\n            }\n            target := shr(96, calldataload(executionData.offset))\n            data.offset := add(executionData.offset, 0x14)\n            data.length := sub(executionData.length, 0x14)\n        }\n    }\n\n    /// @dev Decodes a single delegate execution without bounds checks.\n    function decodeDelegateUnchecked(bytes calldata executionData)\n        internal\n        pure\n        returns (address target, bytes calldata data)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            target := shr(96, calldataload(executionData.offset))\n            data.offset := add(executionData.offset, 0x14)\n            data.length := sub(executionData.length, 0x14)\n        }\n    }\n\n    /// @dev Decodes a batch.\n    /// Reverts if `executionData` is not correctly encoded.\n    function decodeBatch(bytes calldata executionData)\n        internal\n        pure\n        returns (bytes32[] calldata pointers)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let u := calldataload(executionData.offset)\n            let s := add(executionData.offset, u)\n            let e := sub(add(executionData.offset, executionData.length), 0x20)\n            pointers.offset := add(s, 0x20)\n            pointers.length := calldataload(s)\n            if or(shr(64, u), gt(add(s, shl(5, pointers.length)), e)) {\n                mstore(0x00, 0xba597e7e) // `DecodingError()`.\n                revert(0x1c, 0x04)\n            }\n            if pointers.length {\n                // Perform bounds checks on the decoded `pointers`.\n                // Loop runs out-of-gas if `pointers.length` is big enough to cause overflows.\n                for { let i := pointers.length } 1 {} {\n                    i := sub(i, 1)\n                    let p := calldataload(add(pointers.offset, shl(5, i)))\n                    let c := add(pointers.offset, p)\n                    let q := calldataload(add(c, 0x40))\n                    let o := add(c, q)\n                    // forgefmt: disable-next-item\n                    if or(shr(64, or(calldataload(o), or(p, q))),\n                        or(gt(add(c, 0x40), e), gt(add(o, calldataload(o)), e))) {\n                        mstore(0x00, 0xba597e7e) // `DecodingError()`.\n                        revert(0x1c, 0x04)\n                    }\n                    if iszero(i) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Decodes a batch without bounds checks.\n    /// This function can be used in `execute`, if the validation phase has already\n    /// decoded the `executionData` with checks via `decodeBatch`.\n    function decodeBatchUnchecked(bytes calldata executionData)\n        internal\n        pure\n        returns (bytes32[] calldata pointers)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let o := add(executionData.offset, calldataload(executionData.offset))\n            pointers.offset := add(o, 0x20)\n            pointers.length := calldataload(o)\n        }\n    }\n\n    /// @dev Decodes a batch and optional `opData`.\n    /// Reverts if `executionData` is not correctly encoded.\n    function decodeBatchAndOpData(bytes calldata executionData)\n        internal\n        pure\n        returns (bytes32[] calldata pointers, bytes calldata opData)\n    {\n        opData = emptyCalldataBytes();\n        pointers = decodeBatch(executionData);\n        if (hasOpData(executionData)) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let e := sub(add(executionData.offset, executionData.length), 0x20)\n                let p := calldataload(add(0x20, executionData.offset))\n                let q := add(executionData.offset, p)\n                opData.offset := add(q, 0x20)\n                opData.length := calldataload(q)\n                if or(shr(64, or(opData.length, p)), gt(add(q, opData.length), e)) {\n                    mstore(0x00, 0xba597e7e) // `DecodingError()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /// @dev Decodes a batch without bounds checks.\n    /// This function can be used in `execute`, if the validation phase has already\n    /// decoded the `executionData` with checks via `decodeBatchAndOpData`.\n    function decodeBatchAndOpDataUnchecked(bytes calldata executionData)\n        internal\n        pure\n        returns (bytes32[] calldata pointers, bytes calldata opData)\n    {\n        opData = emptyCalldataBytes();\n        pointers = decodeBatchUnchecked(executionData);\n        if (hasOpData(executionData)) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let q := add(executionData.offset, calldataload(add(0x20, executionData.offset)))\n                opData.offset := add(q, 0x20)\n                opData.length := calldataload(q)\n            }\n        }\n    }\n\n    /// @dev Returns whether the `executionData` has optional `opData`.\n    function hasOpData(bytes calldata executionData) internal pure returns (bool result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result :=\n                iszero(or(lt(executionData.length, 0x40), lt(calldataload(executionData.offset), 0x40)))\n        }\n    }\n\n    /// @dev Returns the `i`th execution at `pointers`, without bounds checks.\n    /// The bounds check is excluded as this function is intended to be called in a bounded loop.\n    function getExecution(bytes32[] calldata pointers, uint256 i)\n        internal\n        pure\n        returns (address target, uint256 value, bytes calldata data)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let c := add(pointers.offset, calldataload(add(pointers.offset, shl(5, i))))\n            target := calldataload(c)\n            value := calldataload(add(c, 0x20))\n            let o := add(c, calldataload(add(c, 0x40)))\n            data.offset := add(o, 0x20)\n            data.length := calldataload(o)\n        }\n    }\n\n    /// @dev Reencodes `executionData` such that it has `opData` added to it.\n    /// Like `abi.encode(abi.decode(executionData, (Call[])), opData)`.\n    /// Useful for forwarding `executionData` with extra `opData`.\n    /// This function does not perform any check on the validity of `executionData`.\n    function reencodeBatch(bytes calldata executionData, bytes memory opData)\n        internal\n        pure\n        returns (bytes memory result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := add(0x64, mload(0x40)) // Give some space for `reencodeBatchAsExecuteCalldata`.\n            let s := calldataload(executionData.offset) // Offset of `calls`.\n            let n := sub(executionData.length, s) // Byte length of `calls`.\n            mstore(add(result, 0x20), 0x40) // Store the new offset of `calls`.\n            calldatacopy(add(result, 0x60), add(executionData.offset, s), n)\n            mstore(add(result, 0x40), add(0x40, n)) // Store the new offset of `opData`.\n            let o := add(add(result, 0x60), n) // Start offset of `opData` destination in memory.\n            let d := sub(opData, o) // Offset difference between `opData` source and `o`.\n            let end := add(mload(opData), add(0x20, o)) // End of `opData` destination in memory.\n            for {} 1 {} {\n                mstore(o, mload(add(o, d)))\n                o := add(o, 0x20)\n                if iszero(lt(o, end)) { break }\n            }\n            mstore(result, sub(o, add(result, 0x20))) // Store the length of `result`.\n            calldatacopy(end, calldatasize(), 0x40) // Zeroize the bytes after `end`.\n            mstore(0x40, add(0x20, o)) // Allocate memory.\n        }\n    }\n\n    /// @dev `abi.encodeWithSignature(\"execute(bytes32,bytes)\", mode, reencodeBatch(executionData, opData))`.\n    function reencodeBatchAsExecuteCalldata(\n        bytes32 mode,\n        bytes calldata executionData,\n        bytes memory opData\n    ) internal pure returns (bytes memory result) {\n        result = reencodeBatch(executionData, opData);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let n := mload(result)\n            result := sub(result, 0x64)\n            mstore(add(result, 0x44), 0x40) // Offset of `executionData`.\n            mstore(add(result, 0x24), mode)\n            mstore(add(result, 0x04), 0xe9ae5c53) // `execute(bytes32,bytes)`.\n            mstore(result, add(0x64, n))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          HELPERS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Helper function to return empty calldata bytes.\n    function emptyCalldataBytes() internal pure returns (bytes calldata result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result.offset := 0\n            result.length := 0\n        }\n    }\n}\n\n// lib/solady/src/accounts/Receiver.sol\n\n/// @notice Receiver mixin for ETH and safe-transferred ERC721 and ERC1155 tokens.\n/// @author Solady (https://github.com/Vectorized/solady/blob/main/src/accounts/Receiver.sol)\n///\n/// @dev Note:\n/// - Handles all ERC721 and ERC1155 token safety callbacks.\n/// - Collapses function table gas overhead and code size.\n/// - Utilizes fallback so unknown calldata will pass on.\nabstract contract Receiver {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The function selector is not recognized.\n    error FnSelectorNotRecognized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     RECEIVE / FALLBACK                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For receiving ETH.\n    receive() external payable virtual {}\n\n    /// @dev Fallback function with the `receiverFallback` modifier.\n    fallback() external payable virtual receiverFallback {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x3c10b94e) // `FnSelectorNotRecognized()`.\n            revert(0x1c, 0x04)\n        }\n    }\n\n    /// @dev Modifier for the fallback function to handle token callbacks.\n    modifier receiverFallback() virtual {\n        _beforeReceiverFallbackBody();\n        if (_useReceiverFallbackBody()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let s := shr(224, calldataload(0))\n                // 0x150b7a02: `onERC721Received(address,address,uint256,bytes)`.\n                // 0xf23a6e61: `onERC1155Received(address,address,uint256,uint256,bytes)`.\n                // 0xbc197c81: `onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)`.\n                if or(eq(s, 0x150b7a02), or(eq(s, 0xf23a6e61), eq(s, 0xbc197c81))) {\n                    // Assumes `mload(0x40) <= 0xffffffff` to save gas on cleaning lower bytes.\n                    mstore(0x20, s) // Store `msg.sig`.\n                    return(0x3c, 0x20) // Return `msg.sig`.\n                }\n            }\n        }\n        _afterReceiverFallbackBody();\n        _;\n    }\n\n    /// @dev Whether we want to use the body of the `receiverFallback` modifier.\n    function _useReceiverFallbackBody() internal view virtual returns (bool) {\n        return true;\n    }\n\n    /// @dev Called before the body of the `receiverFallback` modifier.\n    function _beforeReceiverFallbackBody() internal virtual {}\n\n    /// @dev Called after the body of the `receiverFallback` modifier.\n    function _afterReceiverFallbackBody() internal virtual {}\n}\n\n// lib/solady/src/accounts/ERC7821.sol\n\n/// @notice Minimal batch executor mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/accounts/ERC7821.sol)\n///\n/// @dev This contract can be inherited to create fully-fledged smart accounts.\n/// If you merely want to combine approve-swap transactions into a single transaction\n/// using [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702), you will need to implement basic\n/// [ERC-1271](https://eips.ethereum.org/EIPS/eip-1271) `isValidSignature` functionality to\n/// validate signatures with `ecrecover` against the EOA address. This is necessary because some\n/// signature checks skip `ecrecover` if the signer has code. For a basic EOA batch executor,\n/// please refer to [BEBE](https://github.com/vectorized/bebe), which inherits from this class.\ncontract ERC7821 is Receiver {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STRUCTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Call struct for the `execute` function.\n    struct Call {\n        address to; // Replaced as `address(this)` if `address(0)`. Renamed to `to` for Ithaca Porto.\n        uint256 value; // Amount of native currency (i.e. Ether) to send.\n        bytes data; // Calldata to send with the call.\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The execution mode is not supported.\n    error UnsupportedExecutionMode();\n\n    /// @dev Cannot decode `executionData` as a batch of batches `abi.encode(bytes[])`.\n    error BatchOfBatchesDecodingError();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                    EXECUTION OPERATIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Executes the calls in `executionData`.\n    /// Reverts and bubbles up error if any call fails.\n    ///\n    /// `executionData` encoding (single batch):\n    /// - If `opData` is empty, `executionData` is simply `abi.encode(calls)`.\n    /// - Else, `executionData` is `abi.encode(calls, opData)`.\n    ///   See: https://eips.ethereum.org/EIPS/eip-7579\n    ///\n    /// `executionData` encoding (batch of batches):\n    /// - `executionData` is `abi.encode(bytes[])`, where each element in `bytes[]`\n    ///   is an `executionData` for a single batch.\n    ///\n    /// Supported modes:\n    /// - `0x01000000000000000000...`: Single batch. Does not support optional `opData`.\n    /// - `0x01000000000078210001...`: Single batch. Supports optional `opData`.\n    /// - `0x01000000000078210002...`: Batch of batches.\n    ///\n    /// For the \"batch of batches\" mode, each batch will be recursively passed into\n    /// `execute` internally with mode `0x01000000000078210001...`.\n    /// Useful for passing in batches signed by different signers.\n    ///\n    /// Authorization checks:\n    /// - If `opData` is empty, the implementation SHOULD require that\n    ///   `msg.sender == address(this)`.\n    /// - If `opData` is not empty, the implementation SHOULD use the signature\n    ///   encoded in `opData` to determine if the caller can perform the execution.\n    /// - If `msg.sender` is an authorized entry point, then `execute` MAY accept\n    ///   calls from the entry point, and MAY use `opData` for specialized logic.\n    ///\n    /// `opData` may be used to store additional data for authentication,\n    /// paymaster data, gas limits, etc.\n    function execute(bytes32 mode, bytes calldata executionData) public payable virtual {\n        uint256 id = _executionModeId(mode);\n        if (id == 3) return _executeBatchOfBatches(mode, executionData);\n        Call[] calldata calls;\n        bytes calldata opData;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(id) {\n                mstore(0x00, 0x7f181275) // `UnsupportedExecutionMode()`.\n                revert(0x1c, 0x04)\n            }\n            // Use inline assembly to extract the calls and optional `opData` efficiently.\n            opData.length := 0\n            let o := add(executionData.offset, calldataload(executionData.offset))\n            calls.offset := add(o, 0x20)\n            calls.length := calldataload(o)\n            // If the offset of `executionData` allows for `opData`, and the mode supports it.\n            if gt(eq(id, 2), gt(0x40, calldataload(executionData.offset))) {\n                let q := add(executionData.offset, calldataload(add(0x20, executionData.offset)))\n                opData.offset := add(q, 0x20)\n                opData.length := calldataload(q)\n            }\n            // Bounds checking for `executionData` is skipped here for efficiency.\n            // This is safe if it is only used as an argument to `execute` externally.\n            // If `executionData` used as an argument to other functions externally,\n            // please perform the bounds checks via `LibERC7579.decodeBatchAndOpData`\n            /// or `abi.decode` in the other functions for safety.\n        }\n        _execute(mode, executionData, calls, opData);\n    }\n\n    /// @dev Provided for execution mode support detection.\n    function supportsExecutionMode(bytes32 mode) public view virtual returns (bool result) {\n        return _executionModeId(mode) != 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      INTERNAL HELPERS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev 0: invalid mode, 1: no `opData` support, 2: with `opData` support, 3: batch of batches.\n    function _executionModeId(bytes32 mode) internal view virtual returns (uint256 id) {\n        // Only supports atomic batched executions.\n        // For the encoding scheme, see: https://eips.ethereum.org/EIPS/eip-7579\n        // Bytes Layout:\n        // - [0]      ( 1 byte )  `0x01` for batch call.\n        // - [1]      ( 1 byte )  `0x00` for revert on any failure.\n        // - [2..5]   ( 4 bytes)  Reserved by ERC7579 for future standardization.\n        // - [6..9]   ( 4 bytes)  `0x00000000` or `0x78210001` or `0x78210002`.\n        // - [10..31] (22 bytes)  Unused. Free for use.\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := and(shr(mul(22, 8), mode), 0xffff00000000ffffffff)\n            id := eq(m, 0x01000000000000000000) // 1.\n            id := or(shl(1, eq(m, 0x01000000000078210001)), id) // 2.\n            id := or(mul(3, eq(m, 0x01000000000078210002)), id) // 3.\n        }\n    }\n\n    /// @dev For execution of a batch of batches.\n    function _executeBatchOfBatches(bytes32 mode, bytes calldata executionData) internal virtual {\n        // Replace with `0x0100________78210001...` while preserving optional and reserved fields.\n        mode ^= bytes32(uint256(3 << (22 * 8))); // `2 XOR 3 = 1`.\n        (uint256 n, uint256 o, uint256 e) = (0, 0, 0);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let j := calldataload(executionData.offset)\n            let t := add(executionData.offset, j)\n            n := calldataload(t) // `batches.length`.\n            o := add(0x20, t) // Offset of `batches[0]`.\n            e := add(executionData.offset, executionData.length) // End of `executionData`.\n            // Do the bounds check on `executionData` treating it as `abi.encode(bytes[])`.\n            // Not too expensive, so we will just do it right here right now.\n            if or(shr(64, j), or(lt(executionData.length, 0x20), gt(add(o, shl(5, n)), e))) {\n                mstore(0x00, 0x3995943b) // `BatchOfBatchesDecodingError()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        unchecked {\n            for (uint256 i; i != n; ++i) {\n                bytes calldata batch;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    let j := calldataload(add(o, shl(5, i)))\n                    let t := add(o, j)\n                    batch.offset := add(t, 0x20)\n                    batch.length := calldataload(t)\n                    // Validate that `batches[i]` is not out-of-bounds.\n                    if or(shr(64, j), gt(add(batch.offset, batch.length), e)) {\n                        mstore(0x00, 0x3995943b) // `BatchOfBatchesDecodingError()`.\n                        revert(0x1c, 0x04)\n                    }\n                }\n                execute(mode, batch);\n            }\n        }\n    }\n\n    /// @dev Executes the calls.\n    /// Reverts and bubbles up error if any call fails.\n    /// The `mode` and `executionData` are passed along in case there's a need to use them.\n    function _execute(\n        bytes32 mode,\n        bytes calldata executionData,\n        Call[] calldata calls,\n        bytes calldata opData\n    ) internal virtual {\n        // Silence compiler warning on unused variables.\n        mode = mode;\n        executionData = executionData;\n        // Very basic auth to only allow this contract to be called by itself.\n        // Override this function to perform more complex auth with `opData`.\n        if (opData.length == uint256(0)) {\n            require(msg.sender == address(this));\n            // Remember to return `_execute(calls, extraData)` when you override this function.\n            return _execute(calls, bytes32(0));\n        }\n        revert(); // In your override, replace this with logic to operate on `opData`.\n    }\n\n    /// @dev Executes the calls.\n    /// Reverts and bubbles up error if any call fails.\n    /// `extraData` can be any supplementary data (e.g. a memory pointer, some hash).\n    function _execute(Call[] calldata calls, bytes32 extraData) internal virtual {\n        unchecked {\n            uint256 i;\n            if (calls.length == uint256(0)) return;\n            do {\n                (address to, uint256 value, bytes calldata data) = _get(calls, i);\n                _execute(to, value, data, extraData);\n            } while (++i != calls.length);\n        }\n    }\n\n    /// @dev Executes the call.\n    /// Reverts and bubbles up error if any call fails.\n    /// `extraData` can be any supplementary data (e.g. a memory pointer, some hash).\n    function _execute(address to, uint256 value, bytes calldata data, bytes32 extraData)\n        internal\n        virtual\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            extraData := extraData // Silence unused variable compiler warning.\n            let m := mload(0x40) // Grab the free memory pointer.\n            calldatacopy(m, data.offset, data.length)\n            if iszero(call(gas(), to, value, m, data.length, codesize(), 0x00)) {\n                // Bubble up the revert if the call reverts.\n                returndatacopy(m, 0x00, returndatasize())\n                revert(m, returndatasize())\n            }\n        }\n    }\n\n    /// @dev Convenience function for getting `calls[i]`, without bounds checks.\n    function _get(Call[] calldata calls, uint256 i)\n        internal\n        view\n        virtual\n        returns (address to, uint256 value, bytes calldata data)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let c := add(calls.offset, calldataload(add(calls.offset, shl(5, i))))\n            // Replaces `to` with `address(this)` if `address(0)` is provided.\n            let t := shr(96, shl(96, calldataload(c)))\n            to := or(mul(address(), iszero(t)), t)\n            value := calldataload(add(c, 0x20))\n            let o := add(c, calldataload(add(c, 0x40)))\n            data.offset := add(o, 0x20)\n            data.length := calldataload(o)\n        }\n    }\n}\n\n// lib/solady/src/accounts/Timelock.sol\n\n/// @notice Simple timelock.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/accounts/Timelock.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/governance/TimelockController.sol)\n///\n/// @dev Note:\n/// - This implementation only supports ERC7821 style execution.\n/// - This implementation uses EnumerableRoles for better auditability.\n/// - This implementation uses custom errors with arguments for easier debugging.\n/// - `executionData` can be encoded in three different ways:\n///   1. `abi.encode(calls)`.\n///   2. `abi.encode(calls, abi.encode(predecessor))`.\n///   3. `abi.encode(calls, abi.encode(predecessor, salt))`.\n/// - Where `calls` is of type `(address,uint256,bytes)[]`, and\n///   `predecessor` is the id of the proposal that is required to be already executed.\n/// - If `predecessor` is `bytes32(0)`, it will be ignored (treated as if not required).\n/// - The optional `salt` allows for multiple proposals representing the same payload.\n/// - The proposal id is given by:\n///   `keccak256(abi.encode(mode, keccak256(executionData)))`.\n///\n/// We recommended including the salt, even though it is optional for convenience.\n///\n/// Supported modes:\n/// - `bytes32(0x01000000000000000000...)`: does not support optional `opData`.\n/// - `bytes32(0x01000000000078210001...)`: supports optional `opData`.\n/// Where `opData` is `abi.encode(predecessor)` or `abi.encode(predecessor, salt)`,\n/// and `...` is the remaining 22 bytes which can be anything.\n/// For ease of mind, just use:\n/// `0x0100000000007821000100000000000000000000000000000000000000000000`.\ncontract Timelock is ERC7821, EnumerableRoles {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Role that can add / remove roles without wait time.\n    /// This role cannot directly propose, execute, or cancel.\n    /// This role is NOT exempt from the execution wait time.\n    uint256 public constant ADMIN_ROLE = 0;\n\n    /// @dev Role that can propose operations.\n    uint256 public constant PROPOSER_ROLE = 1;\n\n    /// @dev Role that can execute operations.\n    uint256 public constant EXECUTOR_ROLE = 2;\n\n    /// @dev Role that can cancel proposed operations.\n    uint256 public constant CANCELLER_ROLE = 3;\n\n    /// @dev The maximum role.\n    uint256 public constant MAX_ROLE = 3;\n\n    /// @dev Assign this holder to a role to allow anyone to call\n    /// the function guarded by `onlyRoleOrOpenRole`.\n    address public constant OPEN_ROLE_HOLDER = 0x0303030303030303030303030303030303030303;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           ENUMS                            */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Represents the state of an operation.\n    enum OperationState {\n        Unset, // 0.\n        Waiting, // 1.\n        Ready, // 2.\n        Done // 3.\n\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The proposed operation has insufficient delay.\n    error TimelockInsufficientDelay(uint256 delay, uint256 minDelay);\n\n    /// @dev The operation cannot be performed.\n    /// The `expectedStates` is a bitmap with the bits enabled for\n    /// each enum position, starting from the least significant bit.\n    error TimelockInvalidOperation(bytes32 id, uint256 expectedStates);\n\n    /// @dev The operation has a predecessor that has not been executed.\n    error TimelockUnexecutedPredecessor(bytes32 predecessor);\n\n    /// @dev Unauthorized to call the function.\n    error TimelockUnauthorized();\n\n    /// @dev The delay cannot be greater than `2 ** 254 - 1`.\n    error TimelockDelayOverflow();\n\n    /// @dev The timelock has already been initialized.\n    error TimelockAlreadyInitialized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage slot for the timelock's minimum delay.\n    /// We restrict the `minDelay` to be less than `2 ** 254 - 1`, and store the negation of it.\n    /// This allows us to check if it has been initialized via a non-zero check.\n    /// Slot of operation `id` is given by:\n    /// ```\n    ///     mstore(0x09, _TIMELOCK_SLOT)\n    ///     mstore(0x00, id)\n    ///     let operationIdSlot := keccak256(0x00, 0x29)\n    /// ```\n    /// Bits layout:\n    /// - [0]       `done`.\n    /// - [1..255]  `readyTimestamp`.\n    uint256 private constant _TIMELOCK_SLOT = 0x477f2812565c76a73f;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         IMMUTABLES                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For guarding `initialize` if not via a delegate call.\n    uint256 private immutable __timelockSelf = uint256(uint160(address(this)));\n\n    /// @dev For guarding `initialize` if not via a delegate call.\n    uint256 private immutable __timelockDeployer = uint256(uint160(address(msg.sender)));\n\n    /// @dev For guarding `initialize` if not via a delegate call.\n    uint256 private immutable __timelockDeployerOrigin = uint256(uint160(address(tx.origin)));\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The proposal `id` has been created.\n    event Proposed(bytes32 indexed id, bytes32 mode, bytes executionData, uint256 readyTimestamp);\n\n    /// @dev The proposal `id` has been executed.\n    event Executed(bytes32 indexed id, bytes32 mode, bytes executionData);\n\n    /// @dev The proposal `id` has been cancelled.\n    event Cancelled(bytes32 indexed id);\n\n    /// @dev The minimum delay has been set to `newMinDelay`.\n    event MinDelaySet(uint256 newMinDelay);\n\n    /// @dev `keccak256(bytes(\"Proposed(bytes32,bytes32,bytes,uint256)\"))`.\n    uint256 private constant _PROPOSED_EVENT_SIGNATURE =\n        0x9b40ebcd599cbeb62eedb5e0c1db0879688a09d169ab92dbed4957d49a44b671;\n\n    /// @dev `keccak256(bytes(\"Executed(bytes32,bytes32,bytes)\"))`.\n    uint256 private constant _EXECUTED_EVENT_SIGNATURE =\n        0xb1fdd61c3a5405a73ea1f8fb29bfd62c6152241cb59843d3def17bfadb7cb0bf;\n\n    /// @dev `keccak256(bytes(\"Cancelled(bytes32)\"))`.\n    uint256 private constant _CANCELLED_EVENT_SIGNATURE =\n        0xbaa1eb22f2a492ba1a5fea61b8df4d27c6c8b5f3971e63bb58fa14ff72eedb70;\n\n    /// @dev `keccak256(bytes(\"MinDelaySet(uint256)\"))`.\n    uint256 private constant _MIN_DELAY_SET_EVENT_SIGNATURE =\n        0x496c64b8781f4ad77f1c285beea54cc413b72276389ad6dd916ea2841395e63d;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                        INITIALIZER                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Initializes the timelock contract.\n    function initialize(\n        uint256 initialMinDelay,\n        address initialAdmin,\n        address[] calldata proposers,\n        address[] calldata executors,\n        address[] calldata cancellers\n    ) public virtual {\n        _initializeTimelockAuthorizationCheck();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if shr(254, initialMinDelay) {\n                mstore(0x00, 0xd1efaf25) // `TimelockDelayOverflow()`.\n                revert(0x1c, 0x04)\n            }\n            let s := _TIMELOCK_SLOT\n            if sload(s) {\n                mstore(0x00, 0xc44f149c) // `TimelockAlreadyInitialized()`.\n                revert(0x1c, 0x04)\n            }\n            sstore(s, not(initialMinDelay))\n            mstore(0x00, initialMinDelay)\n            log1(0x00, 0x20, _MIN_DELAY_SET_EVENT_SIGNATURE)\n        }\n        if (initialAdmin != address(0)) {\n            _setRole(initialAdmin, ADMIN_ROLE, true);\n        }\n        _bulkSetRole(proposers, PROPOSER_ROLE, true);\n        _bulkSetRole(executors, EXECUTOR_ROLE, true);\n        _bulkSetRole(cancellers, CANCELLER_ROLE, true);\n    }\n\n    /// @dev The Timelock is best used via a minimal proxy.\n    /// But in case it is not, we want to guard `initialize` from frontrun griefing.\n    /// Authorizing both `msg.sender` and `tx.origin` caters to the use case where\n    /// the Timelock is being deployed via a factory (e.g. Nicks, CreateX).\n    ///\n    /// Always call `initialize` as soon as possible after deployment.\n    /// In the rare case where `msg.sender` or `tx.origin` are untrusted\n    /// and abused to frontrun, `initialize` will revert on reinitialization,\n    /// so you will know that the deployment is compromised and must be discarded.\n    function _initializeTimelockAuthorizationCheck() internal virtual {\n        uint256 self = __timelockSelf;\n        uint256 deployer = __timelockDeployer;\n        uint256 deployerOrigin = __timelockDeployerOrigin;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if eq(self, address()) {\n                if iszero(or(eq(caller(), deployer), eq(caller(), deployerOrigin))) {\n                    mstore(0x00, 0x55140ae8) // `TimelockUnauthorized()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Proposes an execute payload (`mode`, `executionData`) with `delay`.\n    /// Emits a {Proposed} event.\n    function propose(bytes32 mode, bytes calldata executionData, uint256 delay)\n        public\n        virtual\n        onlyRole(PROPOSER_ROLE)\n        returns (bytes32 id)\n    {\n        LibERC7579.decodeBatchAndOpData(executionData); // Check if properly encoded.\n        uint256 t = minDelay();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if shr(254, delay) {\n                mstore(0x00, 0xd1efaf25) // `TimelockDelayOverflow()`.\n                revert(0x1c, 0x04)\n            }\n            if lt(delay, t) {\n                mstore(0x00, 0x54336609) // `TimelockInsufficientDelay(uint256,uint256)`.\n                mstore(0x20, delay)\n                mstore(0x40, t)\n                revert(0x1c, 0x44)\n            }\n            let m := mload(0x40)\n            calldatacopy(add(m, 0x80), executionData.offset, executionData.length)\n            mstore(0x00, mode)\n            mstore(0x20, keccak256(add(m, 0x80), executionData.length))\n            id := keccak256(0x00, 0x40)\n            mstore(0x09, _TIMELOCK_SLOT)\n            mstore(0x00, id)\n            let s := keccak256(0x00, 0x29) // Operation slot.\n            if sload(s) {\n                mstore(0x00, 0xd639b0bf) // `TimelockInvalidOperation(bytes32,uint256)`.\n                mstore(0x20, id)\n                mstore(0x40, 1) // `1 << OperationState.Unset`\n                revert(0x1c, 0x44)\n            }\n            // Emits the {Proposed} event.\n            mstore(m, mode)\n            mstore(add(m, 0x20), 0x60)\n            let r := add(delay, timestamp()) // `readyTimestamp`.\n            sstore(s, shl(1, r)) // Update the operation in the storage.\n            mstore(add(m, 0x40), r)\n            mstore(add(m, 0x60), executionData.length)\n            // Some indexers require the bytes to be zero-right padded.\n            mstore(add(add(m, 0x80), executionData.length), 0) // Zeroize the slot after the end.\n            // forgefmt: disable-next-item\n            log2(m, add(0x80, and(not(0x1f), add(0x1f, executionData.length))),\n                _PROPOSED_EVENT_SIGNATURE, id)\n        }\n    }\n\n    /// @dev Cancels the operation with `id`.\n    /// Emits a {Cancelled} event.\n    function cancel(bytes32 id) public virtual onlyRole(CANCELLER_ROLE) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x09, _TIMELOCK_SLOT)\n            mstore(0x00, id)\n            let s := keccak256(0x00, 0x29) // Operation slot.\n            let p := sload(s)\n            if or(and(1, p), iszero(p)) {\n                mstore(0x00, 0xd639b0bf) // `TimelockInvalidOperation(bytes32,uint256)`.\n                mstore(0x20, id)\n                mstore(0x40, 6) // `(1 << OperationState.Waiting) | (1 << OperationState.Ready)`\n                revert(0x1c, 0x44)\n            }\n            sstore(s, 0) // Clears the operation's storage slot.\n            // Emits the {Cancelled} event.\n            log2(0x00, 0x00, _CANCELLED_EVENT_SIGNATURE, id)\n        }\n    }\n\n    /// @dev Allows the timelock itself to set the minimum delay.\n    /// Emits a {MinDelaySet} event.\n    function setMinDelay(uint256 newMinDelay) public virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(eq(caller(), address())) {\n                mstore(0x00, 0x55140ae8) // `TimelockUnauthorized()`.\n                revert(0x1c, 0x04)\n            }\n            if shr(254, newMinDelay) {\n                mstore(0x00, 0xd1efaf25) // `TimelockDelayOverflow()`.\n                revert(0x1c, 0x04)\n            }\n            sstore(_TIMELOCK_SLOT, not(newMinDelay))\n            // Emits the {SetMinDelay} event.\n            mstore(0x00, newMinDelay)\n            log1(0x00, 0x20, _MIN_DELAY_SET_EVENT_SIGNATURE)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC VIEW FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the minimum delay.\n    function minDelay() public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := not(sload(_TIMELOCK_SLOT))\n        }\n    }\n\n    /// @dev Returns the ready timestamp for `id`.\n    function readyTimestamp(bytes32 id) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x09, _TIMELOCK_SLOT)\n            mstore(0x00, id)\n            result := shr(1, sload(keccak256(0x00, 0x29)))\n        }\n    }\n\n    /// @dev Returns the current operation state of `id`.\n    function operationState(bytes32 id) public view virtual returns (OperationState result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x09, _TIMELOCK_SLOT)\n            mstore(0x00, id)\n            result := sload(keccak256(0x00, 0x29))\n            // forgefmt: disable-next-item\n            result := mul(iszero(iszero(result)),\n                add(and(result, 1), sub(2, lt(timestamp(), shr(1, result)))))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      INTERNAL HELPERS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Helper to set roles in bulk.\n    function _bulkSetRole(address[] calldata addresses, uint256 role, bool active)\n        internal\n        virtual\n    {\n        for (uint256 i; i != addresses.length;) {\n            address a;\n            /// @solidity memory-safe-assembly\n            assembly {\n                a := calldataload(add(addresses.offset, shl(5, i)))\n                i := add(i, 1)\n            }\n            _setRole(a, role, active);\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         OVERRIDES                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For ERC7821.\n    /// To ensure that the function can only be called by the proper role holder.\n    /// To ensure that the operation is ready to be executed.\n    /// Updates the operation state and emits a {Executed} event after the calls.\n    function _execute(\n        bytes32 mode,\n        bytes calldata executionData,\n        Call[] calldata calls,\n        bytes calldata opData\n    ) internal virtual override(ERC7821) {\n        if (!hasRole(OPEN_ROLE_HOLDER, EXECUTOR_ROLE)) _checkRole(EXECUTOR_ROLE);\n        bytes32 id;\n        uint256 s;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Copies the `executionData` for the event and to compute the `id`.\n            calldatacopy(mload(0x40), executionData.offset, executionData.length)\n            mstore(0x00, mode)\n            mstore(0x20, keccak256(mload(0x40), executionData.length))\n            id := keccak256(0x00, 0x40)\n            mstore(0x09, _TIMELOCK_SLOT)\n            mstore(0x00, id)\n            s := keccak256(0x00, 0x29)\n            let p := sload(s)\n            if or(or(and(1, p), iszero(p)), lt(timestamp(), shr(1, p))) {\n                mstore(0x00, 0xd639b0bf) // `TimelockInvalidOperation(bytes32,uint256)`.\n                mstore(0x20, id)\n                mstore(0x40, 4) // `1 << OperationState.Ready`\n                revert(0x1c, 0x44)\n            }\n            // Check if optional predecessor has been executed.\n            if iszero(lt(opData.length, 0x20)) {\n                let b := calldataload(opData.offset) // Predecessor's id.\n                mstore(0x00, b) // `_TIMELOCK_SLOT` is already at `0x09`.\n                if iszero(or(iszero(b), and(1, sload(keccak256(0x00, 0x29))))) {\n                    mstore(0x00, 0x90a9a618) // `TimelockUnexecutedPredecessor(bytes32)`.\n                    mstore(0x20, b)\n                    revert(0x1c, 0x24)\n                }\n            }\n        }\n        _execute(calls, id);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Recheck the operation after the calls, in case of reentrancy.\n            let p := sload(s)\n            if or(or(and(1, p), iszero(p)), lt(timestamp(), shr(1, p))) {\n                mstore(0x00, 0xd639b0bf) // `TimelockInvalidOperation(bytes32,uint256)`.\n                mstore(0x20, id)\n                mstore(0x40, 4) // `1 << OperationState.Ready`\n                revert(0x1c, 0x44)\n            }\n            let m := mload(0x40)\n            // Copies the `executionData` for the event.\n            calldatacopy(add(m, 0x60), executionData.offset, executionData.length)\n            // Emits the {Executed} event.\n            mstore(m, mode)\n            mstore(add(m, 0x20), 0x40)\n            mstore(add(m, 0x40), executionData.length)\n            // Some indexers require the bytes to be zero-right padded.\n            mstore(add(add(m, 0x60), executionData.length), 0) // Zeroize the slot after the end.\n            // forgefmt: disable-next-item\n            log2(m, add(0x60, and(not(0x1f), add(0x1f, executionData.length))),\n                _EXECUTED_EVENT_SIGNATURE, id)\n            sstore(s, or(1, p)) // Set the operation as executed in the storage.\n        }\n    }\n\n    /// @dev This guards the public `setRole` function,\n    /// such that it can only be called by the timelock itself, or an admin.\n    function _authorizeSetRole(address, uint256, bool) internal virtual override(EnumerableRoles) {\n        if (msg.sender != address(this)) _checkRole(ADMIN_ROLE);\n    }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"osaka","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":1000000},"remappings":[]},"optimization_runs":1000000,"sourcify_repo_url":"https://repo.sourcify.dev/contracts/partial_match/137/0x47EbFAC3353314C788B96CDCbf41daadfE03629C/","decoded_constructor_args":null,"compiler_version":"0.8.34+commit.80d5c536","is_verified_via_verifier_alliance":false,"verified_at":"2026-04-16T05:01:21.162791Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":null,"name":"Timelock","is_blueprint":false,"license_type":"none","is_fully_verified":false,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"osaka","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":true,"additional_sources":[],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[],"name":"BatchOfBatchesDecodingError","type":"error"},{"inputs":[],"name":"EnumerableRolesUnauthorized","type":"error"},{"inputs":[],"name":"FnSelectorNotRecognized","type":"error"},{"inputs":[],"name":"InvalidRole","type":"error"},{"inputs":[],"name":"RoleHolderIsZeroAddress","type":"error"},{"inputs":[],"name":"RoleHoldersIndexOutOfBounds","type":"error"},{"inputs":[],"name":"TimelockAlreadyInitialized","type":"error"},{"inputs":[],"name":"TimelockDelayOverflow","type":"error"},{"inputs":[{"internalType":"uint256","name":"delay","type":"uint256"},{"internalType":"uint256","name":"minDelay","type":"uint256"}],"name":"TimelockInsufficientDelay","type":"error"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"},{"internalType":"uint256","name":"expectedStates","type":"uint256"}],"name":"TimelockInvalidOperation","type":"error"},{"inputs":[],"name":"TimelockUnauthorized","type":"error"},{"inputs":[{"internalType":"bytes32","name":"predecessor","type":"bytes32"}],"name":"TimelockUnexecutedPredecessor","type":"error"},{"inputs":[],"name":"UnsupportedExecutionMode","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"Cancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"mode","type":"bytes32"},{"indexed":false,"internalType":"bytes","name":"executionData","type":"bytes"}],"name":"Executed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMinDelay","type":"uint256"}],"name":"MinDelaySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"mode","type":"bytes32"},{"indexed":false,"internalType":"bytes","name":"executionData","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"readyTimestamp","type":"uint256"}],"name":"Proposed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"holder","type":"address"},{"indexed":true,"internalType":"uint256","name":"role","type":"uint256"},{"indexed":true,"internalType":"bool","name":"active","type":"bool"}],"name":"RoleSet","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"ADMIN_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CANCELLER_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EXECUTOR_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPEN_ROLE_HOLDER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROPOSER_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"cancel","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"mode","type":"bytes32"},{"internalType":"bytes","name":"executionData","type":"bytes"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"uint256","name":"role","type":"uint256"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"result","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"initialMinDelay","type":"uint256"},{"internalType":"address","name":"initialAdmin","type":"address"},{"internalType":"address[]","name":"proposers","type":"address[]"},{"internalType":"address[]","name":"executors","type":"address[]"},{"internalType":"address[]","name":"cancellers","type":"address[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minDelay","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"operationState","outputs":[{"internalType":"enum Timelock.OperationState","name":"result","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"mode","type":"bytes32"},{"internalType":"bytes","name":"executionData","type":"bytes"},{"internalType":"uint256","name":"delay","type":"uint256"}],"name":"propose","outputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"readyTimestamp","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"role","type":"uint256"},{"internalType":"uint256","name":"i","type":"uint256"}],"name":"roleHolderAt","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"role","type":"uint256"}],"name":"roleHolderCount","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"role","type":"uint256"}],"name":"roleHolders","outputs":[{"internalType":"address[]","name":"result","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMinDelay","type":"uint256"}],"name":"setMinDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"uint256","name":"role","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"}],"name":"setRole","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"mode","type":"bytes32"}],"name":"supportsExecutionMode","outputs":[{"internalType":"bool","name":"result","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"is_changed_bytecode":false,"is_partially_verified":true,"constructor_args":null}