creation_sourcecode: {{
    "language": "Solidity",
    "sources": {
      "@openzeppelin/contracts/access/Ownable.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
      },
      "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Interface that must be implemented by smart contracts in order to receive\n * ERC-1155 token transfers.\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"
      },
      "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/utils/ERC1155Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165, ERC165} from \"../../../utils/introspection/ERC165.sol\";\nimport {IERC1155Receiver} from \"../IERC1155Receiver.sol\";\n\n/**\n * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC1155 tokens.\n *\n * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be\n * stuck.\n */\nabstract contract ERC1155Holder is ERC165, IERC1155Receiver {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    function onERC1155Received(\n        address,\n        address,\n        uint256,\n        uint256,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155Received.selector;\n    }\n\n    function onERC1155BatchReceived(\n        address,\n        address,\n        uint256[] memory,\n        uint256[] memory,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155BatchReceived.selector;\n    }\n}\n"
      },
      "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"
      },
      "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\n\n/**\n * @dev Implementation of the {IERC721Receiver} interface.\n *\n * Accepts all token transfers.\n * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or\n * {IERC721-setApprovalForAll}.\n */\nabstract contract ERC721Holder is IERC721Receiver {\n    /**\n     * @dev See {IERC721Receiver-onERC721Received}.\n     *\n     * Always returns `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {\n        return this.onERC721Received.selector;\n    }\n}\n"
      },
      "@openzeppelin/contracts/utils/Context.sol": {
        "content": "// 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"
      },
      "@openzeppelin/contracts/utils/introspection/ERC165.sol": {
        "content": "// 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"
      },
      "@openzeppelin/contracts/utils/introspection/IERC165.sol": {
        "content": "// 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"
      },
      "@timeholder/asset-box/contracts/AssetBox.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {Ownable} from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport {Callable} from \"./base/Callable.sol\";\nimport {NFTHolder} from \"./base/NFTHolder.sol\";\nimport {Receivable} from \"./base/Receivable.sol\";\nimport {Withdrawable} from \"./base/Withdrawable.sol\";\n\ncontract AssetBox is Ownable, Callable, NFTHolder, Receivable, Withdrawable {\n  function name()\n  external pure virtual\n  returns (string memory) {\n    return \"AssetBox\";\n  }\n\n  function version()\n  external pure virtual\n  returns (string memory) {\n    return \"1.1.0\";\n  }\n\n  constructor(address initialOwner) Ownable(initialOwner) {}\n\n  function _authorizeWithdraw(address)\n  internal view virtual override(Withdrawable) onlyOwner {}\n\n  function _authorizeCall(address)\n  internal view virtual override(Callable) onlyOwner {}\n}\n"
      },
      "@timeholder/asset-box/contracts/base/Callable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {ICallable} from \"../interface/ICallable.sol\";\n\nabstract contract Callable is ICallable {\n  error CallableInsufficientBalance(uint256 balance, uint256 needed);\n  error CallableContractCallFailed();\n\n  /**\n   * @dev Function that should revert when `msg.sender` is not authorized to call.\n   *\n   * ```solidity\n   * function _authorizeCall(address) internal override(Callable) onlyOwner {}\n   * ```\n   */\n  function _authorizeCall(address sender)\n  internal virtual;\n\n  function callContract(address target, bytes calldata data)\n  external payable virtual\n  returns (bytes memory) {\n    _authorizeCall(msg.sender);\n    (bool success, bytes memory result) = target.call{value: msg.value}(data);\n    if (!success) revert CallableContractCallFailed();\n    emit ContractCalled(target, data, result);\n    return result;\n  }\n\n  function callContract(address target, bytes calldata data, uint256 amount)\n  external virtual\n  returns (bytes memory) {\n    _authorizeCall(msg.sender);\n    uint256 balance = address(this).balance;\n    if (balance < amount) revert CallableInsufficientBalance(balance, amount);\n    (bool success, bytes memory result) = target.call{value: amount}(data);\n    if (!success) revert CallableContractCallFailed();\n    emit ContractCalled(target, data, result);\n    return result;\n  }\n}\n"
      },
      "@timeholder/asset-box/contracts/base/NFTHolder.sol": {
        "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.20;\n\nimport {ERC721Holder} from \"@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol\";\nimport {ERC1155Holder} from \"@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol\";\n\nabstract contract NFTHolder is ERC721Holder, ERC1155Holder {}\n"
      },
      "@timeholder/asset-box/contracts/base/Receivable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {IReceivable} from \"../interface/IReceivable.sol\";\n\nabstract contract Receivable is IReceivable {\n  receive() external payable virtual {\n    emit Received(msg.sender, msg.value);\n  }\n}\n"
      },
      "@timeholder/asset-box/contracts/base/Withdrawable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {IWithdrawable} from \"../interface/IWithdrawable.sol\";\n\nabstract contract Withdrawable is IWithdrawable {\n  error WithdrawableInsufficientBalance(uint256 balance, uint256 needed);\n  error WithdrawableERC20InsufficientBalance(address token, uint256 balance, uint256 needed);\n  error WithdrawableWithdrawalFailed();\n\n  /**\n   * @dev Function that should revert when `msg.sender` is not authorized to withdraw.\n   *\n   * ```solidity\n   * function _authorizeWithdraw(address) internal override(Withdrawable) onlyOwner {}\n   * ```\n   */\n  function _authorizeWithdraw(address sender)\n  internal virtual;\n\n  function withdraw()\n  external virtual {\n    _authorizeWithdraw(msg.sender);\n    _withdraw(0);\n  }\n\n  function withdraw(uint256 amount)\n  external virtual {\n    _authorizeWithdraw(msg.sender);\n    _withdraw(amount);\n  }\n\n  function withdrawERC20(address token)\n  external virtual {\n    _authorizeWithdraw(msg.sender);\n    _withdrawERC20(token, 0);\n  }\n\n  function withdrawERC20(address token, uint256 amount)\n  external virtual {\n    _authorizeWithdraw(msg.sender);\n    _withdrawERC20(token, amount);\n  }\n\n  function withdrawERC721(address token, uint256 tokenId, bytes calldata data)\n  external virtual {\n    _authorizeWithdraw(msg.sender);\n    _withdrawERC721(token, tokenId, data);\n  }\n\n  function withdrawERC1155(address token, uint256 id, uint256 value, bytes calldata data)\n  external virtual {\n    _authorizeWithdraw(msg.sender);\n    _withdrawERC1155(token, id, value, data);\n  }\n\n  function withdrawERC1155Batch(address token, uint256[] calldata ids, uint256[] calldata values, bytes calldata data)\n  external virtual {\n    _authorizeWithdraw(msg.sender);\n    _withdrawERC1155Batch(token, ids, values, data);\n  }\n\n  function _withdraw(uint256 amount)\n  private {\n    uint256 balance = address(this).balance;\n\n    if (amount == 0) amount = balance;\n    else if (balance < amount) revert WithdrawableInsufficientBalance(balance, amount);\n\n    (bool ok,) = payable(msg.sender).call{value: amount}(\"\");\n    if (!ok) revert WithdrawableWithdrawalFailed();\n\n    emit Withdrawal(msg.sender, amount);\n  }\n\n  function _withdrawERC20(address token, uint256 amount)\n  private {\n    (bool success, bytes memory result) = token.call(\n      abi.encodeWithSignature(\"balanceOf(address)\", address(this))\n    );\n    if (!success) revert WithdrawableWithdrawalFailed();\n    uint256 balance = abi.decode(result, (uint256));\n\n    if (amount == 0) amount = balance;\n    else if (balance < amount) revert WithdrawableERC20InsufficientBalance(token, balance, amount);\n\n    (bool ok,) = token.call(\n      abi.encodeWithSignature(\"transfer(address,uint256)\", msg.sender, amount)\n    );\n    if (!ok) revert WithdrawableWithdrawalFailed();\n\n    emit WithdrawalERC20(msg.sender, token, amount);\n  }\n\n  function _withdrawERC721(address token, uint256 tokenId, bytes calldata data)\n  private {\n    (bool ok,) = token.call(\n      abi.encodeWithSignature(\"safeTransferFrom(address,address,uint256,bytes)\", address(this), msg.sender, tokenId, data)\n    );\n    if (!ok) revert WithdrawableWithdrawalFailed();\n\n    emit WithdrawalERC721(msg.sender, token, tokenId);\n  }\n\n  function _withdrawERC1155(address token, uint256 id, uint256 value, bytes calldata data)\n  private {\n    (bool ok,) = token.call(\n      abi.encodeWithSignature(\"safeTransferFrom(address,address,uint256,uint256,bytes)\", address(this), msg.sender, id, value, data)\n    );\n    if (!ok) revert WithdrawableWithdrawalFailed();\n\n    emit WithdrawalERC1155(msg.sender, token, id, value);\n  }\n\n  function _withdrawERC1155Batch(address token, uint256[] calldata ids, uint256[] calldata values, bytes calldata data)\n  private {\n    (bool ok,) = token.call(\n      abi.encodeWithSignature(\"safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)\", address(this), msg.sender, ids, values, data)\n    );\n    if (!ok) revert WithdrawableWithdrawalFailed();\n\n    emit WithdrawalERC1155Batch(msg.sender, token, ids, values);\n  }\n}\n"
      },
      "@timeholder/asset-box/contracts/interface/ICallable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface ICallable {\n  event ContractCalled(address indexed target, bytes data, bytes result);\n\n  /**\n   * @dev Call the specified contract's function.\n   * @param target The address of the target contract to call.\n   * @param data The bytecode of the target contract to call function and parameters.\n   *\n   * You can choose to send ETH to the target contract when calling the function.\n   */\n  function callContract(address target, bytes calldata data) external payable returns (bytes memory result);\n\n  /**\n   * @dev Call the specified contract's function.\n   * @param target The address of the target contract to call.\n   * @param data The bytecode of the target contract to call function and parameters.\n   * @param amount Send a specified amount of ETH from the current contract to the target contract.\n   */\n  function callContract(address target, bytes calldata data, uint256 amount) external returns (bytes memory result);\n}\n"
      },
      "@timeholder/asset-box/contracts/interface/IReceivable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface IReceivable {\n  event Received(address indexed sender, uint256 value);\n\n  receive() external payable;\n}\n"
      },
      "@timeholder/asset-box/contracts/interface/IWithdrawable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface IWithdrawable {\n  event Withdrawal(address indexed sender, uint256 amount);\n  event WithdrawalERC20(address indexed sender, address indexed token, uint256 amount);\n  event WithdrawalERC721(address indexed sender, address indexed token, uint256 tokenId);\n  event WithdrawalERC1155(address indexed sender, address indexed token, uint256 id, uint256 value);\n  event WithdrawalERC1155Batch(address indexed sender, address indexed token, uint256[] ids, uint256[] values);\n\n  /**\n   * @dev Withdraw all ETH.\n   * Can only be called by the authorized.\n   */\n  function withdraw() external;\n\n  /**\n   * @dev Withdraw a specified amount of ETH.\n   * Can only be called by the authorized.\n   */\n  function withdraw(uint256 amount) external;\n\n  /**\n   * @dev Withdraw all ERC20 tokens.\n   * Can only be called by the authorized.\n   */\n  function withdrawERC20(address token) external;\n\n  /**\n   * @dev Withdraw a specified amount of ERC20 tokens.\n   * Can only be called by the authorized.\n   */\n  function withdrawERC20(address token, uint256 amount) external;\n\n  /**\n   * @dev Withdraw a ERC721 token.\n   * Can only be called by the authorized.\n   */\n  function withdrawERC721(address token, uint256 tokenId, bytes calldata data) external;\n\n  /**\n   * @dev Withdraw a ERC1155 token.\n   * Can only be called by the authorized.\n   */\n  function withdrawERC1155(address token, uint256 id, uint256 value, bytes calldata data) external;\n\n  /**\n   * @dev Withdraw multiple ERC1155 tokens.\n   * Can only be called by the authorized.\n   */\n  function withdrawERC1155Batch(address token, uint256[] calldata ids, uint256[] calldata values, bytes calldata data) external;\n}\n"
      },
      "@timeholder/asset-locker/contracts/AssetLocker.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {IAssetLocker} from \"./interface/IAssetLocker.sol\";\nimport {AssetBox} from \"@timeholder/asset-box/contracts/AssetBox.sol\";\n\ncontract AssetLocker is IAssetLocker, AssetBox {\n  function name()\n  external pure virtual override\n  returns (string memory) {\n    return \"AssetLocker\";\n  }\n\n  function version()\n  external pure virtual override\n  returns (string memory) {\n    return \"1.1.1\";\n  }\n\n  error ShortenedTimeMustBeGreaterThanZero();\n  error UnauthorizedAccount(address account);\n  error UnlockTimeHasNotArrivedYet(uint256 timestamp);\n\n  address private _guardian;\n  uint256 private _unlockTime;\n\n  constructor(\n    address initialOwner,\n    address initialGuardian,\n    uint256 lockTime\n  ) AssetBox(initialOwner) {\n    _transferGuardianship(initialGuardian);\n    _setUnlockTime(block.timestamp + lockTime);\n  }\n\n  function _authorizeWithdraw(address)\n  internal view override(AssetBox) onlyOwner {\n    if (block.timestamp < _unlockTime) revert UnlockTimeHasNotArrivedYet(block.timestamp);\n  }\n\n  function _authorizeCall(address)\n  internal view override(AssetBox) onlyOwner {\n    if (block.timestamp < _unlockTime) revert UnlockTimeHasNotArrivedYet(block.timestamp);\n  }\n\n  modifier onlyGuardian() {\n    if (_guardian != msg.sender) revert UnauthorizedAccount(msg.sender);\n    _;\n  }\n\n  function guardian()\n  external view\n  returns (address) {\n    return _guardian;\n  }\n\n  function unlockTime()\n  external view\n  returns (uint256) {\n    return _unlockTime;\n  }\n\n  function isUnlocked()\n  external view\n  returns (bool) {\n    return block.timestamp >= _unlockTime;\n  }\n\n  function transferGuardianship(address newGuardian)\n  external\n  onlyGuardian {\n    _transferGuardianship(newGuardian);\n  }\n\n  function _transferGuardianship(address newGuardian)\n  private {\n    address oldGuardian = _guardian;\n    _guardian = newGuardian;\n    emit GuardianshipTransferred(oldGuardian, newGuardian);\n  }\n\n  function unlock()\n  external\n  onlyGuardian {\n    _setUnlockTime(block.timestamp);\n  }\n\n  function shortenUnlockTime(uint256 shortenedTime)\n  external\n  onlyGuardian {\n    if (shortenedTime == 0) revert ShortenedTimeMustBeGreaterThanZero();\n    _setUnlockTime(_unlockTime - shortenedTime);\n  }\n\n  function _setUnlockTime(uint256 newUnlockTime)\n  private {\n    _unlockTime = newUnlockTime;\n    emit UpdateUnlockTime(newUnlockTime);\n  }\n}\n"
      },
      "@timeholder/asset-locker/contracts/interface/IAssetLocker.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\ninterface IAssetLocker {\n  event GuardianshipTransferred(address indexed previousGuardian, address indexed newGuardian);\n  event UpdateUnlockTime(uint256 unlockTime);\n\n  function guardian() external view returns (address);\n  function unlockTime() external view returns (uint256);\n\n  /**\n   * @dev The return value indicates whether it has been unlocked.\n   */\n  function isUnlocked() external view returns (bool);\n\n  /**\n   * @dev Transfers guardianship of the contract to a new account (`newGuardian`).\n   * Can only be called by the current guardian.\n   */\n  function transferGuardianship(address newGuardian) external;\n\n  /**\n   * @dev Unlock.\n   * Can only be called by the current guardian.\n   */\n  function unlock() external;\n\n  /**\n   * @dev Shorten unlock time.\n   * Can only be called by the current guardian.\n   *\n   * @param shortenedTime is seconds and must be greater than `0`.\n   */\n  function shortenUnlockTime(uint256 shortenedTime) external;\n}\n"
      }
    },
    "settings": {
      "optimizer": {
        "enabled": true,
        "runs": 200
      },
      "evmVersion": "paris",
      "outputSelection": {
        "*": {
          "*": [
            "evm.bytecode",
            "evm.deployedBytecode",
            "devdoc",
            "userdoc",
            "metadata",
            "abi"
          ]
        }
      },
      "libraries": {}
    }
  }}