{"compiler":{"version":"0.8.9+commit.e5eed63a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_l1Router","type":"address"},{"internalType":"address","name":"_l1LPTEscrow","type":"address"},{"internalType":"address","name":"_l1Lpt","type":"address"},{"internalType":"address","name":"_l2Lpt","type":"address"},{"internalType":"address","name":"_inbox","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_l1Token","type":"address"},{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":true,"internalType":"uint256","name":"_sequenceNumber","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"DepositInitiated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_l2Counterpart","type":"address"}],"name":"L2CounterpartUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_minter","type":"address"}],"name":"MinterUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"seqNum","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"TxToL2","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_l1Token","type":"address"},{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":true,"internalType":"uint256","name":"_exitNum","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"WithdrawalFinalized","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"l1Token","type":"address"}],"name":"calculateL2TokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"counterpartGateway","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"l1Token","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"finalizeInboundTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"l1Token","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"getOutboundCalldata","outputs":[{"internalType":"bytes","name":"outboundCalldata","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inbox","outputs":[{"internalType":"contract IInbox","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1LPTEscrow","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1Lpt","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1Router","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2Counterpart","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2Lpt","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_l1Token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_maxGas","type":"uint256"},{"internalType":"uint256","name":"_gasPriceBid","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"outboundTransfer","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_l2Counterpart","type":"address"}],"name":"setCounterpart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"details":"the contract can be paused by the admin which will prevent any outbound transfers but pausing the contract does not affect inbound transfers (tokens coming from L2)","kind":"dev","methods":{"finalizeInboundTransfer(address,address,address,uint256,bytes)":{"details":"can only accept txs coming directly from L2 LPT Gateway","params":{"amount":"Amount of tokens transferred","data":"Contains exitNum which is always set to 0","from":"Address of the sender","l1Token":"L1 Address of LPT","to":"Recepient address on L1"}},"getOutboundCalldata(address,address,address,uint256,bytes)":{"details":"encodes the target function with its params which will be called on L2 when the retryable ticket is redeemed"},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"outboundTransfer(address,address,uint256,uint256,uint256,bytes)":{"details":"maxGas and gasPriceBid must be set using arbitrum's Inbox.estimateRetryableTicket method.","params":{"_amount":"Amount of tokens to tranfer","_data":"Encoded maxSubmission cost and sender address along with additional calldata","_gasPriceBid":"Price per gas on L2","_l1Token":"L1 Address of LPT","_maxGas":"Gas limit for L2 execution of the ticket","_to":"Recepient address on L2"},"returns":{"_0":"seqNum Sequence number of the retryable ticket created by Inbox"}},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role."},"setCounterpart(address)":{"details":"Only address with the admin role is allowed to change the value of l2Counterpart","params":{"_l2Counterpart":"L2 Address of the counterpart"}},"setMinter(address)":{"details":"Only address with the admin role is allowed to change the value of minter","params":{"_minter":"L1 Address of minter"}},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."}},"title":"L1LPTGateway","version":1},"userdoc":{"kind":"user","methods":{"calculateL2TokenAddress(address)":{"notice":"returns address of L2 version of LPT"},"counterpartGateway()":{"notice":"returns address of L2 LPT Gateway"},"finalizeInboundTransfer(address,address,address,uint256,bytes)":{"notice":"Receives withdrawn token amount from L2 The equivalent tokens are released from the Escrow contract and sent to the destination In case the escrow doesn't have enough balance, new tokens are minted"},"getOutboundCalldata(address,address,address,uint256,bytes)":{"notice":"Creates calldata required to create a retryable ticket"},"outboundTransfer(address,address,uint256,uint256,uint256,bytes)":{"notice":"Creates and sends a retryable ticket to migrate LPT to L2 using arbitrum Inbox. The tokens are sent to the Escrow contract for safekeeping until they are withdrawn The ticket must be redeemed on L2 to receive tokens at the specified address."},"setCounterpart(address)":{"notice":"Sets address of companion L2LPTGateway"},"setMinter(address)":{"notice":"Sets address of Minter"}},"notice":"Manages inbound and outbound transfers of LPT between L1 and Arbitrum Rollup","version":1}},"settings":{"compilationTarget":{"contracts/L1/gateway/L1LPTGateway.sol":"L1LPTGateway"},"evmVersion":"london","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"@openzeppelin/contracts/access/AccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControl.sol\";\nimport \"../utils/Context.sol\";\nimport \"../utils/Strings.sol\";\nimport \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address => bool) members;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with a standardized message including the required role.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     *\n     * _Available since v4.1._\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role, _msgSender());\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view override returns (bool) {\n        return _roles[role].members[account];\n    }\n\n    /**\n     * @dev Revert with a standard message if `account` is missing `role`.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    function _checkRole(bytes32 role, address account) internal view {\n        if (!hasRole(role, account)) {\n            revert(\n                string(\n                    abi.encodePacked(\n                        \"AccessControl: account \",\n                        Strings.toHexString(uint160(account), 20),\n                        \" is missing role \",\n                        Strings.toHexString(uint256(role), 32)\n                    )\n                )\n            );\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) public virtual override {\n        require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event. Note that unlike {grantRole}, this function doesn't perform any\n     * checks on the calling account.\n     *\n     * [WARNING]\n     * ====\n     * This function should only be called from the constructor when setting\n     * up the initial roles for the system.\n     *\n     * Using this function in any other way is effectively circumventing the admin\n     * system imposed by {AccessControl}.\n     * ====\n     *\n     * NOTE: This function is deprecated in favor of {_grantRole}.\n     */\n    function _setupRole(bytes32 role, address account) internal virtual {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * Internal function without access restriction.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual {\n        if (!hasRole(role, account)) {\n            _roles[role].members[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * Internal function without access restriction.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual {\n        if (hasRole(role, account)) {\n            _roles[role].members[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n        }\n    }\n}\n","keccak256":"0xb9a137b317dc4806805f2259686186c0c053c32d80fe9c15ecdbf2eb1cf52849","license":"MIT"},"@openzeppelin/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n}\n","keccak256":"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57","license":"MIT"},"@openzeppelin/contracts/security/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.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 Pausable is Context {\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    constructor() {\n        _paused = false;\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 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        require(!paused(), \"Pausable: paused\");\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        require(paused(), \"Pausable: not paused\");\n        _;\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","keccak256":"0xe68ed7fb8766ed1e888291f881e36b616037f852b37d96877045319ad298ba87","license":"MIT"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n","keccak256":"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7","license":"MIT"},"@openzeppelin/contracts/utils/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/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n","keccak256":"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b","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/ControlledGateway.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport {Pausable} from \"@openzeppelin/contracts/security/Pausable.sol\";\nimport {AccessControl} from \"@openzeppelin/contracts/access/AccessControl.sol\";\n\n/**\n * @title ControlledGateway\n * @notice Base Contract for both L1 and L2 LPT gateways. Provides AccessControl.\n * Gateways can be paused by the admin to stop outgoing token migrations\n */\ncontract ControlledGateway is AccessControl, Pausable {\n    address public immutable l1Lpt;\n    address public immutable l2Lpt;\n\n    constructor(address _l1Lpt, address _l2Lpt) {\n        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);\n\n        l1Lpt = _l1Lpt;\n        l2Lpt = _l2Lpt;\n    }\n\n    function pause() external onlyRole(DEFAULT_ADMIN_ROLE) {\n        _pause();\n    }\n\n    function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) {\n        _unpause();\n    }\n}\n","keccak256":"0xf17a5db4b19585d848d60c6d38c09938275a767f59c1918d9f65a40d97c26841","license":"MIT"},"contracts/L1/gateway/IL1LPTGateway.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\ninterface IL1LPTGateway {\n    event DepositInitiated(\n        address _l1Token,\n        address indexed _from,\n        address indexed _to,\n        uint256 indexed _sequenceNumber,\n        uint256 _amount\n    );\n\n    event WithdrawalFinalized(\n        address _l1Token,\n        address indexed _from,\n        address indexed _to,\n        uint256 indexed _exitNum,\n        uint256 _amount\n    );\n\n    function outboundTransfer(\n        address _l1Token,\n        address _to,\n        uint256 _amount,\n        uint256 _maxGas,\n        uint256 _gasPriceBid,\n        bytes calldata _data\n    ) external payable returns (bytes memory);\n\n    function finalizeInboundTransfer(\n        address _token,\n        address _from,\n        address _to,\n        uint256 _amount,\n        bytes calldata _data\n    ) external;\n\n    // if token is not supported this should return 0x0 address\n    function calculateL2TokenAddress(address l1Token)\n        external\n        view\n        returns (address);\n\n    // used by router\n    function counterpartGateway() external view returns (address);\n}\n","keccak256":"0x3d47adc8ef84079e4bcc5bfd3cf7929794cc5fa443e188119438688ebeeaa57e","license":"MIT"},"contracts/L1/gateway/L1ArbitrumMessenger.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport {IBridge} from \"../../arbitrum/IBridge.sol\";\nimport {IInbox} from \"../../arbitrum/IInbox.sol\";\nimport {IOutbox} from \"../../arbitrum/IOutbox.sol\";\n\nabstract contract L1ArbitrumMessenger {\n    IInbox public immutable inbox;\n\n    event TxToL2(\n        address indexed from,\n        address indexed to,\n        uint256 indexed seqNum,\n        bytes data\n    );\n\n    constructor(address _inbox) {\n        inbox = IInbox(_inbox);\n    }\n\n    modifier onlyL2Counterpart(address l2Counterpart) {\n        // a message coming from the counterpart gateway was executed by the bridge\n        address bridge = inbox.bridge();\n        require(msg.sender == bridge, \"NOT_FROM_BRIDGE\");\n\n        // and the outbox reports that the L2 address of the sender is the counterpart gateway\n        address l2ToL1Sender = IOutbox(IBridge(bridge).activeOutbox())\n            .l2ToL1Sender();\n        require(l2ToL1Sender == l2Counterpart, \"ONLY_COUNTERPART_GATEWAY\");\n        _;\n    }\n\n    function sendTxToL2(\n        address target,\n        address from,\n        uint256 maxSubmissionCost,\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        bytes memory data\n    ) internal returns (uint256) {\n        return\n            sendTxToL2(\n                target,\n                from,\n                msg.value,\n                0, // we always assume that l2CallValue = 0\n                maxSubmissionCost,\n                maxGas,\n                gasPriceBid,\n                data\n            );\n    }\n\n    function sendTxToL2(\n        address target,\n        address from,\n        uint256 _l1CallValue,\n        uint256 _l2CallValue,\n        uint256 maxSubmissionCost,\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        bytes memory data\n    ) internal returns (uint256) {\n        uint256 seqNum = inbox.createRetryableTicket{value: _l1CallValue}(\n            target,\n            _l2CallValue,\n            maxSubmissionCost,\n            from,\n            from,\n            maxGas,\n            gasPriceBid,\n            data\n        );\n        emit TxToL2(from, target, seqNum, data);\n        return seqNum;\n    }\n}\n","keccak256":"0x5992094d676f73b20bb0f7f014f6b9491ceb44f3a7fc16f4ef78deefae37795c","license":"MIT"},"contracts/L1/gateway/L1LPTGateway.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport {ControlledGateway} from \"../../ControlledGateway.sol\";\nimport {L1ArbitrumMessenger} from \"./L1ArbitrumMessenger.sol\";\nimport {IL1LPTGateway} from \"./IL1LPTGateway.sol\";\nimport {IL2LPTGateway} from \"../../L2/gateway/IL2LPTGateway.sol\";\n\ninterface TokenLike {\n    function transferFrom(\n        address _from,\n        address _to,\n        uint256 _value\n    ) external returns (bool success);\n\n    function balanceOf(address account) external view returns (uint256);\n}\n\ninterface IMinter {\n    function bridgeMint(address _to, uint256 _amount) external;\n}\n\n/**\n * @title L1LPTGateway\n * @notice Manages inbound and outbound transfers of LPT between L1 and Arbitrum Rollup\n * @dev the contract can be paused by the admin which will prevent any outbound transfers\n * but pausing the contract does not affect inbound transfers (tokens coming from L2)\n */\ncontract L1LPTGateway is IL1LPTGateway, ControlledGateway, L1ArbitrumMessenger {\n    address public immutable l1Router;\n    address public immutable l1LPTEscrow;\n    address public l2Counterpart;\n    address public minter;\n\n    event L2CounterpartUpdate(address _l2Counterpart);\n\n    event MinterUpdate(address _minter);\n\n    constructor(\n        address _l1Router,\n        address _l1LPTEscrow,\n        address _l1Lpt,\n        address _l2Lpt,\n        address _inbox\n    ) ControlledGateway(_l1Lpt, _l2Lpt) L1ArbitrumMessenger(_inbox) {\n        l1Router = _l1Router;\n        l1LPTEscrow = _l1LPTEscrow;\n\n        _pause();\n    }\n\n    /**\n     * @notice Sets address of companion L2LPTGateway\n     * @dev Only address with the admin role is allowed to change the value of l2Counterpart\n     * @param _l2Counterpart L2 Address of the counterpart\n     */\n    function setCounterpart(address _l2Counterpart)\n        external\n        onlyRole(DEFAULT_ADMIN_ROLE)\n    {\n        l2Counterpart = _l2Counterpart;\n        emit L2CounterpartUpdate(_l2Counterpart);\n    }\n\n    /**\n     * @notice Sets address of Minter\n     * @dev Only address with the admin role is allowed to change the value of minter\n     * @param _minter L1 Address of minter\n     */\n    function setMinter(address _minter) external onlyRole(DEFAULT_ADMIN_ROLE) {\n        minter = _minter;\n        emit MinterUpdate(_minter);\n    }\n\n    /**\n     * @notice Creates and sends a retryable ticket to migrate LPT to L2 using arbitrum Inbox.\n     * The tokens are sent to the Escrow contract for safekeeping until they are withdrawn\n     * The ticket must be redeemed on L2 to receive tokens at the specified address.\n     * @dev maxGas and gasPriceBid must be set using arbitrum's Inbox.estimateRetryableTicket method.\n     * @param _l1Token L1 Address of LPT\n     * @param _to Recepient address on L2\n     * @param _amount Amount of tokens to tranfer\n     * @param _maxGas Gas limit for L2 execution of the ticket\n     * @param _gasPriceBid Price per gas on L2\n     * @param _data Encoded maxSubmission cost and sender address along with additional calldata\n     * @return seqNum Sequence number of the retryable ticket created by Inbox\n     */\n    function outboundTransfer(\n        address _l1Token,\n        address _to,\n        uint256 _amount,\n        uint256 _maxGas,\n        uint256 _gasPriceBid,\n        bytes calldata _data\n    ) external payable override whenNotPaused returns (bytes memory) {\n        require(_l1Token == l1Lpt, \"TOKEN_NOT_LPT\");\n        require(_amount > 0, \"INVALID_ZERO_AMOUNT\");\n\n        // nested scope to avoid stack too deep errors\n        address from;\n        uint256 seqNum;\n        bytes memory extraData;\n        {\n            uint256 maxSubmissionCost;\n            (from, maxSubmissionCost, extraData) = parseOutboundData(_data);\n            require(extraData.length == 0, \"CALL_HOOK_DATA_NOT_ALLOWED\");\n\n            // makes sure only sufficient ETH is supplied required for successful redemption on L2\n            // if a user does not desire immediate redemption they should provide\n            // a msg.value of AT LEAST maxSubmissionCost\n            uint256 expectedEth = maxSubmissionCost + (_maxGas * _gasPriceBid);\n            require(maxSubmissionCost > 0, \"NO_SUBMISSION_COST\");\n            require(msg.value == expectedEth, \"WRONG_ETH_VALUE\");\n\n            // transfer tokens to escrow\n            TokenLike(_l1Token).transferFrom(from, l1LPTEscrow, _amount);\n\n            bytes memory outboundCalldata = getOutboundCalldata(\n                _l1Token,\n                from,\n                _to,\n                _amount,\n                extraData\n            );\n\n            seqNum = sendTxToL2(\n                l2Counterpart,\n                from,\n                maxSubmissionCost,\n                _maxGas,\n                _gasPriceBid,\n                outboundCalldata\n            );\n        }\n\n        emit DepositInitiated(_l1Token, from, _to, seqNum, _amount);\n\n        return abi.encode(seqNum);\n    }\n\n    /**\n     * @notice Receives withdrawn token amount from L2\n     * The equivalent tokens are released from the Escrow contract and sent to the destination\n     * In case the escrow doesn't have enough balance, new tokens are minted\n     * @dev can only accept txs coming directly from L2 LPT Gateway\n     * @param l1Token L1 Address of LPT\n     * @param from Address of the sender\n     * @param to Recepient address on L1\n     * @param amount Amount of tokens transferred\n     * @param data Contains exitNum which is always set to 0\n     */\n    function finalizeInboundTransfer(\n        address l1Token,\n        address from,\n        address to,\n        uint256 amount,\n        bytes calldata data\n    ) external override onlyL2Counterpart(l2Counterpart) {\n        require(l1Token == l1Lpt, \"TOKEN_NOT_LPT\");\n        (uint256 exitNum, ) = abi.decode(data, (uint256, bytes));\n\n        uint256 escrowBalance = TokenLike(l1Token).balanceOf(l1LPTEscrow);\n\n        // mint additional tokens if requested amount exceeds escrowed amount\n        if (amount <= escrowBalance) {\n            TokenLike(l1Token).transferFrom(l1LPTEscrow, to, amount);\n        } else {\n            if (escrowBalance > 0) {\n                TokenLike(l1Token).transferFrom(l1LPTEscrow, to, escrowBalance);\n            }\n            IMinter(minter).bridgeMint(to, amount - escrowBalance);\n        }\n\n        emit WithdrawalFinalized(l1Token, from, to, exitNum, amount);\n    }\n\n    /**\n     * @notice decodes calldata required for migration of tokens\n     * @dev data must include maxSubmissionCost, extraData can be left empty\n     * @param data encoded callhook data\n     * @return from sender of the tx\n     * @return maxSubmissionCost base ether value required to keep retyrable ticket alive\n     * @return extraData any other data sent to L2\n     */\n    function parseOutboundData(bytes memory data)\n        private\n        view\n        returns (\n            address from,\n            uint256 maxSubmissionCost,\n            bytes memory extraData\n        )\n    {\n        if (msg.sender == l1Router) {\n            // router encoded\n            (from, extraData) = abi.decode(data, (address, bytes));\n        } else {\n            from = msg.sender;\n            extraData = data;\n        }\n        // user encoded\n        (maxSubmissionCost, extraData) = abi.decode(\n            extraData,\n            (uint256, bytes)\n        );\n    }\n\n    /**\n     * @notice returns address of L2 LPT Gateway\n     */\n    function counterpartGateway() external view override returns (address) {\n        return l2Counterpart;\n    }\n\n    /**\n     * @notice returns address of L2 version of LPT\n     */\n    function calculateL2TokenAddress(address l1Token)\n        external\n        view\n        override\n        returns (address)\n    {\n        if (l1Token != l1Lpt) {\n            return address(0);\n        }\n\n        return l2Lpt;\n    }\n\n    /**\n     * @notice Creates calldata required to create a retryable ticket\n     * @dev encodes the target function with its params which\n     * will be called on L2 when the retryable ticket is redeemed\n     */\n    function getOutboundCalldata(\n        address l1Token,\n        address from,\n        address to,\n        uint256 amount,\n        bytes memory data\n    ) public pure returns (bytes memory outboundCalldata) {\n        bytes memory emptyBytes;\n\n        outboundCalldata = abi.encodeWithSelector(\n            IL2LPTGateway.finalizeInboundTransfer.selector,\n            l1Token,\n            from,\n            to,\n            amount,\n            abi.encode(emptyBytes, data)\n        );\n    }\n}\n","keccak256":"0x3f3538b2b8cd8e688d0144436b63bf5104b4ced235d61a1c1d4b11b608badcd1","license":"MIT"},"contracts/L2/gateway/IL2LPTGateway.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\ninterface IL2LPTGateway {\n    event DepositFinalized(\n        address indexed _l1Token,\n        address indexed _from,\n        address indexed _to,\n        uint256 _amount\n    );\n\n    event WithdrawalInitiated(\n        address _l1Token,\n        address indexed _from,\n        address indexed _to,\n        uint256 indexed _l2ToL1Id,\n        uint256 _exitNum,\n        uint256 _amount\n    );\n\n    function outboundTransfer(\n        address _token,\n        address _to,\n        uint256 _amount,\n        bytes calldata _data\n    ) external returns (bytes memory);\n\n    function finalizeInboundTransfer(\n        address _token,\n        address _from,\n        address _to,\n        uint256 _amount,\n        bytes calldata _data\n    ) external;\n\n    // if token is not supported this should return 0x0 address\n    function calculateL2TokenAddress(address _l1Token)\n        external\n        view\n        returns (address);\n\n    // used by router\n    function counterpartGateway() external view returns (address);\n}\n","keccak256":"0x536e2e1380bedaf69662181b2f20c22e975eb19b284f08c319edb2e80900629d","license":"MIT"},"contracts/arbitrum/IBridge.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\n\n/*\n * Copyright 2021, Offchain Labs, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *    http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.9;\n\ninterface IBridge {\n    event MessageDelivered(\n        uint256 indexed messageIndex,\n        bytes32 indexed beforeInboxAcc,\n        address inbox,\n        uint8 kind,\n        address sender,\n        bytes32 messageDataHash\n    );\n\n    event BridgeCallTriggered(\n        address indexed outbox,\n        address indexed destAddr,\n        uint256 amount,\n        bytes data\n    );\n\n    event InboxToggle(address indexed inbox, bool enabled);\n\n    event OutboxToggle(address indexed outbox, bool enabled);\n\n    function deliverMessageToInbox(\n        uint8 kind,\n        address sender,\n        bytes32 messageDataHash\n    ) external payable returns (uint256);\n\n    function executeCall(\n        address destAddr,\n        uint256 amount,\n        bytes calldata data\n    ) external returns (bool success, bytes memory returnData);\n\n    // These are only callable by the admin\n    function setInbox(address inbox, bool enabled) external;\n\n    function setOutbox(address inbox, bool enabled) external;\n\n    // View functions\n\n    function activeOutbox() external view returns (address);\n\n    function allowedInboxes(address inbox) external view returns (bool);\n\n    function allowedOutboxes(address outbox) external view returns (bool);\n\n    function inboxAccs(uint256 index) external view returns (bytes32);\n\n    function messageCount() external view returns (uint256);\n}\n","keccak256":"0x4e72972d4c0f6d4832d5cb338faab1a016d5eee9c9461631334a873bffdc96dd","license":"Apache-2.0"},"contracts/arbitrum/IInbox.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\n\n/*\n * Copyright 2021, Offchain Labs, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *    http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.9;\n\nimport \"./IMessageProvider.sol\";\n\ninterface IInbox is IMessageProvider {\n    function sendL2Message(bytes calldata messageData)\n        external\n        returns (uint256);\n\n    function sendUnsignedTransaction(\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        uint256 nonce,\n        address destAddr,\n        uint256 amount,\n        bytes calldata data\n    ) external returns (uint256);\n\n    function sendContractTransaction(\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        address destAddr,\n        uint256 amount,\n        bytes calldata data\n    ) external returns (uint256);\n\n    function sendL1FundedUnsignedTransaction(\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        uint256 nonce,\n        address destAddr,\n        bytes calldata data\n    ) external payable returns (uint256);\n\n    function sendL1FundedContractTransaction(\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        address destAddr,\n        bytes calldata data\n    ) external payable returns (uint256);\n\n    function createRetryableTicket(\n        address destAddr,\n        uint256 arbTxCallValue,\n        uint256 maxSubmissionCost,\n        address submissionRefundAddress,\n        address valueRefundAddress,\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        bytes calldata data\n    ) external payable returns (uint256);\n\n    function createRetryableTicketNoRefundAliasRewrite(\n        address destAddr,\n        uint256 arbTxCallValue,\n        uint256 maxSubmissionCost,\n        address submissionRefundAddress,\n        address valueRefundAddress,\n        uint256 maxGas,\n        uint256 gasPriceBid,\n        bytes calldata data\n    ) external payable returns (uint256);\n\n    function depositEth(uint256 maxSubmissionCost)\n        external\n        payable\n        returns (uint256);\n\n    function bridge() external view returns (address);\n\n    function pauseCreateRetryables() external;\n\n    function unpauseCreateRetryables() external;\n\n    function startRewriteAddress() external;\n\n    function stopRewriteAddress() external;\n}\n","keccak256":"0xfb28f598c86519a5a414fe4523b3fd17d608e88e02ead26599af32f8605f3583","license":"Apache-2.0"},"contracts/arbitrum/IMessageProvider.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\n\n/*\n * Copyright 2021, Offchain Labs, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *    http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.9;\n\ninterface IMessageProvider {\n    event InboxMessageDelivered(uint256 indexed messageNum, bytes data);\n\n    event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum);\n}\n","keccak256":"0xc1a98f8599fdb5fd7b29abf5c00d48d3e35e5f649cbd81b4f4a940f2e587d9b0","license":"Apache-2.0"},"contracts/arbitrum/IOutbox.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\n\n/*\n * Copyright 2021, Offchain Labs, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *    http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.9;\n\ninterface IOutbox {\n    event OutboxEntryCreated(\n        uint256 indexed batchNum,\n        uint256 outboxEntryIndex,\n        bytes32 outputRoot,\n        uint256 numInBatch\n    );\n    event OutBoxTransactionExecuted(\n        address indexed destAddr,\n        address indexed l2Sender,\n        uint256 indexed outboxEntryIndex,\n        uint256 transactionIndex\n    );\n\n    function l2ToL1Sender() external view returns (address);\n\n    function l2ToL1Block() external view returns (uint256);\n\n    function l2ToL1EthBlock() external view returns (uint256);\n\n    function l2ToL1Timestamp() external view returns (uint256);\n\n    function l2ToL1BatchNum() external view returns (uint256);\n\n    function l2ToL1OutputId() external view returns (bytes32);\n\n    function processOutgoingMessages(\n        bytes calldata sendsData,\n        uint256[] calldata sendLengths\n    ) external;\n\n    function outboxEntryExists(uint256 batchNum) external view returns (bool);\n}\n","keccak256":"0xa3f81acfc7f912053a527abd61058a646fcd1d2ebc8b34cc64a0bd40a5860151","license":"Apache-2.0"}},"version":1}