{ "address": "0x89E9D387555AF0cDE22cb98833Bae40d640AD7fa", "abi": [ { "inputs": [ { "internalType": "address", "name": "_libAddressManager", "type": "address" }, { "internalType": "address", "name": "_l1messenger", "type": "address" }, { "internalType": "uint256", "name": "_fraudProofWindow", "type": "uint256" }, { "internalType": "uint256", "name": "_sequencerPublishWindow", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "constructor" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "uint256", "name": "_startBlockNumber", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "_length", "type": "uint256" }, { "indexed": true, "internalType": "uint256", "name": "_batchTime", "type": "uint256" }, { "indexed": false, "internalType": "address[]", "name": "_tssMembers", "type": "address[]" } ], "name": "DistributeTssReward", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "uint256", "name": "_startBlockNumber", "type": "uint256" } ], "name": "RollBackL2Chain", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "uint256", "name": "_batchIndex", "type": "uint256" }, { "indexed": false, "internalType": "bytes32", "name": "_batchRoot", "type": "bytes32" }, { "indexed": false, "internalType": "uint256", "name": "_batchSize", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "_prevTotalElements", "type": "uint256" }, { "indexed": false, "internalType": "bytes", "name": "_signature", "type": "bytes" }, { "indexed": false, "internalType": "bytes", "name": "_extraData", "type": "bytes" } ], "name": "StateBatchAppended", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "uint256", "name": "_batchIndex", "type": "uint256" }, { "indexed": false, "internalType": "bytes32", "name": "_batchRoot", "type": "bytes32" } ], "name": "StateBatchDeleted", "type": "event" }, { "inputs": [], "name": "FRAUD_PROOF_WINDOW", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "SEQUENCER_PUBLISH_WINDOW", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "bytes32[]", "name": "_batch", "type": "bytes32[]" }, { "internalType": "uint256", "name": "_shouldStartAtElement", "type": "uint256" }, { "internalType": "bytes", "name": "_signature", "type": "bytes" } ], "name": "appendStateBatch", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "batches", "outputs": [ { "internalType": "contract IChainStorageContainer", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "components": [ { "internalType": "uint256", "name": "batchIndex", "type": "uint256" }, { "internalType": "bytes32", "name": "batchRoot", "type": "bytes32" }, { "internalType": "uint256", "name": "batchSize", "type": "uint256" }, { "internalType": "uint256", "name": "prevTotalElements", "type": "uint256" }, { "internalType": "bytes", "name": "signature", "type": "bytes" }, { "internalType": "bytes", "name": "extraData", "type": "bytes" } ], "internalType": "struct Lib_BVMCodec.ChainBatchHeader", "name": "_batchHeader", "type": "tuple" } ], "name": "deleteStateBatch", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "getFraudProofWindow", "outputs": [ { "internalType": "uint256", "name": "_fraudProofWindow", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getLastSequencerTimestamp", "outputs": [ { "internalType": "uint256", "name": "_lastSequencerTimestamp", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getTotalBatches", "outputs": [ { "internalType": "uint256", "name": "_totalBatches", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getTotalElements", "outputs": [ { "internalType": "uint256", "name": "_totalElements", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "components": [ { "internalType": "uint256", "name": "batchIndex", "type": "uint256" }, { "internalType": "bytes32", "name": "batchRoot", "type": "bytes32" }, { "internalType": "uint256", "name": "batchSize", "type": "uint256" }, { "internalType": "uint256", "name": "prevTotalElements", "type": "uint256" }, { "internalType": "bytes", "name": "signature", "type": "bytes" }, { "internalType": "bytes", "name": "extraData", "type": "bytes" } ], "internalType": "struct Lib_BVMCodec.ChainBatchHeader", "name": "_batchHeader", "type": "tuple" } ], "name": "insideFraudProofWindow", "outputs": [ { "internalType": "bool", "name": "_inside", "type": "bool" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "libAddressManager", "outputs": [ { "internalType": "contract Lib_AddressManager", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "messenger", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "string", "name": "_name", "type": "string" } ], "name": "resolve", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_shouldRollBack", "type": "uint256" }, { "internalType": "uint256", "name": "_shouldStartAtElement", "type": "uint256" }, { "internalType": "bytes", "name": "_signature", "type": "bytes" } ], "name": "rollBackL2Chain", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_fraudProofWindow", "type": "uint256" } ], "name": "setFraudProofWindow", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "bytes32", "name": "_element", "type": "bytes32" }, { "components": [ { "internalType": "uint256", "name": "batchIndex", "type": "uint256" }, { "internalType": "bytes32", "name": "batchRoot", "type": "bytes32" }, { "internalType": "uint256", "name": "batchSize", "type": "uint256" }, { "internalType": "uint256", "name": "prevTotalElements", "type": "uint256" }, { "internalType": "bytes", "name": "signature", "type": "bytes" }, { "internalType": "bytes", "name": "extraData", "type": "bytes" } ], "internalType": "struct Lib_BVMCodec.ChainBatchHeader", "name": "_batchHeader", "type": "tuple" }, { "components": [ { "internalType": "uint256", "name": "index", "type": "uint256" }, { "internalType": "bytes32[]", "name": "siblings", "type": "bytes32[]" } ], "internalType": "struct Lib_BVMCodec.ChainInclusionProof", "name": "_proof", "type": "tuple" } ], "name": "verifyStateCommitment", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" } ], "transactionHash": "0xbeb4d36f4f11b19d39a76bc0cf8183e2fb3049f173614e4be6b3fd7b86cf1936", "receipt": { "to": null, "from": "0x2A2954F3989a83Cc43DD58B0f038D5F276f21333", "contractAddress": "0x89E9D387555AF0cDE22cb98833Bae40d640AD7fa", "transactionIndex": 1, "gasUsed": "2276550", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x357de786409fdd5f579e730b75a4174b357157f85d2af982dfe5a6bf45f46292", "transactionHash": "0xbeb4d36f4f11b19d39a76bc0cf8183e2fb3049f173614e4be6b3fd7b86cf1936", "logs": [], "blockNumber": 17577694, "cumulativeGasUsed": "2508152", "status": 1, "byzantium": true }, "args": [ "0x6968f3F16C3e64003F02E121cf0D5CCBf5625a42", "0x676A795fe6E43C17c668de16730c3F690FEB7120", 604800, 12592000 ], "numDeployments": 1, "solcInputHash": "c08114c6452ee36604f3be39c7878b8d", "metadata": "{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_libAddressManager\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_l1messenger\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_fraudProofWindow\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_sequencerPublishWindow\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_startBlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_length\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_batchTime\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"_tssMembers\",\"type\":\"address[]\"}],\"name\":\"DistributeTssReward\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_startBlockNumber\",\"type\":\"uint256\"}],\"name\":\"RollBackL2Chain\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_batchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_batchRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_batchSize\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_prevTotalElements\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"_signature\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"StateBatchAppended\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_batchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_batchRoot\",\"type\":\"bytes32\"}],\"name\":\"StateBatchDeleted\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FRAUD_PROOF_WINDOW\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SEQUENCER_PUBLISH_WINDOW\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"_batch\",\"type\":\"bytes32[]\"},{\"internalType\":\"uint256\",\"name\":\"_shouldStartAtElement\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_signature\",\"type\":\"bytes\"}],\"name\":\"appendStateBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"batches\",\"outputs\":[{\"internalType\":\"contract IChainStorageContainer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"batchRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"batchSize\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"prevTotalElements\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"internalType\":\"struct Lib_BVMCodec.ChainBatchHeader\",\"name\":\"_batchHeader\",\"type\":\"tuple\"}],\"name\":\"deleteStateBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getFraudProofWindow\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"_fraudProofWindow\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastSequencerTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"_lastSequencerTimestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalBatches\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"_totalBatches\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalElements\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"_totalElements\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"batchRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"batchSize\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"prevTotalElements\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"internalType\":\"struct Lib_BVMCodec.ChainBatchHeader\",\"name\":\"_batchHeader\",\"type\":\"tuple\"}],\"name\":\"insideFraudProofWindow\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"_inside\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"libAddressManager\",\"outputs\":[{\"internalType\":\"contract Lib_AddressManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"messenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"}],\"name\":\"resolve\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_shouldRollBack\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_shouldStartAtElement\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_signature\",\"type\":\"bytes\"}],\"name\":\"rollBackL2Chain\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_fraudProofWindow\",\"type\":\"uint256\"}],\"name\":\"setFraudProofWindow\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_element\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"batchRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"batchSize\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"prevTotalElements\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"internalType\":\"struct Lib_BVMCodec.ChainBatchHeader\",\"name\":\"_batchHeader\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"siblings\",\"type\":\"bytes32[]\"}],\"internalType\":\"struct Lib_BVMCodec.ChainInclusionProof\",\"name\":\"_proof\",\"type\":\"tuple\"}],\"name\":\"verifyStateCommitment\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"The State Commitment Chain (SCC) contract contains a list of proposed state roots which Proposers assert to be a result of each transaction in the Canonical Transaction Chain (CTC). Elements here have a 1:1 correspondence with transactions in the CTC, and should be the unique state root calculated off-chain by applying the canonical transactions one by one.\",\"kind\":\"dev\",\"methods\":{\"appendStateBatch(bytes32[],uint256,bytes)\":{\"params\":{\"_batch\":\"Batch of state roots.\",\"_shouldStartAtElement\":\"Index of the element at which this batch should start.\",\"_signature\":\"tss group signature of state batches.\"}},\"batches()\":{\"returns\":{\"_0\":\"Reference to the batch storage container.\"}},\"constructor\":{\"params\":{\"_libAddressManager\":\"Address of the Address Manager.\"}},\"deleteStateBatch((uint256,bytes32,uint256,uint256,bytes,bytes))\":{\"params\":{\"_batchHeader\":\"Header of the batch to start deleting from.\"}},\"getLastSequencerTimestamp()\":{\"returns\":{\"_lastSequencerTimestamp\":\"Last sequencer batch timestamp.\"}},\"getTotalBatches()\":{\"returns\":{\"_totalBatches\":\"Total submitted batches.\"}},\"getTotalElements()\":{\"returns\":{\"_totalElements\":\"Total submitted elements.\"}},\"insideFraudProofWindow((uint256,bytes32,uint256,uint256,bytes,bytes))\":{\"params\":{\"_batchHeader\":\"Header of the batch to check.\"},\"returns\":{\"_inside\":\"Whether or not the batch is inside the fraud proof window.\"}},\"resolve(string)\":{\"params\":{\"_name\":\"Name to resolve an address for.\"},\"returns\":{\"_0\":\"Address associated with the given name.\"}},\"rollBackL2Chain(uint256,uint256,bytes)\":{\"params\":{\"_shouldRollBack\":\"roll back to should start .\",\"_shouldStartAtElement\":\"Index of the element at which this batch should start\",\"_signature\":\"signature of rollback message\"}},\"verifyStateCommitment(bytes32,(uint256,bytes32,uint256,uint256,bytes,bytes),(uint256,bytes32[]))\":{\"params\":{\"_batchHeader\":\"Header of the batch in which the element was included.\",\"_element\":\"Hash of the element to verify a proof for.\",\"_proof\":\"Merkle inclusion proof for the element.\"}}},\"title\":\"StateCommitmentChain\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"appendStateBatch(bytes32[],uint256,bytes)\":{\"notice\":\"Appends a batch of state roots to the chain.\"},\"batches()\":{\"notice\":\"Accesses the batch storage container.\"},\"deleteStateBatch((uint256,bytes32,uint256,uint256,bytes,bytes))\":{\"notice\":\"Deletes all state roots after (and including) a given batch.\"},\"getLastSequencerTimestamp()\":{\"notice\":\"Retrieves the timestamp of the last batch submitted by the sequencer.\"},\"getTotalBatches()\":{\"notice\":\"Retrieves the total number of batches submitted.\"},\"getTotalElements()\":{\"notice\":\"Retrieves the total number of elements submitted.\"},\"insideFraudProofWindow((uint256,bytes32,uint256,uint256,bytes,bytes))\":{\"notice\":\"Checks whether a given batch is still inside its fraud proof window.\"},\"resolve(string)\":{\"notice\":\"Resolves the address associated with a given name.\"},\"rollBackL2Chain(uint256,uint256,bytes)\":{\"notice\":\"Emit event to notify sequencers to roll back.\"},\"verifyStateCommitment(bytes32,(uint256,bytes32,uint256,uint256,bytes,bytes),(uint256,bytes32[]))\":{\"notice\":\"Verifies a batch inclusion proof.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/L1/rollup/StateCommitmentChain.sol\":\"StateCommitmentChain\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\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 _setOwner(_msgSender());\\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 called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\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 _setOwner(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 _setOwner(newOwner);\\n }\\n\\n function _setOwner(address newOwner) private {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0x6bb804a310218875e89d12c053e94a13a4607cdf7cc2052f3e52bd32a0dc50a1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\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\":\"0x90565a39ae45c80f0468dc96c7b20d0afc3055f344c8203a0c9258239f350b9f\",\"license\":\"MIT\"},\"contracts/L1/rollup/ICanonicalTransactionChain.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\n/* Library Imports */\\nimport { Lib_BVMCodec } from \\\"../../libraries/codec/Lib_BVMCodec.sol\\\";\\n\\n/* Interface Imports */\\nimport { IChainStorageContainer } from \\\"./IChainStorageContainer.sol\\\";\\n\\n/**\\n * @title ICanonicalTransactionChain\\n */\\ninterface ICanonicalTransactionChain {\\n /**********\\n * Events *\\n **********/\\n\\n event L2GasParamsUpdated(\\n uint256 l2GasDiscountDivisor,\\n uint256 enqueueGasCost,\\n uint256 enqueueL2GasPrepaid\\n );\\n\\n event TransactionEnqueued(\\n address indexed _l1TxOrigin,\\n address indexed _target,\\n uint256 _gasLimit,\\n bytes _data,\\n uint256 indexed _queueIndex,\\n uint256 _timestamp\\n );\\n\\n event QueueBatchAppended(\\n uint256 _startingQueueIndex,\\n uint256 _numQueueElements,\\n uint256 _totalElements\\n );\\n\\n event SequencerBatchAppended(\\n uint256 _startingQueueIndex,\\n uint256 _numQueueElements,\\n uint256 _totalElements\\n );\\n\\n event TransactionBatchAppended(\\n uint256 indexed _batchIndex,\\n bytes32 _batchRoot,\\n uint256 _batchSize,\\n uint256 _prevTotalElements,\\n bytes _signature,\\n bytes _extraData\\n );\\n\\n\\n event CTCBatchReset(\\n uint256 indexed _batchIndex,\\n uint40 _nextqIndex,\\n uint40 _totalElement,\\n uint40 _batchSize,\\n uint40 _numQueuedTransactions ,\\n uint40 _timestamp,\\n uint40 _blockNumber\\n );\\n\\n /***********\\n * Structs *\\n ***********/\\n\\n struct BatchContext {\\n uint256 numSequencedTransactions;\\n uint256 numSubsequentQueueTransactions;\\n uint256 timestamp;\\n uint256 blockNumber;\\n }\\n\\n /*******************************\\n * Authorized Setter Functions *\\n *******************************/\\n\\n /**\\n * Allows the Burn Admin to update the parameters which determine the amount of gas to burn.\\n * The value of enqueueL2GasPrepaid is immediately updated as well.\\n */\\n function setGasParams(uint256 _l2GasDiscountDivisor, uint256 _enqueueGasCost) external;\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Accesses the batch storage container.\\n * @return Reference to the batch storage container.\\n */\\n function batches() external view returns (IChainStorageContainer);\\n\\n /**\\n * Retrieves the total number of elements submitted.\\n * @return _totalElements Total submitted elements.\\n */\\n function getTotalElements() external view returns (uint256 _totalElements);\\n\\n /**\\n * Retrieves the total number of batches submitted.\\n * @return _totalBatches Total submitted batches.\\n */\\n function getTotalBatches() external view returns (uint256 _totalBatches);\\n\\n /**\\n * Returns the index of the next element to be enqueued.\\n * @return Index for the next queue element.\\n */\\n function getNextQueueIndex() external view returns (uint40);\\n\\n /**\\n * Gets the queue element at a particular index.\\n * @param _index Index of the queue element to access.\\n * @return _element Queue element at the given index.\\n */\\n function getQueueElement(uint256 _index)\\n external\\n view\\n returns (Lib_BVMCodec.QueueElement memory _element);\\n\\n /**\\n * Returns the timestamp of the last transaction.\\n * @return Timestamp for the last transaction.\\n */\\n function getLastTimestamp() external view returns (uint40);\\n\\n /**\\n * Returns the blocknumber of the last transaction.\\n * @return Blocknumber for the last transaction.\\n */\\n function getLastBlockNumber() external view returns (uint40);\\n\\n /**\\n * Get the number of queue elements which have not yet been included.\\n * @return Number of pending queue elements.\\n */\\n function getNumPendingQueueElements() external view returns (uint40);\\n\\n /**\\n * Retrieves the length of the queue, including\\n * both pending and canonical transactions.\\n * @return Length of the queue.\\n */\\n function getQueueLength() external view returns (uint40);\\n\\n /**\\n * Adds a transaction to the queue.\\n * @param _target Target contract to send the transaction to.\\n * @param _gasLimit Gas limit for the given transaction.\\n * @param _data Transaction data.\\n */\\n function enqueue(\\n address _target,\\n uint256 _gasLimit,\\n bytes memory _data\\n ) external;\\n\\n /**\\n * Allows the sequencer to append a batch of transactions.\\n * @dev This function uses a custom encoding scheme for efficiency reasons.\\n * .param _shouldStartAtElement Specific batch we expect to start appending to.\\n * .param _totalElementsToAppend Total number of batch elements we expect to append.\\n * .param _contexts Array of batch contexts.\\n * .param _transactionDataFields Array of raw transaction data.\\n */\\n function appendSequencerBatch(\\n // uint40 _shouldStartAtElement,\\n // uint24 _totalElementsToAppend,\\n // BatchContext[] _contexts,\\n // bytes[] _transactionDataFields\\n ) external;\\n\\n function resetIndex(uint256 _batchIndex, uint40 _totalElement, uint40 _batchSize,\\n uint40 _nextqIndex,uint40 _numQueuedTransactions ,\\n uint40 _timestamp, uint40 _blockNumber) external;\\n}\\n\",\"keccak256\":\"0x36577a00dd6ea0d9268cae7909faec55ab56cffe7d69423fd44768919d8a08bc\",\"license\":\"MIT\"},\"contracts/L1/rollup/IChainStorageContainer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\n/**\\n * @title IChainStorageContainer\\n */\\ninterface IChainStorageContainer {\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Sets the container's global metadata field. We're using `bytes27` here because we use five\\n * bytes to maintain the length of the underlying data structure, meaning we have an extra\\n * 27 bytes to store arbitrary data.\\n * @param _globalMetadata New global metadata to set.\\n */\\n function setGlobalMetadata(bytes27 _globalMetadata) external;\\n\\n /**\\n * Retrieves the container's global metadata field.\\n * @return Container global metadata field.\\n */\\n function getGlobalMetadata() external view returns (bytes27);\\n\\n /**\\n * Retrieves the number of objects stored in the container.\\n * @return Number of objects in the container.\\n */\\n function length() external view returns (uint256);\\n\\n /**\\n * Pushes an object into the container.\\n * @param _object A 32 byte value to insert into the container.\\n */\\n function push(bytes32 _object) external;\\n\\n /**\\n * Pushes an object into the container. Function allows setting the global metadata since\\n * we'll need to touch the \\\"length\\\" storage slot anyway, which also contains the global\\n * metadata (it's an optimization).\\n * @param _object A 32 byte value to insert into the container.\\n * @param _globalMetadata New global metadata for the container.\\n */\\n function push(bytes32 _object, bytes27 _globalMetadata) external;\\n\\n /**\\n * Retrieves an object from the container.\\n * @param _index Index of the particular object to access.\\n * @return 32 byte object value.\\n */\\n function get(uint256 _index) external view returns (bytes32);\\n\\n /**\\n * Removes all objects after and including a given index.\\n * @param _index Object index to delete from.\\n */\\n function deleteElementsAfterInclusive(uint256 _index) external;\\n\\n /**\\n * Removes all objects after and including a given index. Also allows setting the global\\n * metadata field.\\n * @param _index Object index to delete from.\\n * @param _globalMetadata New global metadata for the container.\\n */\\n function deleteElementsAfterInclusive(uint256 _index, bytes27 _globalMetadata) external;\\n}\\n\",\"keccak256\":\"0xe55ad72572ec47dc09a02228d0c5a438571c76a41d16d92b35add057811977ce\",\"license\":\"MIT\"},\"contracts/L1/rollup/IStateCommitmentChain.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\n/* Library Imports */\\nimport { Lib_BVMCodec } from \\\"../../libraries/codec/Lib_BVMCodec.sol\\\";\\n\\n/**\\n * @title IStateCommitmentChain\\n */\\ninterface IStateCommitmentChain {\\n /**********\\n * Events *\\n **********/\\n\\n event StateBatchAppended(\\n uint256 indexed _batchIndex,\\n bytes32 _batchRoot,\\n uint256 _batchSize,\\n uint256 _prevTotalElements,\\n bytes _signature,\\n bytes _extraData\\n );\\n\\n event StateBatchDeleted(uint256 indexed _batchIndex, bytes32 _batchRoot);\\n\\n event DistributeTssReward(\\n uint256 indexed _startBlockNumber,\\n uint256 _length,\\n uint256 indexed _batchTime,\\n address[] _tssMembers\\n );\\n\\n event RollBackL2Chain(uint256 indexed _startBlockNumber);\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Retrieves the total number of elements submitted.\\n * @return _totalElements Total submitted elements.\\n */\\n function getTotalElements() external view returns (uint256 _totalElements);\\n\\n /**\\n * Retrieves the total number of batches submitted.\\n * @return _totalBatches Total submitted batches.\\n */\\n function getTotalBatches() external view returns (uint256 _totalBatches);\\n\\n /**\\n * Retrieves the timestamp of the last batch submitted by the sequencer.\\n * @return _lastSequencerTimestamp Last sequencer batch timestamp.\\n */\\n function getLastSequencerTimestamp() external view returns (uint256 _lastSequencerTimestamp);\\n\\n /**\\n * Appends a batch of state roots to the chain.\\n * @param _batch Batch of state roots.\\n * @param _shouldStartAtElement Index of the element at which this batch should start.\\n * @param _signature tss group signature of state batches.\\n */\\n function appendStateBatch(bytes32[] calldata _batch, uint256 _shouldStartAtElement, bytes memory _signature) external;\\n\\n /**\\n * Deletes all state roots after (and including) a given batch.\\n * @param _batchHeader Header of the batch to start deleting from.\\n */\\n function deleteStateBatch(Lib_BVMCodec.ChainBatchHeader memory _batchHeader) external;\\n\\n /**\\n * Verifies a batch inclusion proof.\\n * @param _element Hash of the element to verify a proof for.\\n * @param _batchHeader Header of the batch in which the element was included.\\n * @param _proof Merkle inclusion proof for the element.\\n */\\n function verifyStateCommitment(\\n bytes32 _element,\\n Lib_BVMCodec.ChainBatchHeader memory _batchHeader,\\n Lib_BVMCodec.ChainInclusionProof memory _proof\\n ) external view returns (bool _verified);\\n\\n /**\\n * Checks whether a given batch is still inside its fraud proof window.\\n * @param _batchHeader Header of the batch to check.\\n * @return _inside Whether or not the batch is inside the fraud proof window.\\n */\\n function insideFraudProofWindow(Lib_BVMCodec.ChainBatchHeader memory _batchHeader)\\n external\\n view\\n returns (bool _inside);\\n\\n /**\\n * Emit event to notify sequencers to roll back.\\n * @param _shouldRollBack roll back to should start .\\n * @param _shouldStartAtElement Index of the element at which this batch should start\\n * @param _signature signature of rollback message\\n */\\n function rollBackL2Chain(uint256 _shouldRollBack,uint256 _shouldStartAtElement, bytes memory _signature) external;\\n\\n}\\n\",\"keccak256\":\"0xf45236553657a6fdbba0248ee9e12150c787ef08ba09e7d5a75c9a38658963f0\",\"license\":\"MIT\"},\"contracts/L1/rollup/StateCommitmentChain.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* Library Imports */\\nimport {Lib_BVMCodec} from \\\"../../libraries/codec/Lib_BVMCodec.sol\\\";\\nimport {Lib_AddressResolver} from \\\"../../libraries/resolver/Lib_AddressResolver.sol\\\";\\nimport {Lib_MerkleTree} from \\\"../../libraries/utils/Lib_MerkleTree.sol\\\";\\nimport {CrossDomainEnabled} from \\\"../../libraries/bridge/CrossDomainEnabled.sol\\\";\\n\\n/* Interface Imports */\\nimport {IStateCommitmentChain} from \\\"./IStateCommitmentChain.sol\\\";\\nimport {ICanonicalTransactionChain} from \\\"./ICanonicalTransactionChain.sol\\\";\\nimport {IBondManager} from \\\"../verification/IBondManager.sol\\\";\\nimport {IChainStorageContainer} from \\\"./IChainStorageContainer.sol\\\";\\nimport {ITssGroupManager} from \\\"../tss/ITssGroupManager.sol\\\";\\nimport {ITssRewardContract} from \\\"../../L2/predeploys/iTssRewardContract.sol\\\";\\n\\n/**\\n * @title StateCommitmentChain\\n * @dev The State Commitment Chain (SCC) contract contains a list of proposed state roots which\\n * Proposers assert to be a result of each transaction in the Canonical Transaction Chain (CTC).\\n * Elements here have a 1:1 correspondence with transactions in the CTC, and should be the unique\\n * state root calculated off-chain by applying the canonical transactions one by one.\\n *\\n */\\ncontract StateCommitmentChain is IStateCommitmentChain, Lib_AddressResolver, CrossDomainEnabled {\\n /*************\\n * Constants *\\n *************/\\n\\n uint256 public FRAUD_PROOF_WINDOW;\\n uint256 public SEQUENCER_PUBLISH_WINDOW;\\n\\n /***************\\n * Constructor *\\n ***************/\\n\\n /**\\n * @param _libAddressManager Address of the Address Manager.\\n */\\n constructor(\\n address _libAddressManager,\\n address _l1messenger,\\n uint256 _fraudProofWindow,\\n uint256 _sequencerPublishWindow\\n ) Lib_AddressResolver(_libAddressManager) CrossDomainEnabled(address(0)) {\\n messenger = _l1messenger;\\n FRAUD_PROOF_WINDOW = _fraudProofWindow;\\n SEQUENCER_PUBLISH_WINDOW = _sequencerPublishWindow;\\n }\\n\\n function setFraudProofWindow(uint256 _fraudProofWindow) public {\\n require(msg.sender == libAddressManager.owner(), \\\"Only callable by the libAddressManager owner.\\\");\\n FRAUD_PROOF_WINDOW = _fraudProofWindow;\\n }\\n\\n function getFraudProofWindow() public view returns (uint256 _fraudProofWindow) {\\n return uint256(FRAUD_PROOF_WINDOW);\\n }\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Accesses the batch storage container.\\n * @return Reference to the batch storage container.\\n */\\n function batches() public view returns (IChainStorageContainer) {\\n return IChainStorageContainer(resolve(\\\"ChainStorageContainer-SCC-batches\\\"));\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n function getTotalElements() public view returns (uint256 _totalElements) {\\n (uint40 totalElements,) = _getBatchExtraData();\\n return uint256(totalElements);\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n function getTotalBatches() public view returns (uint256 _totalBatches) {\\n return batches().length();\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n // slither-disable-next-line external-function\\n function getLastSequencerTimestamp() public view returns (uint256 _lastSequencerTimestamp) {\\n (, uint40 lastSequencerTimestamp) = _getBatchExtraData();\\n return uint256(lastSequencerTimestamp);\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n // slither-disable-next-line external-function\\n function appendStateBatch(bytes32[] memory _batch, uint256 _shouldStartAtElement, bytes memory _signature) public {\\n // Fail fast in to make sure our batch roots aren't accidentally made fraudulent by the\\n // publication of batches by some other user.\\n require(\\n _shouldStartAtElement == getTotalElements(),\\n \\\"Actual batch start index does not match expected start index.\\\"\\n );\\n\\n // Proposers must have previously staked at the BondManager\\n require(\\n IBondManager(resolve(\\\"BondManager\\\")).isCollateralized(msg.sender),\\n \\\"Proposer does not have enough collateral posted\\\"\\n );\\n\\n require(_batch.length > 0, \\\"Cannot submit an empty state batch.\\\");\\n\\n require(\\n getTotalElements() + _batch.length <=\\n ICanonicalTransactionChain(resolve(\\\"CanonicalTransactionChain\\\")).getTotalElements(),\\n \\\"Number of state roots cannot exceed the number of canonical transactions.\\\"\\n );\\n\\n // Call tss group register contract to verify the signature\\n _checkClusterSignature(_batch, _shouldStartAtElement, _signature);\\n\\n // Pass the block's timestamp and the publisher of the data\\n // to be used in the fraud proofs\\n _appendBatch(_batch, _signature, abi.encode(block.timestamp, msg.sender));\\n\\n // Update distributed state batch, and emit message\\n _distributeTssReward(_batch.length, _shouldStartAtElement);\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n // slither-disable-next-line external-function\\n function deleteStateBatch(Lib_BVMCodec.ChainBatchHeader memory _batchHeader) public {\\n require(\\n msg.sender == resolve(\\\"BVM_FraudVerifier\\\"),\\n \\\"State batches can only be deleted by the BVM_FraudVerifier.\\\"\\n );\\n\\n require(_isValidBatchHeader(_batchHeader), \\\"Invalid batch header.\\\");\\n\\n require(\\n insideFraudProofWindow(_batchHeader),\\n \\\"State batches can only be deleted within the fraud proof window.\\\"\\n );\\n\\n _deleteBatch(_batchHeader);\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n // slither-disable-next-line external-function\\n function verifyStateCommitment(\\n bytes32 _element,\\n Lib_BVMCodec.ChainBatchHeader memory _batchHeader,\\n Lib_BVMCodec.ChainInclusionProof memory _proof\\n ) public view returns (bool) {\\n require(_isValidBatchHeader(_batchHeader), \\\"Invalid batch header.\\\");\\n\\n require(\\n Lib_MerkleTree.verify(\\n _batchHeader.batchRoot,\\n _element,\\n _proof.index,\\n _proof.siblings,\\n _batchHeader.batchSize\\n ),\\n \\\"Invalid inclusion proof.\\\"\\n );\\n\\n return true;\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n function insideFraudProofWindow(Lib_BVMCodec.ChainBatchHeader memory _batchHeader)\\n public\\n view\\n returns (bool _inside)\\n {\\n (uint256 timestamp,) = abi.decode(_batchHeader.extraData, (uint256, address));\\n\\n require(timestamp != 0, \\\"Batch header timestamp cannot be zero\\\");\\n return (timestamp + FRAUD_PROOF_WINDOW) > block.timestamp;\\n }\\n\\n /**\\n * @inheritdoc IStateCommitmentChain\\n */\\n // slither-disable-next-line external-function\\n function rollBackL2Chain(uint256 _shouldRollBack, uint256 _shouldStartAtElement, bytes memory _signature) public {\\n // Fail fast in to make sure our batch roots aren't accidentally made fraudulent by the\\n // publication of batches by some other user.\\n require(\\n _shouldStartAtElement == getTotalElements(),\\n \\\"Actual batch start index does not match expected start index.\\\"\\n );\\n\\n // Proposers must have previously staked at the BondManager\\n require(\\n IBondManager(resolve(\\\"BondManager\\\")).isCollateralized(msg.sender),\\n \\\"Proposer does not have enough collateral posted\\\"\\n );\\n\\n _checkRollBackSignature(_shouldRollBack,_signature);\\n\\n }\\n\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Parses the batch context from the extra data.\\n * @return Total number of elements submitted.\\n * @return Timestamp of the last batch submitted by the sequencer.\\n */\\n function _getBatchExtraData() internal view returns (uint40, uint40) {\\n bytes27 extraData = batches().getGlobalMetadata();\\n\\n // solhint-disable max-line-length\\n uint40 totalElements;\\n uint40 lastSequencerTimestamp;\\n assembly {\\n extraData := shr(40, extraData)\\n totalElements := and(\\n extraData,\\n 0x000000000000000000000000000000000000000000000000000000FFFFFFFFFF\\n )\\n lastSequencerTimestamp := shr(\\n 40,\\n and(extraData, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000000000)\\n )\\n }\\n // solhint-enable max-line-length\\n\\n return (totalElements, lastSequencerTimestamp);\\n }\\n\\n /**\\n * Encodes the batch context for the extra data.\\n * @param _totalElements Total number of elements submitted.\\n * @param _lastSequencerTimestamp Timestamp of the last batch submitted by the sequencer.\\n * @return Encoded batch context.\\n */\\n function _makeBatchExtraData(uint40 _totalElements, uint40 _lastSequencerTimestamp)\\n internal\\n pure\\n returns (bytes27)\\n {\\n bytes27 extraData;\\n assembly {\\n extraData := _totalElements\\n extraData := or(extraData, shl(40, _lastSequencerTimestamp))\\n extraData := shl(40, extraData)\\n }\\n\\n return extraData;\\n }\\n\\n /**\\n * Appends a batch to the chain.\\n * @param _batch Elements within the batch.\\n * @param _shouldStartAtElement Relative rollup block height.\\n * @param _signature Signature of batch roots and rollup start height.\\n */\\n function _checkClusterSignature(bytes32[] memory _batch, uint256 _shouldStartAtElement, bytes memory _signature)\\n internal\\n {\\n // abi hash encode to bytes\\n require(\\n ITssGroupManager(resolve(\\\"Proxy__TSS_GroupManager\\\")).verifySign(\\n keccak256(abi.encode(_batch, _shouldStartAtElement)), _signature),\\n \\\"verify signature failed\\\"\\n );\\n }\\n\\n /**\\n * Appends a batch to the chain.\\n * @param _batch Elements within the batch.\\n * @param _extraData Any extra data to append to the batch.\\n */\\n function _appendBatch(bytes32[] memory _batch, bytes memory _signature, bytes memory _extraData) internal {\\n address sequencer = resolve(\\\"BVM_Proposer\\\");\\n (uint40 totalElements, uint40 lastSequencerTimestamp) = _getBatchExtraData();\\n\\n if (msg.sender == sequencer) {\\n lastSequencerTimestamp = uint40(block.timestamp);\\n } else {\\n // We keep track of the last batch submitted by the sequencer so there's a window in\\n // which only the sequencer can publish state roots. A window like this just reduces\\n // the chance of \\\"system breaking\\\" state roots being published while we're still in\\n // testing mode. This window should be removed or significantly reduced in the future.\\n require(\\n lastSequencerTimestamp + SEQUENCER_PUBLISH_WINDOW < block.timestamp,\\n \\\"Cannot publish state roots within the sequencer publication window.\\\"\\n );\\n }\\n // For efficiency reasons getMerkleRoot modifies the `_batch` argument in place\\n // while calculating the root hash therefore any arguments passed to it must not\\n // be used again afterwards\\n Lib_BVMCodec.ChainBatchHeader memory batchHeader = Lib_BVMCodec.ChainBatchHeader({\\n batchIndex : getTotalBatches(),\\n batchRoot : Lib_MerkleTree.getMerkleRoot(_batch),\\n batchSize : _batch.length,\\n prevTotalElements : totalElements,\\n signature : _signature,\\n extraData : _extraData\\n });\\n\\n emit StateBatchAppended(\\n batchHeader.batchIndex,\\n batchHeader.batchRoot,\\n batchHeader.batchSize,\\n batchHeader.prevTotalElements,\\n batchHeader.signature,\\n batchHeader.extraData\\n );\\n\\n batches().push(\\n Lib_BVMCodec.hashBatchHeader(batchHeader),\\n _makeBatchExtraData(\\n uint40(batchHeader.prevTotalElements + batchHeader.batchSize),\\n lastSequencerTimestamp\\n )\\n );\\n }\\n\\n /**\\n * Removes a batch and all subsequent batches from the chain.\\n * @param _batchHeader Header of the batch to remove.\\n */\\n function _deleteBatch(Lib_BVMCodec.ChainBatchHeader memory _batchHeader) internal {\\n require(_batchHeader.batchIndex < batches().length(), \\\"Invalid batch index.\\\");\\n\\n require(_isValidBatchHeader(_batchHeader), \\\"Invalid batch header.\\\");\\n\\n // slither-disable-next-line reentrancy-events\\n batches().deleteElementsAfterInclusive(\\n _batchHeader.batchIndex,\\n _makeBatchExtraData(uint40(_batchHeader.prevTotalElements), 0)\\n );\\n\\n // slither-disable-next-line reentrancy-events\\n emit StateBatchDeleted(_batchHeader.batchIndex, _batchHeader.batchRoot);\\n }\\n\\n /**\\n * Distribute Reward to tss node.\\n * @param _batch_length rollup batch.\\n * @param _shouldStartAtElement.\\n */\\n function _distributeTssReward(uint256 _batch_length, uint256 _shouldStartAtElement) internal {\\n // get address of tss group member\\n address[] memory tssMembers = ITssGroupManager(resolve(\\\"Proxy__TSS_GroupManager\\\")).getTssGroupUnJailMembers();\\n require(tssMembers.length > 0, \\\"get tss members in error\\\");\\n\\n // construct calldata for claimReward call\\n bytes memory message = abi.encodeWithSelector(\\n ITssRewardContract.claimReward.selector,\\n _shouldStartAtElement,\\n _batch_length,\\n block.timestamp,\\n tssMembers\\n );\\n\\n // send call data into L2, hardcode address\\n sendCrossDomainMessage(\\n address(0x4200000000000000000000000000000000000020),\\n 2000000,\\n message\\n );\\n\\n // emit message\\n emit DistributeTssReward(\\n _shouldStartAtElement,\\n _batch_length,\\n block.timestamp,\\n tssMembers\\n );\\n }\\n\\n /**\\n * Checks that a batch header matches the stored hash for the given index.\\n * @param _batchHeader Batch header to validate.\\n * @return Whether or not the header matches the stored one.\\n */\\n function _isValidBatchHeader(Lib_BVMCodec.ChainBatchHeader memory _batchHeader)\\n internal\\n view\\n returns (bool)\\n {\\n return Lib_BVMCodec.hashBatchHeader(_batchHeader) == batches().get(_batchHeader.batchIndex);\\n }\\n\\n\\n /**\\n * roll back l2 chain to should start block number.\\n * @param _shouldRollBack roll back number.\\n * @param _signature Signature of roll back number.\\n */\\n function _checkRollBackSignature(uint256 _shouldRollBack, bytes memory _signature)\\n internal\\n {\\n // abi hash encode to bytes\\n require(\\n ITssGroupManager(resolve(\\\"Proxy__TSS_GroupManager\\\")).verifySign(\\n keccak256(abi.encode(_shouldRollBack)), _signature),\\n \\\"verify signature failed\\\"\\n );\\n\\n\\n bytes memory message = abi.encodeWithSignature(\\n \\\"rollBackMessage(uint256)\\\",\\n _shouldRollBack\\n );\\n\\n // send call data into L2, hardcode address\\n sendCrossDomainMessage(\\n address(0xDeADdeaDdEaDdeADdEaDDeADDEaddEaDDEad2222),\\n 2000000,\\n message\\n );\\n\\n //emit roll back l2chain from block number\\n emit RollBackL2Chain(_shouldRollBack);\\n }\\n}\\n\",\"keccak256\":\"0x1bfc9db9ba6847b8a6e2cd031cac608e38004e4dd630a29ce77529e80148201d\",\"license\":\"MIT\"},\"contracts/L1/tss/ITssGroupManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\ninterface ITssGroupManager {\\n enum MemberStatus {\\n unJail,\\n jail\\n }\\n\\n struct TssMember {\\n bytes publicKey;\\n address nodeAddress;\\n MemberStatus status;\\n }\\n\\n function setTssGroupMember(uint256 _threshold, bytes[] memory _batchPublicKey) external;\\n function setGroupPublicKey(bytes memory _publicKey, bytes memory _groupPublicKey) external;\\n function getTssGroupInfo() external returns (uint256, uint256, bytes memory, bytes[] memory);\\n function getTssInactiveGroupInfo() external returns (uint256, uint256, bytes[] memory);\\n function memberJail(bytes memory _publicKey) external;\\n function memberUnJail(bytes memory _publicKey) external;\\n function removeMember(bytes memory _publicKey) external;\\n function getTssGroupUnJailMembers() external returns (address[] memory);\\n function getTssGroupMembers() external returns (bytes[] memory);\\n function getTssMember(bytes memory _publicKey) external returns (TssMember memory);\\n function memberExistActive(bytes memory _publicKey) external returns (bool);\\n function memberExistInActive(bytes memory _publicKey) external returns (bool);\\n function inActiveIsEmpty() external returns (bool);\\n function verifySign(bytes32 _message, bytes memory _sig) external returns (bool);\\n function isTssGroupUnJailMembers(address _addr) external returns (bool);\\n function memberExistActive(address _addr) external returns (bool);\\n}\\n\",\"keccak256\":\"0xb5ba6959a8081f00f8f8322d6b3cdab4f7a92e86df4a035ad1485caaf98e6558\",\"license\":\"MIT\"},\"contracts/L1/verification/IBondManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title IBondManager\\n */\\ninterface IBondManager {\\n /********************\\n * Public Functions *\\n ********************/\\n\\n function isCollateralized(address _who) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x4ae2dc7bf175626d2930299e73d50a7ba936171d07810497ef71fa38a4e246a7\",\"license\":\"MIT\"},\"contracts/L2/predeploys/iTssRewardContract.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title ITssRewardContract\\n */\\n\\ninterface ITssRewardContract {\\n /**********\\n * Events *\\n **********/\\n\\n event DistributeTssReward(\\n uint256 lastBatchTime,\\n uint256 batchTime,\\n uint256 amount,\\n address[] tssMembers\\n );\\n\\n event DistributeTssRewardByBlock(\\n uint256 blockStartHeight,\\n uint32 length,\\n uint256 amount,\\n address[] tssMembers\\n );\\n\\n event Claim(\\n address owner,\\n uint256 amount\\n );\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * @dev Query total undistributed balance.\\n * @return Amount of undistributed rewards.\\n */\\n function queryReward() external view returns (uint256);\\n\\n /**\\n * @dev Auto distribute reward to tss members.\\n * @param _blockStartHeight L2 rollup batch block start height.\\n * @param _length Rollup batch length.\\n * @param _batchTime rollup batch time.\\n * @param _tssMembers Tss member address array.\\n */\\n function claimReward(uint256 _blockStartHeight, uint32 _length, uint256 _batchTime, address[] calldata _tssMembers) external;\\n\\n /**\\n * @dev clear contract(canonical).\\n */\\n function withdraw() external;\\n\\n /**\\n * @dev Claim reward and withdraw\\n */\\n function claim() external;\\n\\n /**\\n * @dev default claimer == staker, if staker is multi-signature address,must set claimer\\n * @param _staker the address of staker\\n * @param _claimer the address for staker to claim reward\\n */\\n function setClaimer(address _staker, address _claimer) external;\\n\\n /**\\n * @dev Initiate a request to claim\\n */\\n function requestClaim() external returns (bool);\\n\\n /**\\n * @dev Query the remaining time required to claim\\n */\\n function queryClaimTime() external returns (uint256);\\n\\n function setSccAddr(address sccAddr) external;\\n\\n function setStakeSlashAddr(address ssAddr) external;\\n\\n function setSendAmountPerYear(uint256) external;\\n\\n function setWaitingTime(uint256) external;\\n\\n}\\n\",\"keccak256\":\"0x6ad08d2584dad803f6f537abe1fa4e556295d2463df8f2681062cbb33b86b775\",\"license\":\"MIT\"},\"contracts/libraries/bridge/CrossDomainEnabled.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\n/* Interface Imports */\\nimport { ICrossDomainMessenger } from \\\"./ICrossDomainMessenger.sol\\\";\\n\\n/**\\n * @title CrossDomainEnabled\\n * @dev Helper contract for contracts performing cross-domain communications\\n *\\n * Compiler used: defined by inheriting contract\\n */\\ncontract CrossDomainEnabled {\\n /*************\\n * Variables *\\n *************/\\n\\n // Messenger contract used to send and recieve messages from the other domain.\\n address public messenger;\\n\\n /***************\\n * Constructor *\\n ***************/\\n\\n /**\\n * @param _messenger Address of the CrossDomainMessenger on the current layer.\\n */\\n constructor(address _messenger) {\\n messenger = _messenger;\\n }\\n\\n /**********************\\n * Function Modifiers *\\n **********************/\\n\\n /**\\n * Enforces that the modified function is only callable by a specific cross-domain account.\\n * @param _sourceDomainAccount The only account on the originating domain which is\\n * authenticated to call this function.\\n */\\n modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {\\n require(\\n msg.sender == address(getCrossDomainMessenger()),\\n \\\"BVM_XCHAIN: messenger contract unauthenticated\\\"\\n );\\n\\n require(\\n getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,\\n \\\"BVM_XCHAIN: wrong sender of cross-domain message\\\"\\n );\\n\\n _;\\n }\\n\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Gets the messenger, usually from storage. This function is exposed in case a child contract\\n * needs to override.\\n * @return The address of the cross-domain messenger contract which should be used.\\n */\\n function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {\\n return ICrossDomainMessenger(messenger);\\n }\\n\\n /**q\\n * Sends a message to an account on another domain\\n * @param _crossDomainTarget The intended recipient on the destination domain\\n * @param _message The data to send to the target (usually calldata to a function with\\n * `onlyFromCrossDomainAccount()`)\\n * @param _gasLimit The gasLimit for the receipt of the message on the target domain.\\n */\\n function sendCrossDomainMessage(\\n address _crossDomainTarget,\\n uint32 _gasLimit,\\n bytes memory _message\\n ) internal {\\n // slither-disable-next-line reentrancy-events, reentrancy-benign\\n getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);\\n }\\n}\\n\",\"keccak256\":\"0xa7f0c49f2d81e43aa48b72020aa594770ee244353d4dc96d367ec6bf120fb467\",\"license\":\"MIT\"},\"contracts/libraries/bridge/ICrossDomainMessenger.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\n/**\\n * @title ICrossDomainMessenger\\n */\\ninterface ICrossDomainMessenger {\\n /**********\\n * Events *\\n **********/\\n\\n event SentMessage(\\n address indexed target,\\n address sender,\\n bytes message,\\n uint256 messageNonce,\\n uint256 gasLimit\\n );\\n event RelayedMessage(bytes32 indexed msgHash);\\n event FailedRelayedMessage(bytes32 indexed msgHash);\\n\\n /*************\\n * Variables *\\n *************/\\n\\n function xDomainMessageSender() external view returns (address);\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Sends a cross domain message to the target messenger.\\n * @param _target Target contract address.\\n * @param _message Message to send to the target.\\n * @param _gasLimit Gas limit for the provided message.\\n */\\n function sendMessage(\\n address _target,\\n bytes calldata _message,\\n uint32 _gasLimit\\n ) external;\\n}\\n\",\"keccak256\":\"0x8f29ae23021345a20ccac7b5edb3fc38268aef943b65adc8a32e74b80bf1833a\",\"license\":\"MIT\"},\"contracts/libraries/codec/Lib_BVMCodec.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* Library Imports */\\nimport { Lib_RLPReader } from \\\"../rlp/Lib_RLPReader.sol\\\";\\nimport { Lib_RLPWriter } from \\\"../rlp/Lib_RLPWriter.sol\\\";\\nimport { Lib_BytesUtils } from \\\"../utils/Lib_BytesUtils.sol\\\";\\nimport { Lib_Bytes32Utils } from \\\"../utils/Lib_Bytes32Utils.sol\\\";\\n\\n/**\\n * @title Lib_BVMCodec\\n */\\nlibrary Lib_BVMCodec {\\n /*********\\n * Enums *\\n *********/\\n\\n enum QueueOrigin {\\n SEQUENCER_QUEUE,\\n L1TOL2_QUEUE\\n }\\n\\n /***********\\n * Structs *\\n ***********/\\n\\n struct EVMAccount {\\n uint256 nonce;\\n uint256 balance;\\n bytes32 storageRoot;\\n bytes32 codeHash;\\n }\\n\\n struct ChainBatchHeader {\\n uint256 batchIndex;\\n bytes32 batchRoot;\\n uint256 batchSize;\\n uint256 prevTotalElements;\\n bytes signature;\\n bytes extraData;\\n }\\n\\n struct ChainInclusionProof {\\n uint256 index;\\n bytes32[] siblings;\\n }\\n\\n struct Transaction {\\n uint256 timestamp;\\n uint256 blockNumber;\\n QueueOrigin l1QueueOrigin;\\n address l1TxOrigin;\\n address entrypoint;\\n uint256 gasLimit;\\n bytes data;\\n }\\n\\n struct TransactionChainElement {\\n bool isSequenced;\\n uint256 queueIndex; // QUEUED TX ONLY\\n uint256 timestamp; // SEQUENCER TX ONLY\\n uint256 blockNumber; // SEQUENCER TX ONLY\\n bytes txData; // SEQUENCER TX ONLY\\n }\\n\\n struct QueueElement {\\n bytes32 transactionHash;\\n uint40 timestamp;\\n uint40 blockNumber;\\n }\\n\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Encodes a standard BVM transaction.\\n * @param _transaction BVM transaction to encode.\\n * @return Encoded transaction bytes.\\n */\\n function encodeTransaction(Transaction memory _transaction)\\n internal\\n pure\\n returns (bytes memory)\\n {\\n return\\n abi.encodePacked(\\n _transaction.timestamp,\\n _transaction.blockNumber,\\n _transaction.l1QueueOrigin,\\n _transaction.l1TxOrigin,\\n _transaction.entrypoint,\\n _transaction.gasLimit,\\n _transaction.data\\n );\\n }\\n\\n /**\\n * Hashes a standard BVM transaction.\\n * @param _transaction BVM transaction to encode.\\n * @return Hashed transaction\\n */\\n function hashTransaction(Transaction memory _transaction) internal pure returns (bytes32) {\\n return keccak256(encodeTransaction(_transaction));\\n }\\n\\n /**\\n * @notice Decodes an RLP-encoded account state into a useful struct.\\n * @param _encoded RLP-encoded account state.\\n * @return Account state struct.\\n */\\n function decodeEVMAccount(bytes memory _encoded) internal pure returns (EVMAccount memory) {\\n Lib_RLPReader.RLPItem[] memory accountState = Lib_RLPReader.readList(_encoded);\\n\\n return\\n EVMAccount({\\n nonce: Lib_RLPReader.readUint256(accountState[0]),\\n balance: Lib_RLPReader.readUint256(accountState[1]),\\n storageRoot: Lib_RLPReader.readBytes32(accountState[2]),\\n codeHash: Lib_RLPReader.readBytes32(accountState[3])\\n });\\n }\\n\\n /**\\n * Calculates a hash for a given batch header.\\n * @param _batchHeader Header to hash.\\n * @return Hash of the header.\\n */\\n function hashBatchHeader(Lib_BVMCodec.ChainBatchHeader memory _batchHeader)\\n internal\\n pure\\n returns (bytes32)\\n {\\n return\\n keccak256(\\n abi.encode(\\n _batchHeader.batchRoot,\\n _batchHeader.batchSize,\\n _batchHeader.prevTotalElements,\\n _batchHeader.signature,\\n _batchHeader.extraData\\n )\\n );\\n }\\n}\\n\",\"keccak256\":\"0xc74431c3b4f435e5581dc786892a5cb1674b717a03eaa4a79a4987ee19700f99\",\"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/libraries/resolver/Lib_AddressResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* Library Imports */\\nimport { Lib_AddressManager } from \\\"./Lib_AddressManager.sol\\\";\\n\\n/**\\n * @title Lib_AddressResolver\\n */\\nabstract contract Lib_AddressResolver {\\n /*************\\n * Variables *\\n *************/\\n\\n Lib_AddressManager public libAddressManager;\\n\\n /***************\\n * Constructor *\\n ***************/\\n\\n /**\\n * @param _libAddressManager Address of the Lib_AddressManager.\\n */\\n constructor(address _libAddressManager) {\\n libAddressManager = Lib_AddressManager(_libAddressManager);\\n }\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Resolves the address associated with a given name.\\n * @param _name Name to resolve an address for.\\n * @return Address associated with the given name.\\n */\\n function resolve(string memory _name) public view returns (address) {\\n return libAddressManager.getAddress(_name);\\n }\\n}\\n\",\"keccak256\":\"0x515c4db671a28e2fe180201f6d11c0208c05f582ca3489fb6b8e81c27659bc62\",\"license\":\"MIT\"},\"contracts/libraries/rlp/Lib_RLPReader.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Lib_RLPReader\\n * @dev Adapted from \\\"RLPReader\\\" by Hamdi Allam (hamdi.allam97@gmail.com).\\n */\\nlibrary Lib_RLPReader {\\n /*************\\n * Constants *\\n *************/\\n\\n uint256 internal constant MAX_LIST_LENGTH = 32;\\n\\n /*********\\n * Enums *\\n *********/\\n\\n enum RLPItemType {\\n DATA_ITEM,\\n LIST_ITEM\\n }\\n\\n /***********\\n * Structs *\\n ***********/\\n\\n struct RLPItem {\\n uint256 length;\\n uint256 ptr;\\n }\\n\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Converts bytes to a reference to memory position and length.\\n * @param _in Input bytes to convert.\\n * @return Output memory reference.\\n */\\n function toRLPItem(bytes memory _in) internal pure returns (RLPItem memory) {\\n uint256 ptr;\\n assembly {\\n ptr := add(_in, 32)\\n }\\n\\n return RLPItem({ length: _in.length, ptr: ptr });\\n }\\n\\n /**\\n * Reads an RLP list value into a list of RLP items.\\n * @param _in RLP list value.\\n * @return Decoded RLP list items.\\n */\\n function readList(RLPItem memory _in) internal pure returns (RLPItem[] memory) {\\n (uint256 listOffset, , RLPItemType itemType) = _decodeLength(_in);\\n\\n require(itemType == RLPItemType.LIST_ITEM, \\\"Invalid RLP list value.\\\");\\n\\n // Solidity in-memory arrays can't be increased in size, but *can* be decreased in size by\\n // writing to the length. Since we can't know the number of RLP items without looping over\\n // the entire input, we'd have to loop twice to accurately size this array. It's easier to\\n // simply set a reasonable maximum list length and decrease the size before we finish.\\n RLPItem[] memory out = new RLPItem[](MAX_LIST_LENGTH);\\n\\n uint256 itemCount = 0;\\n uint256 offset = listOffset;\\n while (offset < _in.length) {\\n require(itemCount < MAX_LIST_LENGTH, \\\"Provided RLP list exceeds max list length.\\\");\\n\\n (uint256 itemOffset, uint256 itemLength, ) = _decodeLength(\\n RLPItem({ length: _in.length - offset, ptr: _in.ptr + offset })\\n );\\n\\n out[itemCount] = RLPItem({ length: itemLength + itemOffset, ptr: _in.ptr + offset });\\n\\n itemCount += 1;\\n offset += itemOffset + itemLength;\\n }\\n\\n // Decrease the array size to match the actual item count.\\n assembly {\\n mstore(out, itemCount)\\n }\\n\\n return out;\\n }\\n\\n /**\\n * Reads an RLP list value into a list of RLP items.\\n * @param _in RLP list value.\\n * @return Decoded RLP list items.\\n */\\n function readList(bytes memory _in) internal pure returns (RLPItem[] memory) {\\n return readList(toRLPItem(_in));\\n }\\n\\n /**\\n * Reads an RLP bytes value into bytes.\\n * @param _in RLP bytes value.\\n * @return Decoded bytes.\\n */\\n function readBytes(RLPItem memory _in) internal pure returns (bytes memory) {\\n (uint256 itemOffset, uint256 itemLength, RLPItemType itemType) = _decodeLength(_in);\\n\\n require(itemType == RLPItemType.DATA_ITEM, \\\"Invalid RLP bytes value.\\\");\\n\\n return _copy(_in.ptr, itemOffset, itemLength);\\n }\\n\\n /**\\n * Reads an RLP bytes value into bytes.\\n * @param _in RLP bytes value.\\n * @return Decoded bytes.\\n */\\n function readBytes(bytes memory _in) internal pure returns (bytes memory) {\\n return readBytes(toRLPItem(_in));\\n }\\n\\n /**\\n * Reads an RLP string value into a string.\\n * @param _in RLP string value.\\n * @return Decoded string.\\n */\\n function readString(RLPItem memory _in) internal pure returns (string memory) {\\n return string(readBytes(_in));\\n }\\n\\n /**\\n * Reads an RLP string value into a string.\\n * @param _in RLP string value.\\n * @return Decoded string.\\n */\\n function readString(bytes memory _in) internal pure returns (string memory) {\\n return readString(toRLPItem(_in));\\n }\\n\\n /**\\n * Reads an RLP bytes32 value into a bytes32.\\n * @param _in RLP bytes32 value.\\n * @return Decoded bytes32.\\n */\\n function readBytes32(RLPItem memory _in) internal pure returns (bytes32) {\\n require(_in.length <= 33, \\\"Invalid RLP bytes32 value.\\\");\\n\\n (uint256 itemOffset, uint256 itemLength, RLPItemType itemType) = _decodeLength(_in);\\n\\n require(itemType == RLPItemType.DATA_ITEM, \\\"Invalid RLP bytes32 value.\\\");\\n\\n uint256 ptr = _in.ptr + itemOffset;\\n bytes32 out;\\n assembly {\\n out := mload(ptr)\\n\\n // Shift the bytes over to match the item size.\\n if lt(itemLength, 32) {\\n out := div(out, exp(256, sub(32, itemLength)))\\n }\\n }\\n\\n return out;\\n }\\n\\n /**\\n * Reads an RLP bytes32 value into a bytes32.\\n * @param _in RLP bytes32 value.\\n * @return Decoded bytes32.\\n */\\n function readBytes32(bytes memory _in) internal pure returns (bytes32) {\\n return readBytes32(toRLPItem(_in));\\n }\\n\\n /**\\n * Reads an RLP uint256 value into a uint256.\\n * @param _in RLP uint256 value.\\n * @return Decoded uint256.\\n */\\n function readUint256(RLPItem memory _in) internal pure returns (uint256) {\\n return uint256(readBytes32(_in));\\n }\\n\\n /**\\n * Reads an RLP uint256 value into a uint256.\\n * @param _in RLP uint256 value.\\n * @return Decoded uint256.\\n */\\n function readUint256(bytes memory _in) internal pure returns (uint256) {\\n return readUint256(toRLPItem(_in));\\n }\\n\\n /**\\n * Reads an RLP bool value into a bool.\\n * @param _in RLP bool value.\\n * @return Decoded bool.\\n */\\n function readBool(RLPItem memory _in) internal pure returns (bool) {\\n require(_in.length == 1, \\\"Invalid RLP boolean value.\\\");\\n\\n uint256 ptr = _in.ptr;\\n uint256 out;\\n assembly {\\n out := byte(0, mload(ptr))\\n }\\n\\n require(out == 0 || out == 1, \\\"Lib_RLPReader: Invalid RLP boolean value, must be 0 or 1\\\");\\n\\n return out != 0;\\n }\\n\\n /**\\n * Reads an RLP bool value into a bool.\\n * @param _in RLP bool value.\\n * @return Decoded bool.\\n */\\n function readBool(bytes memory _in) internal pure returns (bool) {\\n return readBool(toRLPItem(_in));\\n }\\n\\n /**\\n * Reads an RLP address value into a address.\\n * @param _in RLP address value.\\n * @return Decoded address.\\n */\\n function readAddress(RLPItem memory _in) internal pure returns (address) {\\n if (_in.length == 1) {\\n return address(0);\\n }\\n\\n require(_in.length == 21, \\\"Invalid RLP address value.\\\");\\n\\n return address(uint160(readUint256(_in)));\\n }\\n\\n /**\\n * Reads an RLP address value into a address.\\n * @param _in RLP address value.\\n * @return Decoded address.\\n */\\n function readAddress(bytes memory _in) internal pure returns (address) {\\n return readAddress(toRLPItem(_in));\\n }\\n\\n /**\\n * Reads the raw bytes of an RLP item.\\n * @param _in RLP item to read.\\n * @return Raw RLP bytes.\\n */\\n function readRawBytes(RLPItem memory _in) internal pure returns (bytes memory) {\\n return _copy(_in);\\n }\\n\\n /*********************\\n * Private Functions *\\n *********************/\\n\\n /**\\n * Decodes the length of an RLP item.\\n * @param _in RLP item to decode.\\n * @return Offset of the encoded data.\\n * @return Length of the encoded data.\\n * @return RLP item type (LIST_ITEM or DATA_ITEM).\\n */\\n function _decodeLength(RLPItem memory _in)\\n private\\n pure\\n returns (\\n uint256,\\n uint256,\\n RLPItemType\\n )\\n {\\n require(_in.length > 0, \\\"RLP item cannot be null.\\\");\\n\\n uint256 ptr = _in.ptr;\\n uint256 prefix;\\n assembly {\\n prefix := byte(0, mload(ptr))\\n }\\n\\n if (prefix <= 0x7f) {\\n // Single byte.\\n\\n return (0, 1, RLPItemType.DATA_ITEM);\\n } else if (prefix <= 0xb7) {\\n // Short string.\\n\\n // slither-disable-next-line variable-scope\\n uint256 strLen = prefix - 0x80;\\n\\n require(_in.length > strLen, \\\"Invalid RLP short string.\\\");\\n\\n return (1, strLen, RLPItemType.DATA_ITEM);\\n } else if (prefix <= 0xbf) {\\n // Long string.\\n uint256 lenOfStrLen = prefix - 0xb7;\\n\\n require(_in.length > lenOfStrLen, \\\"Invalid RLP long string length.\\\");\\n\\n uint256 strLen;\\n assembly {\\n // Pick out the string length.\\n strLen := div(mload(add(ptr, 1)), exp(256, sub(32, lenOfStrLen)))\\n }\\n\\n require(_in.length > lenOfStrLen + strLen, \\\"Invalid RLP long string.\\\");\\n\\n return (1 + lenOfStrLen, strLen, RLPItemType.DATA_ITEM);\\n } else if (prefix <= 0xf7) {\\n // Short list.\\n // slither-disable-next-line variable-scope\\n uint256 listLen = prefix - 0xc0;\\n\\n require(_in.length > listLen, \\\"Invalid RLP short list.\\\");\\n\\n return (1, listLen, RLPItemType.LIST_ITEM);\\n } else {\\n // Long list.\\n uint256 lenOfListLen = prefix - 0xf7;\\n\\n require(_in.length > lenOfListLen, \\\"Invalid RLP long list length.\\\");\\n\\n uint256 listLen;\\n assembly {\\n // Pick out the list length.\\n listLen := div(mload(add(ptr, 1)), exp(256, sub(32, lenOfListLen)))\\n }\\n\\n require(_in.length > lenOfListLen + listLen, \\\"Invalid RLP long list.\\\");\\n\\n return (1 + lenOfListLen, listLen, RLPItemType.LIST_ITEM);\\n }\\n }\\n\\n /**\\n * Copies the bytes from a memory location.\\n * @param _src Pointer to the location to read from.\\n * @param _offset Offset to start reading from.\\n * @param _length Number of bytes to read.\\n * @return Copied bytes.\\n */\\n function _copy(\\n uint256 _src,\\n uint256 _offset,\\n uint256 _length\\n ) private pure returns (bytes memory) {\\n bytes memory out = new bytes(_length);\\n if (out.length == 0) {\\n return out;\\n }\\n\\n uint256 src = _src + _offset;\\n uint256 dest;\\n assembly {\\n dest := add(out, 32)\\n }\\n\\n // Copy over as many complete words as we can.\\n for (uint256 i = 0; i < _length / 32; i++) {\\n assembly {\\n mstore(dest, mload(src))\\n }\\n\\n src += 32;\\n dest += 32;\\n }\\n\\n // Pick out the remaining bytes.\\n uint256 mask;\\n unchecked {\\n mask = 256**(32 - (_length % 32)) - 1;\\n }\\n\\n assembly {\\n mstore(dest, or(and(mload(src), not(mask)), and(mload(dest), mask)))\\n }\\n return out;\\n }\\n\\n /**\\n * Copies an RLP item into bytes.\\n * @param _in RLP item to copy.\\n * @return Copied bytes.\\n */\\n function _copy(RLPItem memory _in) private pure returns (bytes memory) {\\n return _copy(_in.ptr, 0, _in.length);\\n }\\n}\\n\",\"keccak256\":\"0xd794d1b32c6e31d40e2526b5e519de1b4e8d14d6933889f9b916e69c5d1848c6\",\"license\":\"MIT\"},\"contracts/libraries/rlp/Lib_RLPWriter.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Lib_RLPWriter\\n * @author Bakaoh (with modifications)\\n */\\nlibrary Lib_RLPWriter {\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * RLP encodes a byte string.\\n * @param _in The byte string to encode.\\n * @return The RLP encoded string in bytes.\\n */\\n function writeBytes(bytes memory _in) internal pure returns (bytes memory) {\\n bytes memory encoded;\\n\\n if (_in.length == 1 && uint8(_in[0]) < 128) {\\n encoded = _in;\\n } else {\\n encoded = abi.encodePacked(_writeLength(_in.length, 128), _in);\\n }\\n\\n return encoded;\\n }\\n\\n /**\\n * RLP encodes a list of RLP encoded byte byte strings.\\n * @param _in The list of RLP encoded byte strings.\\n * @return The RLP encoded list of items in bytes.\\n */\\n function writeList(bytes[] memory _in) internal pure returns (bytes memory) {\\n bytes memory list = _flatten(_in);\\n return abi.encodePacked(_writeLength(list.length, 192), list);\\n }\\n\\n /**\\n * RLP encodes a string.\\n * @param _in The string to encode.\\n * @return The RLP encoded string in bytes.\\n */\\n function writeString(string memory _in) internal pure returns (bytes memory) {\\n return writeBytes(bytes(_in));\\n }\\n\\n /**\\n * RLP encodes an address.\\n * @param _in The address to encode.\\n * @return The RLP encoded address in bytes.\\n */\\n function writeAddress(address _in) internal pure returns (bytes memory) {\\n return writeBytes(abi.encodePacked(_in));\\n }\\n\\n /**\\n * RLP encodes a uint.\\n * @param _in The uint256 to encode.\\n * @return The RLP encoded uint256 in bytes.\\n */\\n function writeUint(uint256 _in) internal pure returns (bytes memory) {\\n return writeBytes(_toBinary(_in));\\n }\\n\\n /**\\n * RLP encodes a bool.\\n * @param _in The bool to encode.\\n * @return The RLP encoded bool in bytes.\\n */\\n function writeBool(bool _in) internal pure returns (bytes memory) {\\n bytes memory encoded = new bytes(1);\\n encoded[0] = (_in ? bytes1(0x01) : bytes1(0x80));\\n return encoded;\\n }\\n\\n /*********************\\n * Private Functions *\\n *********************/\\n\\n /**\\n * Encode the first byte, followed by the `len` in binary form if `length` is more than 55.\\n * @param _len The length of the string or the payload.\\n * @param _offset 128 if item is string, 192 if item is list.\\n * @return RLP encoded bytes.\\n */\\n function _writeLength(uint256 _len, uint256 _offset) private pure returns (bytes memory) {\\n bytes memory encoded;\\n\\n if (_len < 56) {\\n encoded = new bytes(1);\\n encoded[0] = bytes1(uint8(_len) + uint8(_offset));\\n } else {\\n uint256 lenLen;\\n uint256 i = 1;\\n while (_len / i != 0) {\\n lenLen++;\\n i *= 256;\\n }\\n\\n encoded = new bytes(lenLen + 1);\\n encoded[0] = bytes1(uint8(lenLen) + uint8(_offset) + 55);\\n for (i = 1; i <= lenLen; i++) {\\n encoded[i] = bytes1(uint8((_len / (256**(lenLen - i))) % 256));\\n }\\n }\\n\\n return encoded;\\n }\\n\\n /**\\n * Encode integer in big endian binary form with no leading zeroes.\\n * @notice TODO: This should be optimized with assembly to save gas costs.\\n * @param _x The integer to encode.\\n * @return RLP encoded bytes.\\n */\\n function _toBinary(uint256 _x) private pure returns (bytes memory) {\\n bytes memory b = abi.encodePacked(_x);\\n\\n uint256 i = 0;\\n for (; i < 32; i++) {\\n if (b[i] != 0) {\\n break;\\n }\\n }\\n\\n bytes memory res = new bytes(32 - i);\\n for (uint256 j = 0; j < res.length; j++) {\\n res[j] = b[i++];\\n }\\n\\n return res;\\n }\\n\\n /**\\n * Copies a piece of memory to another location.\\n * @notice From: https://github.com/Arachnid/solidity-stringutils/blob/master/src/strings.sol.\\n * @param _dest Destination location.\\n * @param _src Source location.\\n * @param _len Length of memory to copy.\\n */\\n function _memcpy(\\n uint256 _dest,\\n uint256 _src,\\n uint256 _len\\n ) private pure {\\n uint256 dest = _dest;\\n uint256 src = _src;\\n uint256 len = _len;\\n\\n for (; len >= 32; len -= 32) {\\n assembly {\\n mstore(dest, mload(src))\\n }\\n dest += 32;\\n src += 32;\\n }\\n\\n uint256 mask;\\n unchecked {\\n mask = 256**(32 - len) - 1;\\n }\\n assembly {\\n let srcpart := and(mload(src), not(mask))\\n let destpart := and(mload(dest), mask)\\n mstore(dest, or(destpart, srcpart))\\n }\\n }\\n\\n /**\\n * Flattens a list of byte strings into one byte string.\\n * @notice From: https://github.com/sammayo/solidity-rlp-encoder/blob/master/RLPEncode.sol.\\n * @param _list List of byte strings to flatten.\\n * @return The flattened byte string.\\n */\\n function _flatten(bytes[] memory _list) private pure returns (bytes memory) {\\n if (_list.length == 0) {\\n return new bytes(0);\\n }\\n\\n uint256 len;\\n uint256 i = 0;\\n for (; i < _list.length; i++) {\\n len += _list[i].length;\\n }\\n\\n bytes memory flattened = new bytes(len);\\n uint256 flattenedPtr;\\n assembly {\\n flattenedPtr := add(flattened, 0x20)\\n }\\n\\n for (i = 0; i < _list.length; i++) {\\n bytes memory item = _list[i];\\n\\n uint256 listPtr;\\n assembly {\\n listPtr := add(item, 0x20)\\n }\\n\\n _memcpy(flattenedPtr, listPtr, item.length);\\n flattenedPtr += _list[i].length;\\n }\\n\\n return flattened;\\n }\\n}\\n\",\"keccak256\":\"0x215b90672ce126effc3f2df61ca0cdf52d2b1cc9be602877e637829b0bf229fd\",\"license\":\"MIT\"},\"contracts/libraries/utils/Lib_Bytes32Utils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Lib_Byte32Utils\\n */\\nlibrary Lib_Bytes32Utils {\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Converts a bytes32 value to a boolean. Anything non-zero will be converted to \\\"true.\\\"\\n * @param _in Input bytes32 value.\\n * @return Bytes32 as a boolean.\\n */\\n function toBool(bytes32 _in) internal pure returns (bool) {\\n return _in != 0;\\n }\\n\\n /**\\n * Converts a boolean to a bytes32 value.\\n * @param _in Input boolean value.\\n * @return Boolean as a bytes32.\\n */\\n function fromBool(bool _in) internal pure returns (bytes32) {\\n return bytes32(uint256(_in ? 1 : 0));\\n }\\n\\n /**\\n * Converts a bytes32 value to an address. Takes the *last* 20 bytes.\\n * @param _in Input bytes32 value.\\n * @return Bytes32 as an address.\\n */\\n function toAddress(bytes32 _in) internal pure returns (address) {\\n return address(uint160(uint256(_in)));\\n }\\n\\n /**\\n * Converts an address to a bytes32.\\n * @param _in Input address value.\\n * @return Address as a bytes32.\\n */\\n function fromAddress(address _in) internal pure returns (bytes32) {\\n return bytes32(uint256(uint160(_in)));\\n }\\n}\\n\",\"keccak256\":\"0xf2d1a526f2529e51fc2fffccf093c1691e291cbbb6de8a3da7d7f80024a9a234\",\"license\":\"MIT\"},\"contracts/libraries/utils/Lib_BytesUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Lib_BytesUtils\\n */\\nlibrary Lib_BytesUtils {\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n function slice(\\n bytes memory _bytes,\\n uint256 _start,\\n uint256 _length\\n ) internal pure returns (bytes memory) {\\n require(_length + 31 >= _length, \\\"slice_overflow\\\");\\n require(_start + _length >= _start, \\\"slice_overflow\\\");\\n require(_bytes.length >= _start + _length, \\\"slice_outOfBounds\\\");\\n\\n bytes memory tempBytes;\\n\\n assembly {\\n switch iszero(_length)\\n case 0 {\\n // Get a location of some free memory and store it in tempBytes as\\n // Solidity does for memory variables.\\n tempBytes := mload(0x40)\\n\\n // The first word of the slice result is potentially a partial\\n // word read from the original array. To read it, we calculate\\n // the length of that partial word and start copying that many\\n // bytes into the array. The first word we copy will start with\\n // data we don't care about, but the last `lengthmod` bytes will\\n // land at the beginning of the contents of the new array. When\\n // we're done copying, we overwrite the full first word with\\n // the actual length of the slice.\\n let lengthmod := and(_length, 31)\\n\\n // The multiplication in the next line is necessary\\n // because when slicing multiples of 32 bytes (lengthmod == 0)\\n // the following copy loop was copying the origin's length\\n // and then ending prematurely not copying everything it should.\\n let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))\\n let end := add(mc, _length)\\n\\n for {\\n // The multiplication in the next line has the same exact purpose\\n // as the one above.\\n let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)\\n } lt(mc, end) {\\n mc := add(mc, 0x20)\\n cc := add(cc, 0x20)\\n } {\\n mstore(mc, mload(cc))\\n }\\n\\n mstore(tempBytes, _length)\\n\\n //update free-memory pointer\\n //allocating the array padded to 32 bytes like the compiler does now\\n mstore(0x40, and(add(mc, 31), not(31)))\\n }\\n //if we want a zero-length slice let's just return a zero-length array\\n default {\\n tempBytes := mload(0x40)\\n\\n //zero out the 32 bytes slice we are about to return\\n //we need to do it because Solidity does not garbage collect\\n mstore(tempBytes, 0)\\n\\n mstore(0x40, add(tempBytes, 0x20))\\n }\\n }\\n\\n return tempBytes;\\n }\\n\\n function slice(bytes memory _bytes, uint256 _start) internal pure returns (bytes memory) {\\n if (_start >= _bytes.length) {\\n return bytes(\\\"\\\");\\n }\\n\\n return slice(_bytes, _start, _bytes.length - _start);\\n }\\n\\n function toBytes32(bytes memory _bytes) internal pure returns (bytes32) {\\n if (_bytes.length < 32) {\\n bytes32 ret;\\n assembly {\\n ret := mload(add(_bytes, 32))\\n }\\n return ret;\\n }\\n\\n return abi.decode(_bytes, (bytes32)); // will truncate if input length > 32 bytes\\n }\\n\\n function toUint256(bytes memory _bytes) internal pure returns (uint256) {\\n return uint256(toBytes32(_bytes));\\n }\\n\\n function toNibbles(bytes memory _bytes) internal pure returns (bytes memory) {\\n bytes memory nibbles = new bytes(_bytes.length * 2);\\n\\n for (uint256 i = 0; i < _bytes.length; i++) {\\n nibbles[i * 2] = _bytes[i] >> 4;\\n nibbles[i * 2 + 1] = bytes1(uint8(_bytes[i]) % 16);\\n }\\n\\n return nibbles;\\n }\\n\\n function fromNibbles(bytes memory _bytes) internal pure returns (bytes memory) {\\n bytes memory ret = new bytes(_bytes.length / 2);\\n\\n for (uint256 i = 0; i < ret.length; i++) {\\n ret[i] = (_bytes[i * 2] << 4) | (_bytes[i * 2 + 1]);\\n }\\n\\n return ret;\\n }\\n\\n function equal(bytes memory _bytes, bytes memory _other) internal pure returns (bool) {\\n return keccak256(_bytes) == keccak256(_other);\\n }\\n}\\n\",\"keccak256\":\"0xc39ee13f97e4ccfbc72a5aac571deb3c1aff882fca2dd18be794d43ac5de0a30\",\"license\":\"MIT\"},\"contracts/libraries/utils/Lib_MerkleTree.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Lib_MerkleTree\\n * @author River Keefer\\n */\\nlibrary Lib_MerkleTree {\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Calculates a merkle root for a list of 32-byte leaf hashes. WARNING: If the number\\n * of leaves passed in is not a power of two, it pads out the tree with zero hashes.\\n * If you do not know the original length of elements for the tree you are verifying, then\\n * this may allow empty leaves past _elements.length to pass a verification check down the line.\\n * Note that the _elements argument is modified, therefore it must not be used again afterwards\\n * @param _elements Array of hashes from which to generate a merkle root.\\n * @return Merkle root of the leaves, with zero hashes for non-powers-of-two (see above).\\n */\\n function getMerkleRoot(bytes32[] memory _elements) internal pure returns (bytes32) {\\n require(_elements.length > 0, \\\"Lib_MerkleTree: Must provide at least one leaf hash.\\\");\\n\\n if (_elements.length == 1) {\\n return _elements[0];\\n }\\n\\n uint256[16] memory defaults = [\\n 0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563,\\n 0x633dc4d7da7256660a892f8f1604a44b5432649cc8ec5cb3ced4c4e6ac94dd1d,\\n 0x890740a8eb06ce9be422cb8da5cdafc2b58c0a5e24036c578de2a433c828ff7d,\\n 0x3b8ec09e026fdc305365dfc94e189a81b38c7597b3d941c279f042e8206e0bd8,\\n 0xecd50eee38e386bd62be9bedb990706951b65fe053bd9d8a521af753d139e2da,\\n 0xdefff6d330bb5403f63b14f33b578274160de3a50df4efecf0e0db73bcdd3da5,\\n 0x617bdd11f7c0a11f49db22f629387a12da7596f9d1704d7465177c63d88ec7d7,\\n 0x292c23a9aa1d8bea7e2435e555a4a60e379a5a35f3f452bae60121073fb6eead,\\n 0xe1cea92ed99acdcb045a6726b2f87107e8a61620a232cf4d7d5b5766b3952e10,\\n 0x7ad66c0a68c72cb89e4fb4303841966e4062a76ab97451e3b9fb526a5ceb7f82,\\n 0xe026cc5a4aed3c22a58cbd3d2ac754c9352c5436f638042dca99034e83636516,\\n 0x3d04cffd8b46a874edf5cfae63077de85f849a660426697b06a829c70dd1409c,\\n 0xad676aa337a485e4728a0b240d92b3ef7b3c372d06d189322bfd5f61f1e7203e,\\n 0xa2fca4a49658f9fab7aa63289c91b7c7b6c832a6d0e69334ff5b0a3483d09dab,\\n 0x4ebfd9cd7bca2505f7bef59cc1c12ecc708fff26ae4af19abe852afe9e20c862,\\n 0x2def10d13dd169f550f578bda343d9717a138562e0093b380a1120789d53cf10\\n ];\\n\\n // Reserve memory space for our hashes.\\n bytes memory buf = new bytes(64);\\n\\n // We'll need to keep track of left and right siblings.\\n bytes32 leftSibling;\\n bytes32 rightSibling;\\n\\n // Number of non-empty nodes at the current depth.\\n uint256 rowSize = _elements.length;\\n\\n // Current depth, counting from 0 at the leaves\\n uint256 depth = 0;\\n\\n // Common sub-expressions\\n uint256 halfRowSize; // rowSize / 2\\n bool rowSizeIsOdd; // rowSize % 2 == 1\\n\\n while (rowSize > 1) {\\n halfRowSize = rowSize / 2;\\n rowSizeIsOdd = rowSize % 2 == 1;\\n\\n for (uint256 i = 0; i < halfRowSize; i++) {\\n leftSibling = _elements[(2 * i)];\\n rightSibling = _elements[(2 * i) + 1];\\n assembly {\\n mstore(add(buf, 32), leftSibling)\\n mstore(add(buf, 64), rightSibling)\\n }\\n\\n _elements[i] = keccak256(buf);\\n }\\n\\n if (rowSizeIsOdd) {\\n leftSibling = _elements[rowSize - 1];\\n rightSibling = bytes32(defaults[depth]);\\n assembly {\\n mstore(add(buf, 32), leftSibling)\\n mstore(add(buf, 64), rightSibling)\\n }\\n\\n _elements[halfRowSize] = keccak256(buf);\\n }\\n\\n rowSize = halfRowSize + (rowSizeIsOdd ? 1 : 0);\\n depth++;\\n }\\n\\n return _elements[0];\\n }\\n\\n /**\\n * Verifies a merkle branch for the given leaf hash. Assumes the original length\\n * of leaves generated is a known, correct input, and does not return true for indices\\n * extending past that index (even if _siblings would be otherwise valid.)\\n * @param _root The Merkle root to verify against.\\n * @param _leaf The leaf hash to verify inclusion of.\\n * @param _index The index in the tree of this leaf.\\n * @param _siblings Array of sibline nodes in the inclusion proof, starting from depth 0\\n * (bottom of the tree).\\n * @param _totalLeaves The total number of leaves originally passed into.\\n * @return Whether or not the merkle branch and leaf passes verification.\\n */\\n function verify(\\n bytes32 _root,\\n bytes32 _leaf,\\n uint256 _index,\\n bytes32[] memory _siblings,\\n uint256 _totalLeaves\\n ) internal pure returns (bool) {\\n require(_totalLeaves > 0, \\\"Lib_MerkleTree: Total leaves must be greater than zero.\\\");\\n\\n require(_index < _totalLeaves, \\\"Lib_MerkleTree: Index out of bounds.\\\");\\n\\n require(\\n _siblings.length == _ceilLog2(_totalLeaves),\\n \\\"Lib_MerkleTree: Total siblings does not correctly correspond to total leaves.\\\"\\n );\\n\\n bytes32 computedRoot = _leaf;\\n\\n for (uint256 i = 0; i < _siblings.length; i++) {\\n if ((_index & 1) == 1) {\\n computedRoot = keccak256(abi.encodePacked(_siblings[i], computedRoot));\\n } else {\\n computedRoot = keccak256(abi.encodePacked(computedRoot, _siblings[i]));\\n }\\n\\n _index >>= 1;\\n }\\n\\n return _root == computedRoot;\\n }\\n\\n /*********************\\n * Private Functions *\\n *********************/\\n\\n /**\\n * Calculates the integer ceiling of the log base 2 of an input.\\n * @param _in Unsigned input to calculate the log.\\n * @return ceil(log_base_2(_in))\\n */\\n function _ceilLog2(uint256 _in) private pure returns (uint256) {\\n require(_in > 0, \\\"Lib_MerkleTree: Cannot compute ceil(log_2) of 0.\\\");\\n\\n if (_in == 1) {\\n return 0;\\n }\\n\\n // Find the highest set bit (will be floor(log_2)).\\n // Borrowed with <3 from https://github.com/ethereum/solidity-examples\\n uint256 val = _in;\\n uint256 highest = 0;\\n for (uint256 i = 128; i >= 1; i >>= 1) {\\n if (val & (((uint256(1) << i) - 1) << i) != 0) {\\n highest += i;\\n val >>= i;\\n }\\n }\\n\\n // Increment by one if this is not a perfect logarithm.\\n if ((uint256(1) << highest) != _in) {\\n highest += 1;\\n }\\n\\n return highest;\\n }\\n}\\n\",\"keccak256\":\"0x84351e7b8be5007b77a67c1e3f34f46ed0c1ddc67e4e76797fd06f01ca9325aa\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "details": "The State Commitment Chain (SCC) contract contains a list of proposed state roots which Proposers assert to be a result of each transaction in the Canonical Transaction Chain (CTC). Elements here have a 1:1 correspondence with transactions in the CTC, and should be the unique state root calculated off-chain by applying the canonical transactions one by one.", "kind": "dev", "methods": { "appendStateBatch(bytes32[],uint256,bytes)": { "params": { "_batch": "Batch of state roots.", "_shouldStartAtElement": "Index of the element at which this batch should start.", "_signature": "tss group signature of state batches." } }, "batches()": { "returns": { "_0": "Reference to the batch storage container." } }, "constructor": { "params": { "_libAddressManager": "Address of the Address Manager." } }, "deleteStateBatch((uint256,bytes32,uint256,uint256,bytes,bytes))": { "params": { "_batchHeader": "Header of the batch to start deleting from." } }, "getLastSequencerTimestamp()": { "returns": { "_lastSequencerTimestamp": "Last sequencer batch timestamp." } }, "getTotalBatches()": { "returns": { "_totalBatches": "Total submitted batches." } }, "getTotalElements()": { "returns": { "_totalElements": "Total submitted elements." } }, "insideFraudProofWindow((uint256,bytes32,uint256,uint256,bytes,bytes))": { "params": { "_batchHeader": "Header of the batch to check." }, "returns": { "_inside": "Whether or not the batch is inside the fraud proof window." } }, "resolve(string)": { "params": { "_name": "Name to resolve an address for." }, "returns": { "_0": "Address associated with the given name." } }, "rollBackL2Chain(uint256,uint256,bytes)": { "params": { "_shouldRollBack": "roll back to should start .", "_shouldStartAtElement": "Index of the element at which this batch should start", "_signature": "signature of rollback message" } }, "verifyStateCommitment(bytes32,(uint256,bytes32,uint256,uint256,bytes,bytes),(uint256,bytes32[]))": { "params": { "_batchHeader": "Header of the batch in which the element was included.", "_element": "Hash of the element to verify a proof for.", "_proof": "Merkle inclusion proof for the element." } } }, "title": "StateCommitmentChain", "version": 1 }, "userdoc": { "kind": "user", "methods": { "appendStateBatch(bytes32[],uint256,bytes)": { "notice": "Appends a batch of state roots to the chain." }, "batches()": { "notice": "Accesses the batch storage container." }, "deleteStateBatch((uint256,bytes32,uint256,uint256,bytes,bytes))": { "notice": "Deletes all state roots after (and including) a given batch." }, "getLastSequencerTimestamp()": { "notice": "Retrieves the timestamp of the last batch submitted by the sequencer." }, "getTotalBatches()": { "notice": "Retrieves the total number of batches submitted." }, "getTotalElements()": { "notice": "Retrieves the total number of elements submitted." }, "insideFraudProofWindow((uint256,bytes32,uint256,uint256,bytes,bytes))": { "notice": "Checks whether a given batch is still inside its fraud proof window." }, "resolve(string)": { "notice": "Resolves the address associated with a given name." }, "rollBackL2Chain(uint256,uint256,bytes)": { "notice": "Emit event to notify sequencers to roll back." }, "verifyStateCommitment(bytes32,(uint256,bytes32,uint256,uint256,bytes,bytes),(uint256,bytes32[]))": { "notice": "Verifies a batch inclusion proof." } }, "version": 1 }, "storageLayout": { "storage": [ { "astId": 52622, "contract": "contracts/L1/rollup/StateCommitmentChain.sol:StateCommitmentChain", "label": "libAddressManager", "offset": 0, "slot": "0", "type": "t_contract(Lib_AddressManager)52614" }, { "astId": 48549, "contract": "contracts/L1/rollup/StateCommitmentChain.sol:StateCommitmentChain", "label": "messenger", "offset": 0, "slot": "1", "type": "t_address" }, { "astId": 39761, "contract": "contracts/L1/rollup/StateCommitmentChain.sol:StateCommitmentChain", "label": "FRAUD_PROOF_WINDOW", "offset": 0, "slot": "2", "type": "t_uint256" }, { "astId": 39763, "contract": "contracts/L1/rollup/StateCommitmentChain.sol:StateCommitmentChain", "label": "SEQUENCER_PUBLISH_WINDOW", "offset": 0, "slot": "3", "type": "t_uint256" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_contract(Lib_AddressManager)52614": { "encoding": "inplace", "label": "contract Lib_AddressManager", "numberOfBytes": "20" }, "t_uint256": { "encoding": "inplace", "label": "uint256", "numberOfBytes": "32" } } } }