{ "address": "0x2e07967571dB8896178A65039b4Dd13Be354B002", "abi": [ { "inputs": [], "stateMutability": "nonpayable", "type": "constructor" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "chainid", "type": "uint256" }, { "indexed": false, "internalType": "bytes", "name": "configs", "type": "bytes" } ], "name": "PushConfig", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "chainid", "type": "uint256" }, { "indexed": false, "internalType": "address", "name": "wallet", "type": "address" }, { "indexed": false, "internalType": "address", "name": "manager", "type": "address" } ], "name": "SwitchSeq", "type": "event" }, { "inputs": [], "name": "CONFIG_OWNER_KEY", "outputs": [ { "internalType": "string", "name": "", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "addressmgr", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "messenger", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_chainId", "type": "uint256" }, { "internalType": "bytes", "name": "_configs", "type": "bytes" } ], "name": "pushConfig", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "_chainId", "type": "uint256" }, { "internalType": "address", "name": "wallet", "type": "address" }, { "internalType": "address", "name": "manager", "type": "address" } ], "name": "switchSequencer", "outputs": [], "stateMutability": "payable", "type": "function" } ], "transactionHash": "0x340ee7ce6eaf549e67c12eec350c0bfb08659597ed4aed2936eec397b5292cd2", "receipt": { "to": null, "from": "0x012347D9D1cC9df8d53289d43d84b5bCdED7F480", "contractAddress": "0x2e07967571dB8896178A65039b4Dd13Be354B002", "transactionIndex": 0, "gasUsed": "577184", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0xf24efbdc9b9febf9aa5773b6063d0a79ccfcc6099535ad8ffd14980ea7a2c629", "transactionHash": "0x340ee7ce6eaf549e67c12eec350c0bfb08659597ed4aed2936eec397b5292cd2", "logs": [], "blockNumber": 133, "cumulativeGasUsed": "577184", "status": 1, "byzantium": true }, "args": [], "numDeployments": 1, "solcInputHash": "452b4108adbe7ec4e50c9cf8a60feb9d", "metadata": "{\"compiler\":{\"version\":\"0.8.15+commit.e14f2714\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"chainid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"configs\",\"type\":\"bytes\"}],\"name\":\"PushConfig\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"chainid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"manager\",\"type\":\"address\"}],\"name\":\"SwitchSeq\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CONFIG_OWNER_KEY\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"addressmgr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"messenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_chainId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_configs\",\"type\":\"bytes\"}],\"name\":\"pushConfig\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_chainId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"manager\",\"type\":\"address\"}],\"name\":\"switchSequencer\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"if want support multi l2 chain on l1,it should add a manager to desc how many l2 chain now ,and dispatch the l2 chain id to make it is unique. Compiler used: solc Runtime target: EVM\",\"kind\":\"dev\",\"methods\":{},\"title\":\"MVM_L2ChainManagerOnL1\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/MVM/MVM_L2ChainManagerOnL1.sol\":\"MVM_L2ChainManagerOnL1\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":5000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9750c6b834f7b43000631af5cc30001c5f547b3ceb3635488f140f60e897ea6b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.2) (utils/introspection/ERC165Checker.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Library used to query support of an interface declared via {IERC165}.\\n *\\n * Note that these functions return the actual result of the query: they do not\\n * `revert` if an interface is not supported. It is up to the caller to decide\\n * what to do in these cases.\\n */\\nlibrary ERC165Checker {\\n // As per the EIP-165 spec, no interface should ever match 0xffffffff\\n bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;\\n\\n /**\\n * @dev Returns true if `account` supports the {IERC165} interface,\\n */\\n function supportsERC165(address account) internal view returns (bool) {\\n // Any contract that implements ERC165 must explicitly indicate support of\\n // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid\\n return\\n _supportsERC165Interface(account, type(IERC165).interfaceId) &&\\n !_supportsERC165Interface(account, _INTERFACE_ID_INVALID);\\n }\\n\\n /**\\n * @dev Returns true if `account` supports the interface defined by\\n * `interfaceId`. Support for {IERC165} itself is queried automatically.\\n *\\n * See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {\\n // query support of both ERC165 as per the spec and support of _interfaceId\\n return supportsERC165(account) && _supportsERC165Interface(account, interfaceId);\\n }\\n\\n /**\\n * @dev Returns a boolean array where each value corresponds to the\\n * interfaces passed in and whether they're supported or not. This allows\\n * you to batch check interfaces for a contract where your expectation\\n * is that some interfaces may not be supported.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * _Available since v3.4._\\n */\\n function getSupportedInterfaces(address account, bytes4[] memory interfaceIds)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n // an array of booleans corresponding to interfaceIds and whether they're supported or not\\n bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);\\n\\n // query support of ERC165 itself\\n if (supportsERC165(account)) {\\n // query support of each interface in interfaceIds\\n for (uint256 i = 0; i < interfaceIds.length; i++) {\\n interfaceIdsSupported[i] = _supportsERC165Interface(account, interfaceIds[i]);\\n }\\n }\\n\\n return interfaceIdsSupported;\\n }\\n\\n /**\\n * @dev Returns true if `account` supports all the interfaces defined in\\n * `interfaceIds`. Support for {IERC165} itself is queried automatically.\\n *\\n * Batch-querying can lead to gas savings by skipping repeated checks for\\n * {IERC165} support.\\n *\\n * See {IERC165-supportsInterface}.\\n */\\n function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {\\n // query support of ERC165 itself\\n if (!supportsERC165(account)) {\\n return false;\\n }\\n\\n // query support of each interface in _interfaceIds\\n for (uint256 i = 0; i < interfaceIds.length; i++) {\\n if (!_supportsERC165Interface(account, interfaceIds[i])) {\\n return false;\\n }\\n }\\n\\n // all interfaces supported\\n return true;\\n }\\n\\n /**\\n * @notice Query if a contract implements an interface, does not check ERC165 support\\n * @param account The address of the contract to query for support of an interface\\n * @param interfaceId The interface identifier, as specified in ERC-165\\n * @return true if the contract at account indicates support of the interface with\\n * identifier interfaceId, false otherwise\\n * @dev Assumes that account contains a contract that supports ERC165, otherwise\\n * the behavior of this method is undefined. This precondition can be checked\\n * with {supportsERC165}.\\n * Interface identification is specified in ERC-165.\\n */\\n function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {\\n // prepare call\\n bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);\\n\\n // perform static call\\n bool success;\\n uint256 returnSize;\\n uint256 returnValue;\\n assembly {\\n success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)\\n returnSize := returndatasize()\\n returnValue := mload(0x00)\\n }\\n\\n return success && returnSize >= 0x20 && returnValue > 0;\\n }\\n}\\n\",\"keccak256\":\"0xc65c83c1039508fa7a42a09a3c6a32babd1c438ba4dbb23581255e784b5d5eed\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/L1/messaging/IL1ERC20Bridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\n/**\\n * @title IL1ERC20Bridge\\n */\\ninterface IL1ERC20Bridge {\\n /**********\\n * Events *\\n **********/\\n\\n event ERC20DepositInitiated(\\n address indexed _l1Token,\\n address indexed _l2Token,\\n address indexed _from,\\n address _to,\\n uint256 _amount,\\n bytes _data\\n );\\n\\n event ERC20WithdrawalFinalized(\\n address indexed _l1Token,\\n address indexed _l2Token,\\n address indexed _from,\\n address _to,\\n uint256 _amount,\\n bytes _data\\n );\\n\\n event ERC20ChainID(uint256 _chainid);\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * @dev get the address of the corresponding L2 bridge contract.\\n * @return Address of the corresponding L2 bridge contract.\\n */\\n function l2TokenBridge() external returns (address);\\n\\n /**\\n * @dev deposit an amount of the ERC20 to the caller's balance on L2.\\n * @param _l1Token Address of the L1 ERC20 we are depositing\\n * @param _l2Token Address of the L1 respective L2 ERC20\\n * @param _amount Amount of the ERC20 to deposit\\n * @param _l2Gas Gas limit required to complete the deposit on L2.\\n * @param _data Optional data to forward to L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function depositERC20(\\n address _l1Token,\\n address _l2Token,\\n uint256 _amount,\\n uint32 _l2Gas,\\n bytes calldata _data\\n ) external;\\n\\n /**\\n * @dev deposit an amount of ERC20 to a recipient's balance on L2.\\n * @param _l1Token Address of the L1 ERC20 we are depositing\\n * @param _l2Token Address of the L1 respective L2 ERC20\\n * @param _to L2 address to credit the withdrawal to.\\n * @param _amount Amount of the ERC20 to deposit.\\n * @param _l2Gas Gas limit required to complete the deposit on L2.\\n * @param _data Optional data to forward to L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function depositERC20To(\\n address _l1Token,\\n address _l2Token,\\n address _to,\\n uint256 _amount,\\n uint32 _l2Gas,\\n bytes calldata _data\\n ) external;\\n\\n /**\\n * @dev deposit an amount of the ERC20 to the caller's balance on L2.\\n * @param _chainid chainid\\n * @param _l1Token Address of the L1 ERC20 we are depositing\\n * @param _l2Token Address of the L1 respective L2 ERC20\\n * @param _amount Amount of the ERC20 to deposit\\n * @param _l2Gas Gas limit required to complete the deposit on L2.\\n * @param _data Optional data to forward to L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function depositERC20ByChainId(\\n uint256 _chainid,\\n address _l1Token,\\n address _l2Token,\\n uint256 _amount,\\n uint32 _l2Gas,\\n bytes calldata _data\\n ) external payable;\\n\\n /**\\n * @dev deposit an amount of ERC20 to a recipient's balance on L2.\\n * @param _chainid chainid\\n * @param _l1Token Address of the L1 ERC20 we are depositing\\n * @param _l2Token Address of the L1 respective L2 ERC20\\n * @param _to L2 address to credit the withdrawal to.\\n * @param _amount Amount of the ERC20 to deposit.\\n * @param _l2Gas Gas limit required to complete the deposit on L2.\\n * @param _data Optional data to forward to L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function depositERC20ToByChainId(\\n uint256 _chainid,\\n address _l1Token,\\n address _l2Token,\\n address _to,\\n uint256 _amount,\\n uint32 _l2Gas,\\n bytes calldata _data\\n ) external payable;\\n\\n /*************************\\n * Cross-chain Functions *\\n *************************/\\n\\n /**\\n * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the\\n * L1 ERC20 token.\\n * This call will fail if the initialized withdrawal from L2 has not been finalized.\\n *\\n * @param _l1Token Address of L1 token to finalizeWithdrawal for.\\n * @param _l2Token Address of L2 token where withdrawal was initiated.\\n * @param _from L2 address initiating the transfer.\\n * @param _to L1 address to credit the withdrawal to.\\n * @param _amount Amount of the ERC20 to deposit.\\n * @param _data Data provided by the sender on L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function finalizeERC20Withdrawal(\\n address _l1Token,\\n address _l2Token,\\n address _from,\\n address _to,\\n uint256 _amount,\\n bytes calldata _data\\n ) external;\\n\\n /**\\n * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the\\n * L1 ERC20 token.\\n * This call will fail if the initialized withdrawal from L2 has not been finalized.\\n *\\n * @param _chainid chainid\\n * @param _l1Token Address of L1 token to finalizeWithdrawal for.\\n * @param _l2Token Address of L2 token where withdrawal was initiated.\\n * @param _from L2 address initiating the transfer.\\n * @param _to L1 address to credit the withdrawal to.\\n * @param _amount Amount of the ERC20 to deposit.\\n * @param _data Data provided by the sender on L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function finalizeERC20WithdrawalByChainId(\\n uint256 _chainid,\\n address _l1Token,\\n address _l2Token,\\n address _from,\\n address _to,\\n uint256 _amount,\\n bytes calldata _data\\n ) external;\\n\\n /**\\n * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the\\n * L1 ERC20 token.\\n * This call will fail if the initialized withdrawal from L2 has not been finalized.\\n *\\n * @param _chainid chainid\\n * @param _from L2 address initiating the transfer.\\n * @param _to L1 address to credit the withdrawal to.\\n * @param _amount Amount of the ERC20 to deposit.\\n * @param _data Data provided by the sender on L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function finalizeMetisWithdrawalByChainId(\\n uint256 _chainid,\\n address _from,\\n address _to,\\n uint256 _amount,\\n bytes calldata _data\\n ) external;\\n}\\n\",\"keccak256\":\"0xd2f1b05e6eda3419de13aa06e77bbba6c165b41cdca911014349c8f0814f6189\",\"license\":\"MIT\"},\"contracts/L1/messaging/IL1StandardBridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >0.5.0 <0.9.0;\\n\\nimport \\\"./IL1ERC20Bridge.sol\\\";\\n\\n/**\\n * @title IL1StandardBridge\\n */\\ninterface IL1StandardBridge is IL1ERC20Bridge {\\n /**********\\n * Events *\\n **********/\\n event ETHDepositInitiated(\\n address indexed _from,\\n address indexed _to,\\n uint256 _amount,\\n bytes _data,\\n uint256 chainId\\n );\\n\\n event ETHWithdrawalFinalized(\\n address indexed _from,\\n address indexed _to,\\n uint256 _amount,\\n bytes _data,\\n uint256 chainId\\n );\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * @dev Deposit an amount of the ETH to the caller's balance on L2.\\n * @param _l2Gas Gas limit required to complete the deposit on L2.\\n * @param _data Optional data to forward to L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;\\n\\n /**\\n * @dev Deposit an amount of ETH to a recipient's balance on L2.\\n * @param _to L2 address to credit the withdrawal to.\\n * @param _l2Gas Gas limit required to complete the deposit on L2.\\n * @param _data Optional data to forward to L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function depositETHTo(\\n address _to,\\n uint32 _l2Gas,\\n bytes calldata _data\\n ) external payable;\\n\\n function depositETHByChainId(\\n uint256 _chainId,\\n uint32 _l2Gas,\\n bytes calldata _data\\n ) external payable;\\n\\n function depositETHToByChainId(\\n uint256 _chainId,\\n address _to,\\n uint32 _l2Gas,\\n bytes calldata _data\\n ) external payable;\\n\\n /*************************\\n * Cross-chain Functions *\\n *************************/\\n\\n /**\\n * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the\\n * L1 ETH token. Since only the xDomainMessenger can call this function, it will never be called\\n * before the withdrawal is finalized.\\n * @param _from L2 address initiating the transfer.\\n * @param _to L1 address to credit the withdrawal to.\\n * @param _amount Amount of the ERC20 to deposit.\\n * @param _data Optional data to forward to L2. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function finalizeETHWithdrawal(\\n address _from,\\n address _to,\\n uint256 _amount,\\n bytes calldata _data\\n ) external;\\n\\n function finalizeETHWithdrawalByChainId(\\n uint256 _chainId,\\n address _from,\\n address _to,\\n uint256 _amount,\\n bytes calldata _data\\n ) external;\\n}\\n\",\"keccak256\":\"0xd3e15efd57982ef06164126b717a7b10c53e790433126e1844f35abdd55a78f3\",\"license\":\"MIT\"},\"contracts/L2/messaging/IL2ERC20Bridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title IL2ERC20Bridge\\n */\\ninterface IL2ERC20Bridge {\\n /**********\\n * Events *\\n **********/\\n\\n event WithdrawalInitiated(\\n address indexed _l1Token,\\n address indexed _l2Token,\\n address indexed _from,\\n address _to,\\n uint256 _amount,\\n bytes _data\\n );\\n\\n event DepositFinalized(\\n address indexed _l1Token,\\n address indexed _l2Token,\\n address indexed _from,\\n address _to,\\n uint256 _amount,\\n bytes _data\\n );\\n\\n event DepositFailed(\\n address indexed _l1Token,\\n address indexed _l2Token,\\n address indexed _from,\\n address _to,\\n uint256 _amount,\\n bytes _data\\n );\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * @dev get the address of the corresponding L1 bridge contract.\\n * @return Address of the corresponding L1 bridge contract.\\n */\\n function l1TokenBridge() external returns (address);\\n\\n /**\\n * @dev initiate a withdraw of some tokens to the caller's account on L1\\n * @param _l2Token Address of L2 token where withdrawal was initiated.\\n * @param _amount Amount of the token to withdraw.\\n * param _l1Gas Unused, but included for potential forward compatibility considerations.\\n * @param _data Optional data to forward to L1. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function withdraw(\\n address _l2Token,\\n uint256 _amount,\\n uint32 _l1Gas,\\n bytes calldata _data\\n ) external payable;\\n\\n /**\\n * @dev initiate a withdraw of some token to a recipient's account on L1.\\n * @param _l2Token Address of L2 token where withdrawal is initiated.\\n * @param _to L1 adress to credit the withdrawal to.\\n * @param _amount Amount of the token to withdraw.\\n * param _l1Gas Unused, but included for potential forward compatibility considerations.\\n * @param _data Optional data to forward to L1. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function withdrawTo(\\n address _l2Token,\\n address _to,\\n uint256 _amount,\\n uint32 _l1Gas,\\n bytes calldata _data\\n ) external payable;\\n\\n /*************************\\n * Cross-chain Functions *\\n *************************/\\n\\n /**\\n * @dev Complete a deposit from L1 to L2, and credits funds to the recipient's balance of this\\n * L2 token. This call will fail if it did not originate from a corresponding deposit in\\n * L1StandardTokenBridge.\\n * @param _l1Token Address for the l1 token this is called with\\n * @param _l2Token Address for the l2 token this is called with\\n * @param _from Account to pull the deposit from on L2.\\n * @param _to Address to receive the withdrawal at\\n * @param _amount Amount of the token to withdraw\\n * @param _data Data provider by the sender on L1. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function finalizeDeposit(\\n address _l1Token,\\n address _l2Token,\\n address _from,\\n address _to,\\n uint256 _amount,\\n bytes calldata _data\\n ) external;\\n}\\n\",\"keccak256\":\"0xfa58c036b094f8d57e1c575830b6c079b6e746c5408410bac912b03ee27bba8a\",\"license\":\"MIT\"},\"contracts/L2/messaging/L2StandardBridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* Interface Imports */\\nimport { IL1StandardBridge } from \\\"../../L1/messaging/IL1StandardBridge.sol\\\";\\nimport { IL1ERC20Bridge } from \\\"../../L1/messaging/IL1ERC20Bridge.sol\\\";\\nimport { IL2ERC20Bridge } from \\\"./IL2ERC20Bridge.sol\\\";\\n\\n/* Library Imports */\\nimport { ERC165Checker } from \\\"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\\\";\\nimport { CrossDomainEnabled } from \\\"../../libraries/bridge/CrossDomainEnabled.sol\\\";\\nimport { Lib_PredeployAddresses } from \\\"../../libraries/constants/Lib_PredeployAddresses.sol\\\";\\nimport { Lib_Uint } from \\\"../../libraries/utils/Lib_Uint.sol\\\";\\n\\n/* Contract Imports */\\nimport { IL2StandardERC20 } from \\\"../../standards/IL2StandardERC20.sol\\\";\\nimport { OVM_GasPriceOracle } from \\\"../predeploys/OVM_GasPriceOracle.sol\\\";\\n\\n/**\\n * @title L2StandardBridge\\n * @dev The L2 Standard bridge is a contract which works together with the L1 Standard bridge to\\n * enable ETH and ERC20 transitions between L1 and L2.\\n * This contract acts as a minter for new tokens when it hears about deposits into the L1 Standard\\n * bridge.\\n * This contract also acts as a burner of the tokens intended for withdrawal, informing the L1\\n * bridge to release L1 funds.\\n */\\ncontract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {\\n /********************************\\n * External Contract References *\\n ********************************/\\n\\n address public l1TokenBridge;\\n\\n /***************\\n * Constructor *\\n ***************/\\n\\n /**\\n * @param _l2CrossDomainMessenger Cross-domain messenger used by this contract.\\n * @param _l1TokenBridge Address of the L1 bridge deployed to the main chain.\\n */\\n constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)\\n CrossDomainEnabled(_l2CrossDomainMessenger)\\n {\\n l1TokenBridge = _l1TokenBridge;\\n }\\n\\n function getChainID() internal view returns (uint256) {\\n uint256 id;\\n assembly {\\n id := chainid()\\n }\\n return id;\\n }\\n\\n /***************\\n * Withdrawing *\\n ***************/\\n\\n /**\\n * @inheritdoc IL2ERC20Bridge\\n */\\n function withdraw(\\n address _l2Token,\\n uint256 _amount,\\n uint32 _l1Gas,\\n bytes calldata _data\\n ) external payable virtual {\\n _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);\\n }\\n\\n function withdrawMetis(\\n uint256 _amount,\\n uint32 _l1Gas,\\n bytes calldata _data\\n ) external payable virtual {\\n _initiateWithdrawal(\\n Lib_PredeployAddresses.MVM_COINBASE,\\n msg.sender,\\n msg.sender,\\n _amount,\\n _l1Gas,\\n _data\\n );\\n }\\n\\n /**\\n * @inheritdoc IL2ERC20Bridge\\n */\\n function withdrawTo(\\n address _l2Token,\\n address _to,\\n uint256 _amount,\\n uint32 _l1Gas,\\n bytes calldata _data\\n ) external payable virtual {\\n _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);\\n }\\n\\n function withdrawMetisTo(\\n address _to,\\n uint256 _amount,\\n uint32 _l1Gas,\\n bytes calldata _data\\n ) external payable virtual {\\n _initiateWithdrawal(\\n Lib_PredeployAddresses.MVM_COINBASE,\\n msg.sender,\\n _to,\\n _amount,\\n _l1Gas,\\n _data\\n );\\n }\\n\\n /**\\n * @dev Performs the logic for deposits by storing the token and informing the L2 token Gateway\\n * of the deposit.\\n * @param _l2Token Address of L2 token where withdrawal was initiated.\\n * @param _from Account to pull the deposit from on L2.\\n * @param _to Account to give the withdrawal to on L1.\\n * @param _amount Amount of the token to withdraw.\\n * param _l1Gas Unused, but included for potential forward compatibility considerations.\\n * @param _data Optional data to forward to L1. This data is provided\\n * solely as a convenience for external contracts. Aside from enforcing a maximum\\n * length, these contracts provide no guarantees about its content.\\n */\\n function _initiateWithdrawal(\\n address _l2Token,\\n address _from,\\n address _to,\\n uint256 _amount,\\n uint32 _l1Gas,\\n bytes calldata _data\\n ) internal {\\n uint256 minL1Gas = OVM_GasPriceOracle(Lib_PredeployAddresses.OVM_GASPRICE_ORACLE)\\n .minErc20BridgeCost();\\n\\n // require minimum gas unless, the metis manager is the sender\\n require(\\n msg.value >= minL1Gas || _from == Lib_PredeployAddresses.SEQUENCER_FEE_WALLET,\\n string(\\n abi.encodePacked(\\n \\\"insufficient withdrawal fee supplied. need at least \\\",\\n Lib_Uint.uint2str(minL1Gas)\\n )\\n )\\n );\\n\\n // When a withdrawal is initiated, we burn the withdrawer's funds to prevent subsequent L2\\n // usage\\n IL2StandardERC20(_l2Token).burn(msg.sender, _amount);\\n\\n // Construct calldata for l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)\\n address l1Token = IL2StandardERC20(_l2Token).l1Token();\\n bytes memory message;\\n\\n if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {\\n message = abi.encodeWithSelector(\\n IL1StandardBridge.finalizeETHWithdrawalByChainId.selector,\\n getChainID(),\\n _from,\\n _to,\\n _amount,\\n _data\\n );\\n } else if (_l2Token == Lib_PredeployAddresses.MVM_COINBASE) {\\n message = abi.encodeWithSelector(\\n IL1ERC20Bridge.finalizeMetisWithdrawalByChainId.selector,\\n getChainID(),\\n _from,\\n _to,\\n _amount,\\n _data\\n );\\n } else {\\n message = abi.encodeWithSelector(\\n IL1ERC20Bridge.finalizeERC20WithdrawalByChainId.selector,\\n getChainID(),\\n l1Token,\\n _l2Token,\\n _from,\\n _to,\\n _amount,\\n _data\\n );\\n }\\n\\n // Send message up to L1 bridge\\n sendCrossDomainMessage(\\n l1TokenBridge,\\n _l1Gas,\\n message,\\n msg.value // send all value as fees to cover relayer cost\\n );\\n\\n emit WithdrawalInitiated(l1Token, _l2Token, msg.sender, _to, _amount, _data);\\n }\\n\\n /************************************\\n * Cross-chain Function: Depositing *\\n ************************************/\\n\\n /**\\n * @inheritdoc IL2ERC20Bridge\\n */\\n function finalizeDeposit(\\n address _l1Token,\\n address _l2Token,\\n address _from,\\n address _to,\\n uint256 _amount,\\n bytes calldata _data\\n ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {\\n // Check the target token is compliant and\\n // verify the deposited token on L1 matches the L2 deposited token representation here\\n if (\\n ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&\\n _l1Token == IL2StandardERC20(_l2Token).l1Token()\\n ) {\\n // When a deposit is finalized, we credit the account on L2 with the same amount of\\n // tokens.\\n IL2StandardERC20(_l2Token).mint(_to, _amount);\\n emit DepositFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);\\n } else {\\n // disable because the mechanism is incompatible with the new xdomain fee structure.\\n\\n // Either the L2 token which is being deposited-into disagrees about the correct address\\n // of its L1 token, or does not support the correct interface.\\n // This should only happen if there is a malicious L2 token, or if a user somehow\\n // specified the wrong L2 token address to deposit into.\\n // In either case, we stop the process here and construct a withdrawal\\n // message so that users can get their funds out in some cases.\\n // There is no way to prevent malicious token contracts altogether, but this does limit\\n // user error and mitigate some forms of malicious contract behavior.\\n //bytes memory message = abi.encodeWithSelector(\\n // iOVM_L1ERC20Bridge.finalizeERC20Withdrawal.selector,\\n // _l1Token,\\n // _l2Token,\\n // _to, // switched the _to and _from here to bounce back the deposit to the sender\\n // _from,\\n // _amount,\\n // _data\\n //);\\n\\n // Send message up to L1 bridge\\n //sendCrossDomainMessage(\\n // l1TokenBridge,\\n // 0,\\n // message,\\n // 0\\n //);\\n emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x13652b86f30566caede48d1ef896f3d8c2831c971cf324939a2557864689ec49\",\"license\":\"MIT\"},\"contracts/L2/predeploys/OVM_GasPriceOracle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* External Imports */\\n\\nimport { iOVM_SequencerFeeVault } from \\\"./iOVM_SequencerFeeVault.sol\\\";\\nimport { Lib_PredeployAddresses } from \\\"../../libraries/constants/Lib_PredeployAddresses.sol\\\";\\n\\n/**\\n * @title OVM_GasPriceOracle\\n * @dev This contract exposes the current l2 gas price, a measure of how congested the network\\n * currently is. This measure is used by the Sequencer to determine what fee to charge for\\n * transactions. When the system is more congested, the l2 gas price will increase and fees\\n * will also increase as a result.\\n *\\n * All public variables are set while generating the initial L2 state. The\\n * constructor doesn't run in practice as the L2 state generation script uses\\n * the deployed bytecode instead of running the initcode.\\n */\\ncontract OVM_GasPriceOracle {\\n /*************\\n * Variables *\\n *************/\\n address public owner;\\n // Current L2 gas price\\n uint256 public gasPrice;\\n // Current L1 base fee\\n uint256 public l1BaseFee;\\n // Amortized cost of batch submission per transaction\\n uint256 public overhead;\\n // Value to scale the fee up by\\n uint256 public scalar;\\n // Number of decimals of the scalar\\n uint256 public decimals;\\n\\n // minimum gas to bridge the asset back to l1\\n uint256 public minErc20BridgeCost;\\n\\n /**********************\\n * Function Modifiers *\\n **********************/\\n\\n /**\\n * Blocks functions to anyone except the contract owner.\\n */\\n modifier onlyOwner() {\\n require(msg.sender == owner, \\\"Function can only be called by the owner of this contract.\\\");\\n _;\\n }\\n\\n modifier onlyManager() {\\n require(\\n msg.sender ==\\n iOVM_SequencerFeeVault(Lib_PredeployAddresses.SEQUENCER_FEE_WALLET).getL2Manager(),\\n \\\"Function can only be called by the l2manager.\\\"\\n );\\n _;\\n }\\n\\n /***************\\n * Constructor *\\n ***************/\\n\\n /**\\n * @param _owner Address that will initially own this contract.\\n */\\n constructor(address _owner) {\\n owner = _owner;\\n }\\n\\n /**********\\n * Events *\\n **********/\\n\\n event GasPriceUpdated(uint256);\\n event L1BaseFeeUpdated(uint256);\\n event OverheadUpdated(uint256);\\n event ScalarUpdated(uint256);\\n event DecimalsUpdated(uint256);\\n event MinErc20BridgeCostUpdated(uint256);\\n event OwnerChanged(address oldOwner, address newOwner);\\n\\n /********************\\n * Public Functions *\\n ********************/\\n /**\\n * Updates the owner of this contract.\\n * @param _owner Address of the new owner.\\n */\\n function setOwner(address _owner) public onlyManager {\\n emit OwnerChanged(owner, _owner);\\n owner = _owner;\\n }\\n\\n /**\\n * Allows the owner to modify the l2 gas price.\\n * @param _gasPrice New l2 gas price.\\n */\\n function setGasPrice(uint256 _gasPrice) public onlyOwner {\\n gasPrice = _gasPrice;\\n emit GasPriceUpdated(_gasPrice);\\n }\\n\\n /**\\n * Allows the owner to modify the l1 bridge price.\\n * @param _minCost New l2 gas price.\\n */\\n function setMinErc20BridgeCost(uint256 _minCost) public onlyOwner {\\n minErc20BridgeCost = _minCost;\\n emit MinErc20BridgeCostUpdated(_minCost);\\n }\\n\\n /**\\n * Allows the owner to modify the l1 base fee.\\n * @param _baseFee New l1 base fee\\n */\\n function setL1BaseFee(uint256 _baseFee) public onlyOwner {\\n if (l1BaseFee > 0) {\\n require(_baseFee < (l1BaseFee * 105) / 100, \\\"increase is capped at 5%\\\");\\n }\\n l1BaseFee = _baseFee;\\n emit L1BaseFeeUpdated(_baseFee);\\n }\\n\\n /**\\n * Allows the owner to modify the overhead.\\n * @param _overhead New overhead\\n */\\n function setOverhead(uint256 _overhead) public onlyOwner {\\n if (overhead > 0) {\\n require(_overhead < (overhead * 105) / 100, \\\"increase is capped at 5%\\\");\\n }\\n overhead = _overhead;\\n emit OverheadUpdated(_overhead);\\n }\\n\\n /**\\n * Allows the owner to modify the scalar.\\n * @param _scalar New scalar\\n */\\n function setScalar(uint256 _scalar) public onlyOwner {\\n if (scalar > 0) {\\n require(_scalar < (scalar * 105) / 100, \\\"increase is capped at 5%\\\");\\n }\\n scalar = _scalar;\\n emit ScalarUpdated(_scalar);\\n }\\n\\n /**\\n * Allows the owner to modify the decimals.\\n * For maximum safety, this method should only be called when there is no active tx\\n * @param _decimals New decimals\\n */\\n function setDecimals(uint256 _decimals) public onlyOwner {\\n decimals = _decimals;\\n emit DecimalsUpdated(_decimals);\\n }\\n\\n /**\\n * Computes the L1 portion of the fee\\n * based on the size of the RLP encoded tx\\n * and the current l1BaseFee\\n * @param _data Unsigned RLP encoded tx, 6 elements\\n * @return L1 fee that should be paid for the tx\\n */\\n function getL1Fee(bytes memory _data) public view returns (uint256) {\\n uint256 l1GasUsed = getL1GasUsed(_data);\\n uint256 l1Fee = l1GasUsed * l1BaseFee;\\n uint256 divisor = 10**decimals;\\n uint256 unscaled = l1Fee * scalar;\\n uint256 scaled = unscaled / divisor;\\n return scaled;\\n }\\n\\n // solhint-disable max-line-length\\n /**\\n * Computes the amount of L1 gas used for a transaction\\n * The overhead represents the per batch gas overhead of\\n * posting both transaction and state roots to L1 given larger\\n * batch sizes.\\n * 4 gas for 0 byte\\n * https://github.com/ethereum/go-ethereum/blob/9ada4a2e2c415e6b0b51c50e901336872e028872/params/protocol_params.go#L33\\n * 16 gas for non zero byte\\n * https://github.com/ethereum/go-ethereum/blob/9ada4a2e2c415e6b0b51c50e901336872e028872/params/protocol_params.go#L87\\n * This will need to be updated if calldata gas prices change\\n * Account for the transaction being unsigned\\n * Padding is added to account for lack of signature on transaction\\n * 1 byte for RLP V prefix\\n * 1 byte for V\\n * 1 byte for RLP R prefix\\n * 32 bytes for R\\n * 1 byte for RLP S prefix\\n * 32 bytes for S\\n * Total: 68 bytes of padding\\n * @param _data Unsigned RLP encoded tx, 6 elements\\n * @return Amount of L1 gas used for a transaction\\n */\\n // solhint-enable max-line-length\\n function getL1GasUsed(bytes memory _data) public view returns (uint256) {\\n uint256 total = 0;\\n for (uint256 i = 0; i < _data.length; i++) {\\n if (_data[i] == 0) {\\n total += 4;\\n } else {\\n total += 16;\\n }\\n }\\n uint256 unsigned = total + overhead;\\n return unsigned + (68 * 16);\\n }\\n}\\n\",\"keccak256\":\"0x690f276bbd7c6c7faec682538145f2605b65ad19bce4a54f131d896a42ed1c4f\",\"license\":\"MIT\"},\"contracts/L2/predeploys/iOVM_SequencerFeeVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* Library Imports */\\nimport { Lib_PredeployAddresses } from \\\"../../libraries/constants/Lib_PredeployAddresses.sol\\\";\\n\\n/* Contract Imports */\\nimport { L2StandardBridge } from \\\"../messaging/L2StandardBridge.sol\\\";\\nimport { CrossDomainEnabled } from \\\"../../libraries/bridge/CrossDomainEnabled.sol\\\";\\n\\n/**\\n * @title OVM_SequencerFeeVault\\n * @dev Simple holding contract for fees paid to the Sequencer. Likely to be replaced in the future\\n * but \\\"good enough for now\\\".\\n */\\ninterface iOVM_SequencerFeeVault {\\n /*************\\n * Constants *\\n *************/\\n\\n event ChainSwitch(address l1Wallet, address l2Manager);\\n event ConfigChange(bytes config);\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n function withdraw(uint256 amount) external payable;\\n\\n function finalizeChainSwitch(address _FeeWallet, address _L2Manager) external;\\n\\n function finalizeChainConfig(bytes calldata config) external;\\n\\n function send(address payable to, uint256 amount) external;\\n\\n function sendBatch(address payable[] calldata tos, uint256[] calldata amounts) external;\\n\\n function getL2Manager() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf406d9f8b607535ac8c1f277425b725ff842596cd47d5b74596e2ea56b7569b1\",\"license\":\"MIT\"},\"contracts/MVM/MVM_L2ChainManagerOnL1.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\npragma experimental ABIEncoderV2;\\n\\n/* Library Imports */\\nimport { CrossDomainEnabled } from \\\"../libraries/bridge/CrossDomainEnabled.sol\\\";\\nimport { Lib_PredeployAddresses } from \\\"../libraries/constants/Lib_PredeployAddresses.sol\\\";\\nimport { Lib_AddressManager } from \\\"../libraries/resolver/Lib_AddressManager.sol\\\";\\nimport { iOVM_SequencerFeeVault } from \\\"../L2/predeploys/iOVM_SequencerFeeVault.sol\\\";\\nimport { iMVM_L2ChainManagerOnL1 } from \\\"./iMVM_L2ChainManagerOnL1.sol\\\";\\nimport { iMVM_DiscountOracle } from \\\"./iMVM_DiscountOracle.sol\\\";\\n\\n/* Interface Imports */\\n\\n/* External Imports */\\n\\n/**\\n * @title MVM_L2ChainManagerOnL1\\n * @dev if want support multi l2 chain on l1,it should add a manager to desc\\n * how many l2 chain now ,and dispatch the l2 chain id to make it is unique.\\n *\\n * Compiler used: solc\\n * Runtime target: EVM\\n */\\ncontract MVM_L2ChainManagerOnL1 is iMVM_L2ChainManagerOnL1, CrossDomainEnabled {\\n /*************\\n * Constants *\\n *************/\\n string public constant CONFIG_OWNER_KEY = \\\"METIS_MANAGER\\\";\\n\\n /*************\\n * Variables *\\n *************/\\n address public addressmgr;\\n // chainid => sequencer\\n mapping(uint256 => address) squencers;\\n\\n // chainid => configs (unused for now);\\n mapping(uint256 => bytes) configs;\\n\\n /***************\\n * Constructor *\\n ***************/\\n // This contract lives behind a proxy, so the constructor parameters will go unused.\\n constructor() CrossDomainEnabled(address(0)) {}\\n\\n /**********************\\n * Function Modifiers *\\n **********************/\\n\\n modifier onlyManager() {\\n require(\\n msg.sender == Lib_AddressManager(addressmgr).getAddress(CONFIG_OWNER_KEY),\\n \\\"MVM_L2ChainManagerOnL1: Function can only be called by the METIS_MANAGER.\\\"\\n );\\n _;\\n }\\n\\n /********************\\n * Public Functions *\\n ********************/\\n function switchSequencer(\\n uint256 _chainId,\\n address wallet,\\n address manager\\n ) public payable onlyManager {\\n bytes memory message = abi.encodeWithSelector(\\n iOVM_SequencerFeeVault.finalizeChainSwitch.selector,\\n wallet,\\n manager\\n );\\n\\n // Send calldata into L2\\n sendCrossDomainMessageViaChainId(\\n _chainId,\\n Lib_PredeployAddresses.SEQUENCER_FEE_WALLET,\\n uint32(1_000_000_000),\\n message,\\n msg.value\\n );\\n\\n emit SwitchSeq(_chainId, wallet, manager);\\n }\\n\\n function pushConfig(uint256 _chainId, bytes calldata _configs) public payable onlyManager {\\n bytes memory message = abi.encodeWithSelector(\\n iOVM_SequencerFeeVault.finalizeChainConfig.selector,\\n _configs\\n );\\n\\n // Send calldata into L2\\n sendCrossDomainMessageViaChainId(\\n _chainId,\\n Lib_PredeployAddresses.SEQUENCER_FEE_WALLET,\\n uint32(1_000_000_000),\\n message,\\n msg.value\\n );\\n\\n emit PushConfig(_chainId, _configs);\\n }\\n}\\n\",\"keccak256\":\"0x39c4c32803b3db215ff826a5d7272ed801fa3a127ff7144668f700e6efb93650\",\"license\":\"MIT\"},\"contracts/MVM/iMVM_DiscountOracle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\ninterface iMVM_DiscountOracle {\\n function setDiscount(uint256 _discount) external;\\n\\n function setMinL2Gas(uint256 _minL2Gas) external;\\n\\n function setWhitelistedXDomainSender(address _sender, bool _isWhitelisted) external;\\n\\n function isXDomainSenderAllowed(address _sender) external view returns (bool);\\n\\n function setAllowAllXDomainSenders(bool _allowAllXDomainSenders) external;\\n\\n function getMinL2Gas() external view returns (uint256);\\n\\n function getDiscount() external view returns (uint256);\\n\\n function processL2SeqGas(address sender, uint256 _chainId) external payable;\\n\\n function withdrawToSeq(uint256 _amount, uint256 _chainId) external;\\n}\\n\",\"keccak256\":\"0x5fae2a8ff4190e28fc8a9bb6a0f258e21d07b1487f734b634c692f732c313f37\",\"license\":\"MIT\"},\"contracts/MVM/iMVM_L2ChainManagerOnL1.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\npragma experimental ABIEncoderV2;\\n\\n/* Interface Imports */\\n\\n/* External Imports */\\n\\n/**\\n * @title MVM_L2ChainManagerOnL1\\n * @dev if want support multi l2 chain on l1,it should add a manager to desc\\n * how many l2 chain now ,and dispatch the l2 chain id to make it is unique.\\n *\\n * Compiler used: solc\\n * Runtime target: EVM\\n */\\ninterface iMVM_L2ChainManagerOnL1 {\\n event SwitchSeq(uint256 chainid, address wallet, address manager);\\n event PushConfig(uint256 chainid, bytes configs);\\n\\n /********************\\n * Public Functions *\\n ********************/\\n function switchSequencer(\\n uint256 _chainId,\\n address wallet,\\n address manager\\n ) external payable;\\n\\n function pushConfig(uint256 _chainId, bytes calldata configs) external payable;\\n}\\n\",\"keccak256\":\"0xb8bc5e16135b433673c07c12bc40c8171a3a667048fb8879fbe5e52ce0671f8c\",\"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 * Runtime target: 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 \\\"OVM_XCHAIN: messenger contract unauthenticated\\\"\\n );\\n\\n require(\\n getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,\\n \\\"OVM_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 uint256 fee\\n ) internal {\\n getCrossDomainMessenger().sendMessage{ value: fee }(\\n _crossDomainTarget,\\n _message,\\n _gasLimit\\n );\\n }\\n\\n /**\\n * @notice Sends a message to an account on another domain\\n * @param _chainId L2 chain id.\\n * @param _crossDomainTarget The intended recipient on the destination domain\\n * @param _gasLimit The gasLimit for the receipt of the message on the target domain.\\n * @param _message The data to send to the target (usually calldata to a function with `onlyFromCrossDomainAccount()`)\\n */\\n function sendCrossDomainMessageViaChainId(\\n uint256 _chainId,\\n address _crossDomainTarget,\\n uint32 _gasLimit,\\n bytes memory _message,\\n uint256 fee\\n ) internal {\\n getCrossDomainMessenger().sendMessageViaChainId{ value: fee }(\\n _chainId,\\n _crossDomainTarget,\\n _message,\\n _gasLimit\\n );\\n }\\n}\\n\",\"keccak256\":\"0x212c518d3885cfb01ac3435929aa2fe8e0e693e8a243b35e31501400d76fd585\",\"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 uint256 chainId\\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 payable;\\n\\n /**\\n * Sends a cross domain message to the target messenger.\\n * @param _chainId L2 chain id.\\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 sendMessageViaChainId(\\n uint256 _chainId,\\n address _target,\\n bytes calldata _message,\\n uint32 _gasLimit\\n ) external payable;\\n}\\n\",\"keccak256\":\"0xf60aa858a26d3cbde2efb1d8825c581278804445361ab7426aadeeb1e4e2fabe\",\"license\":\"MIT\"},\"contracts/libraries/constants/Lib_PredeployAddresses.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Lib_PredeployAddresses\\n */\\nlibrary Lib_PredeployAddresses {\\n address internal constant L2_TO_L1_MESSAGE_PASSER = 0x4200000000000000000000000000000000000000;\\n address internal constant L1_MESSAGE_SENDER = 0x4200000000000000000000000000000000000001;\\n address internal constant DEPLOYER_WHITELIST = 0x4200000000000000000000000000000000000002;\\n address internal constant MVM_CHAIN_CONFIG = 0x4200000000000000000000000000000000000005;\\n address internal constant OVM_ETH = 0x420000000000000000000000000000000000000A;\\n address internal constant MVM_COINBASE = 0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000;\\n address internal constant L2_CROSS_DOMAIN_MESSENGER =\\n 0x4200000000000000000000000000000000000007;\\n address internal constant LIB_ADDRESS_MANAGER = 0x4200000000000000000000000000000000000008;\\n address internal constant PROXY_EOA = 0x4200000000000000000000000000000000000009;\\n address internal constant L2_STANDARD_BRIDGE = 0x4200000000000000000000000000000000000010;\\n address payable internal constant SEQUENCER_FEE_WALLET =\\n payable(0x4200000000000000000000000000000000000011);\\n address internal constant L2_STANDARD_TOKEN_FACTORY =\\n 0x4200000000000000000000000000000000000012;\\n address internal constant L1_BLOCK_NUMBER = 0x4200000000000000000000000000000000000013;\\n address internal constant OVM_GASPRICE_ORACLE = 0x420000000000000000000000000000000000000F;\\n}\\n\",\"keccak256\":\"0x7043ee8f718a47aaf1bdcc24c64b879f993b5a9f2a7510c8663d15c0b681725d\",\"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/utils/Lib_Uint.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Lib_Uint\\n * @author\\n */\\nlibrary Lib_Uint {\\n /**********************\\n * Internal Functions *\\n **********************/\\n\\n /**\\n * Convert uint to string\\n * @param _i uint value.\\n * @return _uintAsString string momery value.\\n */\\n function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {\\n if (_i == 0) {\\n return \\\"0\\\";\\n }\\n uint256 j = _i;\\n uint256 len;\\n while (j != 0) {\\n len++;\\n j /= 10;\\n }\\n bytes memory bstr = new bytes(len);\\n uint256 k = len;\\n while (_i != 0) {\\n k = k - 1;\\n uint8 temp = (48 + uint8(_i - (_i / 10) * 10));\\n bytes1 b1 = bytes1(temp);\\n bstr[k] = b1;\\n _i /= 10;\\n }\\n return string(bstr);\\n }\\n}\\n\",\"keccak256\":\"0x00408d812fdd202f5693796c9b67821b5c7114aca93484c88cdc63b0caa3c288\",\"license\":\"MIT\"},\"contracts/standards/IL2StandardERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC165 } from \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\n\\ninterface IL2StandardERC20 is IERC20, IERC165 {\\n function l1Token() external returns (address);\\n\\n function mint(address _to, uint256 _amount) external;\\n\\n function burn(address _from, uint256 _amount) external;\\n\\n event Mint(address indexed _account, uint256 _amount);\\n event Burn(address indexed _account, uint256 _amount);\\n}\\n\",\"keccak256\":\"0xef4cf5b2335d7709c88f0d16f7fa9965e618a7572d47bb75bcdbebb88e96a21a\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "details": "if want support multi l2 chain on l1,it should add a manager to desc how many l2 chain now ,and dispatch the l2 chain id to make it is unique. Compiler used: solc Runtime target: EVM", "kind": "dev", "methods": {}, "title": "MVM_L2ChainManagerOnL1", "version": 1 }, "userdoc": { "kind": "user", "methods": {}, "version": 1 }, "storageLayout": { "storage": [ { "astId": 32769, "contract": "contracts/MVM/MVM_L2ChainManagerOnL1.sol:MVM_L2ChainManagerOnL1", "label": "messenger", "offset": 0, "slot": "0", "type": "t_address" }, { "astId": 27713, "contract": "contracts/MVM/MVM_L2ChainManagerOnL1.sol:MVM_L2ChainManagerOnL1", "label": "addressmgr", "offset": 0, "slot": "1", "type": "t_address" }, { "astId": 27717, "contract": "contracts/MVM/MVM_L2ChainManagerOnL1.sol:MVM_L2ChainManagerOnL1", "label": "squencers", "offset": 0, "slot": "2", "type": "t_mapping(t_uint256,t_address)" }, { "astId": 27721, "contract": "contracts/MVM/MVM_L2ChainManagerOnL1.sol:MVM_L2ChainManagerOnL1", "label": "configs", "offset": 0, "slot": "3", "type": "t_mapping(t_uint256,t_bytes_storage)" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_bytes_storage": { "encoding": "bytes", "label": "bytes", "numberOfBytes": "32" }, "t_mapping(t_uint256,t_address)": { "encoding": "mapping", "key": "t_uint256", "label": "mapping(uint256 => address)", "numberOfBytes": "32", "value": "t_address" }, "t_mapping(t_uint256,t_bytes_storage)": { "encoding": "mapping", "key": "t_uint256", "label": "mapping(uint256 => bytes)", "numberOfBytes": "32", "value": "t_bytes_storage" }, "t_uint256": { "encoding": "inplace", "label": "uint256", "numberOfBytes": "32" } } } }