{
  "address": "0x2fBFa09Db7f33b7a8fBCEEf80C75DA48E6B8c550",
  "abi": [
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_messenger",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_otherBridge",
          "type": "address"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "constructor"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "localToken",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "remoteToken",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "from",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "address",
          "name": "to",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "tokenId",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "bytes",
          "name": "extraData",
          "type": "bytes"
        }
      ],
      "name": "ERC721BridgeFinalized",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "localToken",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "remoteToken",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "from",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "address",
          "name": "to",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "tokenId",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "bytes",
          "name": "extraData",
          "type": "bytes"
        }
      ],
      "name": "ERC721BridgeInitiated",
      "type": "event"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_localToken",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_remoteToken",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "_tokenId",
          "type": "uint256"
        },
        {
          "internalType": "uint32",
          "name": "_minGasLimit",
          "type": "uint32"
        },
        {
          "internalType": "bytes",
          "name": "_extraData",
          "type": "bytes"
        }
      ],
      "name": "bridgeERC721",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_localToken",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_remoteToken",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_to",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "_tokenId",
          "type": "uint256"
        },
        {
          "internalType": "uint32",
          "name": "_minGasLimit",
          "type": "uint32"
        },
        {
          "internalType": "bytes",
          "name": "_extraData",
          "type": "bytes"
        }
      ],
      "name": "bridgeERC721To",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_localToken",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_remoteToken",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_from",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_to",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "_tokenId",
          "type": "uint256"
        },
        {
          "internalType": "bytes",
          "name": "_extraData",
          "type": "bytes"
        }
      ],
      "name": "finalizeBridgeERC721",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "messenger",
      "outputs": [
        {
          "internalType": "contract CrossDomainMessenger",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "otherBridge",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "version",
      "outputs": [
        {
          "internalType": "string",
          "name": "",
          "type": "string"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    }
  ],
  "transactionHash": "0x8363e49e509912bacb8b74e676cc4d1f7470c2ed9df31b93ccf4cb951bfec27a",
  "receipt": {
    "to": null,
    "from": "0x5c679a57e018F5F146838138d3E032Ef4913D551",
    "contractAddress": "0x2fBFa09Db7f33b7a8fBCEEf80C75DA48E6B8c550",
    "transactionIndex": 0,
    "gasUsed": "1344187",
    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "blockHash": "0x5aaf338316da4a5490579ef2d262419e00fc47635c18308f7491535236e31650",
    "transactionHash": "0x8363e49e509912bacb8b74e676cc4d1f7470c2ed9df31b93ccf4cb951bfec27a",
    "logs": [],
    "blockNumber": 1562997,
    "cumulativeGasUsed": "1344187",
    "status": 1,
    "byzantium": true
  },
  "args": [
    "0x4200000000000000000000000000000000000007",
    "0x8DD330DdE8D9898d43b4dc840Da27A07dF91b3c9"
  ],
  "numDeployments": 1,
  "solcInputHash": "ab9b77493f35e63b7a63fb2fa8d618b4",
  "metadata": "{\"compiler\":{\"version\":\"0.8.15+commit.e14f2714\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_messenger\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_otherBridge\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"localToken\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"remoteToken\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"ERC721BridgeFinalized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"localToken\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"remoteToken\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"ERC721BridgeInitiated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_localToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_remoteToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"_minGasLimit\",\"type\":\"uint32\"},{\"internalType\":\"bytes\",\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"bridgeERC721\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_localToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_remoteToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"_minGasLimit\",\"type\":\"uint32\"},{\"internalType\":\"bytes\",\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"bridgeERC721To\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_localToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_remoteToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"finalizeBridgeERC721\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"messenger\",\"outputs\":[{\"internalType\":\"contract CrossDomainMessenger\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"otherBridge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"bridgeERC721(address,address,uint256,uint32,bytes)\":{\"params\":{\"_extraData\":\"Optional data to forward to the other chain. Data supplied here will not                     be used to execute any code on the other chain and is only emitted as                     extra data for the convenience of off-chain tooling.\",\"_localToken\":\"Address of the ERC721 on this domain.\",\"_minGasLimit\":\"Minimum gas limit for the bridge message on the other domain.\",\"_remoteToken\":\"Address of the ERC721 on the remote domain.\",\"_tokenId\":\"Token ID to bridge.\"}},\"bridgeERC721To(address,address,address,uint256,uint32,bytes)\":{\"params\":{\"_extraData\":\"Optional data to forward to the other chain. Data supplied here will not                     be used to execute any code on the other chain and is only emitted as                     extra data for the convenience of off-chain tooling.\",\"_localToken\":\"Address of the ERC721 on this domain.\",\"_minGasLimit\":\"Minimum gas limit for the bridge message on the other domain.\",\"_remoteToken\":\"Address of the ERC721 on the remote domain.\",\"_to\":\"Address to receive the token on the other domain.\",\"_tokenId\":\"Token ID to bridge.\"}},\"constructor\":{\"custom:semver\":\"1.0.0\",\"params\":{\"_messenger\":\"Address of the CrossDomainMessenger on this network.\",\"_otherBridge\":\"Address of the ERC721 bridge on the other network.\"}},\"finalizeBridgeERC721(address,address,address,address,uint256,bytes)\":{\"params\":{\"_extraData\":\"Optional data to forward to L1. Data supplied here will not be used to                     execute any code on L1 and is only emitted as extra data for the                     convenience of off-chain tooling.\",\"_from\":\"Address that triggered the bridge on the other domain.\",\"_localToken\":\"Address of the ERC721 token on this domain.\",\"_remoteToken\":\"Address of the ERC721 token on the other domain.\",\"_to\":\"Address to receive the token on this domain.\",\"_tokenId\":\"ID of the token being deposited.\"}},\"version()\":{\"returns\":{\"_0\":\"Semver contract version as a string.\"}}},\"title\":\"L2ERC721Bridge\",\"version\":1},\"userdoc\":{\"events\":{\"ERC721BridgeFinalized(address,address,address,address,uint256,bytes)\":{\"notice\":\"Emitted when an ERC721 bridge from the other network is finalized.\"},\"ERC721BridgeInitiated(address,address,address,address,uint256,bytes)\":{\"notice\":\"Emitted when an ERC721 bridge to the other network is initiated.\"}},\"kind\":\"user\",\"methods\":{\"bridgeERC721(address,address,uint256,uint32,bytes)\":{\"notice\":\"Initiates a bridge of an NFT to the caller's account on the other chain. Note that         this function can only be called by EOAs. Smart contract wallets should use the         `bridgeERC721To` function after ensuring that the recipient address on the remote         chain exists. Also note that the current owner of the token on this chain must         approve this contract to operate the NFT before it can be bridged.         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This         bridge only supports ERC721s originally deployed on Ethereum. Users will need to         wait for the one-week challenge period to elapse before their Optimism-native NFT         can be refunded on L2.\"},\"bridgeERC721To(address,address,address,uint256,uint32,bytes)\":{\"notice\":\"Initiates a bridge of an NFT to some recipient's account on the other chain. Note         that the current owner of the token on this chain must approve this contract to         operate the NFT before it can be bridged.         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This         bridge only supports ERC721s originally deployed on Ethereum. Users will need to         wait for the one-week challenge period to elapse before their Optimism-native NFT         can be refunded on L2.\"},\"finalizeBridgeERC721(address,address,address,address,uint256,bytes)\":{\"notice\":\"Completes an ERC721 bridge from the other domain and sends the ERC721 token to the         recipient on this domain.\"},\"messenger()\":{\"notice\":\"Messenger contract on this domain.\"},\"otherBridge()\":{\"notice\":\"Address of the bridge on the other network.\"},\"version()\":{\"notice\":\"Returns the full semver contract version.\"}},\"notice\":\"The L2 ERC721 bridge is a contract which works together with the L1 ERC721 bridge to         make it possible to transfer ERC721 tokens from Ethereum to Optimism. This contract         acts as a minter for new tokens when it hears about deposits into the L1 ERC721 bridge.         This contract also acts as a burner for tokens being withdrawn.         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This         bridge ONLY supports ERC721s originally deployed on Ethereum. Users will need to         wait for the one-week challenge period to elapse before their Optimism-native NFT         can be refunded on L2.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/L2/L2ERC721Bridge.sol\":\"L2ERC721Bridge\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@eth-optimism/contracts-bedrock/contracts/libraries/Encoding.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Types } from \\\"./Types.sol\\\";\\nimport { Hashing } from \\\"./Hashing.sol\\\";\\nimport { RLPWriter } from \\\"./rlp/RLPWriter.sol\\\";\\n\\n/**\\n * @title Encoding\\n * @notice Encoding handles Optimism's various different encoding schemes.\\n */\\nlibrary Encoding {\\n    /**\\n     * @notice RLP encodes the L2 transaction that would be generated when a given deposit is sent\\n     *         to the L2 system. Useful for searching for a deposit in the L2 system. The\\n     *         transaction is prefixed with 0x7e to identify its EIP-2718 type.\\n     *\\n     * @param _tx User deposit transaction to encode.\\n     *\\n     * @return RLP encoded L2 deposit transaction.\\n     */\\n    function encodeDepositTransaction(Types.UserDepositTransaction memory _tx)\\n        internal\\n        pure\\n        returns (bytes memory)\\n    {\\n        bytes32 source = Hashing.hashDepositSource(_tx.l1BlockHash, _tx.logIndex);\\n        bytes[] memory raw = new bytes[](8);\\n        raw[0] = RLPWriter.writeBytes(abi.encodePacked(source));\\n        raw[1] = RLPWriter.writeAddress(_tx.from);\\n        raw[2] = _tx.isCreation ? RLPWriter.writeBytes(\\\"\\\") : RLPWriter.writeAddress(_tx.to);\\n        raw[3] = RLPWriter.writeUint(_tx.mint);\\n        raw[4] = RLPWriter.writeUint(_tx.value);\\n        raw[5] = RLPWriter.writeUint(uint256(_tx.gasLimit));\\n        raw[6] = RLPWriter.writeBool(false);\\n        raw[7] = RLPWriter.writeBytes(_tx.data);\\n        return abi.encodePacked(uint8(0x7e), RLPWriter.writeList(raw));\\n    }\\n\\n    /**\\n     * @notice Encodes the cross domain message based on the version that is encoded into the\\n     *         message nonce.\\n     *\\n     * @param _nonce    Message nonce with version encoded into the first two bytes.\\n     * @param _sender   Address of the sender of the message.\\n     * @param _target   Address of the target of the message.\\n     * @param _value    ETH value to send to the target.\\n     * @param _gasLimit Gas limit to use for the message.\\n     * @param _data     Data to send with the message.\\n     *\\n     * @return Encoded cross domain message.\\n     */\\n    function encodeCrossDomainMessage(\\n        uint256 _nonce,\\n        address _sender,\\n        address _target,\\n        uint256 _value,\\n        uint256 _gasLimit,\\n        bytes memory _data\\n    ) internal pure returns (bytes memory) {\\n        (, uint16 version) = decodeVersionedNonce(_nonce);\\n        if (version == 0) {\\n            return encodeCrossDomainMessageV0(_target, _sender, _data, _nonce);\\n        } else if (version == 1) {\\n            return encodeCrossDomainMessageV1(_nonce, _sender, _target, _value, _gasLimit, _data);\\n        } else {\\n            revert(\\\"Encoding: unknown cross domain message version\\\");\\n        }\\n    }\\n\\n    /**\\n     * @notice Encodes a cross domain message based on the V0 (legacy) encoding.\\n     *\\n     * @param _target Address of the target of the message.\\n     * @param _sender Address of the sender of the message.\\n     * @param _data   Data to send with the message.\\n     * @param _nonce  Message nonce.\\n     *\\n     * @return Encoded cross domain message.\\n     */\\n    function encodeCrossDomainMessageV0(\\n        address _target,\\n        address _sender,\\n        bytes memory _data,\\n        uint256 _nonce\\n    ) internal pure returns (bytes memory) {\\n        return\\n            abi.encodeWithSignature(\\n                \\\"relayMessage(address,address,bytes,uint256)\\\",\\n                _target,\\n                _sender,\\n                _data,\\n                _nonce\\n            );\\n    }\\n\\n    /**\\n     * @notice Encodes a cross domain message based on the V1 (current) encoding.\\n     *\\n     * @param _nonce    Message nonce.\\n     * @param _sender   Address of the sender of the message.\\n     * @param _target   Address of the target of the message.\\n     * @param _value    ETH value to send to the target.\\n     * @param _gasLimit Gas limit to use for the message.\\n     * @param _data     Data to send with the message.\\n     *\\n     * @return Encoded cross domain message.\\n     */\\n    function encodeCrossDomainMessageV1(\\n        uint256 _nonce,\\n        address _sender,\\n        address _target,\\n        uint256 _value,\\n        uint256 _gasLimit,\\n        bytes memory _data\\n    ) internal pure returns (bytes memory) {\\n        return\\n            abi.encodeWithSignature(\\n                \\\"relayMessage(uint256,address,address,uint256,uint256,bytes)\\\",\\n                _nonce,\\n                _sender,\\n                _target,\\n                _value,\\n                _gasLimit,\\n                _data\\n            );\\n    }\\n\\n    /**\\n     * @notice Adds a version number into the first two bytes of a message nonce.\\n     *\\n     * @param _nonce   Message nonce to encode into.\\n     * @param _version Version number to encode into the message nonce.\\n     *\\n     * @return Message nonce with version encoded into the first two bytes.\\n     */\\n    function encodeVersionedNonce(uint240 _nonce, uint16 _version) internal pure returns (uint256) {\\n        uint256 nonce;\\n        assembly {\\n            nonce := or(shl(240, _version), _nonce)\\n        }\\n        return nonce;\\n    }\\n\\n    /**\\n     * @notice Pulls the version out of a version-encoded nonce.\\n     *\\n     * @param _nonce Message nonce with version encoded into the first two bytes.\\n     *\\n     * @return Nonce without encoded version.\\n     * @return Version of the message.\\n     */\\n    function decodeVersionedNonce(uint256 _nonce) internal pure returns (uint240, uint16) {\\n        uint240 nonce;\\n        uint16 version;\\n        assembly {\\n            nonce := and(_nonce, 0x0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\\n            version := shr(240, _nonce)\\n        }\\n        return (nonce, version);\\n    }\\n}\\n\",\"keccak256\":\"0x170cd0821cec37976a6391da20f1dcdcb1ea9ffada96ccd3c57ff2e357589418\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/libraries/Hashing.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Types } from \\\"./Types.sol\\\";\\nimport { Encoding } from \\\"./Encoding.sol\\\";\\n\\n/**\\n * @title Hashing\\n * @notice Hashing handles Optimism's various different hashing schemes.\\n */\\nlibrary Hashing {\\n    /**\\n     * @notice Computes the hash of the RLP encoded L2 transaction that would be generated when a\\n     *         given deposit is sent to the L2 system. Useful for searching for a deposit in the L2\\n     *         system.\\n     *\\n     * @param _tx User deposit transaction to hash.\\n     *\\n     * @return Hash of the RLP encoded L2 deposit transaction.\\n     */\\n    function hashDepositTransaction(Types.UserDepositTransaction memory _tx)\\n        internal\\n        pure\\n        returns (bytes32)\\n    {\\n        return keccak256(Encoding.encodeDepositTransaction(_tx));\\n    }\\n\\n    /**\\n     * @notice Computes the deposit transaction's \\\"source hash\\\", a value that guarantees the hash\\n     *         of the L2 transaction that corresponds to a deposit is unique and is\\n     *         deterministically generated from L1 transaction data.\\n     *\\n     * @param _l1BlockHash Hash of the L1 block where the deposit was included.\\n     * @param _logIndex    The index of the log that created the deposit transaction.\\n     *\\n     * @return Hash of the deposit transaction's \\\"source hash\\\".\\n     */\\n    function hashDepositSource(bytes32 _l1BlockHash, uint256 _logIndex)\\n        internal\\n        pure\\n        returns (bytes32)\\n    {\\n        bytes32 depositId = keccak256(abi.encode(_l1BlockHash, _logIndex));\\n        return keccak256(abi.encode(bytes32(0), depositId));\\n    }\\n\\n    /**\\n     * @notice Hashes the cross domain message based on the version that is encoded into the\\n     *         message nonce.\\n     *\\n     * @param _nonce    Message nonce with version encoded into the first two bytes.\\n     * @param _sender   Address of the sender of the message.\\n     * @param _target   Address of the target of the message.\\n     * @param _value    ETH value to send to the target.\\n     * @param _gasLimit Gas limit to use for the message.\\n     * @param _data     Data to send with the message.\\n     *\\n     * @return Hashed cross domain message.\\n     */\\n    function hashCrossDomainMessage(\\n        uint256 _nonce,\\n        address _sender,\\n        address _target,\\n        uint256 _value,\\n        uint256 _gasLimit,\\n        bytes memory _data\\n    ) internal pure returns (bytes32) {\\n        (, uint16 version) = Encoding.decodeVersionedNonce(_nonce);\\n        if (version == 0) {\\n            return hashCrossDomainMessageV0(_target, _sender, _data, _nonce);\\n        } else if (version == 1) {\\n            return hashCrossDomainMessageV1(_nonce, _sender, _target, _value, _gasLimit, _data);\\n        } else {\\n            revert(\\\"Hashing: unknown cross domain message version\\\");\\n        }\\n    }\\n\\n    /**\\n     * @notice Hashes a cross domain message based on the V0 (legacy) encoding.\\n     *\\n     * @param _target Address of the target of the message.\\n     * @param _sender Address of the sender of the message.\\n     * @param _data   Data to send with the message.\\n     * @param _nonce  Message nonce.\\n     *\\n     * @return Hashed cross domain message.\\n     */\\n    function hashCrossDomainMessageV0(\\n        address _target,\\n        address _sender,\\n        bytes memory _data,\\n        uint256 _nonce\\n    ) internal pure returns (bytes32) {\\n        return keccak256(Encoding.encodeCrossDomainMessageV0(_target, _sender, _data, _nonce));\\n    }\\n\\n    /**\\n     * @notice Hashes a cross domain message based on the V1 (current) encoding.\\n     *\\n     * @param _nonce    Message nonce.\\n     * @param _sender   Address of the sender of the message.\\n     * @param _target   Address of the target of the message.\\n     * @param _value    ETH value to send to the target.\\n     * @param _gasLimit Gas limit to use for the message.\\n     * @param _data     Data to send with the message.\\n     *\\n     * @return Hashed cross domain message.\\n     */\\n    function hashCrossDomainMessageV1(\\n        uint256 _nonce,\\n        address _sender,\\n        address _target,\\n        uint256 _value,\\n        uint256 _gasLimit,\\n        bytes memory _data\\n    ) internal pure returns (bytes32) {\\n        return\\n            keccak256(\\n                Encoding.encodeCrossDomainMessageV1(\\n                    _nonce,\\n                    _sender,\\n                    _target,\\n                    _value,\\n                    _gasLimit,\\n                    _data\\n                )\\n            );\\n    }\\n\\n    /**\\n     * @notice Derives the withdrawal hash according to the encoding in the L2 Withdrawer contract\\n     *\\n     * @param _tx Withdrawal transaction to hash.\\n     *\\n     * @return Hashed withdrawal transaction.\\n     */\\n    function hashWithdrawal(Types.WithdrawalTransaction memory _tx)\\n        internal\\n        pure\\n        returns (bytes32)\\n    {\\n        return\\n            keccak256(\\n                abi.encode(_tx.nonce, _tx.sender, _tx.target, _tx.value, _tx.gasLimit, _tx.data)\\n            );\\n    }\\n\\n    /**\\n     * @notice Hashes the various elements of an output root proof into an output root hash which\\n     *         can be used to check if the proof is valid.\\n     *\\n     * @param _outputRootProof Output root proof which should hash to an output root.\\n     *\\n     * @return Hashed output root proof.\\n     */\\n    function hashOutputRootProof(Types.OutputRootProof memory _outputRootProof)\\n        internal\\n        pure\\n        returns (bytes32)\\n    {\\n        return\\n            keccak256(\\n                abi.encode(\\n                    _outputRootProof.version,\\n                    _outputRootProof.stateRoot,\\n                    _outputRootProof.messagePasserStorageRoot,\\n                    _outputRootProof.latestBlockhash\\n                )\\n            );\\n    }\\n}\\n\",\"keccak256\":\"0x5d4988987899306d2785b3de068194a39f8e829a7864762a07a0016db5189f5e\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/libraries/SafeCall.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.15;\\n\\n/**\\n * @title SafeCall\\n * @notice Perform low level safe calls\\n */\\nlibrary SafeCall {\\n    /**\\n     * @notice Perform a low level call without copying any returndata\\n     *\\n     * @param _target   Address to call\\n     * @param _gas      Amount of gas to pass to the call\\n     * @param _value    Amount of value to pass to the call\\n     * @param _calldata Calldata to pass to the call\\n     */\\n    function call(\\n        address _target,\\n        uint256 _gas,\\n        uint256 _value,\\n        bytes memory _calldata\\n    ) internal returns (bool) {\\n        bool _success;\\n        assembly {\\n            _success := call(\\n                _gas, // gas\\n                _target, // recipient\\n                _value, // ether value\\n                add(_calldata, 0x20), // inloc\\n                mload(_calldata), // inlen\\n                0, // outloc\\n                0 // outlen\\n            )\\n        }\\n        return _success;\\n    }\\n}\\n\",\"keccak256\":\"0xbb0621c028c18e9d5a54cf1a8136cf2e77f161de48aeb8d911e230f6b280c9ed\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/libraries/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Types\\n * @notice Contains various types used throughout the Optimism contract system.\\n */\\nlibrary Types {\\n    /**\\n     * @notice OutputProposal represents a commitment to the L2 state. The timestamp is the L1\\n     *         timestamp that the output root is posted. This timestamp is used to verify that the\\n     *         finalization period has passed since the output root was submitted.\\n     */\\n    struct OutputProposal {\\n        bytes32 outputRoot;\\n        uint256 timestamp;\\n    }\\n\\n    /**\\n     * @notice Struct representing the elements that are hashed together to generate an output root\\n     *         which itself represents a snapshot of the L2 state.\\n     */\\n    struct OutputRootProof {\\n        bytes32 version;\\n        bytes32 stateRoot;\\n        bytes32 messagePasserStorageRoot;\\n        bytes32 latestBlockhash;\\n    }\\n\\n    /**\\n     * @notice Struct representing a deposit transaction (L1 => L2 transaction) created by an end\\n     *         user (as opposed to a system deposit transaction generated by the system).\\n     */\\n    struct UserDepositTransaction {\\n        address from;\\n        address to;\\n        bool isCreation;\\n        uint256 value;\\n        uint256 mint;\\n        uint64 gasLimit;\\n        bytes data;\\n        bytes32 l1BlockHash;\\n        uint256 logIndex;\\n    }\\n\\n    /**\\n     * @notice Struct representing a withdrawal transaction.\\n     */\\n    struct WithdrawalTransaction {\\n        uint256 nonce;\\n        address sender;\\n        address target;\\n        uint256 value;\\n        uint256 gasLimit;\\n        bytes data;\\n    }\\n}\\n\",\"keccak256\":\"0x69ca98e57a7cbe60cffeb0f76f6f9279010941b1931581e9a35478f30e2546d1\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/libraries/rlp/RLPWriter.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @custom:attribution https://github.com/bakaoh/solidity-rlp-encode\\n * @title RLPWriter\\n * @author RLPWriter is a library for encoding Solidity types to RLP bytes. Adapted from Bakaoh's\\n *         RLPEncode library (https://github.com/bakaoh/solidity-rlp-encode) with minor\\n *         modifications to improve legibility.\\n */\\nlibrary RLPWriter {\\n    /**\\n     * @notice RLP encodes a byte string.\\n     *\\n     * @param _in The byte string to encode.\\n     *\\n     * @return The RLP encoded string in bytes.\\n     */\\n    function writeBytes(bytes memory _in) internal pure returns (bytes memory) {\\n        bytes memory encoded;\\n\\n        if (_in.length == 1 && uint8(_in[0]) < 128) {\\n            encoded = _in;\\n        } else {\\n            encoded = abi.encodePacked(_writeLength(_in.length, 128), _in);\\n        }\\n\\n        return encoded;\\n    }\\n\\n    /**\\n     * @notice RLP encodes a list of RLP encoded byte byte strings.\\n     *\\n     * @param _in The list of RLP encoded byte strings.\\n     *\\n     * @return The RLP encoded list of items in bytes.\\n     */\\n    function writeList(bytes[] memory _in) internal pure returns (bytes memory) {\\n        bytes memory list = _flatten(_in);\\n        return abi.encodePacked(_writeLength(list.length, 192), list);\\n    }\\n\\n    /**\\n     * @notice RLP encodes a string.\\n     *\\n     * @param _in The string to encode.\\n     *\\n     * @return The RLP encoded string in bytes.\\n     */\\n    function writeString(string memory _in) internal pure returns (bytes memory) {\\n        return writeBytes(bytes(_in));\\n    }\\n\\n    /**\\n     * @notice RLP encodes an address.\\n     *\\n     * @param _in The address to encode.\\n     *\\n     * @return The RLP encoded address in bytes.\\n     */\\n    function writeAddress(address _in) internal pure returns (bytes memory) {\\n        return writeBytes(abi.encodePacked(_in));\\n    }\\n\\n    /**\\n     * @notice RLP encodes a uint.\\n     *\\n     * @param _in The uint256 to encode.\\n     *\\n     * @return The RLP encoded uint256 in bytes.\\n     */\\n    function writeUint(uint256 _in) internal pure returns (bytes memory) {\\n        return writeBytes(_toBinary(_in));\\n    }\\n\\n    /**\\n     * @notice RLP encodes a bool.\\n     *\\n     * @param _in The bool to encode.\\n     *\\n     * @return The RLP encoded bool in bytes.\\n     */\\n    function writeBool(bool _in) internal pure returns (bytes memory) {\\n        bytes memory encoded = new bytes(1);\\n        encoded[0] = (_in ? bytes1(0x01) : bytes1(0x80));\\n        return encoded;\\n    }\\n\\n    /**\\n     * @notice Encode the first byte and then the `len` in binary form if `length` is more than 55.\\n     *\\n     * @param _len    The length of the string or the payload.\\n     * @param _offset 128 if item is string, 192 if item is list.\\n     *\\n     * @return RLP encoded bytes.\\n     */\\n    function _writeLength(uint256 _len, uint256 _offset) private pure returns (bytes memory) {\\n        bytes memory encoded;\\n\\n        if (_len < 56) {\\n            encoded = new bytes(1);\\n            encoded[0] = bytes1(uint8(_len) + uint8(_offset));\\n        } else {\\n            uint256 lenLen;\\n            uint256 i = 1;\\n            while (_len / i != 0) {\\n                lenLen++;\\n                i *= 256;\\n            }\\n\\n            encoded = new bytes(lenLen + 1);\\n            encoded[0] = bytes1(uint8(lenLen) + uint8(_offset) + 55);\\n            for (i = 1; i <= lenLen; i++) {\\n                encoded[i] = bytes1(uint8((_len / (256**(lenLen - i))) % 256));\\n            }\\n        }\\n\\n        return encoded;\\n    }\\n\\n    /**\\n     * @notice Encode integer in big endian binary form with no leading zeroes.\\n     *\\n     * @param _x The integer to encode.\\n     *\\n     * @return RLP encoded bytes.\\n     */\\n    function _toBinary(uint256 _x) private pure returns (bytes memory) {\\n        bytes memory b = abi.encodePacked(_x);\\n\\n        uint256 i = 0;\\n        for (; i < 32; i++) {\\n            if (b[i] != 0) {\\n                break;\\n            }\\n        }\\n\\n        bytes memory res = new bytes(32 - i);\\n        for (uint256 j = 0; j < res.length; j++) {\\n            res[j] = b[i++];\\n        }\\n\\n        return res;\\n    }\\n\\n    /**\\n     * @custom:attribution https://github.com/Arachnid/solidity-stringutils\\n     * @notice Copies a piece of memory to another location.\\n     *\\n     * @param _dest Destination location.\\n     * @param _src  Source location.\\n     * @param _len  Length of memory to copy.\\n     */\\n    function _memcpy(\\n        uint256 _dest,\\n        uint256 _src,\\n        uint256 _len\\n    ) private pure {\\n        uint256 dest = _dest;\\n        uint256 src = _src;\\n        uint256 len = _len;\\n\\n        for (; len >= 32; len -= 32) {\\n            assembly {\\n                mstore(dest, mload(src))\\n            }\\n            dest += 32;\\n            src += 32;\\n        }\\n\\n        uint256 mask;\\n        unchecked {\\n            mask = 256**(32 - len) - 1;\\n        }\\n        assembly {\\n            let srcpart := and(mload(src), not(mask))\\n            let destpart := and(mload(dest), mask)\\n            mstore(dest, or(destpart, srcpart))\\n        }\\n    }\\n\\n    /**\\n     * @custom:attribution https://github.com/sammayo/solidity-rlp-encoder\\n     * @notice Flattens a list of byte strings into one byte string.\\n     *\\n     * @param _list List of byte strings to flatten.\\n     *\\n     * @return The flattened byte string.\\n     */\\n    function _flatten(bytes[] memory _list) private pure returns (bytes memory) {\\n        if (_list.length == 0) {\\n            return new bytes(0);\\n        }\\n\\n        uint256 len;\\n        uint256 i = 0;\\n        for (; i < _list.length; i++) {\\n            len += _list[i].length;\\n        }\\n\\n        bytes memory flattened = new bytes(len);\\n        uint256 flattenedPtr;\\n        assembly {\\n            flattenedPtr := add(flattened, 0x20)\\n        }\\n\\n        for (i = 0; i < _list.length; i++) {\\n            bytes memory item = _list[i];\\n\\n            uint256 listPtr;\\n            assembly {\\n                listPtr := add(item, 0x20)\\n            }\\n\\n            _memcpy(flattenedPtr, listPtr, item.length);\\n            flattenedPtr += _list[i].length;\\n        }\\n\\n        return flattened;\\n    }\\n}\\n\",\"keccak256\":\"0x5aa9d21c5b41c9786f23153f819d561ae809a1d55c7b0d423dfeafdfbacedc78\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/universal/CrossDomainMessenger.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.15;\\n\\nimport {\\n    OwnableUpgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport {\\n    PausableUpgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport {\\n    ReentrancyGuardUpgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { SafeCall } from \\\"../libraries/SafeCall.sol\\\";\\nimport { Hashing } from \\\"../libraries/Hashing.sol\\\";\\nimport { Encoding } from \\\"../libraries/Encoding.sol\\\";\\n\\n/**\\n * @custom:legacy\\n * @title CrossDomainMessengerLegacySpacer\\n * @notice Contract only exists to add a spacer to the CrossDomainMessenger where the\\n *         libAddressManager variable used to exist. Must be the first contract in the inheritance\\n *         tree of the CrossDomainMessenger\\n */\\ncontract CrossDomainMessengerLegacySpacer {\\n    /**\\n     * @custom:legacy\\n     * @custom:spacer libAddressManager\\n     * @notice Spacer for backwards compatibility.\\n     */\\n    address private spacer_0_0_20;\\n}\\n\\n/**\\n * @custom:upgradeable\\n * @title CrossDomainMessenger\\n * @notice CrossDomainMessenger is a base contract that provides the core logic for the L1 and L2\\n *         cross-chain messenger contracts. It's designed to be a universal interface that only\\n *         needs to be extended slightly to provide low-level message passing functionality on each\\n *         chain it's deployed on. Currently only designed for message passing between two paired\\n *         chains and does not support one-to-many interactions.\\n */\\nabstract contract CrossDomainMessenger is\\n    CrossDomainMessengerLegacySpacer,\\n    OwnableUpgradeable,\\n    PausableUpgradeable,\\n    ReentrancyGuardUpgradeable\\n{\\n    /**\\n     * @notice Current message version identifier.\\n     */\\n    uint16 public constant MESSAGE_VERSION = 1;\\n\\n    /**\\n     * @notice Constant overhead added to the base gas for a message.\\n     */\\n    uint32 public constant MIN_GAS_CONSTANT_OVERHEAD = 200_000;\\n\\n    /**\\n     * @notice Numerator for dynamic overhead added to the base gas for a message.\\n     */\\n    uint32 public constant MIN_GAS_DYNAMIC_OVERHEAD_NUMERATOR = 1016;\\n\\n    /**\\n     * @notice Denominator for dynamic overhead added to the base gas for a message.\\n     */\\n    uint32 public constant MIN_GAS_DYNAMIC_OVERHEAD_DENOMINATOR = 1000;\\n\\n    /**\\n     * @notice Extra gas added to base gas for each byte of calldata in a message.\\n     */\\n    uint32 public constant MIN_GAS_CALLDATA_OVERHEAD = 16;\\n\\n    /**\\n     * @notice Minimum amount of gas required to relay a message.\\n     */\\n    uint256 internal constant RELAY_GAS_REQUIRED = 45_000;\\n\\n    /**\\n     * @notice Amount of gas held in reserve to guarantee that relay execution completes.\\n     */\\n    uint256 internal constant RELAY_GAS_BUFFER = RELAY_GAS_REQUIRED - 5000;\\n\\n    /**\\n     * @notice Initial value for the xDomainMsgSender variable. We set this to a non-zero value\\n     *         because performing an SSTORE on a non-zero value is significantly cheaper than on a\\n     *         zero value.\\n     */\\n    address internal constant DEFAULT_XDOMAIN_SENDER = 0x000000000000000000000000000000000000dEaD;\\n\\n    /**\\n     * @notice Address of the paired CrossDomainMessenger contract on the other chain.\\n     */\\n    address public immutable otherMessenger;\\n\\n    /**\\n     * @custom:legacy\\n     * @custom:spacer blockedMessages\\n     * @notice Spacer for backwards compatibility.\\n     */\\n    mapping(bytes32 => bool) private spacer_201_0_32;\\n\\n    /**\\n     * @custom:legacy\\n     * @custom:spacer relayedMessages\\n     * @notice Spacer for backwards compatibility.\\n     */\\n    mapping(bytes32 => bool) private spacer_202_0_32;\\n\\n    /**\\n     * @notice Mapping of message hashes to boolean receipt values. Note that a message will only\\n     *         be present in this mapping if it has successfully been relayed on this chain, and\\n     *         can therefore not be relayed again.\\n     */\\n    mapping(bytes32 => bool) public successfulMessages;\\n\\n    /**\\n     * @notice Address of the sender of the currently executing message on the other chain. If the\\n     *         value of this variable is the default value (0x00000000...dead) then no message is\\n     *         currently being executed. Use the xDomainMessageSender getter which will throw an\\n     *         error if this is the case.\\n     */\\n    address internal xDomainMsgSender;\\n\\n    /**\\n     * @notice Nonce for the next message to be sent, without the message version applied. Use the\\n     *         messageNonce getter which will insert the message version into the nonce to give you\\n     *         the actual nonce to be used for the message.\\n     */\\n    uint240 internal msgNonce;\\n\\n    /**\\n     * @notice Mapping of message hashes to boolean receipt values. Note that a message will only\\n     *         be present in this mapping if it failed to be relayed on this chain at least once.\\n     *         If a message is successfully relayed on the first attempt, then it will only be\\n     *         present within the successfulMessages mapping.\\n     */\\n    mapping(bytes32 => bool) public receivedMessages;\\n\\n    /**\\n     * @notice Reserve extra slots in the storage layout for future upgrades.\\n     *         A gap size of 41 was chosen here, so that the first slot used in a child contract\\n     *         would be a multiple of 50.\\n     */\\n    uint256[42] private __gap;\\n\\n    /**\\n     * @notice Emitted whenever a message is sent to the other chain.\\n     *\\n     * @param target       Address of the recipient of the message.\\n     * @param sender       Address of the sender of the message.\\n     * @param message      Message to trigger the recipient address with.\\n     * @param messageNonce Unique nonce attached to the message.\\n     * @param gasLimit     Minimum gas limit that the message can be executed with.\\n     */\\n    event SentMessage(\\n        address indexed target,\\n        address sender,\\n        bytes message,\\n        uint256 messageNonce,\\n        uint256 gasLimit\\n    );\\n\\n    /**\\n     * @notice Additional event data to emit, required as of Bedrock. Cannot be merged with the\\n     *         SentMessage event without breaking the ABI of this contract, this is good enough.\\n     *\\n     * @param sender Address of the sender of the message.\\n     * @param value  ETH value sent along with the message to the recipient.\\n     */\\n    event SentMessageExtension1(address indexed sender, uint256 value);\\n\\n    /**\\n     * @notice Emitted whenever a message is successfully relayed on this chain.\\n     *\\n     * @param msgHash Hash of the message that was relayed.\\n     */\\n    event RelayedMessage(bytes32 indexed msgHash);\\n\\n    /**\\n     * @notice Emitted whenever a message fails to be relayed on this chain.\\n     *\\n     * @param msgHash Hash of the message that failed to be relayed.\\n     */\\n    event FailedRelayedMessage(bytes32 indexed msgHash);\\n\\n    /**\\n     * @param _otherMessenger Address of the messenger on the paired chain.\\n     */\\n    constructor(address _otherMessenger) {\\n        otherMessenger = _otherMessenger;\\n    }\\n\\n    /**\\n     * @notice Allows the owner of this contract to temporarily pause message relaying. Backup\\n     *         security mechanism just in case. Owner should be the same as the upgrade wallet to\\n     *         maintain the security model of the system as a whole.\\n     */\\n    function pause() external onlyOwner {\\n        _pause();\\n    }\\n\\n    /**\\n     * @notice Allows the owner of this contract to resume message relaying once paused.\\n     */\\n    function unpause() external onlyOwner {\\n        _unpause();\\n    }\\n\\n    /**\\n     * @notice Sends a message to some target address on the other chain. Note that if the call\\n     *         always reverts, then the message will be unrelayable, and any ETH sent will be\\n     *         permanently locked. The same will occur if the target on the other chain is\\n     *         considered unsafe (see the _isUnsafeTarget() function).\\n     *\\n     * @param _target      Target contract or wallet address.\\n     * @param _message     Message to trigger the target address with.\\n     * @param _minGasLimit Minimum gas limit that the message can be executed with.\\n     */\\n    function sendMessage(\\n        address _target,\\n        bytes calldata _message,\\n        uint32 _minGasLimit\\n    ) external payable {\\n        // Triggers a message to the other messenger. Note that the amount of gas provided to the\\n        // message is the amount of gas requested by the user PLUS the base gas value. We want to\\n        // guarantee the property that the call to the target contract will always have at least\\n        // the minimum gas limit specified by the user.\\n        _sendMessage(\\n            otherMessenger,\\n            baseGas(_message, _minGasLimit),\\n            msg.value,\\n            abi.encodeWithSelector(\\n                this.relayMessage.selector,\\n                messageNonce(),\\n                msg.sender,\\n                _target,\\n                msg.value,\\n                _minGasLimit,\\n                _message\\n            )\\n        );\\n\\n        emit SentMessage(_target, msg.sender, _message, messageNonce(), _minGasLimit);\\n        emit SentMessageExtension1(msg.sender, msg.value);\\n\\n        unchecked {\\n            ++msgNonce;\\n        }\\n    }\\n\\n    /**\\n     * @notice Relays a message that was sent by the other CrossDomainMessenger contract. Can only\\n     *         be executed via cross-chain call from the other messenger OR if the message was\\n     *         already received once and is currently being replayed.\\n     *\\n     * @param _nonce       Nonce of the message being relayed.\\n     * @param _sender      Address of the user who sent the message.\\n     * @param _target      Address that the message is targeted at.\\n     * @param _value       ETH value to send with the message.\\n     * @param _minGasLimit Minimum amount of gas that the message can be executed with.\\n     * @param _message     Message to send to the target.\\n     */\\n    function relayMessage(\\n        uint256 _nonce,\\n        address _sender,\\n        address _target,\\n        uint256 _value,\\n        uint256 _minGasLimit,\\n        bytes calldata _message\\n    ) external payable nonReentrant whenNotPaused {\\n        (, uint16 version) = Encoding.decodeVersionedNonce(_nonce);\\n\\n        // Block any messages that aren't version 1. All version 0 messages have been guaranteed to\\n        // be relayed OR have been migrated to version 1 messages. Version 0 messages do not commit\\n        // to the value or minGasLimit fields, which can create unexpected issues for end-users.\\n        require(\\n            version == 1,\\n            \\\"CrossDomainMessenger: only version 1 messages are supported after the Bedrock upgrade\\\"\\n        );\\n\\n        bytes32 versionedHash = Hashing.hashCrossDomainMessageV1(\\n            _nonce,\\n            _sender,\\n            _target,\\n            _value,\\n            _minGasLimit,\\n            _message\\n        );\\n\\n        if (_isOtherMessenger()) {\\n            // This property should always hold when the message is first submitted (as opposed to\\n            // being replayed).\\n            assert(msg.value == _value);\\n        } else {\\n            require(\\n                msg.value == 0,\\n                \\\"CrossDomainMessenger: value must be zero unless message is from a system address\\\"\\n            );\\n\\n            require(\\n                receivedMessages[versionedHash],\\n                \\\"CrossDomainMessenger: message cannot be replayed\\\"\\n            );\\n        }\\n\\n        require(\\n            _isUnsafeTarget(_target) == false,\\n            \\\"CrossDomainMessenger: cannot send message to blocked system address\\\"\\n        );\\n\\n        require(\\n            successfulMessages[versionedHash] == false,\\n            \\\"CrossDomainMessenger: message has already been relayed\\\"\\n        );\\n\\n        require(\\n            gasleft() >= _minGasLimit + RELAY_GAS_REQUIRED,\\n            \\\"CrossDomainMessenger: insufficient gas to relay message\\\"\\n        );\\n\\n        xDomainMsgSender = _sender;\\n        bool success = SafeCall.call(_target, gasleft() - RELAY_GAS_BUFFER, _value, _message);\\n        xDomainMsgSender = DEFAULT_XDOMAIN_SENDER;\\n\\n        if (success == true) {\\n            successfulMessages[versionedHash] = true;\\n            emit RelayedMessage(versionedHash);\\n        } else {\\n            receivedMessages[versionedHash] = true;\\n            emit FailedRelayedMessage(versionedHash);\\n        }\\n    }\\n\\n    /**\\n     * @notice Retrieves the address of the contract or wallet that initiated the currently\\n     *         executing message on the other chain. Will throw an error if there is no message\\n     *         currently being executed. Allows the recipient of a call to see who triggered it.\\n     *\\n     * @return Address of the sender of the currently executing message on the other chain.\\n     */\\n    function xDomainMessageSender() external view returns (address) {\\n        require(\\n            xDomainMsgSender != DEFAULT_XDOMAIN_SENDER,\\n            \\\"CrossDomainMessenger: xDomainMessageSender is not set\\\"\\n        );\\n\\n        return xDomainMsgSender;\\n    }\\n\\n    /**\\n     * @notice Retrieves the next message nonce. Message version will be added to the upper two\\n     *         bytes of the message nonce. Message version allows us to treat messages as having\\n     *         different structures.\\n     *\\n     * @return Nonce of the next message to be sent, with added message version.\\n     */\\n    function messageNonce() public view returns (uint256) {\\n        return Encoding.encodeVersionedNonce(msgNonce, MESSAGE_VERSION);\\n    }\\n\\n    /**\\n     * @notice Computes the amount of gas required to guarantee that a given message will be\\n     *         received on the other chain without running out of gas. Guaranteeing that a message\\n     *         will not run out of gas is important because this ensures that a message can always\\n     *         be replayed on the other chain if it fails to execute completely.\\n     *\\n     * @param _message     Message to compute the amount of required gas for.\\n     * @param _minGasLimit Minimum desired gas limit when message goes to target.\\n     *\\n     * @return Amount of gas required to guarantee message receipt.\\n     */\\n    function baseGas(bytes calldata _message, uint32 _minGasLimit) public pure returns (uint32) {\\n        return\\n            // Dynamic overhead\\n            ((_minGasLimit * MIN_GAS_DYNAMIC_OVERHEAD_NUMERATOR) /\\n                MIN_GAS_DYNAMIC_OVERHEAD_DENOMINATOR) +\\n            // Calldata overhead\\n            (uint32(_message.length) * MIN_GAS_CALLDATA_OVERHEAD) +\\n            // Constant overhead\\n            MIN_GAS_CONSTANT_OVERHEAD;\\n    }\\n\\n    /**\\n     * @notice Intializer.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function __CrossDomainMessenger_init() internal onlyInitializing {\\n        xDomainMsgSender = DEFAULT_XDOMAIN_SENDER;\\n        __Context_init_unchained();\\n        __Ownable_init_unchained();\\n        __Pausable_init_unchained();\\n        __ReentrancyGuard_init_unchained();\\n    }\\n\\n    /**\\n     * @notice Sends a low-level message to the other messenger. Needs to be implemented by child\\n     *         contracts because the logic for this depends on the network where the messenger is\\n     *         being deployed.\\n     *\\n     * @param _to       Recipient of the message on the other chain.\\n     * @param _gasLimit Minimum gas limit the message can be executed with.\\n     * @param _value    Amount of ETH to send with the message.\\n     * @param _data     Message data.\\n     */\\n    function _sendMessage(\\n        address _to,\\n        uint64 _gasLimit,\\n        uint256 _value,\\n        bytes memory _data\\n    ) internal virtual;\\n\\n    /**\\n     * @notice Checks whether the message is coming from the other messenger. Implemented by child\\n     *         contracts because the logic for this depends on the network where the messenger is\\n     *         being deployed.\\n     *\\n     * @return Whether the message is coming from the other messenger.\\n     */\\n    function _isOtherMessenger() internal view virtual returns (bool);\\n\\n    /**\\n     * @notice Checks whether a given call target is a system address that could cause the\\n     *         messenger to peform an unsafe action. This is NOT a mechanism for blocking user\\n     *         addresses. This is ONLY used to prevent the execution of messages to specific\\n     *         system addresses that could cause security issues, e.g., having the\\n     *         CrossDomainMessenger send messages to itself.\\n     *\\n     * @param _target Address of the contract to check.\\n     *\\n     * @return Whether or not the address is an unsafe system address.\\n     */\\n    function _isUnsafeTarget(address _target) internal view virtual returns (bool);\\n}\\n\",\"keccak256\":\"0xead7d44e99f3749f1f45e3f70496c27c2d56e532835c13d02b43ee0d8ff1d593\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/universal/Semver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nimport { Strings } from \\\"@openzeppelin/contracts/utils/Strings.sol\\\";\\n\\n/**\\n * @title Semver\\n * @notice Semver is a simple contract for managing contract versions.\\n */\\ncontract Semver {\\n    /**\\n     * @notice Contract version number (major).\\n     */\\n    // solhint-disable-next-line var-name-mixedcase\\n    uint256 private immutable MAJOR_VERSION;\\n\\n    /**\\n     * @notice Contract version number (minor).\\n     */\\n    // solhint-disable-next-line var-name-mixedcase\\n    uint256 private immutable MINOR_VERSION;\\n\\n    /**\\n     * @notice Contract version number (patch).\\n     */\\n    // solhint-disable-next-line var-name-mixedcase\\n    uint256 private immutable PATCH_VERSION;\\n\\n    /**\\n     * @param _major Version number (major).\\n     * @param _minor Version number (minor).\\n     * @param _patch Version number (patch).\\n     */\\n    constructor(\\n        uint256 _major,\\n        uint256 _minor,\\n        uint256 _patch\\n    ) {\\n        MAJOR_VERSION = _major;\\n        MINOR_VERSION = _minor;\\n        PATCH_VERSION = _patch;\\n    }\\n\\n    /**\\n     * @notice Returns the full semver contract version.\\n     *\\n     * @return Semver contract version as a string.\\n     */\\n    function version() public view returns (string memory) {\\n        return\\n            string(\\n                abi.encodePacked(\\n                    Strings.toString(MAJOR_VERSION),\\n                    \\\".\\\",\\n                    Strings.toString(MINOR_VERSION),\\n                    \\\".\\\",\\n                    Strings.toString(PATCH_VERSION)\\n                )\\n            );\\n    }\\n}\\n\",\"keccak256\":\"0x8215e8fbaace5e06fdf0be26cd8ec224847cf03e89bd78dc8ba3ec2cb429d4fe\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n    address private _owner;\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the deployer as the initial owner.\\n     */\\n    function __Ownable_init() internal onlyInitializing {\\n        __Ownable_init_unchained();\\n    }\\n\\n    function __Ownable_init_unchained() internal onlyInitializing {\\n        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        return _owner;\\n    }\\n\\n    /**\\n     * @dev Throws if the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby removing any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x247c62047745915c0af6b955470a72d1696ebad4352d7d3011aef1a2463cd888\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n *     function initialize() initializer public {\\n *         __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n *     }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n *     function initializeV2() reinitializer(2) public {\\n *         __ERC20Permit_init(\\\"MyToken\\\");\\n *     }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n *     _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n    /**\\n     * @dev Indicates that the contract has been initialized.\\n     * @custom:oz-retyped-from bool\\n     */\\n    uint8 private _initialized;\\n\\n    /**\\n     * @dev Indicates that the contract is in the process of being initialized.\\n     */\\n    bool private _initializing;\\n\\n    /**\\n     * @dev Triggered when the contract has been initialized or reinitialized.\\n     */\\n    event Initialized(uint8 version);\\n\\n    /**\\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n     * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n     */\\n    modifier initializer() {\\n        bool isTopLevelCall = !_initializing;\\n        require(\\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n            \\\"Initializable: contract is already initialized\\\"\\n        );\\n        _initialized = 1;\\n        if (isTopLevelCall) {\\n            _initializing = true;\\n        }\\n        _;\\n        if (isTopLevelCall) {\\n            _initializing = false;\\n            emit Initialized(1);\\n        }\\n    }\\n\\n    /**\\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n     * used to initialize parent contracts.\\n     *\\n     * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n     * initialization step. This is essential to configure modules that are added through upgrades and that require\\n     * initialization.\\n     *\\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n     * a contract, executing them in the right order is up to the developer or operator.\\n     */\\n    modifier reinitializer(uint8 version) {\\n        require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n        _initialized = version;\\n        _initializing = true;\\n        _;\\n        _initializing = false;\\n        emit Initialized(version);\\n    }\\n\\n    /**\\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n     */\\n    modifier onlyInitializing() {\\n        require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n     * through proxies.\\n     */\\n    function _disableInitializers() internal virtual {\\n        require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n        if (_initialized < type(uint8).max) {\\n            _initialized = type(uint8).max;\\n            emit Initialized(type(uint8).max);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n    /**\\n     * @dev Emitted when the pause is triggered by `account`.\\n     */\\n    event Paused(address account);\\n\\n    /**\\n     * @dev Emitted when the pause is lifted by `account`.\\n     */\\n    event Unpaused(address account);\\n\\n    bool private _paused;\\n\\n    /**\\n     * @dev Initializes the contract in unpaused state.\\n     */\\n    function __Pausable_init() internal onlyInitializing {\\n        __Pausable_init_unchained();\\n    }\\n\\n    function __Pausable_init_unchained() internal onlyInitializing {\\n        _paused = false;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is not paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    modifier whenNotPaused() {\\n        _requireNotPaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    modifier whenPaused() {\\n        _requirePaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns true if the contract is paused, and false otherwise.\\n     */\\n    function paused() public view virtual returns (bool) {\\n        return _paused;\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is paused.\\n     */\\n    function _requireNotPaused() internal view virtual {\\n        require(!paused(), \\\"Pausable: paused\\\");\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is not paused.\\n     */\\n    function _requirePaused() internal view virtual {\\n        require(paused(), \\\"Pausable: not paused\\\");\\n    }\\n\\n    /**\\n     * @dev Triggers stopped state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    function _pause() internal virtual whenNotPaused {\\n        _paused = true;\\n        emit Paused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Returns to normal state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    function _unpause() internal virtual whenPaused {\\n        _paused = false;\\n        emit Unpaused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n    // Booleans are more expensive than uint256 or any type that takes up a full\\n    // word because each write operation emits an extra SLOAD to first read the\\n    // slot's contents, replace the bits taken up by the boolean, and then write\\n    // back. This is the compiler's defense against contract upgrades and\\n    // pointer aliasing, and it cannot be disabled.\\n\\n    // The values being non-zero value makes deployment a bit more expensive,\\n    // but in exchange the refund on every call to nonReentrant will be lower in\\n    // amount. Since refunds are capped to a percentage of the total\\n    // transaction's gas, it is best to keep them low in cases like this one, to\\n    // increase the likelihood of the full refund coming into effect.\\n    uint256 private constant _NOT_ENTERED = 1;\\n    uint256 private constant _ENTERED = 2;\\n\\n    uint256 private _status;\\n\\n    function __ReentrancyGuard_init() internal onlyInitializing {\\n        __ReentrancyGuard_init_unchained();\\n    }\\n\\n    function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n        _status = _NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev Prevents a contract from calling itself, directly or indirectly.\\n     * Calling a `nonReentrant` function from another `nonReentrant`\\n     * function is not supported. It is possible to prevent this from happening\\n     * by making the `nonReentrant` function external, and making it call a\\n     * `private` function that does the actual work.\\n     */\\n    modifier nonReentrant() {\\n        // On the first call to nonReentrant, _notEntered will be true\\n        require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _status = _ENTERED;\\n\\n        _;\\n\\n        // By storing the original value once again, a refund is triggered (see\\n        // https://eips.ethereum.org/EIPS/eip-2200)\\n        _status = _NOT_ENTERED;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x8cc03c5ac17e8a7396e487cda41fc1f1dfdb91db7d528e6da84bee3b6dd7e167\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n    /**\\n     * @dev Returns true if `account` is a contract.\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * It is unsafe to assume that an address for which this function returns\\n     * false is an externally-owned account (EOA) and not a contract.\\n     *\\n     * Among others, `isContract` will return false for the following\\n     * types of addresses:\\n     *\\n     *  - an externally-owned account\\n     *  - a contract in construction\\n     *  - an address where a contract will be created\\n     *  - an address where a contract lived, but was destroyed\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason, it is bubbled up by this\\n     * function (like regular Solidity function calls).\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n     * `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResult(success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResult(success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            // Look for revert reason and bubble it up if present\\n            if (returndata.length > 0) {\\n                // The easiest way to bubble the revert reason is using memory via assembly\\n                /// @solidity memory-safe-assembly\\n                assembly {\\n                    let returndata_size := mload(returndata)\\n                    revert(add(32, returndata), returndata_size)\\n                }\\n            } else {\\n                revert(errorMessage);\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n    function __Context_init() internal onlyInitializing {\\n    }\\n\\n    function __Context_init_unchained() internal onlyInitializing {\\n    }\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n    /**\\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n    /**\\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n     */\\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n    /**\\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n     */\\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n    /**\\n     * @dev Returns the number of tokens in ``owner``'s account.\\n     */\\n    function balanceOf(address owner) external view returns (uint256 balance);\\n\\n    /**\\n     * @dev Returns the owner of the `tokenId` token.\\n     *\\n     * Requirements:\\n     *\\n     * - `tokenId` must exist.\\n     */\\n    function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n    /**\\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must exist and be owned by `from`.\\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function safeTransferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId,\\n        bytes calldata data\\n    ) external;\\n\\n    /**\\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must exist and be owned by `from`.\\n     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function safeTransferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId\\n    ) external;\\n\\n    /**\\n     * @dev Transfers `tokenId` token from `from` to `to`.\\n     *\\n     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n     *\\n     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `tokenId` token must be owned by `from`.\\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 tokenId\\n    ) external;\\n\\n    /**\\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n     * The approval is cleared when the token is transferred.\\n     *\\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n     *\\n     * Requirements:\\n     *\\n     * - The caller must own the token or be an approved operator.\\n     * - `tokenId` must exist.\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address to, uint256 tokenId) external;\\n\\n    /**\\n     * @dev Approve or remove `operator` as an operator for the caller.\\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n     *\\n     * Requirements:\\n     *\\n     * - The `operator` cannot be the caller.\\n     *\\n     * Emits an {ApprovalForAll} event.\\n     */\\n    function setApprovalForAll(address operator, bool _approved) external;\\n\\n    /**\\n     * @dev Returns the account approved for `tokenId` token.\\n     *\\n     * Requirements:\\n     *\\n     * - `tokenId` must exist.\\n     */\\n    function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n    /**\\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n     *\\n     * See {setApprovalForAll}\\n     */\\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x0d4de01fe5360c38b4ad2b0822a12722958428f5138a7ff47c1720eb6fa52bba\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is IERC721 {\\n    /**\\n     * @dev Returns the total amount of tokens stored by the contract.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.\\n     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.\\n     */\\n    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);\\n\\n    /**\\n     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.\\n     * Use along with {totalSupply} to enumerate all tokens.\\n     */\\n    function tokenByIndex(uint256 index) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xd1556954440b31c97a142c6ba07d5cade45f96fafd52091d33a14ebe365aecbf\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n    /**\\n     * @dev Returns true if `account` is a contract.\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * It is unsafe to assume that an address for which this function returns\\n     * false is an externally-owned account (EOA) and not a contract.\\n     *\\n     * Among others, `isContract` will return false for the following\\n     * types of addresses:\\n     *\\n     *  - an externally-owned account\\n     *  - a contract in construction\\n     *  - an address where a contract will be created\\n     *  - an address where a contract lived, but was destroyed\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason, it is bubbled up by this\\n     * function (like regular Solidity function calls).\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n     * `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResult(success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResult(success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a delegate call.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a delegate call.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function functionDelegateCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n        (bool success, bytes memory returndata) = target.delegatecall(data);\\n        return verifyCallResult(success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            // Look for revert reason and bubble it up if present\\n            if (returndata.length > 0) {\\n                // The easiest way to bubble the revert reason is using memory via assembly\\n\\n                assembly {\\n                    let returndata_size := mload(returndata)\\n                    revert(add(32, returndata), returndata_size)\\n                }\\n            } else {\\n                revert(errorMessage);\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2ccf9d2313a313d41a791505f2b5abfdc62191b5d4334f7f7a82691c088a1c87\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Strings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n    bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef\\\";\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n     */\\n    function toString(uint256 value) internal pure returns (string memory) {\\n        // Inspired by OraclizeAPI's implementation - MIT licence\\n        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n        if (value == 0) {\\n            return \\\"0\\\";\\n        }\\n        uint256 temp = value;\\n        uint256 digits;\\n        while (temp != 0) {\\n            digits++;\\n            temp /= 10;\\n        }\\n        bytes memory buffer = new bytes(digits);\\n        while (value != 0) {\\n            digits -= 1;\\n            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n            value /= 10;\\n        }\\n        return string(buffer);\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(uint256 value) internal pure returns (string memory) {\\n        if (value == 0) {\\n            return \\\"0x00\\\";\\n        }\\n        uint256 temp = value;\\n        uint256 length = 0;\\n        while (temp != 0) {\\n            length++;\\n            temp >>= 8;\\n        }\\n        return toHexString(value, length);\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n     */\\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n        bytes memory buffer = new bytes(2 * length + 2);\\n        buffer[0] = \\\"0\\\";\\n        buffer[1] = \\\"x\\\";\\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\\n            buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n            value >>= 4;\\n        }\\n        require(value == 0, \\\"Strings: hex length insufficient\\\");\\n        return string(buffer);\\n    }\\n}\\n\",\"keccak256\":\"0x32c202bd28995dd20c4347b7c6467a6d3241c74c8ad3edcbb610cd9205916c45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (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        bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);\\n        (bool success, bytes memory result) = account.staticcall{gas: 30000}(encodedParams);\\n        if (result.length < 32) return false;\\n        return success && abi.decode(result, (bool));\\n    }\\n}\\n\",\"keccak256\":\"0xf7291d7213336b00ee7edbf7cd5034778dd7b0bda2a7489e664f1e5cacc6c24e\",\"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/L1ERC721Bridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.15;\\n\\nimport { ERC721Bridge } from \\\"../universal/op-erc721/ERC721Bridge.sol\\\";\\nimport { IERC721 } from \\\"@openzeppelin/contracts/token/ERC721/IERC721.sol\\\";\\nimport { L2ERC721Bridge } from \\\"../L2/L2ERC721Bridge.sol\\\";\\nimport { Semver } from \\\"@eth-optimism/contracts-bedrock/contracts/universal/Semver.sol\\\";\\n\\n/**\\n * @title L1ERC721Bridge\\n * @notice The L1 ERC721 bridge is a contract which works together with the L2 ERC721 bridge to\\n *         make it possible to transfer ERC721 tokens from Ethereum to Optimism. This contract\\n *         acts as an escrow for ERC721 tokens deposited into L2.\\n */\\ncontract L1ERC721Bridge is ERC721Bridge, Semver {\\n    /**\\n     * @notice Mapping of L1 token to L2 token to ID to boolean, indicating if the given L1 token\\n     *         by ID was deposited for a given L2 token.\\n     */\\n    mapping(address => mapping(address => mapping(uint256 => bool))) public deposits;\\n\\n    /**\\n     * @custom:semver 1.0.0\\n     *\\n     * @param _messenger   Address of the CrossDomainMessenger on this network.\\n     * @param _otherBridge Address of the ERC721 bridge on the other network.\\n     */\\n    constructor(address _messenger, address _otherBridge)\\n        Semver(1, 0, 0)\\n        ERC721Bridge(_messenger, _otherBridge)\\n    {}\\n\\n    /*************************\\n     * Cross-chain Functions *\\n     *************************/\\n\\n    /**\\n     * @notice Completes an ERC721 bridge from the other domain and sends the ERC721 token to the\\n     *         recipient on this domain.\\n     *\\n     * @param _localToken  Address of the ERC721 token on this domain.\\n     * @param _remoteToken Address of the ERC721 token on the other domain.\\n     * @param _from        Address that triggered the bridge on the other domain.\\n     * @param _to          Address to receive the token on this domain.\\n     * @param _tokenId     ID of the token being deposited.\\n     * @param _extraData   Optional data to forward to L2. Data supplied here will not be used to\\n     *                     execute any code on L2 and is only emitted as extra data for the\\n     *                     convenience of off-chain tooling.\\n     */\\n    function finalizeBridgeERC721(\\n        address _localToken,\\n        address _remoteToken,\\n        address _from,\\n        address _to,\\n        uint256 _tokenId,\\n        bytes calldata _extraData\\n    ) external onlyOtherBridge {\\n        require(_localToken != address(this), \\\"L1ERC721Bridge: local token cannot be self\\\");\\n\\n        // Checks that the L1/L2 NFT pair has a token ID that is escrowed in the L1 Bridge.\\n        require(\\n            deposits[_localToken][_remoteToken][_tokenId] == true,\\n            \\\"L1ERC721Bridge: Token ID is not escrowed in the L1 Bridge\\\"\\n        );\\n\\n        // Mark that the token ID for this L1/L2 token pair is no longer escrowed in the L1\\n        // Bridge.\\n        deposits[_localToken][_remoteToken][_tokenId] = false;\\n\\n        // When a withdrawal is finalized on L1, the L1 Bridge transfers the NFT to the\\n        // withdrawer.\\n        IERC721(_localToken).safeTransferFrom(address(this), _to, _tokenId);\\n\\n        // slither-disable-next-line reentrancy-events\\n        emit ERC721BridgeFinalized(_localToken, _remoteToken, _from, _to, _tokenId, _extraData);\\n    }\\n\\n    /**\\n     * @inheritdoc ERC721Bridge\\n     */\\n    function _initiateBridgeERC721(\\n        address _localToken,\\n        address _remoteToken,\\n        address _from,\\n        address _to,\\n        uint256 _tokenId,\\n        uint32 _minGasLimit,\\n        bytes calldata _extraData\\n    ) internal override {\\n        require(_remoteToken != address(0), \\\"ERC721Bridge: remote token cannot be address(0)\\\");\\n\\n        // Construct calldata for _l2Token.finalizeBridgeERC721(_to, _tokenId)\\n        bytes memory message = abi.encodeWithSelector(\\n            L2ERC721Bridge.finalizeBridgeERC721.selector,\\n            _remoteToken,\\n            _localToken,\\n            _from,\\n            _to,\\n            _tokenId,\\n            _extraData\\n        );\\n\\n        // Lock token into bridge\\n        deposits[_localToken][_remoteToken][_tokenId] = true;\\n        IERC721(_localToken).transferFrom(_from, address(this), _tokenId);\\n\\n        // Send calldata into L2\\n        messenger.sendMessage(otherBridge, message, _minGasLimit);\\n        emit ERC721BridgeInitiated(_localToken, _remoteToken, _from, _to, _tokenId, _extraData);\\n    }\\n}\\n\",\"keccak256\":\"0x966ae750603761f5636063e4d1441759bd7e140ba933303d31c62220e75c8869\",\"license\":\"MIT\"},\"contracts/L2/L2ERC721Bridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.15;\\n\\nimport { ERC721Bridge } from \\\"../universal/op-erc721/ERC721Bridge.sol\\\";\\nimport { ERC165Checker } from \\\"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\\\";\\nimport { L1ERC721Bridge } from \\\"../L1/L1ERC721Bridge.sol\\\";\\nimport { IOptimismMintableERC721 } from \\\"../universal/op-erc721/IOptimismMintableERC721.sol\\\";\\nimport { Semver } from \\\"@eth-optimism/contracts-bedrock/contracts/universal/Semver.sol\\\";\\n\\n/**\\n * @title L2ERC721Bridge\\n * @notice The L2 ERC721 bridge is a contract which works together with the L1 ERC721 bridge to\\n *         make it possible to transfer ERC721 tokens from Ethereum to Optimism. This contract\\n *         acts as a minter for new tokens when it hears about deposits into the L1 ERC721 bridge.\\n *         This contract also acts as a burner for tokens being withdrawn.\\n *         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This\\n *         bridge ONLY supports ERC721s originally deployed on Ethereum. Users will need to\\n *         wait for the one-week challenge period to elapse before their Optimism-native NFT\\n *         can be refunded on L2.\\n */\\ncontract L2ERC721Bridge is ERC721Bridge, Semver {\\n    /**\\n     * @custom:semver 1.0.0\\n     *\\n     * @param _messenger   Address of the CrossDomainMessenger on this network.\\n     * @param _otherBridge Address of the ERC721 bridge on the other network.\\n     */\\n    constructor(address _messenger, address _otherBridge)\\n        Semver(1, 0, 0)\\n        ERC721Bridge(_messenger, _otherBridge)\\n    {}\\n\\n    /**\\n     * @notice Completes an ERC721 bridge from the other domain and sends the ERC721 token to the\\n     *         recipient on this domain.\\n     *\\n     * @param _localToken  Address of the ERC721 token on this domain.\\n     * @param _remoteToken Address of the ERC721 token on the other domain.\\n     * @param _from        Address that triggered the bridge on the other domain.\\n     * @param _to          Address to receive the token on this domain.\\n     * @param _tokenId     ID of the token being deposited.\\n     * @param _extraData   Optional data to forward to L1. Data supplied here will not be used to\\n     *                     execute any code on L1 and is only emitted as extra data for the\\n     *                     convenience of off-chain tooling.\\n     */\\n    function finalizeBridgeERC721(\\n        address _localToken,\\n        address _remoteToken,\\n        address _from,\\n        address _to,\\n        uint256 _tokenId,\\n        bytes calldata _extraData\\n    ) external onlyOtherBridge {\\n        require(_localToken != address(this), \\\"L2ERC721Bridge: local token cannot be self\\\");\\n\\n        // Note that supportsInterface makes a callback to the _localToken address which is user\\n        // provided.\\n        require(\\n            ERC165Checker.supportsInterface(_localToken, type(IOptimismMintableERC721).interfaceId),\\n            \\\"L2ERC721Bridge: local token interface is not compliant\\\"\\n        );\\n\\n        require(\\n            _remoteToken == IOptimismMintableERC721(_localToken).remoteToken(),\\n            \\\"L2ERC721Bridge: wrong remote token for Optimism Mintable ERC721 local token\\\"\\n        );\\n\\n        // When a deposit is finalized, we give the NFT with the same tokenId to the account\\n        // on L2. Note that safeMint makes a callback to the _to address which is user provided.\\n        IOptimismMintableERC721(_localToken).safeMint(_to, _tokenId);\\n\\n        // slither-disable-next-line reentrancy-events\\n        emit ERC721BridgeFinalized(_localToken, _remoteToken, _from, _to, _tokenId, _extraData);\\n    }\\n\\n    /**\\n     * @inheritdoc ERC721Bridge\\n     */\\n    function _initiateBridgeERC721(\\n        address _localToken,\\n        address _remoteToken,\\n        address _from,\\n        address _to,\\n        uint256 _tokenId,\\n        uint32 _minGasLimit,\\n        bytes calldata _extraData\\n    ) internal override {\\n        require(_remoteToken != address(0), \\\"ERC721Bridge: remote token cannot be address(0)\\\");\\n\\n        // Check that the withdrawal is being initiated by the NFT owner\\n        require(\\n            _from == IOptimismMintableERC721(_localToken).ownerOf(_tokenId),\\n            \\\"Withdrawal is not being initiated by NFT owner\\\"\\n        );\\n\\n        // Construct calldata for l1ERC721Bridge.finalizeBridgeERC721(_to, _tokenId)\\n        // slither-disable-next-line reentrancy-events\\n        address remoteToken = IOptimismMintableERC721(_localToken).remoteToken();\\n        require(\\n            remoteToken == _remoteToken,\\n            \\\"L2ERC721Bridge: remote token does not match given value\\\"\\n        );\\n\\n        // When a withdrawal is initiated, we burn the withdrawer's NFT to prevent subsequent L2\\n        // usage\\n        // slither-disable-next-line reentrancy-events\\n        IOptimismMintableERC721(_localToken).burn(_from, _tokenId);\\n\\n        bytes memory message = abi.encodeWithSelector(\\n            L1ERC721Bridge.finalizeBridgeERC721.selector,\\n            remoteToken,\\n            _localToken,\\n            _from,\\n            _to,\\n            _tokenId,\\n            _extraData\\n        );\\n\\n        // Send message to L1 bridge\\n        // slither-disable-next-line reentrancy-events\\n        messenger.sendMessage(otherBridge, message, _minGasLimit);\\n\\n        // slither-disable-next-line reentrancy-events\\n        emit ERC721BridgeInitiated(_localToken, remoteToken, _from, _to, _tokenId, _extraData);\\n    }\\n}\\n\",\"keccak256\":\"0xedcf2403f87c8c72790c053b44ccd762e99f5cdf0f362123288d6893b4c856b5\",\"license\":\"MIT\"},\"contracts/universal/op-erc721/ERC721Bridge.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.15;\\n\\nimport {\\n    CrossDomainMessenger\\n} from \\\"@eth-optimism/contracts-bedrock/contracts/universal/CrossDomainMessenger.sol\\\";\\nimport { Address } from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @title ERC721Bridge\\n * @notice ERC721Bridge is a base contract for the L1 and L2 ERC721 bridges.\\n */\\nabstract contract ERC721Bridge {\\n    /**\\n     * @notice Emitted when an ERC721 bridge to the other network is initiated.\\n     *\\n     * @param localToken  Address of the token on this domain.\\n     * @param remoteToken Address of the token on the remote domain.\\n     * @param from        Address that initiated bridging action.\\n     * @param to          Address to receive the token.\\n     * @param tokenId     ID of the specific token deposited.\\n     * @param extraData   Extra data for use on the client-side.\\n     */\\n    event ERC721BridgeInitiated(\\n        address indexed localToken,\\n        address indexed remoteToken,\\n        address indexed from,\\n        address to,\\n        uint256 tokenId,\\n        bytes extraData\\n    );\\n\\n    /**\\n     * @notice Emitted when an ERC721 bridge from the other network is finalized.\\n     *\\n     * @param localToken  Address of the token on this domain.\\n     * @param remoteToken Address of the token on the remote domain.\\n     * @param from        Address that initiated bridging action.\\n     * @param to          Address to receive the token.\\n     * @param tokenId     ID of the specific token deposited.\\n     * @param extraData   Extra data for use on the client-side.\\n     */\\n    event ERC721BridgeFinalized(\\n        address indexed localToken,\\n        address indexed remoteToken,\\n        address indexed from,\\n        address to,\\n        uint256 tokenId,\\n        bytes extraData\\n    );\\n\\n    /**\\n     * @notice Messenger contract on this domain.\\n     */\\n    CrossDomainMessenger public immutable messenger;\\n\\n    /**\\n     * @notice Address of the bridge on the other network.\\n     */\\n    address public immutable otherBridge;\\n\\n    /**\\n     * @notice Reserve extra slots (to a total of 50) in the storage layout for future upgrades.\\n     */\\n    uint256[49] private __gap;\\n\\n    /**\\n     * @notice Ensures that the caller is a cross-chain message from the other bridge.\\n     */\\n    modifier onlyOtherBridge() {\\n        require(\\n            msg.sender == address(messenger) && messenger.xDomainMessageSender() == otherBridge,\\n            \\\"ERC721Bridge: function can only be called from the other bridge\\\"\\n        );\\n        _;\\n    }\\n\\n    /**\\n     * @param _messenger   Address of the CrossDomainMessenger on this network.\\n     * @param _otherBridge Address of the ERC721 bridge on the other network.\\n     */\\n    constructor(address _messenger, address _otherBridge) {\\n        require(_messenger != address(0), \\\"ERC721Bridge: messenger cannot be address(0)\\\");\\n        require(_otherBridge != address(0), \\\"ERC721Bridge: other bridge cannot be address(0)\\\");\\n\\n        messenger = CrossDomainMessenger(_messenger);\\n        otherBridge = _otherBridge;\\n    }\\n\\n    /**\\n     * @notice Initiates a bridge of an NFT to the caller's account on the other chain. Note that\\n     *         this function can only be called by EOAs. Smart contract wallets should use the\\n     *         `bridgeERC721To` function after ensuring that the recipient address on the remote\\n     *         chain exists. Also note that the current owner of the token on this chain must\\n     *         approve this contract to operate the NFT before it can be bridged.\\n     *         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This\\n     *         bridge only supports ERC721s originally deployed on Ethereum. Users will need to\\n     *         wait for the one-week challenge period to elapse before their Optimism-native NFT\\n     *         can be refunded on L2.\\n     *\\n     * @param _localToken  Address of the ERC721 on this domain.\\n     * @param _remoteToken Address of the ERC721 on the remote domain.\\n     * @param _tokenId     Token ID to bridge.\\n     * @param _minGasLimit Minimum gas limit for the bridge message on the other domain.\\n     * @param _extraData   Optional data to forward to the other chain. Data supplied here will not\\n     *                     be used to execute any code on the other chain and is only emitted as\\n     *                     extra data for the convenience of off-chain tooling.\\n     */\\n    function bridgeERC721(\\n        address _localToken,\\n        address _remoteToken,\\n        uint256 _tokenId,\\n        uint32 _minGasLimit,\\n        bytes calldata _extraData\\n    ) external {\\n        // Modifier requiring sender to be EOA. This prevents against a user error that would occur\\n        // if the sender is a smart contract wallet that has a different address on the remote chain\\n        // (or doesn't have an address on the remote chain at all). The user would fail to receive\\n        // the NFT if they use this function because it sends the NFT to the same address as the\\n        // caller. This check could be bypassed by a malicious contract via initcode, but it takes\\n        // care of the user error we want to avoid.\\n        require(!Address.isContract(msg.sender), \\\"ERC721Bridge: account is not externally owned\\\");\\n\\n        _initiateBridgeERC721(\\n            _localToken,\\n            _remoteToken,\\n            msg.sender,\\n            msg.sender,\\n            _tokenId,\\n            _minGasLimit,\\n            _extraData\\n        );\\n    }\\n\\n    /**\\n     * @notice Initiates a bridge of an NFT to some recipient's account on the other chain. Note\\n     *         that the current owner of the token on this chain must approve this contract to\\n     *         operate the NFT before it can be bridged.\\n     *         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This\\n     *         bridge only supports ERC721s originally deployed on Ethereum. Users will need to\\n     *         wait for the one-week challenge period to elapse before their Optimism-native NFT\\n     *         can be refunded on L2.\\n     *\\n     * @param _localToken  Address of the ERC721 on this domain.\\n     * @param _remoteToken Address of the ERC721 on the remote domain.\\n     * @param _to          Address to receive the token on the other domain.\\n     * @param _tokenId     Token ID to bridge.\\n     * @param _minGasLimit Minimum gas limit for the bridge message on the other domain.\\n     * @param _extraData   Optional data to forward to the other chain. Data supplied here will not\\n     *                     be used to execute any code on the other chain and is only emitted as\\n     *                     extra data for the convenience of off-chain tooling.\\n     */\\n    function bridgeERC721To(\\n        address _localToken,\\n        address _remoteToken,\\n        address _to,\\n        uint256 _tokenId,\\n        uint32 _minGasLimit,\\n        bytes calldata _extraData\\n    ) external {\\n        require(_to != address(0), \\\"ERC721Bridge: nft recipient cannot be address(0)\\\");\\n\\n        _initiateBridgeERC721(\\n            _localToken,\\n            _remoteToken,\\n            msg.sender,\\n            _to,\\n            _tokenId,\\n            _minGasLimit,\\n            _extraData\\n        );\\n    }\\n\\n    /**\\n     * @notice Internal function for initiating a token bridge to the other domain.\\n     *\\n     * @param _localToken  Address of the ERC721 on this domain.\\n     * @param _remoteToken Address of the ERC721 on the remote domain.\\n     * @param _from        Address of the sender on this domain.\\n     * @param _to          Address to receive the token on the other domain.\\n     * @param _tokenId     Token ID to bridge.\\n     * @param _minGasLimit Minimum gas limit for the bridge message on the other domain.\\n     * @param _extraData   Optional data to forward to the other domain. Data supplied here will\\n     *                     not be used to execute any code on the other domain and is only emitted\\n     *                     as extra data for the convenience of off-chain tooling.\\n     */\\n    function _initiateBridgeERC721(\\n        address _localToken,\\n        address _remoteToken,\\n        address _from,\\n        address _to,\\n        uint256 _tokenId,\\n        uint32 _minGasLimit,\\n        bytes calldata _extraData\\n    ) internal virtual;\\n}\\n\",\"keccak256\":\"0x24898e2e75865a4e35cde2d62518cb4c15a30b7cdae8a1a37624a82ae2a26eb7\",\"license\":\"MIT\"},\"contracts/universal/op-erc721/IOptimismMintableERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n    IERC721Enumerable\\n} from \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol\\\";\\n\\n/**\\n * @title IOptimismMintableERC721\\n * @notice Interface for contracts that are compatible with the OptimismMintableERC721 standard.\\n *         Tokens that follow this standard can be easily transferred across the ERC721 bridge.\\n */\\ninterface IOptimismMintableERC721 is IERC721Enumerable {\\n    /**\\n     * @notice Emitted when a token is minted.\\n     *\\n     * @param account Address of the account the token was minted to.\\n     * @param tokenId Token ID of the minted token.\\n     */\\n    event Mint(address indexed account, uint256 tokenId);\\n\\n    /**\\n     * @notice Emitted when a token is burned.\\n     *\\n     * @param account Address of the account the token was burned from.\\n     * @param tokenId Token ID of the burned token.\\n     */\\n    event Burn(address indexed account, uint256 tokenId);\\n\\n    /**\\n     * @notice Chain ID of the chain where the remote token is deployed.\\n     */\\n    function remoteChainId() external view returns (uint256);\\n\\n    /**\\n     * @notice Address of the token on the remote domain.\\n     */\\n    function remoteToken() external view returns (address);\\n\\n    /**\\n     * @notice Address of the ERC721 bridge on this network.\\n     */\\n    function bridge() external view returns (address);\\n\\n    /**\\n     * @notice Mints some token ID for a user, checking first that contract recipients\\n     *         are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n     *\\n     * @param _to      Address of the user to mint the token for.\\n     * @param _tokenId Token ID to mint.\\n     */\\n    function safeMint(address _to, uint256 _tokenId) external;\\n\\n    /**\\n     * @notice Burns a token ID from a user.\\n     *\\n     * @param _from    Address of the user to burn the token from.\\n     * @param _tokenId Token ID to burn.\\n     */\\n    function burn(address _from, uint256 _tokenId) external;\\n}\\n\",\"keccak256\":\"0xc3703030d0093d65839b02296e3152681fa1c8d717e66ab3f5a7c32ba3fd0a54\",\"license\":\"MIT\"}},\"version\":1}",
  "bytecode": "[encoded data, 13030 characters]",
  "deployedBytecode": "[encoded data, 12004 characters]",
  "devdoc": {
    "kind": "dev",
    "methods": {
      "bridgeERC721(address,address,uint256,uint32,bytes)": {
        "params": {
          "_extraData": "Optional data to forward to the other chain. Data supplied here will not                     be used to execute any code on the other chain and is only emitted as                     extra data for the convenience of off-chain tooling.",
          "_localToken": "Address of the ERC721 on this domain.",
          "_minGasLimit": "Minimum gas limit for the bridge message on the other domain.",
          "_remoteToken": "Address of the ERC721 on the remote domain.",
          "_tokenId": "Token ID to bridge."
        }
      },
      "bridgeERC721To(address,address,address,uint256,uint32,bytes)": {
        "params": {
          "_extraData": "Optional data to forward to the other chain. Data supplied here will not                     be used to execute any code on the other chain and is only emitted as                     extra data for the convenience of off-chain tooling.",
          "_localToken": "Address of the ERC721 on this domain.",
          "_minGasLimit": "Minimum gas limit for the bridge message on the other domain.",
          "_remoteToken": "Address of the ERC721 on the remote domain.",
          "_to": "Address to receive the token on the other domain.",
          "_tokenId": "Token ID to bridge."
        }
      },
      "constructor": {
        "custom:semver": "1.0.0",
        "params": {
          "_messenger": "Address of the CrossDomainMessenger on this network.",
          "_otherBridge": "Address of the ERC721 bridge on the other network."
        }
      },
      "finalizeBridgeERC721(address,address,address,address,uint256,bytes)": {
        "params": {
          "_extraData": "Optional data to forward to L1. Data supplied here will not be used to                     execute any code on L1 and is only emitted as extra data for the                     convenience of off-chain tooling.",
          "_from": "Address that triggered the bridge on the other domain.",
          "_localToken": "Address of the ERC721 token on this domain.",
          "_remoteToken": "Address of the ERC721 token on the other domain.",
          "_to": "Address to receive the token on this domain.",
          "_tokenId": "ID of the token being deposited."
        }
      },
      "version()": {
        "returns": {
          "_0": "Semver contract version as a string."
        }
      }
    },
    "title": "L2ERC721Bridge",
    "version": 1
  },
  "userdoc": {
    "events": {
      "ERC721BridgeFinalized(address,address,address,address,uint256,bytes)": {
        "notice": "Emitted when an ERC721 bridge from the other network is finalized."
      },
      "ERC721BridgeInitiated(address,address,address,address,uint256,bytes)": {
        "notice": "Emitted when an ERC721 bridge to the other network is initiated."
      }
    },
    "kind": "user",
    "methods": {
      "bridgeERC721(address,address,uint256,uint32,bytes)": {
        "notice": "Initiates a bridge of an NFT to the caller's account on the other chain. Note that         this function can only be called by EOAs. Smart contract wallets should use the         `bridgeERC721To` function after ensuring that the recipient address on the remote         chain exists. Also note that the current owner of the token on this chain must         approve this contract to operate the NFT before it can be bridged.         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This         bridge only supports ERC721s originally deployed on Ethereum. Users will need to         wait for the one-week challenge period to elapse before their Optimism-native NFT         can be refunded on L2."
      },
      "bridgeERC721To(address,address,address,uint256,uint32,bytes)": {
        "notice": "Initiates a bridge of an NFT to some recipient's account on the other chain. Note         that the current owner of the token on this chain must approve this contract to         operate the NFT before it can be bridged.         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This         bridge only supports ERC721s originally deployed on Ethereum. Users will need to         wait for the one-week challenge period to elapse before their Optimism-native NFT         can be refunded on L2."
      },
      "finalizeBridgeERC721(address,address,address,address,uint256,bytes)": {
        "notice": "Completes an ERC721 bridge from the other domain and sends the ERC721 token to the         recipient on this domain."
      },
      "messenger()": {
        "notice": "Messenger contract on this domain."
      },
      "otherBridge()": {
        "notice": "Address of the bridge on the other network."
      },
      "version()": {
        "notice": "Returns the full semver contract version."
      }
    },
    "notice": "The L2 ERC721 bridge is a contract which works together with the L1 ERC721 bridge to         make it possible to transfer ERC721 tokens from Ethereum to Optimism. This contract         acts as a minter for new tokens when it hears about deposits into the L1 ERC721 bridge.         This contract also acts as a burner for tokens being withdrawn.         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This         bridge ONLY supports ERC721s originally deployed on Ethereum. Users will need to         wait for the one-week challenge period to elapse before their Optimism-native NFT         can be refunded on L2.",
    "version": 1
  },
  "storageLayout": {
    "storage": [
      {
        "astId": 8088,
        "contract": "contracts/L2/L2ERC721Bridge.sol:L2ERC721Bridge",
        "label": "__gap",
        "offset": 0,
        "slot": "0",
        "type": "t_array(t_uint256)49_storage"
      }
    ],
    "types": {
      "t_array(t_uint256)49_storage": {
        "base": "t_uint256",
        "encoding": "inplace",
        "label": "uint256[49]",
        "numberOfBytes": "1568"
      },
      "t_uint256": {
        "encoding": "inplace",
        "label": "uint256",
        "numberOfBytes": "32"
      }
    }
  }
}