{ "address": "0x174E8c11B0A634c7dA7F9A718BEB6AfB579591Cb", "abi": [ { "inputs": [], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [], "name": "InvalidGameStatus", "type": "error" }, { "inputs": [], "name": "UnregisteredGame", "type": "error" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" } ], "name": "Deposit", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint8", "name": "version", "type": "uint8" } ], "name": "Initialized", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "oldPeriod", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "newPeriod", "type": "uint256" } ], "name": "LockPeriodUpdated", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "previousOwner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "newOwner", "type": "address" } ], "name": "OwnershipTransferred", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "oldRatio", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "newRatio", "type": "uint256" } ], "name": "SlashRatioUpdated", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "recipient", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" } ], "name": "Slashed", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" } ], "name": "Unlock", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" } ], "name": "Withdraw", "type": "event" }, { "inputs": [], "name": "DISPUTE_GAME_FACTORY_NAME", "outputs": [ { "internalType": "string", "name": "", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "addressManager", "outputs": [ { "internalType": "contract Lib_AddressManager", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "balanceOf", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "config", "outputs": [ { "internalType": "contract MetisConfig", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_amount", "type": "uint256" } ], "name": "deposit", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "name": "depositedSequencers", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "_user", "type": "address" } ], "name": "getWithdrawalRequest", "outputs": [ { "internalType": "uint256", "name": "amount", "type": "uint256" }, { "internalType": "uint256", "name": "timestamp", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "_owner", "type": "address" }, { "internalType": "address", "name": "_token", "type": "address" }, { "internalType": "uint256", "name": "_lockPeriod", "type": "uint256" }, { "internalType": "uint256", "name": "_slashRatio", "type": "uint256" }, { "internalType": "contract Lib_AddressManager", "name": "_addressManager", "type": "address" }, { "internalType": "contract MetisConfig", "name": "_config", "type": "address" } ], "name": "initialize", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "lockPeriod", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "owner", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "renounceOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_newPeriod", "type": "uint256" } ], "name": "setLockPeriod", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_newRatio", "type": "uint256" } ], "name": "setSlashRatio", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "_recipient", "type": "address" } ], "name": "slash", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "slashRatio", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "token", "outputs": [ { "internalType": "contract IERC20", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalLocked", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "newOwner", "type": "address" } ], "name": "transferOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_amount", "type": "uint256" } ], "name": "unlock", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_amount", "type": "uint256" } ], "name": "withdraw", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "withdrawals", "outputs": [ { "internalType": "uint256", "name": "amount", "type": "uint256" }, { "internalType": "uint256", "name": "timestamp", "type": "uint256" } ], "stateMutability": "view", "type": "function" } ], "transactionHash": "0xd58379414717d85400a13e8e0ff7103859422fb67dc99cf012de9355c35852a2", "receipt": { "to": null, "from": "0x012347D9D1cC9df8d53289d43d84b5bCdED7F480", "contractAddress": "0x174E8c11B0A634c7dA7F9A718BEB6AfB579591Cb", "transactionIndex": 0, "gasUsed": "1771540", "logsBloom": "0x00000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000024000000000000000000800000000000000000000000000000000400000000020000000000000000000000000000200000080000000000000000000000000000000000000000000000c00000000004000000000000000000000000000000000000000000000000000040000000000000000000000000000010020000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x92a47df3fcfc418d870929b204f2e6a2ca6054fa25fb98d1acb5d4a23d8490e6", "transactionHash": "0xd58379414717d85400a13e8e0ff7103859422fb67dc99cf012de9355c35852a2", "logs": [ { "transactionIndex": 0, "blockNumber": 190, "transactionHash": "0xd58379414717d85400a13e8e0ff7103859422fb67dc99cf012de9355c35852a2", "address": "0x174E8c11B0A634c7dA7F9A718BEB6AfB579591Cb", "topics": [ "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x000000000000000000000000012347d9d1cc9df8d53289d43d84b5bcded7f480" ], "data": "0x", "logIndex": 0, "blockHash": "0x92a47df3fcfc418d870929b204f2e6a2ca6054fa25fb98d1acb5d4a23d8490e6" }, { "transactionIndex": 0, "blockNumber": 190, "transactionHash": "0xd58379414717d85400a13e8e0ff7103859422fb67dc99cf012de9355c35852a2", "address": "0x174E8c11B0A634c7dA7F9A718BEB6AfB579591Cb", "topics": [ "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", "0x000000000000000000000000012347d9d1cc9df8d53289d43d84b5bcded7f480", "0x0000000000000000000000000000000000000000000000000000000000000000" ], "data": "0x", "logIndex": 1, "blockHash": "0x92a47df3fcfc418d870929b204f2e6a2ca6054fa25fb98d1acb5d4a23d8490e6" }, { "transactionIndex": 0, "blockNumber": 190, "transactionHash": "0xd58379414717d85400a13e8e0ff7103859422fb67dc99cf012de9355c35852a2", "address": "0x174E8c11B0A634c7dA7F9A718BEB6AfB579591Cb", "topics": [ "0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000001", "logIndex": 2, "blockHash": "0x92a47df3fcfc418d870929b204f2e6a2ca6054fa25fb98d1acb5d4a23d8490e6" } ], "blockNumber": 190, "cumulativeGasUsed": "1771540", "status": 1, "byzantium": true }, "args": [], "numDeployments": 1, "solcInputHash": "bec4c14685901768be00cd0869023f51", "metadata": "{\"compiler\":{\"version\":\"0.8.15+commit.e14f2714\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"InvalidGameStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnregisteredGame\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldPeriod\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newPeriod\",\"type\":\"uint256\"}],\"name\":\"LockPeriodUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldRatio\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newRatio\",\"type\":\"uint256\"}],\"name\":\"SlashRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Slashed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Unlock\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DISPUTE_GAME_FACTORY_NAME\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"addressManager\",\"outputs\":[{\"internalType\":\"contract Lib_AddressManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"config\",\"outputs\":[{\"internalType\":\"contract MetisConfig\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"depositedSequencers\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_user\",\"type\":\"address\"}],\"name\":\"getWithdrawalRequest\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_lockPeriod\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_slashRatio\",\"type\":\"uint256\"},{\"internalType\":\"contract Lib_AddressManager\",\"name\":\"_addressManager\",\"type\":\"address\"},{\"internalType\":\"contract MetisConfig\",\"name\":\"_config\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lockPeriod\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_newPeriod\",\"type\":\"uint256\"}],\"name\":\"setLockPeriod\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_newRatio\",\"type\":\"uint256\"}],\"name\":\"setSlashRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_recipient\",\"type\":\"address\"}],\"name\":\"slash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"slashRatio\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token\",\"outputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalLocked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"unlock\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"withdrawals\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Based on DelayedWETH's delayed withdrawal mechanism\",\"kind\":\"dev\",\"methods\":{\"deposit(uint256)\":{\"params\":{\"_amount\":\"Amount of tokens to deposit\"}},\"getWithdrawalRequest(address)\":{\"params\":{\"_user\":\"User address\"},\"returns\":{\"amount\":\"Amount requested for withdrawal\",\"timestamp\":\"Timestamp of the withdrawal request\"}},\"initialize(address,address,uint256,uint256,address,address)\":{\"params\":{\"_addressManager\":\"The AddressManager contract address\",\"_config\":\"The MetisConfig contract address\",\"_lockPeriod\":\"Initial lock period in seconds\",\"_owner\":\"The owner address\",\"_slashRatio\":\"Initial slash ratio (base 10000)\",\"_token\":\"The ERC20 token contract address\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"setLockPeriod(uint256)\":{\"params\":{\"_newPeriod\":\"New lock period in seconds\"}},\"setSlashRatio(uint256)\":{\"params\":{\"_newRatio\":\"New slash ratio (base 10000)\"}},\"slash(address)\":{\"params\":{\"_recipient\":\"Address to receive the slashed tokens\"}},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"unlock(uint256)\":{\"params\":{\"_amount\":\"Amount of tokens to unlock\"}},\"withdraw(uint256)\":{\"params\":{\"_amount\":\"Amount of tokens to withdraw\"}}},\"title\":\"LockingPool\",\"version\":1},\"userdoc\":{\"errors\":{\"InvalidGameStatus()\":[{\"notice\":\"Thrown when attempting to set an anchor state using an invalid game result.\"}],\"UnregisteredGame()\":[{\"notice\":\"Thrown when attempting to set an anchor state using an unregistered game.\"}]},\"events\":{\"Deposit(address,uint256)\":{\"notice\":\"Emitted when tokens are deposited\"},\"LockPeriodUpdated(uint256,uint256)\":{\"notice\":\"Emitted when lock period is updated\"},\"SlashRatioUpdated(uint256,uint256)\":{\"notice\":\"Emitted when slash ratio is updated\"},\"Slashed(address,uint256)\":{\"notice\":\"Emitted when tokens are slashed\"},\"Unlock(address,uint256)\":{\"notice\":\"Emitted when a withdrawal is requested\"},\"Withdraw(address,uint256)\":{\"notice\":\"Emitted when tokens are withdrawn\"}},\"kind\":\"user\",\"methods\":{\"addressManager()\":{\"notice\":\"The Address Manager contract\"},\"balanceOf(address)\":{\"notice\":\"Mapping of user balances\"},\"config()\":{\"notice\":\"The MetisConfig contract\"},\"deposit(uint256)\":{\"notice\":\"Deposits tokens into the pool\"},\"depositedSequencers(uint256)\":{\"notice\":\"Array of sequencer addresses\"},\"getWithdrawalRequest(address)\":{\"notice\":\"Gets the withdrawal request details for a user\"},\"initialize(address,address,uint256,uint256,address,address)\":{\"notice\":\"Initializes the contract\"},\"lockPeriod()\":{\"notice\":\"The withdrawal delay period in seconds\"},\"setLockPeriod(uint256)\":{\"notice\":\"Updates the lock period\"},\"setSlashRatio(uint256)\":{\"notice\":\"Updates the slash ratio\"},\"slash(address)\":{\"notice\":\"Slashes a percentage of tokens from the pool\"},\"slashRatio()\":{\"notice\":\"The slash ratio (base 10000, i.e., 100.00%)\"},\"token()\":{\"notice\":\"The token being locked in the pool\"},\"totalLocked()\":{\"notice\":\"Total amount of tokens locked\"},\"unlock(uint256)\":{\"notice\":\"Requests to unlock tokens\"},\"withdraw(uint256)\":{\"notice\":\"Withdraws unlocked tokens\"},\"withdrawals(address)\":{\"notice\":\"Mapping of user withdrawal requests\"}},\"notice\":\"A locking pool contract that allows users to lock tokens with a delayed withdrawal mechanism\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/L1/dispute/LockingPool.sol\":\"LockingPool\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":5000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.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 * By default, the owner account will be the one that deploys the contract. This\\n * can 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 OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\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 require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing 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 require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\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 /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x247c62047745915c0af6b955470a72d1696ebad4352d7d3011aef1a2463cd888\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\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 ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\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 /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../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 * By default, the owner account will be the one that deploys the contract. This\\n * can 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 event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\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 require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing 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 require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\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\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/Address.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2a21b14ff90012878752f230d3ffd5c3405e5938d06c97a7d89c0a64561d0d66\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9750c6b834f7b43000631af5cc30001c5f547b3ceb3635488f140f60e897ea6b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xf41ca991f30855bf80ffd11e9347856a517b977f0a6c2d52e6421a99b7840329\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../extensions/draft-IERC20Permit.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(\\n IERC20 token,\\n address to,\\n uint256 value\\n ) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(\\n IERC20 token,\\n address from,\\n address to,\\n uint256 value\\n ) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(\\n IERC20 token,\\n address spender,\\n uint256 value\\n ) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(\\n IERC20 token,\\n address spender,\\n uint256 value\\n ) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(\\n IERC20 token,\\n address spender,\\n uint256 value\\n ) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n function safePermit(\\n IERC20Permit token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) {\\n // Return data is optional\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x032807210d1d7d218963d7355d62e021a84bf1b3339f4f50be2f63b53cccaf29\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd6153ce99bcdcce22b124f755e72553295be6abcd63804cfdffceb188b8bef10\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\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\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"contracts/L1/config/MetisConfig.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.15;\\n\\nimport {Storage} from \\\"../../libraries/Storage.sol\\\";\\nimport {ISemver} from \\\"../../universal/ISemver.sol\\\";\\nimport {Initializable} from \\\"@openzeppelin/contracts/proxy/utils/Initializable.sol\\\";\\n\\n/// @custom:audit none This contracts is not yet audited.\\n/// @title MetisConfig\\n/// @notice The MetisConfig contract is used to manage configuration of global metis values.\\ncontract MetisConfig is Initializable, ISemver {\\n /// @notice Enum representing different types of updates.\\n /// @custom:value GUARDIAN Represents an update to the guardian.\\n enum UpdateType {\\n GUARDIAN\\n }\\n\\n /// @notice Whether or not the Superchain is paused.\\n bytes32 public constant PAUSED_SLOT = bytes32(uint256(keccak256(\\\"metisConfig.paused\\\")) - 1);\\n\\n /// @notice The address of the guardian, which can pause withdrawals from the System.\\n /// It can only be modified by an upgrade.\\n bytes32 public constant GUARDIAN_SLOT = bytes32(uint256(keccak256(\\\"metisConfig.guardian\\\")) - 1);\\n\\n /// @notice Emitted when the pause is triggered.\\n /// @param identifier A string helping to identify provenance of the pause transaction.\\n event Paused(string identifier);\\n\\n /// @notice Emitted when the pause is lifted.\\n event Unpaused();\\n\\n /// @notice Emitted when configuration is updated.\\n /// @param updateType Type of update.\\n /// @param data Encoded update data.\\n event ConfigUpdate(UpdateType indexed updateType, bytes data);\\n\\n /// @notice Semantic version.\\n /// @custom:semver 1.1.0\\n string public constant version = \\\"1.1.0\\\";\\n\\n /// @notice Constructs the SuperchainConfig contract.\\n constructor() {\\n initialize({_guardian: address(0), _paused: false});\\n }\\n\\n /// @notice Initializer.\\n /// @param _guardian Address of the guardian, can pause the OptimismPortal.\\n /// @param _paused Initial paused status.\\n function initialize(address _guardian, bool _paused) public initializer {\\n _setGuardian(_guardian);\\n if (_paused) {\\n _pause(\\\"Initializer paused\\\");\\n }\\n }\\n\\n /// @notice Getter for the guardian address.\\n function guardian() public view returns (address guardian_) {\\n guardian_ = Storage.getAddress(GUARDIAN_SLOT);\\n }\\n\\n /// @notice Getter for the current paused status.\\n function paused() public view returns (bool paused_) {\\n paused_ = Storage.getBool(PAUSED_SLOT);\\n }\\n\\n /// @notice Pauses withdrawals.\\n /// @param _identifier (Optional) A string to identify provenance of the pause transaction.\\n function pause(string memory _identifier) external {\\n require(msg.sender == guardian(), \\\"MetisConfig: only guardian can pause\\\");\\n _pause(_identifier);\\n }\\n\\n /// @notice Pauses withdrawals.\\n /// @param _identifier (Optional) A string to identify provenance of the pause transaction.\\n function _pause(string memory _identifier) internal {\\n Storage.setBool(PAUSED_SLOT, true);\\n emit Paused(_identifier);\\n }\\n\\n /// @notice Unpauses withdrawals.\\n function unpause() external {\\n require(msg.sender == guardian(), \\\"MetisConfig: only guardian can unpause\\\");\\n Storage.setBool(PAUSED_SLOT, false);\\n emit Unpaused();\\n }\\n\\n /// @notice Sets the guardian address. This is only callable during initialization, so an upgrade\\n /// will be required to change the guardian.\\n /// @param _guardian The new guardian address.\\n function _setGuardian(address _guardian) internal {\\n Storage.setAddress(GUARDIAN_SLOT, _guardian);\\n emit ConfigUpdate(UpdateType.GUARDIAN, abi.encode(_guardian));\\n }\\n}\\n\",\"keccak256\":\"0xa523b4ee709f3c75efbb4624c22d005163126f4d859160194cf68b5fbef7374f\",\"license\":\"MIT\"},\"contracts/L1/dispute/LockingPool.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.15;\\n\\nimport {OwnableUpgradeable} from \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport {MetisConfig} from \\\"../config/MetisConfig.sol\\\";\\nimport {IERC20} from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport {SafeERC20} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {IDisputeGameFactory} from \\\"../dispute/interfaces/IDisputeGameFactory.sol\\\";\\nimport {IFaultDisputeGame} from \\\"../dispute/interfaces/IFaultDisputeGame.sol\\\";\\nimport {IDisputeGame} from \\\"../dispute/interfaces/IDisputeGame.sol\\\";\\nimport \\\"contracts/L1/dispute/lib/Types.sol\\\";\\nimport \\\"contracts/L1/dispute/lib/Errors.sol\\\";\\nimport {ILockingPool} from \\\"./interfaces/ILockingPool.sol\\\";\\nimport {Lib_AddressManager} from \\\"../../libraries/resolver/Lib_AddressManager.sol\\\";\\n\\n/// @title LockingPool\\n/// @notice A locking pool contract that allows users to lock tokens with a delayed withdrawal mechanism\\n/// @dev Based on DelayedWETH's delayed withdrawal mechanism\\ncontract LockingPool is OwnableUpgradeable, ILockingPool {\\n using SafeERC20 for IERC20;\\n\\n /// @notice Struct representing a withdrawal request\\n struct WithdrawalRequest {\\n uint256 amount;\\n uint256 timestamp;\\n }\\n\\n string public constant DISPUTE_GAME_FACTORY_NAME = \\\"DisputeGameFactory\\\";\\n\\n /// @notice The token being locked in the pool\\n IERC20 public token;\\n\\n /// @notice The withdrawal delay period in seconds\\n uint256 public lockPeriod;\\n\\n /// @notice The slash ratio (base 10000, i.e., 100.00%)\\n uint256 public slashRatio;\\n\\n /// @notice The MetisConfig contract\\n MetisConfig public config;\\n\\n /// @notice The Address Manager contract\\n Lib_AddressManager public addressManager;\\n\\n /// @notice Mapping of user withdrawal requests\\n mapping(address => WithdrawalRequest) public withdrawals;\\n\\n /// @notice Mapping of user balances\\n mapping(address => uint256) public balanceOf;\\n\\n /// @notice Total amount of tokens locked\\n uint256 public totalLocked;\\n\\n /// @notice Array of sequencer addresses\\n address[] public depositedSequencers;\\n\\n /// @notice Emitted when tokens are deposited\\n event Deposit(address indexed user, uint256 amount);\\n\\n /// @notice Emitted when a withdrawal is requested\\n event Unlock(address indexed user, uint256 amount);\\n\\n /// @notice Emitted when tokens are withdrawn\\n event Withdraw(address indexed user, uint256 amount);\\n\\n /// @notice Emitted when tokens are slashed\\n event Slashed(address indexed recipient, uint256 amount);\\n\\n /// @notice Emitted when slash ratio is updated\\n event SlashRatioUpdated(uint256 oldRatio, uint256 newRatio);\\n\\n /// @notice Emitted when lock period is updated\\n event LockPeriodUpdated(uint256 oldPeriod, uint256 newPeriod);\\n\\n constructor() {\\n initialize(address(0), address(0), 0,0,\\n Lib_AddressManager(address(0)), MetisConfig(address(0)));\\n }\\n\\n /// @notice Initializes the contract\\n /// @param _owner The owner address\\n /// @param _token The ERC20 token contract address\\n /// @param _lockPeriod Initial lock period in seconds\\n /// @param _slashRatio Initial slash ratio (base 10000)\\n /// @param _addressManager The AddressManager contract address\\n /// @param _config The MetisConfig contract address\\n function initialize(address _owner,\\n address _token,\\n uint256 _lockPeriod,\\n uint256 _slashRatio,\\n Lib_AddressManager _addressManager,\\n MetisConfig _config) public initializer {\\n __Ownable_init();\\n _transferOwnership(_owner);\\n\\n require(slashRatio <= 10000, \\\"LockingPool: invalid slash ratio\\\");\\n\\n token = IERC20(_token);\\n lockPeriod = _lockPeriod;\\n slashRatio = _slashRatio;\\n addressManager = _addressManager;\\n config = _config;\\n }\\n\\n /// @notice Deposits tokens into the pool\\n /// @param _amount Amount of tokens to deposit\\n function deposit(uint256 _amount) external {\\n require(_amount > 0, \\\"LockingPool: zero deposit\\\");\\n \\n token.safeTransferFrom(msg.sender, address(this), _amount);\\n balanceOf[msg.sender] += _amount;\\n totalLocked += _amount;\\n\\n bool depositedBefore = false;\\n for (uint256 i = 0; i < depositedSequencers.length; i++) {\\n if (depositedSequencers[i] == msg.sender) {\\n depositedBefore = true;\\n break;\\n }\\n }\\n\\n if (!depositedBefore) {\\n depositedSequencers.push(msg.sender);\\n }\\n \\n emit Deposit(msg.sender, _amount);\\n }\\n\\n /// @notice Requests to unlock tokens\\n /// @param _amount Amount of tokens to unlock\\n function unlock(uint256 _amount) external {\\n require(balanceOf[msg.sender] >= _amount, \\\"LockingPool: insufficient balance\\\");\\n \\n WithdrawalRequest storage wd = withdrawals[msg.sender];\\n wd.timestamp = block.timestamp;\\n wd.amount += _amount;\\n \\n emit Unlock(msg.sender, _amount);\\n }\\n\\n /// @notice Withdraws unlocked tokens\\n /// @param _amount Amount of tokens to withdraw\\n function withdraw(uint256 _amount) external {\\n require(!config.paused(), \\\"LockingPool: contract is paused\\\");\\n \\n WithdrawalRequest storage wd = withdrawals[msg.sender];\\n require(wd.amount >= _amount, \\\"LockingPool: insufficient unlocked withdrawal\\\");\\n require(wd.timestamp > 0, \\\"LockingPool: withdrawal not unlocked\\\");\\n require(\\n wd.timestamp + lockPeriod <= block.timestamp,\\n \\\"LockingPool: withdrawal delay not met\\\"\\n );\\n \\n wd.amount -= _amount;\\n balanceOf[msg.sender] -= _amount;\\n totalLocked -= _amount;\\n\\n // remove sender from deposited sequencers if balance is zero\\n if (balanceOf[msg.sender] == 0) {\\n for (uint256 i = 0; i < depositedSequencers.length; i++) {\\n if (depositedSequencers[i] == msg.sender) {\\n depositedSequencers[i] = depositedSequencers[depositedSequencers.length - 1];\\n depositedSequencers.pop();\\n break;\\n }\\n }\\n }\\n \\n token.safeTransfer(msg.sender, _amount);\\n emit Withdraw(msg.sender, _amount);\\n }\\n\\n /// @notice Slashes a percentage of tokens from the pool\\n /// @param _recipient Address to receive the slashed tokens\\n function slash(address _recipient) external {\\n require(_recipient != address(0), \\\"LockingPool: invalid recipient\\\");\\n require(totalLocked > 0, \\\"LockingPool: no tokens to slash\\\");\\n\\n // Verify the caller is a valid dispute game\\n IFaultDisputeGame game = IFaultDisputeGame(msg.sender);\\n (GameType gameType, Claim rootClaim, bytes memory extraData) = game.gameData();\\n\\n // Get the verified address of the game based on the game data\\n IDisputeGameFactory disputeGameFactory = IDisputeGameFactory(addressManager.getAddress(DISPUTE_GAME_FACTORY_NAME));\\n require(address(disputeGameFactory) != address(0), \\\"LockingPool: dispute game factory not set\\\");\\n (IDisputeGame factoryRegisteredGame,) = disputeGameFactory.games({\\n _gameType: gameType,\\n _rootClaim: rootClaim,\\n _extraData: extraData\\n });\\n\\n // Must be a valid game\\n if (address(factoryRegisteredGame) != address(game)) revert UnregisteredGame();\\n\\n // Must be a game that resolved in favor of the challenger\\n if (game.status() != GameStatus.CHALLENGER_WINS) {\\n revert InvalidGameStatus();\\n }\\n\\n // Track actual slashed amount\\n uint256 actualSlashedAmount;\\n \\n // Cache users array to avoid multiple storage reads\\n address[] memory users = depositedSequencers;\\n uint256 usersLength = users.length;\\n \\n // First pass: calculate actual slashed amount\\n for (uint256 i; i < usersLength;) {\\n address user = users[i];\\n uint256 userBalance = balanceOf[user];\\n if (userBalance > 0) {\\n // Calculate user's slash amount\\n uint256 userSlashAmount = (userBalance * slashRatio) / 10000;\\n if (userSlashAmount > 0) {\\n actualSlashedAmount += userSlashAmount;\\n // Update user balance\\n balanceOf[user] = userBalance - userSlashAmount;\\n }\\n }\\n // Gas optimization for loops\\n unchecked { ++i; }\\n }\\n\\n // Require some tokens were actually slashed\\n require(actualSlashedAmount > 0, \\\"LockingPool: slash amount too small\\\");\\n\\n // Update total locked amount\\n totalLocked -= actualSlashedAmount;\\n\\n // Transfer the actual slashed amount\\n token.safeTransfer(_recipient, actualSlashedAmount);\\n emit Slashed(_recipient, actualSlashedAmount);\\n }\\n\\n /// @notice Updates the slash ratio\\n /// @param _newRatio New slash ratio (base 10000)\\n function setSlashRatio(uint256 _newRatio) external onlyOwner {\\n require(_newRatio <= 10000, \\\"LockingPool: invalid slash ratio\\\");\\n\\n uint256 oldRatio = slashRatio;\\n slashRatio = _newRatio;\\n emit SlashRatioUpdated(oldRatio, _newRatio);\\n }\\n\\n /// @notice Updates the lock period\\n /// @param _newPeriod New lock period in seconds\\n function setLockPeriod(uint256 _newPeriod) external onlyOwner {\\n uint256 oldPeriod = lockPeriod;\\n lockPeriod = _newPeriod;\\n emit LockPeriodUpdated(oldPeriod, _newPeriod);\\n }\\n\\n /// @notice Gets the withdrawal request details for a user\\n /// @param _user User address\\n /// @return amount Amount requested for withdrawal\\n /// @return timestamp Timestamp of the withdrawal request\\n function getWithdrawalRequest(address _user) \\n external \\n view \\n returns (uint256 amount, uint256 timestamp) \\n {\\n WithdrawalRequest memory wd = withdrawals[_user];\\n return (wd.amount, wd.timestamp);\\n }\\n} \",\"keccak256\":\"0xa0bfc45c341f69e9d8680671a3c31267f365f3970a77a84fcda70930b46cb7c5\",\"license\":\"MIT\"},\"contracts/L1/dispute/interfaces/IDisputeGame.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {IInitializable} from \\\"./IInitializable.sol\\\";\\n\\nimport \\\"contracts/L1/dispute/lib/Types.sol\\\";\\n\\n/// @title IDisputeGame\\n/// @notice The generic interface for a DisputeGame contract.\\ninterface IDisputeGame is IInitializable {\\n /// @notice Emitted when the game is resolved.\\n /// @param status The status of the game after resolution.\\n event Resolved(GameStatus indexed status);\\n\\n /// @notice Returns the timestamp that the DisputeGame contract was created at.\\n /// @return createdAt_ The timestamp that the DisputeGame contract was created at.\\n function createdAt() external view returns (Timestamp createdAt_);\\n\\n /// @notice Returns the timestamp that the DisputeGame contract was resolved at.\\n /// @return resolvedAt_ The timestamp that the DisputeGame contract was resolved at.\\n function resolvedAt() external view returns (Timestamp resolvedAt_);\\n\\n /// @notice Returns the current status of the game.\\n /// @return status_ The current status of the game.\\n function status() external view returns (GameStatus status_);\\n\\n /// @notice Getter for the game type.\\n /// @dev The reference impl should be entirely different depending on the type (fault, validity)\\n /// i.e. The game type should indicate the security model.\\n /// @return gameType_ The type of proof system being used.\\n function gameType() external view returns (GameType gameType_);\\n\\n /// @notice Getter for the creator of the dispute game.\\n /// @dev `clones-with-immutable-args` argument #1\\n /// @return creator_ The creator of the dispute game.\\n function gameCreator() external pure returns (address creator_);\\n\\n /// @notice Getter for the root claim.\\n /// @dev `clones-with-immutable-args` argument #2\\n /// @return rootClaim_ The root claim of the DisputeGame.\\n function rootClaim() external pure returns (Claim rootClaim_);\\n\\n /// @notice Getter for the parent hash of the L1 block when the dispute game was created.\\n /// @dev `clones-with-immutable-args` argument #3\\n /// @return l1Head_ The parent hash of the L1 block when the dispute game was created.\\n function l1Head() external pure returns (Hash l1Head_);\\n\\n /// @notice Getter for the extra data.\\n /// @dev `clones-with-immutable-args` argument #4\\n /// @return extraData_ Any extra data supplied to the dispute game contract by the creator.\\n function extraData() external pure returns (bytes memory extraData_);\\n\\n /// @notice If all necessary information has been gathered, this function should mark the game\\n /// status as either `CHALLENGER_WINS` or `DEFENDER_WINS` and return the status of\\n /// the resolved game. It is at this stage that the bonds should be awarded to the\\n /// necessary parties.\\n /// @dev May only be called if the `status` is `IN_PROGRESS`.\\n /// @return status_ The status of the game after resolution.\\n function resolve() external returns (GameStatus status_);\\n\\n /// @notice A compliant implementation of this interface should return the components of the\\n /// game UUID's preimage provided in the cwia payload. The preimage of the UUID is\\n /// constructed as `keccak256(gameType . rootClaim . extraData)` where `.` denotes\\n /// concatenation.\\n /// @return gameType_ The type of proof system being used.\\n /// @return rootClaim_ The root claim of the DisputeGame.\\n /// @return extraData_ Any extra data supplied to the dispute game contract by the creator.\\n function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_);\\n}\\n\",\"keccak256\":\"0x696a037c405f2ee4f785e45d4765f03066b489bec6a3d5a9c171837cd4696794\",\"license\":\"MIT\"},\"contracts/L1/dispute/interfaces/IDisputeGameFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {IDisputeGame} from \\\"./IDisputeGame.sol\\\";\\n\\nimport \\\"contracts/L1/dispute/lib/Types.sol\\\";\\n\\n/// @title IDisputeGameFactory\\n/// @notice The interface for a DisputeGameFactory contract.\\ninterface IDisputeGameFactory {\\n /// @notice Emitted when a new dispute game is requested\\n /// @param requestor The address of the requestor\\n /// @param gameType The type of the dispute game\\n /// @param bond The bond (in wei) for initializing the game type\\n //. @param extraData Any extra data that should be provided to the created dispute game.\\n event DisputeGameRequested(address indexed requestor, GameType indexed gameType, uint256 bond, bytes extraData);\\n\\n /// @notice Emitted when a new dispute game is created\\n /// @param disputeProxy The address of the dispute game proxy\\n /// @param gameType The type of the dispute game proxy's implementation\\n /// @param rootClaim The root claim of the dispute game\\n event DisputeGameCreated(address indexed disputeProxy, GameType indexed gameType, Claim indexed rootClaim);\\n\\n /// @notice Emitted when a new game implementation added to the factory\\n /// @param impl The implementation contract for the given `GameType`.\\n /// @param gameType The type of the DisputeGame.\\n event ImplementationSet(address indexed impl, GameType indexed gameType);\\n\\n /// @notice Emitted when a game type's initialization bond is updated\\n /// @param gameType The type of the DisputeGame.\\n /// @param newBond The new bond (in wei) for initializing the game type.\\n event InitBondUpdated(GameType indexed gameType, uint256 indexed newBond);\\n\\n /// @notice Information about a dispute game found in a `findLatestGames` search.\\n struct GameSearchResult {\\n uint256 index;\\n GameId metadata;\\n Timestamp timestamp;\\n Claim rootClaim;\\n bytes extraData;\\n }\\n\\n /// @notice The total number of dispute games created by this factory.\\n /// @return gameCount_ The total number of dispute games created by this factory.\\n function gameCount() external view returns (uint256 gameCount_);\\n\\n /// @notice `games` queries an internal mapping that maps the hash of\\n /// `gameType ++ rootClaim ++ extraData` to the deployed `DisputeGame` clone.\\n /// @dev `++` equates to concatenation.\\n /// @param _gameType The type of the DisputeGame - used to decide the proxy implementation\\n /// @param _rootClaim The root claim of the DisputeGame.\\n /// @param _extraData Any extra data that should be provided to the created dispute game.\\n /// @return proxy_ The clone of the `DisputeGame` created with the given parameters.\\n /// Returns `address(0)` if nonexistent.\\n /// @return timestamp_ The timestamp of the creation of the dispute game.\\n function games(\\n GameType _gameType,\\n Claim _rootClaim,\\n bytes calldata _extraData\\n )\\n external\\n view\\n returns (IDisputeGame proxy_, Timestamp timestamp_);\\n\\n /// @notice `gameAtIndex` returns the dispute game contract address and its creation timestamp\\n /// at the given index. Each created dispute game increments the underlying index.\\n /// @param _index The index of the dispute game.\\n /// @return gameType_ The type of the DisputeGame - used to decide the proxy implementation.\\n /// @return timestamp_ The timestamp of the creation of the dispute game.\\n /// @return proxy_ The clone of the `DisputeGame` created with the given parameters.\\n /// Returns `address(0)` if nonexistent.\\n function gameAtIndex(uint256 _index)\\n external\\n view\\n returns (GameType gameType_, Timestamp timestamp_, IDisputeGame proxy_);\\n\\n /// @notice `gameImpls` is a mapping that maps `GameType`s to their respective\\n /// `IDisputeGame` implementations.\\n /// @param _gameType The type of the dispute game.\\n /// @return impl_ The address of the implementation of the game type.\\n /// Will be cloned on creation of a new dispute game with the given `gameType`.\\n function gameImpls(GameType _gameType) external view returns (IDisputeGame impl_);\\n\\n /// @notice Returns the required bonds for initializing a dispute game of the given type.\\n /// @param _gameType The type of the dispute game.\\n /// @return bond_ The required bond for initializing a dispute game of the given type.\\n function initBonds(GameType _gameType) external view returns (uint256 bond_);\\n\\n /// @notice Requests a new dispute game of the given type.\\n /// @dev Emits a `DisputeGameRequested` event.\\n /// @param _gameType The type of the dispute game.\\n /// @param _extraData Any extra data that should be provided to the created dispute game.\\n function dispute(GameType _gameType, bytes calldata _extraData) external payable;\\n\\n /// @notice Creates a new DisputeGame proxy contract.\\n /// @param _gameType The type of the DisputeGame - used to decide the proxy implementation.\\n /// @param _rootClaim The root claim of the DisputeGame.\\n /// @param _extraData Any extra data that should be provided to the created dispute game.\\n /// @return proxy_ The address of the created DisputeGame proxy.\\n function create(\\n GameType _gameType,\\n Claim _rootClaim,\\n bytes calldata _extraData\\n )\\n external\\n returns (IDisputeGame proxy_);\\n\\n /// @notice Sets the implementation contract for a specific `GameType`.\\n /// @dev May only be called by the `owner`.\\n /// @param _gameType The type of the DisputeGame.\\n /// @param _impl The implementation contract for the given `GameType`.\\n function setImplementation(GameType _gameType, IDisputeGame _impl) external;\\n\\n /// @notice Sets the bond (in wei) for initializing a game type.\\n /// @dev May only be called by the `owner`.\\n /// @param _gameType The type of the DisputeGame.\\n /// @param _initBond The bond (in wei) for initializing a game type.\\n function setInitBond(GameType _gameType, uint256 _initBond) external;\\n\\n /// @notice Returns a unique identifier for the given dispute game parameters.\\n /// @dev Hashes the concatenation of `gameType . rootClaim . extraData`\\n /// without expanding memory.\\n /// @param _gameType The type of the DisputeGame.\\n /// @param _rootClaim The root claim of the DisputeGame.\\n /// @param _extraData Any extra data that should be provided to the created dispute game.\\n /// @return uuid_ The unique identifier for the given dispute game parameters.\\n function getGameUUID(\\n GameType _gameType,\\n Claim _rootClaim,\\n bytes memory _extraData\\n )\\n external\\n pure\\n returns (Hash uuid_);\\n\\n /// @notice Finds the `_n` most recent `GameId`'s of type `_gameType` starting at `_start`. If there are less than\\n /// `_n` games of type `_gameType` starting at `_start`, then the returned array will be shorter than `_n`.\\n /// @param _gameType The type of game to find.\\n /// @param _start The index to start the reverse search from.\\n /// @param _n The number of games to find.\\n function findLatestGames(\\n GameType _gameType,\\n uint256 _start,\\n uint256 _n\\n )\\n external\\n view\\n returns (GameSearchResult[] memory games_);\\n}\\n\",\"keccak256\":\"0x290ddc5f8839e6df617519b2678f45d4b16fcffa61b6387beae482212020978b\",\"license\":\"MIT\"},\"contracts/L1/dispute/interfaces/IFaultDisputeGame.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {IDisputeGame} from \\\"./IDisputeGame.sol\\\";\\n\\nimport \\\"contracts/L1/dispute/lib/Types.sol\\\";\\n\\n/// @title IFaultDisputeGame\\n/// @notice The interface for a fault proof backed dispute game.\\ninterface IFaultDisputeGame is IDisputeGame {\\n /// @notice The `ClaimData` struct represents the data associated with a Claim.\\n struct ClaimData {\\n uint32 parentIndex;\\n address counteredBy;\\n address claimant;\\n uint128 bond;\\n Claim claim;\\n Position position;\\n Clock clock;\\n }\\n\\n /// @notice The `ResolutionCheckpoint` struct represents the data associated with an in-progress claim resolution.\\n struct ResolutionCheckpoint {\\n bool initialCheckpointComplete;\\n uint32 subgameIndex;\\n Position leftmostPosition;\\n address counteredBy;\\n }\\n\\n /// @notice Emitted when a new claim is added to the DAG by `claimant`\\n /// @param parentIndex The index within the `claimData` array of the parent claim\\n /// @param claim The claim being added\\n /// @param claimant The address of the claimant\\n event Move(uint256 indexed parentIndex, Claim indexed claim, address indexed claimant);\\n\\n /// @notice Attack a disagreed upon `Claim`.\\n /// @param _disputed The `Claim` being attacked.\\n /// @param _parentIndex Index of the `Claim` to attack in the `claimData` array. This must match the `_disputed`\\n /// claim.\\n /// @param _claim The `Claim` at the relative attack position.\\n function attack(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable;\\n\\n /// @notice Defend an agreed upon `Claim`.\\n /// @notice _disputed The `Claim` being defended.\\n /// @param _parentIndex Index of the claim to defend in the `claimData` array. This must match the `_disputed`\\n /// claim.\\n /// @param _claim The `Claim` at the relative defense position.\\n function defend(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable;\\n\\n /// @notice Perform an instruction step via an on-chain fault proof processor.\\n /// @dev This function should point to a fault proof processor in order to execute\\n /// a step in the fault proof program on-chain. The interface of the fault proof\\n /// processor contract should adhere to the `IBigStepper` interface.\\n /// @param _claimIndex The index of the challenged claim within `claimData`.\\n /// @param _isAttack Whether or not the step is an attack or a defense.\\n /// @param _stateData The stateData of the step is the preimage of the claim at the given\\n /// prestate, which is at `_stateIndex` if the move is an attack and `_claimIndex` if\\n /// the move is a defense. If the step is an attack on the first instruction, it is\\n /// the absolute prestate of the fault proof VM.\\n /// @param _proof Proof to access memory nodes in the VM's merkle state tree.\\n function step(uint256 _claimIndex, bool _isAttack, bytes calldata _stateData, bytes calldata _proof) external;\\n\\n /// @notice Posts the requested local data to the VM's `PreimageOralce`.\\n /// @param _ident The local identifier of the data to post.\\n /// @param _execLeafIdx The index of the leaf claim in an execution subgame that requires the local data for a step.\\n /// @param _partOffset The offset of the data to post.\\n function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) external;\\n\\n /// @notice Resolves the subgame rooted at the given claim index. `_numToResolve` specifies how many children of\\n /// the subgame will be checked in this call. If `_numToResolve` is less than the number of children, an\\n /// internal cursor will be updated and this function may be called again to complete resolution of the\\n /// subgame.\\n /// @dev This function must be called bottom-up in the DAG\\n /// A subgame is a tree of claims that has a maximum depth of 1.\\n /// A subgame root claims is valid if, and only if, all of its child claims are invalid.\\n /// At the deepest level in the DAG, a claim is invalid if there's a successful step against it.\\n /// @param _claimIndex The index of the subgame root claim to resolve.\\n /// @param _numToResolve The number of subgames to resolve in this call. If the input is `0`, and this is the first\\n /// page, this function will attempt to check all of the subgame's children at once.\\n function resolveClaim(uint256 _claimIndex, uint256 _numToResolve) external;\\n\\n /// @notice Returns the number of children that still need to be resolved in order to fully resolve a subgame rooted\\n /// at `_claimIndex`.\\n /// @param _claimIndex The subgame root claim's index within `claimData`.\\n /// @return numRemainingChildren_ The number of children that still need to be checked to resolve the subgame.\\n function getNumToResolve(uint256 _claimIndex) external view returns (uint256 numRemainingChildren_);\\n\\n /// @notice The l2BlockNumber of the disputed output root in the `L2OutputOracle`.\\n function l2BlockNumber() external view returns (uint256 l2BlockNumber_);\\n\\n /// @notice Starting output root and block number of the game.\\n function startingOutputRoot() external view returns (Hash startingRoot_, uint256 l2BlockNumber_);\\n\\n /// @notice Only the starting block number of the game.\\n function startingBlockNumber() external view returns (uint256 startingBlockNumber_);\\n\\n /// @notice Only the starting output root of the game.\\n function startingRootHash() external view returns (Hash startingRootHash_);\\n}\\n\",\"keccak256\":\"0x9cf60036f5aa890fd5de1e9b825edc0a19b58afc0823c44f27a0895b923e5a83\",\"license\":\"MIT\"},\"contracts/L1/dispute/interfaces/IInitializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @title IInitializable\\n/// @notice An interface for initializable contracts.\\ninterface IInitializable {\\n /// @notice Initializes the contract.\\n /// @dev This function may only be called once.\\n function initialize() external payable;\\n}\\n\",\"keccak256\":\"0xbc553af6501a972850a98fc6284943f8e95a5183a7b4f64198c16fca2338c9dc\",\"license\":\"MIT\"},\"contracts/L1/dispute/interfaces/ILockingPool.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @title ILockingPool\\n/// @notice Interface for the LockingPool contract\\ninterface ILockingPool {\\n /// @notice Slashes a percentage of tokens from the pool\\n /// @param _recipient Address to receive the slashed tokens\\n function slash(address _recipient) external;\\n} \",\"keccak256\":\"0xadd5d45defdf3319e9d3bad7024c142bdeeb3644ff5ea3b6ddb567561121a8dc\",\"license\":\"MIT\"},\"contracts/L1/dispute/lib/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nimport \\\"./LibUDT.sol\\\";\\n\\n////////////////////////////////////////////////////////////////\\n// `DisputeGameFactory` Errors //\\n////////////////////////////////////////////////////////////////\\n\\n/// @notice Thrown when a dispute game is attempted to be created with an unsupported game type.\\n/// @param gameType The unsupported game type.\\n error NoImplementation(GameType gameType);\\n\\n/// @notice Thrown when a dispute game that already exists is attempted to be created.\\n/// @param uuid The UUID of the dispute game that already exists.\\n error GameAlreadyExists(Hash uuid);\\n\\n/// @notice Thrown when the root claim has an unexpected VM status.\\n/// Some games can only start with a root-claim with a specific status.\\n/// @param rootClaim is the claim that was unexpected.\\n error UnexpectedRootClaim(Claim rootClaim);\\n\\n/// @notice Thrown when no dispute game requested.\\n error NoDisputeGameRequests();\\n\\n////////////////////////////////////////////////////////////////\\n// `FaultDisputeGame` Errors //\\n////////////////////////////////////////////////////////////////\\n\\n/// @notice Thrown when a dispute game has already been initialized.\\n error AlreadyInitialized();\\n\\n/// @notice Thrown when a supplied bond is not equal to the required bond amount to cover the cost of the interaction.\\n error IncorrectBondAmount();\\n\\n/// @notice Thrown when a credit claim is attempted for a value of 0.\\n error NoCreditToClaim();\\n\\n/// @notice Thrown when the transfer of credit to a recipient account reverts.\\n error BondTransferFailed();\\n\\n/// @notice Thrown when the `extraData` passed to the CWIA proxy is of improper length, or contains invalid information.\\n error BadExtraData();\\n\\n/// @notice Thrown when a defense against the root claim is attempted.\\n error CannotDefendRootClaim();\\n\\n/// @notice Thrown when a claim is attempting to be made that already exists.\\n error ClaimAlreadyExists();\\n\\n/// @notice Thrown when a disputed claim does not match its index in the game.\\n error InvalidDisputedClaimIndex();\\n\\n/// @notice Thrown when an action that requires the game to be `IN_PROGRESS` is invoked when\\n/// the game is not in progress.\\n error GameNotInProgress();\\n\\n/// @notice Thrown when a move is attempted to be made after the clock has timed out.\\n error ClockTimeExceeded();\\n\\n/// @notice Thrown when the game is attempted to be resolved too early.\\n error ClockNotExpired();\\n\\n/// @notice Thrown when a move is attempted to be made at or greater than the max depth of the game.\\n error GameDepthExceeded();\\n\\n/// @notice Thrown when a step is attempted above the maximum game depth.\\n error InvalidParent();\\n\\n/// @notice Thrown when an invalid prestate is supplied to `step`.\\n error InvalidPrestate();\\n\\n/// @notice Thrown when a step is made that computes the expected post state correctly.\\n error ValidStep();\\n\\n/// @notice Thrown when a game is attempted to be initialized with an L1 head that does\\n/// not contain the disputed output root.\\n error L1HeadTooOld();\\n\\n/// @notice Thrown when an invalid local identifier is passed to the `addLocalData` function.\\n error InvalidLocalIdent();\\n\\n/// @notice Thrown when resolving claims out of order.\\n error OutOfOrderResolution();\\n\\n/// @notice Thrown when resolving a claim that has already been resolved.\\n error ClaimAlreadyResolved();\\n\\n/// @notice Thrown when a parent output root is attempted to be found on a claim that is in\\n/// the output root portion of the tree.\\n error ClaimAboveSplit();\\n\\n/// @notice Thrown on deployment if the split depth is greater than or equal to the max\\n/// depth of the game.\\n error InvalidSplitDepth();\\n\\n/// @notice Thrown on deployment if the max clock duration is less than or equal to the clock extension.\\n error InvalidClockExtension();\\n\\n/// @notice Thrown on deployment if the PreimageOracle challenge period is too high.\\n error InvalidChallengePeriod();\\n\\n/// @notice Thrown on deployment if the max depth is greater than `LibPosition.`\\n error MaxDepthTooLarge();\\n\\n/// @notice Thrown when trying to step against a claim for a second time, after it has already been countered with\\n/// an instruction step.\\n error DuplicateStep();\\n\\n/// @notice Thrown when an anchor root is not found for a given game type.\\n error AnchorRootNotFound();\\n\\n/// @notice Thrown when an output root proof is invalid.\\n error InvalidOutputRootProof();\\n\\n/// @notice Thrown when header RLP is invalid with respect to the block hash in an output root proof.\\n error InvalidHeaderRLP();\\n\\n/// @notice Thrown when there is a match between the block number in the output root proof and the block number\\n/// claimed in the dispute game.\\n error BlockNumberMatches();\\n\\n/// @notice Thrown when the L2 block number claim has already been challenged.\\n error L2BlockNumberChallenged();\\n\\n////////////////////////////////////////////////////////////////\\n// `PermissionedDisputeGame` Errors //\\n////////////////////////////////////////////////////////////////\\n\\n/// @notice Thrown when an unauthorized address attempts to interact with the game.\\n error BadAuth();\\n\\n////////////////////////////////////////////////////////////////\\n// `AnchorStateRegistry` Errors //\\n////////////////////////////////////////////////////////////////\\n\\n/// @notice Thrown when attempting to set an anchor state using an unregistered game.\\n error UnregisteredGame();\\n\\n/// @notice Thrown when attempting to set an anchor state using an invalid game result.\\n error InvalidGameStatus();\\n\",\"keccak256\":\"0x03388f8b6d4b6b9aae083e8e6b348673feb74a9f53cb1e6659d4eca761eae959\",\"license\":\"MIT\"},\"contracts/L1/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n using LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\n type Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0xa7636e69177d9cf2c4575d8e5b71442133e1267b750799f30e90ecd14a445219\",\"license\":\"MIT\"},\"contracts/L1/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nimport \\\"./LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\n type Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\n type GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\n type Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\n type Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\n type Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\n type Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\n type VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\n type GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x91be468f622bdd9198209998e30e7079015037512946b600f5a18113acb957c0\",\"license\":\"MIT\"},\"contracts/L1/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nimport \\\"./LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\n enum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n }\\n\\n/// @notice Represents an L2 output root and the L2 block number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2BlockNumber The L2 block number at which the output root was generated.\\n struct OutputRoot {\\n Hash root;\\n uint256 l2BlockNumber;\\n }\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type the uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type the uses the asterisc VM\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0xc3ceda512a854337428c30ef8458f66fa28cb507649d388a3435caf3e9b219c3\",\"license\":\"MIT\"},\"contracts/libraries/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @title Storage\\n/// @notice Storage handles reading and writing to arbitary storage locations\\nlibrary Storage {\\n /// @notice Returns an address stored in an arbitrary storage slot.\\n /// These storage slots decouple the storage layout from\\n /// solc's automation.\\n /// @param _slot The storage slot to retrieve the address from.\\n function getAddress(bytes32 _slot) internal view returns (address addr_) {\\n assembly {\\n addr_ := sload(_slot)\\n }\\n }\\n\\n /// @notice Stores an address in an arbitrary storage slot, `_slot`.\\n /// @param _slot The storage slot to store the address in.\\n /// @param _address The protocol version to store\\n /// @dev WARNING! This function must be used cautiously, as it allows for overwriting addresses\\n /// in arbitrary storage slots.\\n function setAddress(bytes32 _slot, address _address) internal {\\n assembly {\\n sstore(_slot, _address)\\n }\\n }\\n\\n /// @notice Returns a uint256 stored in an arbitrary storage slot.\\n /// These storage slots decouple the storage layout from\\n /// solc's automation.\\n /// @param _slot The storage slot to retrieve the address from.\\n function getUint(bytes32 _slot) internal view returns (uint256 value_) {\\n assembly {\\n value_ := sload(_slot)\\n }\\n }\\n\\n /// @notice Stores a value in an arbitrary storage slot, `_slot`.\\n /// @param _slot The storage slot to store the address in.\\n /// @param _value The protocol version to store\\n /// @dev WARNING! This function must be used cautiously, as it allows for overwriting values\\n /// in arbitrary storage slots.\\n function setUint(bytes32 _slot, uint256 _value) internal {\\n assembly {\\n sstore(_slot, _value)\\n }\\n }\\n\\n /// @notice Returns a bytes32 stored in an arbitrary storage slot.\\n /// These storage slots decouple the storage layout from\\n /// solc's automation.\\n /// @param _slot The storage slot to retrieve the address from.\\n function getBytes32(bytes32 _slot) internal view returns (bytes32 value_) {\\n assembly {\\n value_ := sload(_slot)\\n }\\n }\\n\\n /// @notice Stores a bytes32 value in an arbitrary storage slot, `_slot`.\\n /// @param _slot The storage slot to store the address in.\\n /// @param _value The bytes32 value to store.\\n /// @dev WARNING! This function must be used cautiously, as it allows for overwriting values\\n /// in arbitrary storage slots.\\n function setBytes32(bytes32 _slot, bytes32 _value) internal {\\n assembly {\\n sstore(_slot, _value)\\n }\\n }\\n\\n /// @notice Stores a bool value in an arbitrary storage slot, `_slot`.\\n /// @param _slot The storage slot to store the bool in.\\n /// @param _value The bool value to store\\n /// @dev WARNING! This function must be used cautiously, as it allows for overwriting values\\n /// in arbitrary storage slots.\\n function setBool(bytes32 _slot, bool _value) internal {\\n assembly {\\n sstore(_slot, _value)\\n }\\n }\\n\\n /// @notice Returns a bool stored in an arbitrary storage slot.\\n /// @param _slot The storage slot to retrieve the bool from.\\n function getBool(bytes32 _slot) internal view returns (bool value_) {\\n assembly {\\n value_ := sload(_slot)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7ce27a05552aa69afa6b2ab6684dfe99f27366cf8ef2046baeb1fb62fff0022f\",\"license\":\"MIT\"},\"contracts/libraries/resolver/Lib_AddressManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* External Imports */\\nimport { Ownable } from \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\n\\n/**\\n * @title Lib_AddressManager\\n */\\ncontract Lib_AddressManager is Ownable {\\n /**********\\n * Events *\\n **********/\\n\\n event AddressSet(string indexed _name, address _newAddress, address _oldAddress);\\n\\n /*************\\n * Variables *\\n *************/\\n\\n mapping(bytes32 => address) private addresses;\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Changes the address associated with a particular name.\\n * @param _name String name to associate an address with.\\n * @param _address Address to associate with the name.\\n */\\n function setAddress(string memory _name, address _address) external onlyOwner {\\n bytes32 nameHash = _getNameHash(_name);\\n address oldAddress = addresses[nameHash];\\n addresses[nameHash] = _address;\\n\\n emit AddressSet(_name, _address, oldAddress);\\n }\\n\\n /**\\n * Retrieves the address associated with a given name.\\n * @param _name Name to retrieve an address for.\\n * @return Address associated with the given name.\\n */\\n function getAddress(string memory _name) external view returns (address) {\\n return addresses[_getNameHash(_name)];\\n }\\n\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Computes the hash of a name.\\n * @param _name Name to compute a hash for.\\n * @return Hash of the given name.\\n */\\n function _getNameHash(string memory _name) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(_name));\\n }\\n}\\n\",\"keccak256\":\"0xcde9b29429d512c549f7c1b8a033f161fa71c18cda08b241748663854196ae14\",\"license\":\"MIT\"},\"contracts/universal/ISemver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @title ISemver\\n/// @notice ISemver is a simple contract for ensuring that contracts are\\n/// versioned using semantic versioning.\\ninterface ISemver {\\n /// @notice Getter for the semantic version of the contract. This is not\\n /// meant to be used onchain but instead meant to be used by offchain\\n /// tooling.\\n /// @return Semver contract version as a string.\\n function version() external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xba34562a8026f59886d2e07d1d58d90b9691d00e0788c6263cef6c22740cab44\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "details": "Based on DelayedWETH's delayed withdrawal mechanism", "kind": "dev", "methods": { "deposit(uint256)": { "params": { "_amount": "Amount of tokens to deposit" } }, "getWithdrawalRequest(address)": { "params": { "_user": "User address" }, "returns": { "amount": "Amount requested for withdrawal", "timestamp": "Timestamp of the withdrawal request" } }, "initialize(address,address,uint256,uint256,address,address)": { "params": { "_addressManager": "The AddressManager contract address", "_config": "The MetisConfig contract address", "_lockPeriod": "Initial lock period in seconds", "_owner": "The owner address", "_slashRatio": "Initial slash ratio (base 10000)", "_token": "The ERC20 token contract address" } }, "owner()": { "details": "Returns the address of the current owner." }, "renounceOwnership()": { "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." }, "setLockPeriod(uint256)": { "params": { "_newPeriod": "New lock period in seconds" } }, "setSlashRatio(uint256)": { "params": { "_newRatio": "New slash ratio (base 10000)" } }, "slash(address)": { "params": { "_recipient": "Address to receive the slashed tokens" } }, "transferOwnership(address)": { "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." }, "unlock(uint256)": { "params": { "_amount": "Amount of tokens to unlock" } }, "withdraw(uint256)": { "params": { "_amount": "Amount of tokens to withdraw" } } }, "title": "LockingPool", "version": 1 }, "userdoc": { "errors": { "InvalidGameStatus()": [ { "notice": "Thrown when attempting to set an anchor state using an invalid game result." } ], "UnregisteredGame()": [ { "notice": "Thrown when attempting to set an anchor state using an unregistered game." } ] }, "events": { "Deposit(address,uint256)": { "notice": "Emitted when tokens are deposited" }, "LockPeriodUpdated(uint256,uint256)": { "notice": "Emitted when lock period is updated" }, "SlashRatioUpdated(uint256,uint256)": { "notice": "Emitted when slash ratio is updated" }, "Slashed(address,uint256)": { "notice": "Emitted when tokens are slashed" }, "Unlock(address,uint256)": { "notice": "Emitted when a withdrawal is requested" }, "Withdraw(address,uint256)": { "notice": "Emitted when tokens are withdrawn" } }, "kind": "user", "methods": { "addressManager()": { "notice": "The Address Manager contract" }, "balanceOf(address)": { "notice": "Mapping of user balances" }, "config()": { "notice": "The MetisConfig contract" }, "deposit(uint256)": { "notice": "Deposits tokens into the pool" }, "depositedSequencers(uint256)": { "notice": "Array of sequencer addresses" }, "getWithdrawalRequest(address)": { "notice": "Gets the withdrawal request details for a user" }, "initialize(address,address,uint256,uint256,address,address)": { "notice": "Initializes the contract" }, "lockPeriod()": { "notice": "The withdrawal delay period in seconds" }, "setLockPeriod(uint256)": { "notice": "Updates the lock period" }, "setSlashRatio(uint256)": { "notice": "Updates the slash ratio" }, "slash(address)": { "notice": "Slashes a percentage of tokens from the pool" }, "slashRatio()": { "notice": "The slash ratio (base 10000, i.e., 100.00%)" }, "token()": { "notice": "The token being locked in the pool" }, "totalLocked()": { "notice": "Total amount of tokens locked" }, "unlock(uint256)": { "notice": "Requests to unlock tokens" }, "withdraw(uint256)": { "notice": "Withdraws unlocked tokens" }, "withdrawals(address)": { "notice": "Mapping of user withdrawal requests" } }, "notice": "A locking pool contract that allows users to lock tokens with a delayed withdrawal mechanism", "version": 1 }, "storageLayout": { "storage": [ { "astId": 138, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "_initialized", "offset": 0, "slot": "0", "type": "t_uint8" }, { "astId": 141, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "_initializing", "offset": 1, "slot": "0", "type": "t_bool" }, { "astId": 566, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "__gap", "offset": 0, "slot": "1", "type": "t_array(t_uint256)50_storage" }, { "astId": 10, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "_owner", "offset": 0, "slot": "51", "type": "t_address" }, { "astId": 130, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "__gap", "offset": 0, "slot": "52", "type": "t_array(t_uint256)49_storage" }, { "astId": 5188, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "token", "offset": 0, "slot": "101", "type": "t_contract(IERC20)909" }, { "astId": 5191, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "lockPeriod", "offset": 0, "slot": "102", "type": "t_uint256" }, { "astId": 5194, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "slashRatio", "offset": 0, "slot": "103", "type": "t_uint256" }, { "astId": 5198, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "config", "offset": 0, "slot": "104", "type": "t_contract(MetisConfig)2339" }, { "astId": 5202, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "addressManager", "offset": 0, "slot": "105", "type": "t_contract(Lib_AddressManager)10146" }, { "astId": 5208, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "withdrawals", "offset": 0, "slot": "106", "type": "t_mapping(t_address,t_struct(WithdrawalRequest)5181_storage)" }, { "astId": 5213, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "balanceOf", "offset": 0, "slot": "107", "type": "t_mapping(t_address,t_uint256)" }, { "astId": 5216, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "totalLocked", "offset": 0, "slot": "108", "type": "t_uint256" }, { "astId": 5220, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "depositedSequencers", "offset": 0, "slot": "109", "type": "t_array(t_address)dyn_storage" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_array(t_address)dyn_storage": { "base": "t_address", "encoding": "dynamic_array", "label": "address[]", "numberOfBytes": "32" }, "t_array(t_uint256)49_storage": { "base": "t_uint256", "encoding": "inplace", "label": "uint256[49]", "numberOfBytes": "1568" }, "t_array(t_uint256)50_storage": { "base": "t_uint256", "encoding": "inplace", "label": "uint256[50]", "numberOfBytes": "1600" }, "t_bool": { "encoding": "inplace", "label": "bool", "numberOfBytes": "1" }, "t_contract(IERC20)909": { "encoding": "inplace", "label": "contract IERC20", "numberOfBytes": "20" }, "t_contract(Lib_AddressManager)10146": { "encoding": "inplace", "label": "contract Lib_AddressManager", "numberOfBytes": "20" }, "t_contract(MetisConfig)2339": { "encoding": "inplace", "label": "contract MetisConfig", "numberOfBytes": "20" }, "t_mapping(t_address,t_struct(WithdrawalRequest)5181_storage)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => struct LockingPool.WithdrawalRequest)", "numberOfBytes": "32", "value": "t_struct(WithdrawalRequest)5181_storage" }, "t_mapping(t_address,t_uint256)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => uint256)", "numberOfBytes": "32", "value": "t_uint256" }, "t_struct(WithdrawalRequest)5181_storage": { "encoding": "inplace", "label": "struct LockingPool.WithdrawalRequest", "members": [ { "astId": 5178, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "amount", "offset": 0, "slot": "0", "type": "t_uint256" }, { "astId": 5180, "contract": "contracts/L1/dispute/LockingPool.sol:LockingPool", "label": "timestamp", "offset": 0, "slot": "1", "type": "t_uint256" } ], "numberOfBytes": "64" }, "t_uint256": { "encoding": "inplace", "label": "uint256", "numberOfBytes": "32" }, "t_uint8": { "encoding": "inplace", "label": "uint8", "numberOfBytes": "1" } } } }