Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x9a5eA044...4892C004A The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
ScrollChain
Compiler Version
v0.8.16+commit.07a7930e
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity =0.8.16; import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol"; import {IL1MessageQueue} from "./IL1MessageQueue.sol"; import {IScrollChain} from "./IScrollChain.sol"; import {BatchHeaderV0Codec} from "../../libraries/codec/BatchHeaderV0Codec.sol"; import {ChunkCodec} from "../../libraries/codec/ChunkCodec.sol"; import {IRollupVerifier} from "../../libraries/verifier/IRollupVerifier.sol"; // solhint-disable no-inline-assembly // solhint-disable reason-string /// @title ScrollChain /// @notice This contract maintains data for the Scroll rollup. contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain { /********** * Events * **********/ /// @notice Emitted when owner updates the status of sequencer. /// @param account The address of account updated. /// @param status The status of the account updated. event UpdateSequencer(address indexed account, bool status); /// @notice Emitted when owner updates the status of prover. /// @param account The address of account updated. /// @param status The status of the account updated. event UpdateProver(address indexed account, bool status); /// @notice Emitted when the address of rollup verifier is updated. /// @param oldVerifier The address of old rollup verifier. /// @param newVerifier The address of new rollup verifier. event UpdateVerifier(address indexed oldVerifier, address indexed newVerifier); /// @notice Emitted when the value of `maxNumTxInChunk` is updated. /// @param oldMaxNumTxInChunk The old value of `maxNumTxInChunk`. /// @param newMaxNumTxInChunk The new value of `maxNumTxInChunk`. event UpdateMaxNumTxInChunk(uint256 oldMaxNumTxInChunk, uint256 newMaxNumTxInChunk); /************* * Constants * *************/ /// @notice The chain id of the corresponding layer 2 chain. uint64 public immutable layer2ChainId; /************* * Variables * *************/ /// @notice The maximum number of transactions allowed in each chunk. uint256 public maxNumTxInChunk; /// @notice The address of L1MessageQueue. address public messageQueue; /// @notice The address of RollupVerifier. address public verifier; /// @notice Whether an account is a sequencer. mapping(address => bool) public isSequencer; /// @notice Whether an account is a prover. mapping(address => bool) public isProver; /// @inheritdoc IScrollChain uint256 public override lastFinalizedBatchIndex; /// @inheritdoc IScrollChain mapping(uint256 => bytes32) public override committedBatches; /// @inheritdoc IScrollChain mapping(uint256 => bytes32) public override finalizedStateRoots; /// @inheritdoc IScrollChain mapping(uint256 => bytes32) public override withdrawRoots; /********************** * Function Modifiers * **********************/ modifier OnlySequencer() { // @note In the decentralized mode, it should be only called by a list of validator. require(isSequencer[_msgSender()], "caller not sequencer"); _; } modifier OnlyProver() { require(isProver[_msgSender()], "caller not prover"); _; } /*************** * Constructor * ***************/ constructor(uint64 _chainId) { _disableInitializers(); layer2ChainId = _chainId; } function initialize( address _messageQueue, address _verifier, uint256 _maxNumTxInChunk ) public initializer { OwnableUpgradeable.__Ownable_init(); messageQueue = _messageQueue; verifier = _verifier; maxNumTxInChunk = _maxNumTxInChunk; emit UpdateVerifier(address(0), _verifier); emit UpdateMaxNumTxInChunk(0, _maxNumTxInChunk); } /************************* * Public View Functions * *************************/ /// @inheritdoc IScrollChain function isBatchFinalized(uint256 _batchIndex) external view override returns (bool) { return _batchIndex <= lastFinalizedBatchIndex; } /***************************** * Public Mutating Functions * *****************************/ /// @notice Import layer 2 genesis block function importGenesisBatch(bytes calldata _batchHeader, bytes32 _stateRoot) external { // check genesis batch header length require(_stateRoot != bytes32(0), "zero state root"); // check whether the genesis batch is imported require(finalizedStateRoots[0] == bytes32(0), "Genesis batch imported"); (uint256 memPtr, bytes32 _batchHash) = _loadBatchHeader(_batchHeader); // check all fields except `dataHash` and `lastBlockHash` are zero unchecked { uint256 sum = BatchHeaderV0Codec.version(memPtr) + BatchHeaderV0Codec.batchIndex(memPtr) + BatchHeaderV0Codec.l1MessagePopped(memPtr) + BatchHeaderV0Codec.totalL1MessagePopped(memPtr); require(sum == 0, "not all fields are zero"); } require(BatchHeaderV0Codec.dataHash(memPtr) != bytes32(0), "zero data hash"); require(BatchHeaderV0Codec.parentBatchHash(memPtr) == bytes32(0), "nonzero parent batch hash"); committedBatches[0] = _batchHash; finalizedStateRoots[0] = _stateRoot; emit CommitBatch(0, _batchHash); emit FinalizeBatch(0, _batchHash, _stateRoot, bytes32(0)); } /// @inheritdoc IScrollChain function commitBatch( uint8 _version, bytes calldata _parentBatchHeader, bytes[] memory _chunks, bytes calldata _skippedL1MessageBitmap ) external override OnlySequencer whenNotPaused { require(_version == 0, "invalid version"); // check whether the batch is empty uint256 _chunksLength = _chunks.length; require(_chunksLength > 0, "batch is empty"); // The overall memory layout in this function is organized as follows // +---------------------+-------------------+------------------+ // | parent batch header | chunk data hashes | new batch header | // +---------------------+-------------------+------------------+ // ^ ^ ^ // batchPtr dataPtr newBatchPtr (re-use var batchPtr) // // 1. We copy the parent batch header from calldata to memory starting at batchPtr // 2. We store `_chunksLength` number of Keccak hashes starting at `dataPtr`. Each Keccak // hash corresponds to the data hash of a chunk. So we reserve the memory region from // `dataPtr` to `dataPtr + _chunkLength * 32` for the chunk data hashes. // 3. The memory starting at `newBatchPtr` is used to store the new batch header and compute // the batch hash. // the variable `batchPtr` will be reused later for the current batch (uint256 batchPtr, bytes32 _parentBatchHash) = _loadBatchHeader(_parentBatchHeader); uint256 _batchIndex = BatchHeaderV0Codec.batchIndex(batchPtr); uint256 _totalL1MessagesPoppedOverall = BatchHeaderV0Codec.totalL1MessagePopped(batchPtr); require(committedBatches[_batchIndex] == _parentBatchHash, "incorrect parent batch hash"); require(committedBatches[_batchIndex + 1] == 0, "batch already committed"); // load `dataPtr` and reserve the memory region for chunk data hashes uint256 dataPtr; assembly { dataPtr := mload(0x40) mstore(0x40, add(dataPtr, mul(_chunksLength, 32))) } // compute the data hash for each chunk uint256 _totalL1MessagesPoppedInBatch; for (uint256 i = 0; i < _chunksLength; i++) { uint256 _totalNumL1MessagesInChunk = _commitChunk( dataPtr, _chunks[i], _totalL1MessagesPoppedInBatch, _totalL1MessagesPoppedOverall, _skippedL1MessageBitmap ); unchecked { _totalL1MessagesPoppedInBatch += _totalNumL1MessagesInChunk; _totalL1MessagesPoppedOverall += _totalNumL1MessagesInChunk; dataPtr += 32; } } // check the length of bitmap unchecked { require( ((_totalL1MessagesPoppedInBatch + 255) / 256) * 32 == _skippedL1MessageBitmap.length, "wrong bitmap length" ); } // compute the data hash for current batch bytes32 _dataHash; assembly { let dataLen := mul(_chunksLength, 0x20) _dataHash := keccak256(sub(dataPtr, dataLen), dataLen) batchPtr := mload(0x40) // reset batchPtr _batchIndex := add(_batchIndex, 1) // increase batch index } // store entries, the order matters BatchHeaderV0Codec.storeVersion(batchPtr, _version); BatchHeaderV0Codec.storeBatchIndex(batchPtr, _batchIndex); BatchHeaderV0Codec.storeL1MessagePopped(batchPtr, _totalL1MessagesPoppedInBatch); BatchHeaderV0Codec.storeTotalL1MessagePopped(batchPtr, _totalL1MessagesPoppedOverall); BatchHeaderV0Codec.storeDataHash(batchPtr, _dataHash); BatchHeaderV0Codec.storeParentBatchHash(batchPtr, _parentBatchHash); BatchHeaderV0Codec.storeSkippedBitmap(batchPtr, _skippedL1MessageBitmap); // compute batch hash bytes32 _batchHash = BatchHeaderV0Codec.computeBatchHash(batchPtr, 89 + _skippedL1MessageBitmap.length); committedBatches[_batchIndex] = _batchHash; emit CommitBatch(_batchIndex, _batchHash); } /// @inheritdoc IScrollChain /// @dev If the owner want to revert a sequence of batches by sending multiple transactions, /// make sure to revert recent batches first. function revertBatch(bytes calldata _batchHeader, uint256 _count) external onlyOwner { require(_count > 0, "count must be nonzero"); (uint256 memPtr, bytes32 _batchHash) = _loadBatchHeader(_batchHeader); // check batch hash uint256 _batchIndex = BatchHeaderV0Codec.batchIndex(memPtr); require(committedBatches[_batchIndex] == _batchHash, "incorrect batch hash"); // make sure no gap is left when reverting from the ending to the beginning. require(committedBatches[_batchIndex + _count] == bytes32(0), "reverting must start from the ending"); // check finalization require(_batchIndex > lastFinalizedBatchIndex, "can only revert unfinalized batch"); while (_count > 0) { committedBatches[_batchIndex] = bytes32(0); emit RevertBatch(_batchIndex, _batchHash); unchecked { _batchIndex += 1; _count -= 1; } _batchHash = committedBatches[_batchIndex]; if (_batchHash == bytes32(0)) break; } } /// @inheritdoc IScrollChain function finalizeBatchWithProof( bytes calldata _batchHeader, bytes32 _prevStateRoot, bytes32 _postStateRoot, bytes32 _withdrawRoot, bytes calldata _aggrProof ) external override OnlyProver whenNotPaused { require(_prevStateRoot != bytes32(0), "previous state root is zero"); require(_postStateRoot != bytes32(0), "new state root is zero"); // compute batch hash and verify (uint256 memPtr, bytes32 _batchHash) = _loadBatchHeader(_batchHeader); bytes32 _dataHash = BatchHeaderV0Codec.dataHash(memPtr); uint256 _batchIndex = BatchHeaderV0Codec.batchIndex(memPtr); require(committedBatches[_batchIndex] == _batchHash, "incorrect batch hash"); // verify previous state root. require(finalizedStateRoots[_batchIndex - 1] == _prevStateRoot, "incorrect previous state root"); // avoid duplicated verification require(finalizedStateRoots[_batchIndex] == bytes32(0), "batch already verified"); // compute public input hash bytes32 _publicInputHash = keccak256( abi.encodePacked(layer2ChainId, _prevStateRoot, _postStateRoot, _withdrawRoot, _dataHash) ); // verify batch IRollupVerifier(verifier).verifyAggregateProof(_batchIndex, _aggrProof, _publicInputHash); // check and update lastFinalizedBatchIndex unchecked { require(lastFinalizedBatchIndex + 1 == _batchIndex, "incorrect batch index"); lastFinalizedBatchIndex = _batchIndex; } // record state root and withdraw root finalizedStateRoots[_batchIndex] = _postStateRoot; withdrawRoots[_batchIndex] = _withdrawRoot; // Pop finalized and non-skipped message from L1MessageQueue. uint256 _l1MessagePopped = BatchHeaderV0Codec.l1MessagePopped(memPtr); if (_l1MessagePopped > 0) { IL1MessageQueue _queue = IL1MessageQueue(messageQueue); unchecked { uint256 _startIndex = BatchHeaderV0Codec.totalL1MessagePopped(memPtr) - _l1MessagePopped; for (uint256 i = 0; i < _l1MessagePopped; i += 256) { uint256 _count = 256; if (_l1MessagePopped - i < _count) { _count = _l1MessagePopped - i; } uint256 _skippedBitmap = BatchHeaderV0Codec.skippedBitmap(memPtr, i / 256); _queue.popCrossDomainMessage(_startIndex, _count, _skippedBitmap); _startIndex += 256; } } } emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot); } /************************ * Restricted Functions * ************************/ /// @notice Add an account to the sequencer list. /// @param _account The address of account to add. function addSequencer(address _account) external onlyOwner { isSequencer[_account] = true; emit UpdateSequencer(_account, true); } /// @notice Remove an account from the sequencer list. /// @param _account The address of account to remove. function removeSequencer(address _account) external onlyOwner { isSequencer[_account] = false; emit UpdateSequencer(_account, false); } /// @notice Add an account to the prover list. /// @param _account The address of account to add. function addProver(address _account) external onlyOwner { isProver[_account] = true; emit UpdateProver(_account, true); } /// @notice Add an account from the prover list. /// @param _account The address of account to remove. function removeProver(address _account) external onlyOwner { isProver[_account] = false; emit UpdateProver(_account, false); } /// @notice Update the address verifier contract. /// @param _newVerifier The address of new verifier contract. function updateVerifier(address _newVerifier) external onlyOwner { address _oldVerifier = verifier; verifier = _newVerifier; emit UpdateVerifier(_oldVerifier, _newVerifier); } /// @notice Update the value of `maxNumTxInChunk`. /// @param _maxNumTxInChunk The new value of `maxNumTxInChunk`. function updateMaxNumTxInChunk(uint256 _maxNumTxInChunk) external onlyOwner { uint256 _oldMaxNumTxInChunk = maxNumTxInChunk; maxNumTxInChunk = _maxNumTxInChunk; emit UpdateMaxNumTxInChunk(_oldMaxNumTxInChunk, _maxNumTxInChunk); } /// @notice Pause the contract /// @param _status The pause status to update. function setPause(bool _status) external onlyOwner { if (_status) { _pause(); } else { _unpause(); } } /********************** * Internal Functions * **********************/ /// @dev Internal function to load batch header from calldata to memory. /// @param _batchHeader The batch header in calldata. /// @return memPtr The start memory offset of loaded batch header. /// @return _batchHash The hash of the loaded batch header. function _loadBatchHeader(bytes calldata _batchHeader) internal pure returns (uint256 memPtr, bytes32 _batchHash) { // load to memory uint256 _length; (memPtr, _length) = BatchHeaderV0Codec.loadAndValidate(_batchHeader); // compute batch hash _batchHash = BatchHeaderV0Codec.computeBatchHash(memPtr, _length); } /// @dev Internal function to commit a chunk. /// @param memPtr The start memory offset to store list of `dataHash`. /// @param _chunk The encoded chunk to commit. /// @param _totalL1MessagesPoppedInBatch The total number of L1 messages popped in current batch. /// @param _totalL1MessagesPoppedOverall The total number of L1 messages popped in all batches including current batch. /// @param _skippedL1MessageBitmap The bitmap indicates whether each L1 message is skipped or not. /// @return _totalNumL1MessagesInChunk The total number of L1 message popped in current chunk function _commitChunk( uint256 memPtr, bytes memory _chunk, uint256 _totalL1MessagesPoppedInBatch, uint256 _totalL1MessagesPoppedOverall, bytes calldata _skippedL1MessageBitmap ) internal view returns (uint256 _totalNumL1MessagesInChunk) { uint256 chunkPtr; uint256 startDataPtr; uint256 dataPtr; uint256 blockPtr; assembly { dataPtr := mload(0x40) startDataPtr := dataPtr chunkPtr := add(_chunk, 0x20) // skip chunkLength blockPtr := add(chunkPtr, 1) // skip numBlocks } uint256 _numBlocks = ChunkCodec.validateChunkLength(chunkPtr, _chunk.length); // concatenate block contexts, use scope to avoid stack too deep { uint256 _totalTransactionsInChunk; for (uint256 i = 0; i < _numBlocks; i++) { dataPtr = ChunkCodec.copyBlockContext(chunkPtr, dataPtr, i); uint256 _numTransactionsInBlock = ChunkCodec.numTransactions(blockPtr); unchecked { _totalTransactionsInChunk += _numTransactionsInBlock; blockPtr += ChunkCodec.BLOCK_CONTEXT_LENGTH; } } assembly { mstore(0x40, add(dataPtr, mul(_totalTransactionsInChunk, 0x20))) // reserve memory for tx hashes } } // It is used to compute the actual number of transactions in chunk. uint256 txHashStartDataPtr; assembly { txHashStartDataPtr := dataPtr blockPtr := add(chunkPtr, 1) // reset block ptr } // concatenate tx hashes uint256 l2TxPtr = ChunkCodec.l2TxPtr(chunkPtr, _numBlocks); while (_numBlocks > 0) { // concatenate l1 message hashes uint256 _numL1MessagesInBlock = ChunkCodec.numL1Messages(blockPtr); dataPtr = _loadL1MessageHashes( dataPtr, _numL1MessagesInBlock, _totalL1MessagesPoppedInBatch, _totalL1MessagesPoppedOverall, _skippedL1MessageBitmap ); // concatenate l2 transaction hashes uint256 _numTransactionsInBlock = ChunkCodec.numTransactions(blockPtr); require(_numTransactionsInBlock >= _numL1MessagesInBlock, "num txs less than num L1 msgs"); for (uint256 j = _numL1MessagesInBlock; j < _numTransactionsInBlock; j++) { bytes32 txHash; (txHash, l2TxPtr) = ChunkCodec.loadL2TxHash(l2TxPtr); assembly { mstore(dataPtr, txHash) dataPtr := add(dataPtr, 0x20) } } unchecked { _totalNumL1MessagesInChunk += _numL1MessagesInBlock; _totalL1MessagesPoppedInBatch += _numL1MessagesInBlock; _totalL1MessagesPoppedOverall += _numL1MessagesInBlock; _numBlocks -= 1; blockPtr += ChunkCodec.BLOCK_CONTEXT_LENGTH; } } // check the actual number of transactions in the chunk require((dataPtr - txHashStartDataPtr) / 32 <= maxNumTxInChunk, "too many txs in one chunk"); // check chunk has correct length require(l2TxPtr - chunkPtr == _chunk.length, "incomplete l2 transaction data"); // compute data hash and store to memory assembly { let dataHash := keccak256(startDataPtr, sub(dataPtr, startDataPtr)) mstore(memPtr, dataHash) } return _totalNumL1MessagesInChunk; } /// @dev Internal function to load L1 message hashes from the message queue. /// @param _ptr The memory offset to store the transaction hash. /// @param _numL1Messages The number of L1 messages to load. /// @param _totalL1MessagesPoppedInBatch The total number of L1 messages popped in current batch. /// @param _totalL1MessagesPoppedOverall The total number of L1 messages popped in all batches including current batch. /// @param _skippedL1MessageBitmap The bitmap indicates whether each L1 message is skipped or not. /// @return uint256 The new memory offset after loading. function _loadL1MessageHashes( uint256 _ptr, uint256 _numL1Messages, uint256 _totalL1MessagesPoppedInBatch, uint256 _totalL1MessagesPoppedOverall, bytes calldata _skippedL1MessageBitmap ) internal view returns (uint256) { if (_numL1Messages == 0) return _ptr; IL1MessageQueue _messageQueue = IL1MessageQueue(messageQueue); unchecked { uint256 _bitmap; uint256 rem; for (uint256 i = 0; i < _numL1Messages; i++) { uint256 quo = _totalL1MessagesPoppedInBatch >> 8; rem = _totalL1MessagesPoppedInBatch & 0xff; // load bitmap every 256 bits if (i == 0 || rem == 0) { assembly { _bitmap := calldataload(add(_skippedL1MessageBitmap.offset, mul(0x20, quo))) } } if (((_bitmap >> rem) & 1) == 0) { // message not skipped bytes32 _hash = _messageQueue.getCrossDomainMessage(_totalL1MessagesPoppedOverall); assembly { mstore(_ptr, _hash) _ptr := add(_ptr, 0x20) } } _totalL1MessagesPoppedInBatch += 1; _totalL1MessagesPoppedOverall += 1; } // check last L1 message is not skipped, _totalL1MessagesPoppedInBatch must > 0 rem = (_totalL1MessagesPoppedInBatch - 1) & 0xff; require(((_bitmap >> rem) & 1) == 0, "cannot skip last L1 message"); } return _ptr; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/ContextUpgradeable.sol"; import "../proxy/utils/Initializable.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) pragma solidity ^0.8.0; import "../utils/ContextUpgradeable.sol"; import "../proxy/utils/Initializable.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract PausableUpgradeable is Initializable, ContextUpgradeable { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ function __Pausable_init() internal onlyInitializing { __Pausable_init_unchained(); } function __Pausable_init_unchained() internal onlyInitializing { _paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { require(!paused(), "Pausable: paused"); } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { require(paused(), "Pausable: not paused"); } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.16; interface IL1MessageQueue { /********** * Events * **********/ /// @notice Emitted when a new L1 => L2 transaction is appended to the queue. /// @param sender The address of account who initiates the transaction. /// @param target The address of account who will receive the transaction. /// @param value The value passed with the transaction. /// @param queueIndex The index of this transaction in the queue. /// @param gasLimit Gas limit required to complete the message relay on L2. /// @param data The calldata of the transaction. event QueueTransaction( address indexed sender, address indexed target, uint256 value, uint64 queueIndex, uint256 gasLimit, bytes data ); /// @notice Emitted when some L1 => L2 transactions are included in L1. /// @param startIndex The start index of messages popped. /// @param count The number of messages popped. /// @param skippedBitmap A bitmap indicates whether a message is skipped. event DequeueTransaction(uint256 startIndex, uint256 count, uint256 skippedBitmap); /// @notice Emitted when a message is dropped from L1. /// @param index The index of message dropped. event DropTransaction(uint256 index); /************************* * Public View Functions * *************************/ /// @notice The start index of all pending inclusion messages. function pendingQueueIndex() external view returns (uint256); /// @notice Return the index of next appended message. /// @dev Also the total number of appended messages. function nextCrossDomainMessageIndex() external view returns (uint256); /// @notice Return the message of in `queueIndex`. /// @param queueIndex The index to query. function getCrossDomainMessage(uint256 queueIndex) external view returns (bytes32); /// @notice Return the amount of ETH should pay for cross domain message. /// @param gasLimit Gas limit required to complete the message relay on L2. function estimateCrossDomainMessageFee(uint256 gasLimit) external view returns (uint256); /// @notice Return the amount of intrinsic gas fee should pay for cross domain message. /// @param _calldata The calldata of L1-initiated transaction. function calculateIntrinsicGasFee(bytes memory _calldata) external view returns (uint256); /// @notice Return the hash of a L1 message. /// @param sender The address of sender. /// @param queueIndex The queue index of this message. /// @param value The amount of Ether transfer to target. /// @param target The address of target. /// @param gasLimit The gas limit provided. /// @param data The calldata passed to target address. function computeTransactionHash( address sender, uint256 queueIndex, uint256 value, address target, uint256 gasLimit, bytes calldata data ) external view returns (bytes32); /// @notice Return whether the message is skipped. /// @param queueIndex The queue index of the message to check. function isMessageSkipped(uint256 queueIndex) external view returns (bool); /// @notice Return whether the message is dropped. /// @param queueIndex The queue index of the message to check. function isMessageDropped(uint256 queueIndex) external view returns (bool); /***************************** * Public Mutating Functions * *****************************/ /// @notice Append a L1 to L2 message into this contract. /// @param target The address of target contract to call in L2. /// @param gasLimit The maximum gas should be used for relay this message in L2. /// @param data The calldata passed to target contract. function appendCrossDomainMessage( address target, uint256 gasLimit, bytes calldata data ) external; /// @notice Append an enforced transaction to this contract. /// @dev The address of sender should be an EOA. /// @param sender The address of sender who will initiate this transaction in L2. /// @param target The address of target contract to call in L2. /// @param value The value passed /// @param gasLimit The maximum gas should be used for this transaction in L2. /// @param data The calldata passed to target contract. function appendEnforcedTransaction( address sender, address target, uint256 value, uint256 gasLimit, bytes calldata data ) external; /// @notice Pop finalized messages from queue. /// /// @dev We can pop at most 256 messages each time. And if the message is not skipped, /// the corresponding entry will be cleared. /// /// @param startIndex The start index to pop. /// @param count The number of messages to pop. /// @param skippedBitmap A bitmap indicates whether a message is skipped. function popCrossDomainMessage( uint256 startIndex, uint256 count, uint256 skippedBitmap ) external; /// @notice Drop a skipped message from the queue. function dropCrossDomainMessage(uint256 index) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.16; interface IScrollChain { /********** * Events * **********/ /// @notice Emitted when a new batch is committed. /// @param batchIndex The index of the batch. /// @param batchHash The hash of the batch. event CommitBatch(uint256 indexed batchIndex, bytes32 indexed batchHash); /// @notice revert a pending batch. /// @param batchIndex The index of the batch. /// @param batchHash The hash of the batch event RevertBatch(uint256 indexed batchIndex, bytes32 indexed batchHash); /// @notice Emitted when a batch is finalized. /// @param batchIndex The index of the batch. /// @param batchHash The hash of the batch /// @param stateRoot The state root on layer 2 after this batch. /// @param withdrawRoot The merkle root on layer2 after this batch. event FinalizeBatch(uint256 indexed batchIndex, bytes32 indexed batchHash, bytes32 stateRoot, bytes32 withdrawRoot); /************************* * Public View Functions * *************************/ /// @notice The latest finalized batch index. function lastFinalizedBatchIndex() external view returns (uint256); /// @notice Return the batch hash of a committed batch. /// @param batchIndex The index of the batch. function committedBatches(uint256 batchIndex) external view returns (bytes32); /// @notice Return the state root of a committed batch. /// @param batchIndex The index of the batch. function finalizedStateRoots(uint256 batchIndex) external view returns (bytes32); /// @notice Return the message root of a committed batch. /// @param batchIndex The index of the batch. function withdrawRoots(uint256 batchIndex) external view returns (bytes32); /// @notice Return whether the batch is finalized by batch index. /// @param batchIndex The index of the batch. function isBatchFinalized(uint256 batchIndex) external view returns (bool); /***************************** * Public Mutating Functions * *****************************/ /// @notice Commit a batch of transactions on layer 1. /// /// @param version The version of current batch. /// @param parentBatchHeader The header of parent batch, see the comments of `BatchHeaderV0Codec`. /// @param chunks The list of encoded chunks, see the comments of `ChunkCodec`. /// @param skippedL1MessageBitmap The bitmap indicates whether each L1 message is skipped or not. function commitBatch( uint8 version, bytes calldata parentBatchHeader, bytes[] memory chunks, bytes calldata skippedL1MessageBitmap ) external; /// @notice Revert a pending batch. /// @dev one can only revert unfinalized batches. /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch`. /// @param count The number of subsequent batches to revert, including current batch. function revertBatch(bytes calldata batchHeader, uint256 count) external; /// @notice Finalize a committed batch on layer 1. /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch. /// @param prevStateRoot The state root of parent batch. /// @param postStateRoot The state root of current batch. /// @param withdrawRoot The withdraw trie root of current batch. /// @param aggrProof The aggregation proof for current batch. function finalizeBatchWithProof( bytes calldata batchHeader, bytes32 prevStateRoot, bytes32 postStateRoot, bytes32 withdrawRoot, bytes calldata aggrProof ) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.16; // solhint-disable no-inline-assembly /// @dev Below is the encoding for `BatchHeader` V0, total 89 + ceil(l1MessagePopped / 256) * 32 bytes. /// ```text /// * Field Bytes Type Index Comments /// * version 1 uint8 0 The batch version /// * batchIndex 8 uint64 1 The index of the batch /// * l1MessagePopped 8 uint64 9 Number of L1 messages popped in the batch /// * totalL1MessagePopped 8 uint64 17 Number of total L1 message popped after the batch /// * dataHash 32 bytes32 25 The data hash of the batch /// * parentBatchHash 32 bytes32 57 The parent batch hash /// * skippedL1MessageBitmap dynamic uint256[] 89 A bitmap to indicate which L1 messages are skipped in the batch /// ``` library BatchHeaderV0Codec { /// @notice Load batch header in calldata to memory. /// @param _batchHeader The encoded batch header bytes in calldata. /// @return batchPtr The start memory offset of the batch header in memory. /// @return length The length in bytes of the batch header. function loadAndValidate(bytes calldata _batchHeader) internal pure returns (uint256 batchPtr, uint256 length) { length = _batchHeader.length; require(length >= 89, "batch header length too small"); // copy batch header to memory. assembly { batchPtr := mload(0x40) calldatacopy(batchPtr, _batchHeader.offset, length) mstore(0x40, add(batchPtr, length)) } // check batch header length uint256 _l1MessagePopped = BatchHeaderV0Codec.l1MessagePopped(batchPtr); unchecked { require(length == 89 + ((_l1MessagePopped + 255) / 256) * 32, "wrong bitmap length"); } } /// @notice Get the version of the batch header. /// @param batchPtr The start memory offset of the batch header in memory. /// @return _version The version of the batch header. function version(uint256 batchPtr) internal pure returns (uint256 _version) { assembly { _version := shr(248, mload(batchPtr)) } } /// @notice Get the batch index of the batch. /// @param batchPtr The start memory offset of the batch header in memory. /// @return _batchIndex The batch index of the batch. function batchIndex(uint256 batchPtr) internal pure returns (uint256 _batchIndex) { assembly { _batchIndex := shr(192, mload(add(batchPtr, 1))) } } /// @notice Get the number of L1 messages of the batch. /// @param batchPtr The start memory offset of the batch header in memory. /// @return _l1MessagePopped The number of L1 messages of the batch. function l1MessagePopped(uint256 batchPtr) internal pure returns (uint256 _l1MessagePopped) { assembly { _l1MessagePopped := shr(192, mload(add(batchPtr, 9))) } } /// @notice Get the number of L1 messages popped before this batch. /// @param batchPtr The start memory offset of the batch header in memory. /// @return _totalL1MessagePopped The the number of L1 messages popped before this batch. function totalL1MessagePopped(uint256 batchPtr) internal pure returns (uint256 _totalL1MessagePopped) { assembly { _totalL1MessagePopped := shr(192, mload(add(batchPtr, 17))) } } /// @notice Get the data hash of the batch header. /// @param batchPtr The start memory offset of the batch header in memory. /// @return _dataHash The data hash of the batch header. function dataHash(uint256 batchPtr) internal pure returns (bytes32 _dataHash) { assembly { _dataHash := mload(add(batchPtr, 25)) } } /// @notice Get the parent batch hash of the batch header. /// @param batchPtr The start memory offset of the batch header in memory. /// @return _parentBatchHash The parent batch hash of the batch header. function parentBatchHash(uint256 batchPtr) internal pure returns (bytes32 _parentBatchHash) { assembly { _parentBatchHash := mload(add(batchPtr, 57)) } } /// @notice Get the skipped L1 messages bitmap. /// @param batchPtr The start memory offset of the batch header in memory. /// @param index The index of bitmap to load. /// @return _bitmap The bitmap from bits `index * 256` to `index * 256 + 255`. function skippedBitmap(uint256 batchPtr, uint256 index) internal pure returns (uint256 _bitmap) { assembly { batchPtr := add(batchPtr, 89) _bitmap := mload(add(batchPtr, mul(index, 32))) } } /// @notice Store the version of batch header. /// @param batchPtr The start memory offset of the batch header in memory. /// @param _version The version of batch header. function storeVersion(uint256 batchPtr, uint256 _version) internal pure { assembly { mstore8(batchPtr, _version) } } /// @notice Store the batch index of batch header. /// @dev Because this function can overwrite the subsequent fields, it must be called before /// `storeL1MessagePopped`, `storeTotalL1MessagePopped`, and `storeDataHash`. /// @param batchPtr The start memory offset of the batch header in memory. /// @param _batchIndex The batch index. function storeBatchIndex(uint256 batchPtr, uint256 _batchIndex) internal pure { assembly { mstore(add(batchPtr, 1), shl(192, _batchIndex)) } } /// @notice Store the number of L1 messages popped in current batch to batch header. /// @dev Because this function can overwrite the subsequent fields, it must be called before /// `storeTotalL1MessagePopped` and `storeDataHash`. /// @param batchPtr The start memory offset of the batch header in memory. /// @param _l1MessagePopped The number of L1 messages popped in current batch. function storeL1MessagePopped(uint256 batchPtr, uint256 _l1MessagePopped) internal pure { assembly { mstore(add(batchPtr, 9), shl(192, _l1MessagePopped)) } } /// @notice Store the total number of L1 messages popped after current batch to batch header. /// @dev Because this function can overwrite the subsequent fields, it must be called before /// `storeDataHash`. /// @param batchPtr The start memory offset of the batch header in memory. /// @param _totalL1MessagePopped The total number of L1 messages popped after current batch. function storeTotalL1MessagePopped(uint256 batchPtr, uint256 _totalL1MessagePopped) internal pure { assembly { mstore(add(batchPtr, 17), shl(192, _totalL1MessagePopped)) } } /// @notice Store the data hash of batch header. /// @param batchPtr The start memory offset of the batch header in memory. /// @param _dataHash The data hash. function storeDataHash(uint256 batchPtr, bytes32 _dataHash) internal pure { assembly { mstore(add(batchPtr, 25), _dataHash) } } /// @notice Store the parent batch hash of batch header. /// @param batchPtr The start memory offset of the batch header in memory. /// @param _parentBatchHash The parent batch hash. function storeParentBatchHash(uint256 batchPtr, bytes32 _parentBatchHash) internal pure { assembly { mstore(add(batchPtr, 57), _parentBatchHash) } } /// @notice Store the skipped L1 message bitmap of batch header. /// @param batchPtr The start memory offset of the batch header in memory. /// @param _skippedL1MessageBitmap The skipped L1 message bitmap. function storeSkippedBitmap(uint256 batchPtr, bytes calldata _skippedL1MessageBitmap) internal pure { assembly { calldatacopy(add(batchPtr, 89), _skippedL1MessageBitmap.offset, _skippedL1MessageBitmap.length) } } /// @notice Compute the batch hash. /// @dev Caller should make sure that the encoded batch header is correct. /// /// @param batchPtr The memory offset of the encoded batch header. /// @param length The length of the batch. /// @return _batchHash The hash of the corresponding batch. function computeBatchHash(uint256 batchPtr, uint256 length) internal pure returns (bytes32 _batchHash) { // in the current version, the hash is: keccak(BatchHeader without timestamp) assembly { _batchHash := keccak256(batchPtr, length) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.16; /// @dev Below is the encoding for `Chunk`, total 60*n+1+m bytes. /// ```text /// * Field Bytes Type Index Comments /// * numBlocks 1 uint8 0 The number of blocks in this chunk /// * block[0] 60 BlockContext 1 The first block in this chunk /// * ...... /// * block[i] 60 BlockContext 60*i+1 The (i+1)'th block in this chunk /// * ...... /// * block[n-1] 60 BlockContext 60*n-59 The last block in this chunk /// * l2Transactions dynamic bytes 60*n+1 /// ``` /// /// @dev Below is the encoding for `BlockContext`, total 60 bytes. /// ```text /// * Field Bytes Type Index Comments /// * blockNumber 8 uint64 0 The height of this block. /// * timestamp 8 uint64 8 The timestamp of this block. /// * baseFee 32 uint256 16 The base fee of this block. Currently, it is always 0, because we disable EIP-1559. /// * gasLimit 8 uint64 48 The gas limit of this block. /// * numTransactions 2 uint16 56 The number of transactions in this block, both L1 & L2 txs. /// * numL1Messages 2 uint16 58 The number of l1 messages in this block. /// ``` library ChunkCodec { uint256 internal constant BLOCK_CONTEXT_LENGTH = 60; /// @notice Validate the length of chunk. /// @param chunkPtr The start memory offset of the chunk in memory. /// @param _length The length of the chunk. /// @return _numBlocks The number of blocks in current chunk. function validateChunkLength(uint256 chunkPtr, uint256 _length) internal pure returns (uint256 _numBlocks) { _numBlocks = numBlocks(chunkPtr); // should contain at least one block require(_numBlocks > 0, "no block in chunk"); // should contain at least the number of the blocks and block contexts require(_length >= 1 + _numBlocks * BLOCK_CONTEXT_LENGTH, "invalid chunk length"); } /// @notice Return the start memory offset of `l2Transactions`. /// @dev The caller should make sure `_numBlocks` is correct. /// @param chunkPtr The start memory offset of the chunk in memory. /// @param _numBlocks The number of blocks in current chunk. /// @return _l2TxPtr the start memory offset of `l2Transactions`. function l2TxPtr(uint256 chunkPtr, uint256 _numBlocks) internal pure returns (uint256 _l2TxPtr) { unchecked { _l2TxPtr = chunkPtr + 1 + _numBlocks * BLOCK_CONTEXT_LENGTH; } } /// @notice Return the number of blocks in current chunk. /// @param chunkPtr The start memory offset of the chunk in memory. /// @return _numBlocks The number of blocks in current chunk. function numBlocks(uint256 chunkPtr) internal pure returns (uint256 _numBlocks) { assembly { _numBlocks := shr(248, mload(chunkPtr)) } } /// @notice Copy the block context to another memory. /// @param chunkPtr The start memory offset of the chunk in memory. /// @param dstPtr The destination memory offset to store the block context. /// @param index The index of block context to copy. /// @return uint256 The new destination memory offset after copy. function copyBlockContext( uint256 chunkPtr, uint256 dstPtr, uint256 index ) internal pure returns (uint256) { // only first 58 bytes is needed. assembly { chunkPtr := add(chunkPtr, add(1, mul(BLOCK_CONTEXT_LENGTH, index))) mstore(dstPtr, mload(chunkPtr)) // first 32 bytes mstore( add(dstPtr, 0x20), and(mload(add(chunkPtr, 0x20)), 0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000) ) // next 26 bytes dstPtr := add(dstPtr, 58) } return dstPtr; } /// @notice Return the number of transactions in current block. /// @param blockPtr The start memory offset of the block context in memory. /// @return _numTransactions The number of transactions in current block. function numTransactions(uint256 blockPtr) internal pure returns (uint256 _numTransactions) { assembly { _numTransactions := shr(240, mload(add(blockPtr, 56))) } } /// @notice Return the number of L1 messages in current block. /// @param blockPtr The start memory offset of the block context in memory. /// @return _numL1Messages The number of L1 messages in current block. function numL1Messages(uint256 blockPtr) internal pure returns (uint256 _numL1Messages) { assembly { _numL1Messages := shr(240, mload(add(blockPtr, 58))) } } /// @notice Compute and load the transaction hash. /// @param _l2TxPtr The start memory offset of the transaction in memory. /// @return bytes32 The transaction hash of the transaction. /// @return uint256 The start memory offset of the next transaction in memory. function loadL2TxHash(uint256 _l2TxPtr) internal pure returns (bytes32, uint256) { bytes32 txHash; assembly { // first 4 bytes indicate the length let txPayloadLength := shr(224, mload(_l2TxPtr)) _l2TxPtr := add(_l2TxPtr, 4) txHash := keccak256(_l2TxPtr, txPayloadLength) _l2TxPtr := add(_l2TxPtr, txPayloadLength) } return (txHash, _l2TxPtr); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.16; interface IRollupVerifier { /// @notice Verify aggregate zk proof. /// @param batchIndex The batch index to verify. /// @param aggrProof The aggregated proof. /// @param publicInputHash The public input hash. function verifyAggregateProof( uint256 batchIndex, bytes calldata aggrProof, bytes32 publicInputHash ) external view; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; import "../proxy/utils/Initializable.sol"; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; import "../../utils/AddressUpgradeable.sol"; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ```solidity * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: setting the version to 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized != type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Returns the highest version that has been initialized. See {reinitializer}. */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. */ function _isInitializing() internal view returns (bool) { return _initializing; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint64","name":"_chainId","type":"uint64"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"batchIndex","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"batchHash","type":"bytes32"}],"name":"CommitBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"batchIndex","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"batchHash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"stateRoot","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"withdrawRoot","type":"bytes32"}],"name":"FinalizeBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"batchIndex","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"batchHash","type":"bytes32"}],"name":"RevertBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldMaxNumTxInChunk","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxNumTxInChunk","type":"uint256"}],"name":"UpdateMaxNumTxInChunk","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"UpdateProver","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"UpdateSequencer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldVerifier","type":"address"},{"indexed":true,"internalType":"address","name":"newVerifier","type":"address"}],"name":"UpdateVerifier","type":"event"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"addProver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"addSequencer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_version","type":"uint8"},{"internalType":"bytes","name":"_parentBatchHeader","type":"bytes"},{"internalType":"bytes[]","name":"_chunks","type":"bytes[]"},{"internalType":"bytes","name":"_skippedL1MessageBitmap","type":"bytes"}],"name":"commitBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"committedBatches","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_batchHeader","type":"bytes"},{"internalType":"bytes32","name":"_prevStateRoot","type":"bytes32"},{"internalType":"bytes32","name":"_postStateRoot","type":"bytes32"},{"internalType":"bytes32","name":"_withdrawRoot","type":"bytes32"},{"internalType":"bytes","name":"_aggrProof","type":"bytes"}],"name":"finalizeBatchWithProof","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"finalizedStateRoots","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_batchHeader","type":"bytes"},{"internalType":"bytes32","name":"_stateRoot","type":"bytes32"}],"name":"importGenesisBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_messageQueue","type":"address"},{"internalType":"address","name":"_verifier","type":"address"},{"internalType":"uint256","name":"_maxNumTxInChunk","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_batchIndex","type":"uint256"}],"name":"isBatchFinalized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isProver","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isSequencer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastFinalizedBatchIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"layer2ChainId","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxNumTxInChunk","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"messageQueue","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"removeProver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"removeSequencer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_batchHeader","type":"bytes"},{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"revertBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_status","type":"bool"}],"name":"setPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxNumTxInChunk","type":"uint256"}],"name":"updateMaxNumTxInChunk","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newVerifier","type":"address"}],"name":"updateVerifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"verifier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"withdrawRoots","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.