{"matchId":"43326055","creationMatch":null,"runtimeMatch":"match","verifiedAt":"2026-08-05T20:54:04Z","creationBytecode":{"onchainBytecode":null,"recompiledBytecode":"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","sourceMap":"22126:1157:0:-:0;;;;;;;;;;;;-1:-1:-1;1924:32:0;830:10;1924:18;:32::i;:::-;22126:1157;;3470:191;3544:16;3563:6;;-1:-1:-1;;;;;3580:17:0;;;-1:-1:-1;;;;;;3580:17:0;;;;;;3613:40;;3563:6;;;;;;;3613:40;;3544:16;3613:40;3470:191;;:::o;22126:1157::-;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220889c392979defbdf7e97cc7e379b27b39071d35ceed8447318b3d35bfffd99c564736f6c63430008040033","offset":3448}},"transformations":null,"transformationValues":null},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"22126:1157:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22743:384;;;;;;;;;;-1:-1:-1;22743:384:0;;;;;:::i;:::-;;:::i;:::-;;22343:394;;;;;;:::i;:::-;;:::i;2851:103::-;;;;;;;;;;;;;:::i;2203:87::-;;;;;;;;;;-1:-1:-1;2249:7:0;2276:6;2203:87;;;2276:6;;;;2776:74:1;;2203:87:0;;;;;2764:2:1;2203:87:0;;;3109:201;;;;;;;;;;-1:-1:-1;3109:201:0;;;;;:::i;:::-;;:::i;22743:384::-;22799:15;22825:19;;;;22821:180;;22865:38;;;;;22897:4;22865:38;;;2776:74:1;22865:23:0;;;;;;2749:18:1;;22865:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22855:48;-1:-1:-1;22916:11:0;;22912:82;;22940:44;22967:7;2249;2276:6;;;;2203:87;22967:7;22940:26;;;;22976:7;22940:26;:44::i;:::-;-1:-1:-1;23019:21:0;23051:11;;23047:75;;2249:7;2276:6;;;23073:21;;23102:7;23073:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23047:75;22743:384;;:::o;22343:394::-;2089:13;:11;:13::i;:::-;22422:6:::1;22417:315;22432:14:::0;;::::1;22417:315;;;22463:12;22477:19:::0;22508:5:::1;;22514:1;22508:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:15;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;22500:29;;22537:5;;22543:1;22537:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:14;;;22553:5;;22559:1;22553:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:13;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;22500:67;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22462:105;;;;22581:7;22576:149;;22639:1;22661:5;;22667:1;22661:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:15;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;22697:6;22608:107;;;;;;;;;;;;;:::i;:::-;;;;;;;;22576:149;22417:315;;22448:3;;;;;:::i;:::-;;;;22417:315;;;;22343:394:::0;;:::o;2851:103::-;2089:13;:11;:13::i;:::-;2916:30:::1;2943:1;2916:18;:30::i;:::-;2851:103::o:0;3109:201::-;2089:13;:11;:13::i;:::-;3198:22:::1;::::0;::::1;3190:73;;;::::0;::::1;::::0;;3589:2:1;3190:73:0::1;::::0;::::1;3571:21:1::0;3628:2;3608:18;;;3601:30;3667:34;3647:18;;;3640:62;3738:8;3718:18;;;3711:36;3764:19;;3190:73:0::1;3561:228:1::0;3190:73:0::1;3274:28;3293:8;3274:18;:28::i;:::-;3109:201:::0;:::o;18201:211::-;18345:58;;;3065:42:1;3053:55;;18345:58:0;;;3035:74:1;3125:18;;;;3118:34;;;18345:58:0;;;;;;;;;;3008:18:1;;;;18345:58:0;;;;;;;;;;18368:23;18345:58;;;18318:86;;18338:5;;18318:19;:86::i;2368:132::-;2249:7;2276:6;2432:23;2276:6;830:10;2432:23;2424:68;;;;;;;4403:2:1;2424:68:0;;;4385:21:1;;;4422:18;;;4415:30;4481:34;4461:18;;;4454:62;4533:18;;2424:68:0;4375:182:1;3470:191:0;3544:16;3563:6;;;3580:17;;;;;;;;;;3613:40;;3563:6;;;;;;;3613:40;;3544:16;3613:40;3470:191;;:::o;21268:716::-;21692:23;21718:69;21746:4;21718:69;;;;;;;;;;;;;;;;;21726:5;21718:27;;;;:69;;;;;:::i;:::-;21802:17;;21692:95;;-1:-1:-1;21802:21:0;21798:179;;21899:10;21888:30;;;;;;;;;;;;:::i;:::-;21880:85;;;;;;;5122:2:1;21880:85:0;;;5104:21:1;5161:2;5141:18;;;5134:30;5200:34;5180:18;;;5173:62;5271:12;5251:18;;;5244:40;5301:19;;21880:85:0;5094:232:1;12908:229:0;13045:12;13077:52;13099:6;13107:4;13113:1;13116:12;13077:21;:52::i;:::-;13070:59;;12908:229;;;;;;:::o;14028:510::-;14198:12;14256:5;14231:21;:30;;14223:81;;;;;;;3996:2:1;14223:81:0;;;3978:21:1;4035:2;4015:18;;;4008:30;4074:34;4054:18;;;4047:62;4145:8;4125:18;;;4118:36;4171:19;;14223:81:0;3968:228:1;14223:81:0;10458:19;;;;14315:60;;;;;;;4764:2:1;14315:60:0;;;4746:21:1;4803:2;4783:18;;;4776:30;4842:31;4822:18;;;4815:59;4891:18;;14315:60:0;4736:179:1;14315:60:0;14389:12;14403:23;14430:6;:11;;14449:5;14456:4;14430:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14388:73;;;;14479:51;14496:7;14505:10;14517:12;14479:16;:51::i;:::-;14472:58;14028:510;-1:-1:-1;;;;;;;14028:510:0:o;16714:762::-;16864:12;16893:7;16889:580;;;-1:-1:-1;16924:10:0;16917:17;;16889:580;17038:17;;:21;17034:424;;17286:10;17280:17;17347:15;17334:10;17330:2;17326:19;17319:44;17234:148;17429:12;17422:20;;;;;;;;;;;:::i;14:329:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;241:42;234:5;230:54;223:5;220:65;210:2;;304:6;296;289:22;348:688;457:6;465;518:2;506:9;497:7;493:23;489:32;486:2;;;539:6;531;524:22;486:2;584:9;571:23;613:18;654:2;646:6;643:14;640:2;;;675:6;667;660:22;640:2;718:6;707:9;703:22;693:32;;763:7;756:4;752:2;748:13;744:27;734:2;;790:6;782;775:22;734:2;835;822:16;861:2;853:6;850:14;847:2;;;882:6;874;867:22;847:2;940:7;935:2;925:6;922:1;918:14;914:2;910:23;906:32;903:45;900:2;;;966:6;958;951:22;900:2;1002;994:11;;;;;1024:6;;-1:-1:-1;476:560:1;;-1:-1:-1;;;;476:560:1:o;1041:297::-;1108:6;1161:2;1149:9;1140:7;1136:23;1132:32;1129:2;;;1182:6;1174;1167:22;1129:2;1219:9;1213:16;1272:5;1265:13;1258:21;1251:5;1248:32;1238:2;;1299:6;1291;1284:22;1343:194;1413:6;1466:2;1454:9;1445:7;1441:23;1437:32;1434:2;;;1487:6;1479;1472:22;1434:2;-1:-1:-1;1515:16:1;;1424:113;-1:-1:-1;1424:113:1:o;1542:316::-;1583:3;1621:5;1615:12;1648:6;1643:3;1636:19;1664:63;1720:6;1713:4;1708:3;1704:14;1697:4;1690:5;1686:16;1664:63;:::i;:::-;1772:2;1760:15;1777:66;1756:88;1747:98;;;;1847:4;1743:109;;1591:267;-1:-1:-1;;1591:267:1:o;1863:273::-;2046:6;2038;2033:3;2020:33;2002:3;2072:16;;2097:15;;;2072:16;2010:126;-1:-1:-1;2010:126:1:o;2141:274::-;2270:3;2308:6;2302:13;2324:53;2370:6;2365:3;2358:4;2350:6;2346:17;2324:53;:::i;:::-;2393:16;;;;;2278:137;-1:-1:-1;;2278:137:1:o;3163:219::-;3312:2;3301:9;3294:21;3275:4;3332:44;3372:2;3361:9;3357:18;3349:6;3332:44;:::i;5331:408::-;5534:6;5523:9;5516:25;5589:42;5581:6;5577:55;5572:2;5561:9;5557:18;5550:83;5669:2;5664;5653:9;5649:18;5642:30;5497:4;5689:44;5729:2;5718:9;5714:18;5706:6;5689:44;:::i;:::-;5681:52;5506:233;-1:-1:-1;;;;;5506:233:1:o;5744:592::-;5821:4;5827:6;5887:11;5874:25;5977:66;5966:8;5950:14;5946:29;5942:102;5922:18;5918:127;5908:2;;6062:4;6056;6049:18;5908:2;6092:33;;6144:20;;;-1:-1:-1;6187:18:1;6176:30;;6173:2;;;6222:4;6216;6209:18;6173:2;6258:4;6246:17;;-1:-1:-1;6289:14:1;6285:27;;;6275:38;;6272:2;;;6326:1;6323;6316:12;6272:2;5838:498;;;;;:::o;6341:385::-;6430:4;6488:11;6475:25;6578:66;6567:8;6551:14;6547:29;6543:102;6523:18;6519:127;6509:2;;6663:4;6657;6650:18;6731:258;6803:1;6813:113;6827:6;6824:1;6821:13;6813:113;;;6903:11;;;6897:18;6884:11;;;6877:39;6849:2;6842:10;6813:113;;;6944:6;6941:1;6938:13;6935:2;;;6979:1;6970:6;6965:3;6961:16;6954:27;6935:2;;6784:205;;;:::o;6994:353::-;7033:3;7064:66;7057:5;7054:77;7051:2;;;7166:77;7161:3;7154:90;7267:4;7264:1;7257:15;7297:4;7292:3;7285:17;7051:2;-1:-1:-1;7339:1:1;7328:13;;7041:306::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220889c392979defbdf7e97cc7e379b27b39071d35ceed8447318b3d35bfffd99c564736f6c63430008040033","offset":3322}},"immutableReferences":{},"transformations":[{"id":"1","type":"replace","offset":3322,"reason":"cborAuxdata"}],"transformationValues":{"cborAuxdata":{"1":"0xa264697066735822122065fc99af916dd6aa9adb0ff72a0fcc273c4fe04a6c16213bb628d02b7b1b013464736f6c63430008040033"}}},"deployment":{"transactionHash":null,"blockNumber":null,"transactionIndex":null,"deployer":null},"sources":{"BridgeVM.sol":{"content":"// Sources flattened with hardhat v2.22.6 https://hardhat.org\r\n\r\n\r\n// File @openzeppelin/contracts/utils/Context.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Provides information about the current execution context, including the\r\n * sender of the transaction and its data. While these are generally available\r\n * via msg.sender and msg.data, they should not be accessed in such a direct\r\n * manner, since when dealing with meta-transactions the account sending and\r\n * paying for execution may not be the actual sender (as far as an application\r\n * is concerned).\r\n *\r\n * This contract is only required for intermediate, library-like contracts.\r\n */\r\nabstract contract Context {\r\n    function _msgSender() internal view virtual returns (address) {\r\n        return msg.sender;\r\n    }\r\n\r\n    function _msgData() internal view virtual returns (bytes calldata) {\r\n        return msg.data;\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/access/Ownable.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Contract module which provides a basic access control mechanism, where\r\n * there is an account (an owner) that can be granted exclusive access to\r\n * specific functions.\r\n *\r\n * By default, the owner account will be the one that deploys the contract. This\r\n * can later be changed with {transferOwnership}.\r\n *\r\n * This module is used through inheritance. It will make available the modifier\r\n * `onlyOwner`, which can be applied to your functions to restrict their use to\r\n * the owner.\r\n */\r\nabstract contract Ownable is Context {\r\n    address private _owner;\r\n\r\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r\n\r\n    /**\r\n     * @dev Initializes the contract setting the deployer as the initial owner.\r\n     */\r\n    constructor() {\r\n        _transferOwnership(_msgSender());\r\n    }\r\n\r\n    /**\r\n     * @dev Throws if called by any account other than the owner.\r\n     */\r\n    modifier onlyOwner() {\r\n        _checkOwner();\r\n        _;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the address of the current owner.\r\n     */\r\n    function owner() public view virtual returns (address) {\r\n        return _owner;\r\n    }\r\n\r\n    /**\r\n     * @dev Throws if the sender is not the owner.\r\n     */\r\n    function _checkOwner() internal view virtual {\r\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\r\n    }\r\n\r\n    /**\r\n     * @dev Leaves the contract without owner. It will not be possible to call\r\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\r\n     *\r\n     * NOTE: Renouncing ownership will leave the contract without an owner,\r\n     * thereby removing any functionality that is only available to the owner.\r\n     */\r\n    function renounceOwnership() public virtual onlyOwner {\r\n        _transferOwnership(address(0));\r\n    }\r\n\r\n    /**\r\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\r\n     * Can only be called by the current owner.\r\n     */\r\n    function transferOwnership(address newOwner) public virtual onlyOwner {\r\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\r\n        _transferOwnership(newOwner);\r\n    }\r\n\r\n    /**\r\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\r\n     * Internal function without access restriction.\r\n     */\r\n    function _transferOwnership(address newOwner) internal virtual {\r\n        address oldOwner = _owner;\r\n        _owner = newOwner;\r\n        emit OwnershipTransferred(oldOwner, newOwner);\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\r\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\r\n *\r\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\r\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\r\n * need to send a transaction, and thus is not required to hold Ether at all.\r\n */\r\ninterface IERC20Permit {\r\n    /**\r\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\r\n     * given ``owner``'s signed approval.\r\n     *\r\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\r\n     * ordering also apply here.\r\n     *\r\n     * Emits an {Approval} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `spender` cannot be the zero address.\r\n     * - `deadline` must be a timestamp in the future.\r\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\r\n     * over the EIP712-formatted function arguments.\r\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\r\n     *\r\n     * For more information on the signature format, see the\r\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\r\n     * section].\r\n     */\r\n    function permit(\r\n        address owner,\r\n        address spender,\r\n        uint256 value,\r\n        uint256 deadline,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external;\r\n\r\n    /**\r\n     * @dev Returns the current nonce for `owner`. This value must be\r\n     * included whenever a signature is generated for {permit}.\r\n     *\r\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\r\n     * prevents a signature from being used multiple times.\r\n     */\r\n    function nonces(address owner) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\r\n     */\r\n    // solhint-disable-next-line func-name-mixedcase\r\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Interface of the ERC20 standard as defined in the EIP.\r\n */\r\ninterface IERC20 {\r\n    /**\r\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\r\n     * another (`to`).\r\n     *\r\n     * Note that `value` may be zero.\r\n     */\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n    /**\r\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\r\n     * a call to {approve}. `value` is the new allowance.\r\n     */\r\n    event Approval(address indexed owner, address indexed spender, uint256 value);\r\n\r\n    /**\r\n     * @dev Returns the amount of tokens in existence.\r\n     */\r\n    function totalSupply() external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Returns the amount of tokens owned by `account`.\r\n     */\r\n    function balanceOf(address account) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Moves `amount` tokens from the caller's account to `to`.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function transfer(address to, uint256 amount) external returns (bool);\r\n\r\n    /**\r\n     * @dev Returns the remaining number of tokens that `spender` will be\r\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\r\n     * zero by default.\r\n     *\r\n     * This value changes when {approve} or {transferFrom} are called.\r\n     */\r\n    function allowance(address owner, address spender) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\r\n     * that someone may use both the old and the new allowance by unfortunate\r\n     * transaction ordering. One possible solution to mitigate this race\r\n     * condition is to first reduce the spender's allowance to 0 and set the\r\n     * desired value afterwards:\r\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\r\n     *\r\n     * Emits an {Approval} event.\r\n     */\r\n    function approve(address spender, uint256 amount) external returns (bool);\r\n\r\n    /**\r\n     * @dev Moves `amount` tokens from `from` to `to` using the\r\n     * allowance mechanism. `amount` is then deducted from the caller's\r\n     * allowance.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function transferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 amount\r\n    ) external returns (bool);\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/utils/Address.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\r\n\r\npragma solidity ^0.8.1;\r\n\r\n/**\r\n * @dev Collection of functions related to the address type\r\n */\r\nlibrary Address {\r\n    /**\r\n     * @dev Returns true if `account` is a contract.\r\n     *\r\n     * [IMPORTANT]\r\n     * ====\r\n     * It is unsafe to assume that an address for which this function returns\r\n     * false is an externally-owned account (EOA) and not a contract.\r\n     *\r\n     * Among others, `isContract` will return false for the following\r\n     * types of addresses:\r\n     *\r\n     *  - an externally-owned account\r\n     *  - a contract in construction\r\n     *  - an address where a contract will be created\r\n     *  - an address where a contract lived, but was destroyed\r\n     * ====\r\n     *\r\n     * [IMPORTANT]\r\n     * ====\r\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\r\n     *\r\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\r\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\r\n     * constructor.\r\n     * ====\r\n     */\r\n    function isContract(address account) internal view returns (bool) {\r\n        // This method relies on extcodesize/address.code.length, which returns 0\r\n        // for contracts in construction, since the code is only stored at the end\r\n        // of the constructor execution.\r\n\r\n        return account.code.length > 0;\r\n    }\r\n\r\n    /**\r\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\r\n     * `recipient`, forwarding all available gas and reverting on errors.\r\n     *\r\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\r\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\r\n     * imposed by `transfer`, making them unable to receive funds via\r\n     * `transfer`. {sendValue} removes this limitation.\r\n     *\r\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\r\n     *\r\n     * IMPORTANT: because control is transferred to `recipient`, care must be\r\n     * taken to not create reentrancy vulnerabilities. Consider using\r\n     * {ReentrancyGuard} or the\r\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\r\n     */\r\n    function sendValue(address payable recipient, uint256 amount) internal {\r\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\r\n\r\n        (bool success, ) = recipient.call{value: amount}(\"\");\r\n        require(success, \"Address: unable to send value, recipient may have reverted\");\r\n    }\r\n\r\n    /**\r\n     * @dev Performs a Solidity function call using a low level `call`. A\r\n     * plain `call` is an unsafe replacement for a function call: use this\r\n     * function instead.\r\n     *\r\n     * If `target` reverts with a revert reason, it is bubbled up by this\r\n     * function (like regular Solidity function calls).\r\n     *\r\n     * Returns the raw returned data. To convert to the expected return value,\r\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `target` must be a contract.\r\n     * - calling `target` with `data` must not revert.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionCall(target, data, \"Address: low-level call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\r\n     * `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, 0, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but also transferring `value` wei to `target`.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the calling contract must have an ETH balance of at least `value`.\r\n     * - the called Solidity function must be `payable`.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value\r\n    ) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\r\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\r\n        require(isContract(target), \"Address: call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\r\n        return verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\r\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal view returns (bytes memory) {\r\n        require(isContract(target), \"Address: static call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.staticcall(data);\r\n        return verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        require(isContract(target), \"Address: delegate call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.delegatecall(data);\r\n        return verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\r\n     * revert reason using the provided one.\r\n     *\r\n     * _Available since v4.3._\r\n     */\r\n    function verifyCallResult(\r\n        bool success,\r\n        bytes memory returndata,\r\n        string memory errorMessage\r\n    ) internal pure returns (bytes memory) {\r\n        if (success) {\r\n            return returndata;\r\n        } else {\r\n            // Look for revert reason and bubble it up if present\r\n            if (returndata.length > 0) {\r\n                // The easiest way to bubble the revert reason is using memory via assembly\r\n                /// @solidity memory-safe-assembly\r\n                assembly {\r\n                    let returndata_size := mload(returndata)\r\n                    revert(add(32, returndata), returndata_size)\r\n                }\r\n            } else {\r\n                revert(errorMessage);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n\r\n\r\n/**\r\n * @title SafeERC20\r\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\r\n * contract returns false). Tokens that return no value (and instead revert or\r\n * throw on failure) are also supported, non-reverting calls are assumed to be\r\n * successful.\r\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\r\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\r\n */\r\nlibrary SafeERC20 {\r\n    using Address for address;\r\n\r\n    function safeTransfer(\r\n        IERC20 token,\r\n        address to,\r\n        uint256 value\r\n    ) internal {\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\r\n    }\r\n\r\n    function safeTransferFrom(\r\n        IERC20 token,\r\n        address from,\r\n        address to,\r\n        uint256 value\r\n    ) internal {\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\r\n    }\r\n\r\n    /**\r\n     * @dev Deprecated. This function has issues similar to the ones found in\r\n     * {IERC20-approve}, and its usage is discouraged.\r\n     *\r\n     * Whenever possible, use {safeIncreaseAllowance} and\r\n     * {safeDecreaseAllowance} instead.\r\n     */\r\n    function safeApprove(\r\n        IERC20 token,\r\n        address spender,\r\n        uint256 value\r\n    ) internal {\r\n        // safeApprove should only be called when setting an initial allowance,\r\n        // or when resetting it to zero. To increase and decrease it, use\r\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\r\n        require(\r\n            (value == 0) || (token.allowance(address(this), spender) == 0),\r\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\r\n        );\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\r\n    }\r\n\r\n    function safeIncreaseAllowance(\r\n        IERC20 token,\r\n        address spender,\r\n        uint256 value\r\n    ) internal {\r\n        uint256 newAllowance = token.allowance(address(this), spender) + value;\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\r\n    }\r\n\r\n    function safeDecreaseAllowance(\r\n        IERC20 token,\r\n        address spender,\r\n        uint256 value\r\n    ) internal {\r\n        unchecked {\r\n            uint256 oldAllowance = token.allowance(address(this), spender);\r\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\r\n            uint256 newAllowance = oldAllowance - value;\r\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\r\n        }\r\n    }\r\n\r\n    function safePermit(\r\n        IERC20Permit token,\r\n        address owner,\r\n        address spender,\r\n        uint256 value,\r\n        uint256 deadline,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) internal {\r\n        uint256 nonceBefore = token.nonces(owner);\r\n        token.permit(owner, spender, value, deadline, v, r, s);\r\n        uint256 nonceAfter = token.nonces(owner);\r\n        require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\r\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\r\n     * @param token The token targeted by the call.\r\n     * @param data The call data (encoded using abi.encode or one of its variants).\r\n     */\r\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\r\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\r\n        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\r\n        // the target address contains contract code and also asserts for success in the low-level call.\r\n\r\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\r\n        if (returndata.length > 0) {\r\n            // Return data is optional\r\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// File contracts/BridgeVM.sol\r\n\r\npragma solidity >=0.4.22 <0.9.0;\r\n\r\n\r\n\r\n/**\r\n * VM contract to execute calldata in a sandbox\r\n */\r\ncontract BridgeVM is Ownable {\r\n  using SafeERC20 for IERC20;\r\n\r\n  error CallFailed(uint256 index, address target, bytes result);\r\n\r\n  struct Call {\r\n    address target;\r\n    uint256 value;\r\n    bytes data;\r\n  }\r\n\r\n  function execute(Call[] calldata datas) external payable onlyOwner {\r\n    for (uint i=0; i<datas.length; i++) {\r\n      (bool success, bytes memory result) = payable(datas[i].target).call{value: datas[i].value}(datas[i].data);\r\n      if (!success) {\r\n        revert CallFailed({\r\n          index: i,\r\n          target: datas[i].target,\r\n          result: result\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  function withdrawVmFunds(address token) external {\r\n    uint256 balance;\r\n    if (token != address(0)) {\r\n      balance = IERC20(token).balanceOf(address(this));\r\n      if (balance > 0) {\r\n        IERC20(token).safeTransfer(owner(), balance);\r\n      }\r\n    }\r\n\r\n    balance = address(this).balance;\r\n    if (balance > 0) {\r\n      payable(owner()).call{value: balance}(\"\");\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @dev allow receiving native funds in case any failure returned funds back\r\n   * to this contract\r\n   */\r\n  receive() external payable { }\r\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.4+commit.c7e474f2","compilerSettings":{"libraries":{},"optimizer":{"runs":10000,"enabled":true}},"name":"BridgeVM","fullyQualifiedName":"BridgeVM.sol:BridgeVM"},"abi":[{"name":"CallFailed","type":"error","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"target","type":"address","internalType":"address"},{"name":"result","type":"bytes","internalType":"bytes"}]},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"execute","type":"function","inputs":[{"name":"datas","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct BridgeVM.Call[]"}],"outputs":[],"stateMutability":"payable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdrawVmFunds","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.4+commit.c7e474f2"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"result","type":"bytes"}],"name":"CallFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct BridgeVM.Call[]","name":"datas","type":"tuple[]"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"withdrawVmFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"userdoc":{"kind":"user","methods":{},"notice":"VM contract to execute calldata in a sandbox","version":1}},"settings":{"compilationTarget":{"BridgeVM.sol":"BridgeVM"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":10000},"remappings":[]},"sources":{"BridgeVM.sol":{"keccak256":"0x077f8735abc2c8ec17732511f22aae87da9f6226ad9db3948b2fe26438962ca2","urls":["bzz-raw://3f39a6f020f0659efcf7c36acb3616599b612f72ce9f4c5a24f6b5483b5bdee7","dweb:/ipfs/QmUvs47nSqr4w2ecCk8CwU9d4H4M73uQ8Vhru7uB9T4zFs"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":27,"label":"_owner","offset":0,"contract":"BridgeVM.sol:BridgeVM"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"VM contract to execute calldata in a sandbox","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"sourceIds":{"BridgeVM.sol":{"id":0}},"additionalInput":null,"stdJsonInput":{"sources":{"BridgeVM.sol":{"content":"// Sources flattened with hardhat v2.22.6 https://hardhat.org\r\n\r\n\r\n// File @openzeppelin/contracts/utils/Context.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Provides information about the current execution context, including the\r\n * sender of the transaction and its data. While these are generally available\r\n * via msg.sender and msg.data, they should not be accessed in such a direct\r\n * manner, since when dealing with meta-transactions the account sending and\r\n * paying for execution may not be the actual sender (as far as an application\r\n * is concerned).\r\n *\r\n * This contract is only required for intermediate, library-like contracts.\r\n */\r\nabstract contract Context {\r\n    function _msgSender() internal view virtual returns (address) {\r\n        return msg.sender;\r\n    }\r\n\r\n    function _msgData() internal view virtual returns (bytes calldata) {\r\n        return msg.data;\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/access/Ownable.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Contract module which provides a basic access control mechanism, where\r\n * there is an account (an owner) that can be granted exclusive access to\r\n * specific functions.\r\n *\r\n * By default, the owner account will be the one that deploys the contract. This\r\n * can later be changed with {transferOwnership}.\r\n *\r\n * This module is used through inheritance. It will make available the modifier\r\n * `onlyOwner`, which can be applied to your functions to restrict their use to\r\n * the owner.\r\n */\r\nabstract contract Ownable is Context {\r\n    address private _owner;\r\n\r\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r\n\r\n    /**\r\n     * @dev Initializes the contract setting the deployer as the initial owner.\r\n     */\r\n    constructor() {\r\n        _transferOwnership(_msgSender());\r\n    }\r\n\r\n    /**\r\n     * @dev Throws if called by any account other than the owner.\r\n     */\r\n    modifier onlyOwner() {\r\n        _checkOwner();\r\n        _;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the address of the current owner.\r\n     */\r\n    function owner() public view virtual returns (address) {\r\n        return _owner;\r\n    }\r\n\r\n    /**\r\n     * @dev Throws if the sender is not the owner.\r\n     */\r\n    function _checkOwner() internal view virtual {\r\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\r\n    }\r\n\r\n    /**\r\n     * @dev Leaves the contract without owner. It will not be possible to call\r\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\r\n     *\r\n     * NOTE: Renouncing ownership will leave the contract without an owner,\r\n     * thereby removing any functionality that is only available to the owner.\r\n     */\r\n    function renounceOwnership() public virtual onlyOwner {\r\n        _transferOwnership(address(0));\r\n    }\r\n\r\n    /**\r\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\r\n     * Can only be called by the current owner.\r\n     */\r\n    function transferOwnership(address newOwner) public virtual onlyOwner {\r\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\r\n        _transferOwnership(newOwner);\r\n    }\r\n\r\n    /**\r\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\r\n     * Internal function without access restriction.\r\n     */\r\n    function _transferOwnership(address newOwner) internal virtual {\r\n        address oldOwner = _owner;\r\n        _owner = newOwner;\r\n        emit OwnershipTransferred(oldOwner, newOwner);\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\r\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\r\n *\r\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\r\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\r\n * need to send a transaction, and thus is not required to hold Ether at all.\r\n */\r\ninterface IERC20Permit {\r\n    /**\r\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\r\n     * given ``owner``'s signed approval.\r\n     *\r\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\r\n     * ordering also apply here.\r\n     *\r\n     * Emits an {Approval} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `spender` cannot be the zero address.\r\n     * - `deadline` must be a timestamp in the future.\r\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\r\n     * over the EIP712-formatted function arguments.\r\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\r\n     *\r\n     * For more information on the signature format, see the\r\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\r\n     * section].\r\n     */\r\n    function permit(\r\n        address owner,\r\n        address spender,\r\n        uint256 value,\r\n        uint256 deadline,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external;\r\n\r\n    /**\r\n     * @dev Returns the current nonce for `owner`. This value must be\r\n     * included whenever a signature is generated for {permit}.\r\n     *\r\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\r\n     * prevents a signature from being used multiple times.\r\n     */\r\n    function nonces(address owner) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\r\n     */\r\n    // solhint-disable-next-line func-name-mixedcase\r\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Interface of the ERC20 standard as defined in the EIP.\r\n */\r\ninterface IERC20 {\r\n    /**\r\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\r\n     * another (`to`).\r\n     *\r\n     * Note that `value` may be zero.\r\n     */\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n    /**\r\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\r\n     * a call to {approve}. `value` is the new allowance.\r\n     */\r\n    event Approval(address indexed owner, address indexed spender, uint256 value);\r\n\r\n    /**\r\n     * @dev Returns the amount of tokens in existence.\r\n     */\r\n    function totalSupply() external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Returns the amount of tokens owned by `account`.\r\n     */\r\n    function balanceOf(address account) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Moves `amount` tokens from the caller's account to `to`.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function transfer(address to, uint256 amount) external returns (bool);\r\n\r\n    /**\r\n     * @dev Returns the remaining number of tokens that `spender` will be\r\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\r\n     * zero by default.\r\n     *\r\n     * This value changes when {approve} or {transferFrom} are called.\r\n     */\r\n    function allowance(address owner, address spender) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\r\n     * that someone may use both the old and the new allowance by unfortunate\r\n     * transaction ordering. One possible solution to mitigate this race\r\n     * condition is to first reduce the spender's allowance to 0 and set the\r\n     * desired value afterwards:\r\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\r\n     *\r\n     * Emits an {Approval} event.\r\n     */\r\n    function approve(address spender, uint256 amount) external returns (bool);\r\n\r\n    /**\r\n     * @dev Moves `amount` tokens from `from` to `to` using the\r\n     * allowance mechanism. `amount` is then deducted from the caller's\r\n     * allowance.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function transferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 amount\r\n    ) external returns (bool);\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/utils/Address.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\r\n\r\npragma solidity ^0.8.1;\r\n\r\n/**\r\n * @dev Collection of functions related to the address type\r\n */\r\nlibrary Address {\r\n    /**\r\n     * @dev Returns true if `account` is a contract.\r\n     *\r\n     * [IMPORTANT]\r\n     * ====\r\n     * It is unsafe to assume that an address for which this function returns\r\n     * false is an externally-owned account (EOA) and not a contract.\r\n     *\r\n     * Among others, `isContract` will return false for the following\r\n     * types of addresses:\r\n     *\r\n     *  - an externally-owned account\r\n     *  - a contract in construction\r\n     *  - an address where a contract will be created\r\n     *  - an address where a contract lived, but was destroyed\r\n     * ====\r\n     *\r\n     * [IMPORTANT]\r\n     * ====\r\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\r\n     *\r\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\r\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\r\n     * constructor.\r\n     * ====\r\n     */\r\n    function isContract(address account) internal view returns (bool) {\r\n        // This method relies on extcodesize/address.code.length, which returns 0\r\n        // for contracts in construction, since the code is only stored at the end\r\n        // of the constructor execution.\r\n\r\n        return account.code.length > 0;\r\n    }\r\n\r\n    /**\r\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\r\n     * `recipient`, forwarding all available gas and reverting on errors.\r\n     *\r\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\r\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\r\n     * imposed by `transfer`, making them unable to receive funds via\r\n     * `transfer`. {sendValue} removes this limitation.\r\n     *\r\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\r\n     *\r\n     * IMPORTANT: because control is transferred to `recipient`, care must be\r\n     * taken to not create reentrancy vulnerabilities. Consider using\r\n     * {ReentrancyGuard} or the\r\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\r\n     */\r\n    function sendValue(address payable recipient, uint256 amount) internal {\r\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\r\n\r\n        (bool success, ) = recipient.call{value: amount}(\"\");\r\n        require(success, \"Address: unable to send value, recipient may have reverted\");\r\n    }\r\n\r\n    /**\r\n     * @dev Performs a Solidity function call using a low level `call`. A\r\n     * plain `call` is an unsafe replacement for a function call: use this\r\n     * function instead.\r\n     *\r\n     * If `target` reverts with a revert reason, it is bubbled up by this\r\n     * function (like regular Solidity function calls).\r\n     *\r\n     * Returns the raw returned data. To convert to the expected return value,\r\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `target` must be a contract.\r\n     * - calling `target` with `data` must not revert.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionCall(target, data, \"Address: low-level call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\r\n     * `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, 0, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but also transferring `value` wei to `target`.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the calling contract must have an ETH balance of at least `value`.\r\n     * - the called Solidity function must be `payable`.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value\r\n    ) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\r\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\r\n        require(isContract(target), \"Address: call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\r\n        return verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\r\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal view returns (bytes memory) {\r\n        require(isContract(target), \"Address: static call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.staticcall(data);\r\n        return verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        require(isContract(target), \"Address: delegate call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.delegatecall(data);\r\n        return verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\r\n     * revert reason using the provided one.\r\n     *\r\n     * _Available since v4.3._\r\n     */\r\n    function verifyCallResult(\r\n        bool success,\r\n        bytes memory returndata,\r\n        string memory errorMessage\r\n    ) internal pure returns (bytes memory) {\r\n        if (success) {\r\n            return returndata;\r\n        } else {\r\n            // Look for revert reason and bubble it up if present\r\n            if (returndata.length > 0) {\r\n                // The easiest way to bubble the revert reason is using memory via assembly\r\n                /// @solidity memory-safe-assembly\r\n                assembly {\r\n                    let returndata_size := mload(returndata)\r\n                    revert(add(32, returndata), returndata_size)\r\n                }\r\n            } else {\r\n                revert(errorMessage);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.7.3\r\n\r\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n\r\n\r\n/**\r\n * @title SafeERC20\r\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\r\n * contract returns false). Tokens that return no value (and instead revert or\r\n * throw on failure) are also supported, non-reverting calls are assumed to be\r\n * successful.\r\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\r\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\r\n */\r\nlibrary SafeERC20 {\r\n    using Address for address;\r\n\r\n    function safeTransfer(\r\n        IERC20 token,\r\n        address to,\r\n        uint256 value\r\n    ) internal {\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\r\n    }\r\n\r\n    function safeTransferFrom(\r\n        IERC20 token,\r\n        address from,\r\n        address to,\r\n        uint256 value\r\n    ) internal {\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\r\n    }\r\n\r\n    /**\r\n     * @dev Deprecated. This function has issues similar to the ones found in\r\n     * {IERC20-approve}, and its usage is discouraged.\r\n     *\r\n     * Whenever possible, use {safeIncreaseAllowance} and\r\n     * {safeDecreaseAllowance} instead.\r\n     */\r\n    function safeApprove(\r\n        IERC20 token,\r\n        address spender,\r\n        uint256 value\r\n    ) internal {\r\n        // safeApprove should only be called when setting an initial allowance,\r\n        // or when resetting it to zero. To increase and decrease it, use\r\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\r\n        require(\r\n            (value == 0) || (token.allowance(address(this), spender) == 0),\r\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\r\n        );\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\r\n    }\r\n\r\n    function safeIncreaseAllowance(\r\n        IERC20 token,\r\n        address spender,\r\n        uint256 value\r\n    ) internal {\r\n        uint256 newAllowance = token.allowance(address(this), spender) + value;\r\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\r\n    }\r\n\r\n    function safeDecreaseAllowance(\r\n        IERC20 token,\r\n        address spender,\r\n        uint256 value\r\n    ) internal {\r\n        unchecked {\r\n            uint256 oldAllowance = token.allowance(address(this), spender);\r\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\r\n            uint256 newAllowance = oldAllowance - value;\r\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\r\n        }\r\n    }\r\n\r\n    function safePermit(\r\n        IERC20Permit token,\r\n        address owner,\r\n        address spender,\r\n        uint256 value,\r\n        uint256 deadline,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) internal {\r\n        uint256 nonceBefore = token.nonces(owner);\r\n        token.permit(owner, spender, value, deadline, v, r, s);\r\n        uint256 nonceAfter = token.nonces(owner);\r\n        require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\r\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\r\n     * @param token The token targeted by the call.\r\n     * @param data The call data (encoded using abi.encode or one of its variants).\r\n     */\r\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\r\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\r\n        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\r\n        // the target address contains contract code and also asserts for success in the low-level call.\r\n\r\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\r\n        if (returndata.length > 0) {\r\n            // Return data is optional\r\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// File contracts/BridgeVM.sol\r\n\r\npragma solidity >=0.4.22 <0.9.0;\r\n\r\n\r\n\r\n/**\r\n * VM contract to execute calldata in a sandbox\r\n */\r\ncontract BridgeVM is Ownable {\r\n  using SafeERC20 for IERC20;\r\n\r\n  error CallFailed(uint256 index, address target, bytes result);\r\n\r\n  struct Call {\r\n    address target;\r\n    uint256 value;\r\n    bytes data;\r\n  }\r\n\r\n  function execute(Call[] calldata datas) external payable onlyOwner {\r\n    for (uint i=0; i<datas.length; i++) {\r\n      (bool success, bytes memory result) = payable(datas[i].target).call{value: datas[i].value}(datas[i].data);\r\n      if (!success) {\r\n        revert CallFailed({\r\n          index: i,\r\n          target: datas[i].target,\r\n          result: result\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  function withdrawVmFunds(address token) external {\r\n    uint256 balance;\r\n    if (token != address(0)) {\r\n      balance = IERC20(token).balanceOf(address(this));\r\n      if (balance > 0) {\r\n        IERC20(token).safeTransfer(owner(), balance);\r\n      }\r\n    }\r\n\r\n    balance = address(this).balance;\r\n    if (balance > 0) {\r\n      payable(owner()).call{value: balance}(\"\");\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @dev allow receiving native funds in case any failure returned funds back\r\n   * to this contract\r\n   */\r\n  receive() external payable { }\r\n}"}},"language":"Solidity","settings":{"libraries":{},"optimizer":{"runs":10000,"enabled":true}}},"stdJsonOutput":{"sources":{"BridgeVM.sol":{"id":0}},"contracts":{"BridgeVM.sol":{"BridgeVM":{"abi":[{"name":"CallFailed","type":"error","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"target","type":"address","internalType":"address"},{"name":"result","type":"bytes","internalType":"bytes"}]},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"execute","type":"function","inputs":[{"name":"datas","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct BridgeVM.Call[]"}],"outputs":[],"stateMutability":"payable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdrawVmFunds","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.4+commit.c7e474f2\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"result\",\"type\":\"bytes\"}],\"name\":\"CallFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"struct BridgeVM.Call[]\",\"name\":\"datas\",\"type\":\"tuple[]\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"withdrawVmFunds\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"VM contract to execute calldata in a sandbox\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"BridgeVM.sol\":\"BridgeVM\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"BridgeVM.sol\":{\"keccak256\":\"0x077f8735abc2c8ec17732511f22aae87da9f6226ad9db3948b2fe26438962ca2\",\"urls\":[\"bzz-raw://3f39a6f020f0659efcf7c36acb3616599b612f72ce9f4c5a24f6b5483b5bdee7\",\"dweb:/ipfs/QmUvs47nSqr4w2ecCk8CwU9d4H4M73uQ8Vhru7uB9T4zFs\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"VM contract to execute calldata in a sandbox","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":27,"label":"_owner","offset":0,"contract":"BridgeVM.sol:BridgeVM"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"22126:1157:0:-:0;;;;;;;;;;;;-1:-1:-1;1924:32:0;830:10;1924:18;:32::i;:::-;22126:1157;;3470:191;3544:16;3563:6;;-1:-1:-1;;;;;3580:17:0;;;-1:-1:-1;;;;;;3580:17:0;;;;;;3613:40;;3563:6;;;;;;;3613:40;;3544:16;3613:40;3470:191;;:::o;22126:1157::-;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"22126:1157:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22743:384;;;;;;;;;;-1:-1:-1;22743:384:0;;;;;:::i;:::-;;:::i;:::-;;22343:394;;;;;;:::i;:::-;;:::i;2851:103::-;;;;;;;;;;;;;:::i;2203:87::-;;;;;;;;;;-1:-1:-1;2249:7:0;2276:6;2203:87;;;2276:6;;;;2776:74:1;;2203:87:0;;;;;2764:2:1;2203:87:0;;;3109:201;;;;;;;;;;-1:-1:-1;3109:201:0;;;;;:::i;:::-;;:::i;22743:384::-;22799:15;22825:19;;;;22821:180;;22865:38;;;;;22897:4;22865:38;;;2776:74:1;22865:23:0;;;;;;2749:18:1;;22865:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22855:48;-1:-1:-1;22916:11:0;;22912:82;;22940:44;22967:7;2249;2276:6;;;;2203:87;22967:7;22940:26;;;;22976:7;22940:26;:44::i;:::-;-1:-1:-1;23019:21:0;23051:11;;23047:75;;2249:7;2276:6;;;23073:21;;23102:7;23073:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23047:75;22743:384;;:::o;22343:394::-;2089:13;:11;:13::i;:::-;22422:6:::1;22417:315;22432:14:::0;;::::1;22417:315;;;22463:12;22477:19:::0;22508:5:::1;;22514:1;22508:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:15;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;22500:29;;22537:5;;22543:1;22537:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:14;;;22553:5;;22559:1;22553:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:13;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;22500:67;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22462:105;;;;22581:7;22576:149;;22639:1;22661:5;;22667:1;22661:8;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:15;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;22697:6;22608:107;;;;;;;;;;;;;:::i;:::-;;;;;;;;22576:149;22417:315;;22448:3;;;;;:::i;:::-;;;;22417:315;;;;22343:394:::0;;:::o;2851:103::-;2089:13;:11;:13::i;:::-;2916:30:::1;2943:1;2916:18;:30::i;:::-;2851:103::o:0;3109:201::-;2089:13;:11;:13::i;:::-;3198:22:::1;::::0;::::1;3190:73;;;::::0;::::1;::::0;;3589:2:1;3190:73:0::1;::::0;::::1;3571:21:1::0;3628:2;3608:18;;;3601:30;3667:34;3647:18;;;3640:62;3738:8;3718:18;;;3711:36;3764:19;;3190:73:0::1;3561:228:1::0;3190:73:0::1;3274:28;3293:8;3274:18;:28::i;:::-;3109:201:::0;:::o;18201:211::-;18345:58;;;3065:42:1;3053:55;;18345:58:0;;;3035:74:1;3125:18;;;;3118:34;;;18345:58:0;;;;;;;;;;3008:18:1;;;;18345:58:0;;;;;;;;;;18368:23;18345:58;;;18318:86;;18338:5;;18318:19;:86::i;2368:132::-;2249:7;2276:6;2432:23;2276:6;830:10;2432:23;2424:68;;;;;;;4403:2:1;2424:68:0;;;4385:21:1;;;4422:18;;;4415:30;4481:34;4461:18;;;4454:62;4533:18;;2424:68:0;4375:182:1;3470:191:0;3544:16;3563:6;;;3580:17;;;;;;;;;;3613:40;;3563:6;;;;;;;3613:40;;3544:16;3613:40;3470:191;;:::o;21268:716::-;21692:23;21718:69;21746:4;21718:69;;;;;;;;;;;;;;;;;21726:5;21718:27;;;;:69;;;;;:::i;:::-;21802:17;;21692:95;;-1:-1:-1;21802:21:0;21798:179;;21899:10;21888:30;;;;;;;;;;;;:::i;:::-;21880:85;;;;;;;5122:2:1;21880:85:0;;;5104:21:1;5161:2;5141:18;;;5134:30;5200:34;5180:18;;;5173:62;5271:12;5251:18;;;5244:40;5301:19;;21880:85:0;5094:232:1;12908:229:0;13045:12;13077:52;13099:6;13107:4;13113:1;13116:12;13077:21;:52::i;:::-;13070:59;;12908:229;;;;;;:::o;14028:510::-;14198:12;14256:5;14231:21;:30;;14223:81;;;;;;;3996:2:1;14223:81:0;;;3978:21:1;4035:2;4015:18;;;4008:30;4074:34;4054:18;;;4047:62;4145:8;4125:18;;;4118:36;4171:19;;14223:81:0;3968:228:1;14223:81:0;10458:19;;;;14315:60;;;;;;;4764:2:1;14315:60:0;;;4746:21:1;4803:2;4783:18;;;4776:30;4842:31;4822:18;;;4815:59;4891:18;;14315:60:0;4736:179:1;14315:60:0;14389:12;14403:23;14430:6;:11;;14449:5;14456:4;14430:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14388:73;;;;14479:51;14496:7;14505:10;14517:12;14479:16;:51::i;:::-;14472:58;14028:510;-1:-1:-1;;;;;;;14028:510:0:o;16714:762::-;16864:12;16893:7;16889:580;;;-1:-1:-1;16924:10:0;16917:17;;16889:580;17038:17;;:21;17034:424;;17286:10;17280:17;17347:15;17334:10;17330:2;17326:19;17319:44;17234:148;17429:12;17422:20;;;;;;;;;;;:::i;14:329:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;241:42;234:5;230:54;223:5;220:65;210:2;;304:6;296;289:22;348:688;457:6;465;518:2;506:9;497:7;493:23;489:32;486:2;;;539:6;531;524:22;486:2;584:9;571:23;613:18;654:2;646:6;643:14;640:2;;;675:6;667;660:22;640:2;718:6;707:9;703:22;693:32;;763:7;756:4;752:2;748:13;744:27;734:2;;790:6;782;775:22;734:2;835;822:16;861:2;853:6;850:14;847:2;;;882:6;874;867:22;847:2;940:7;935:2;925:6;922:1;918:14;914:2;910:23;906:32;903:45;900:2;;;966:6;958;951:22;900:2;1002;994:11;;;;;1024:6;;-1:-1:-1;476:560:1;;-1:-1:-1;;;;476:560:1:o;1041:297::-;1108:6;1161:2;1149:9;1140:7;1136:23;1132:32;1129:2;;;1182:6;1174;1167:22;1129:2;1219:9;1213:16;1272:5;1265:13;1258:21;1251:5;1248:32;1238:2;;1299:6;1291;1284:22;1343:194;1413:6;1466:2;1454:9;1445:7;1441:23;1437:32;1434:2;;;1487:6;1479;1472:22;1434:2;-1:-1:-1;1515:16:1;;1424:113;-1:-1:-1;1424:113:1:o;1542:316::-;1583:3;1621:5;1615:12;1648:6;1643:3;1636:19;1664:63;1720:6;1713:4;1708:3;1704:14;1697:4;1690:5;1686:16;1664:63;:::i;:::-;1772:2;1760:15;1777:66;1756:88;1747:98;;;;1847:4;1743:109;;1591:267;-1:-1:-1;;1591:267:1:o;1863:273::-;2046:6;2038;2033:3;2020:33;2002:3;2072:16;;2097:15;;;2072:16;2010:126;-1:-1:-1;2010:126:1:o;2141:274::-;2270:3;2308:6;2302:13;2324:53;2370:6;2365:3;2358:4;2350:6;2346:17;2324:53;:::i;:::-;2393:16;;;;;2278:137;-1:-1:-1;;2278:137:1:o;3163:219::-;3312:2;3301:9;3294:21;3275:4;3332:44;3372:2;3361:9;3357:18;3349:6;3332:44;:::i;5331:408::-;5534:6;5523:9;5516:25;5589:42;5581:6;5577:55;5572:2;5561:9;5557:18;5550:83;5669:2;5664;5653:9;5649:18;5642:30;5497:4;5689:44;5729:2;5718:9;5714:18;5706:6;5689:44;:::i;:::-;5681:52;5506:233;-1:-1:-1;;;;;5506:233:1:o;5744:592::-;5821:4;5827:6;5887:11;5874:25;5977:66;5966:8;5950:14;5946:29;5942:102;5922:18;5918:127;5908:2;;6062:4;6056;6049:18;5908:2;6092:33;;6144:20;;;-1:-1:-1;6187:18:1;6176:30;;6173:2;;;6222:4;6216;6209:18;6173:2;6258:4;6246:17;;-1:-1:-1;6289:14:1;6285:27;;;6275:38;;6272:2;;;6326:1;6323;6316:12;6272:2;5838:498;;;;;:::o;6341:385::-;6430:4;6488:11;6475:25;6578:66;6567:8;6551:14;6547:29;6543:102;6523:18;6519:127;6509:2;;6663:4;6657;6650:18;6731:258;6803:1;6813:113;6827:6;6824:1;6821:13;6813:113;;;6903:11;;;6897:18;6884:11;;;6877:39;6849:2;6842:10;6813:113;;;6944:6;6941:1;6938:13;6935:2;;;6979:1;6970:6;6965:3;6961:16;6954:27;6935:2;;6784:205;;;:::o;6994:353::-;7033:3;7064:66;7057:5;7054:77;7051:2;;;7166:77;7161:3;7154:90;7267:4;7264:1;7257:15;7297:4;7292:3;7285:17;7051:2;-1:-1:-1;7339:1:1;7328:13;;7041:306::o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"execute((address,uint256,bytes)[])","signatureHash4":"0x3f707e6b","signatureHash32":"0x3f707e6bbba86bcfecfd45b973cdc6ddd6412f233e9e7b093948e393f549221e"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"withdrawVmFunds(address)","signatureHash4":"0x1c6dd8a1","signatureHash32":"0x1c6dd8a1a6d688798f9a1cb5ada9e759265bd0744a52fff236a256e1fb46747f"}],"event":[{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"}],"error":[{"signature":"CallFailed(uint256,address,bytes)","signatureHash4":"0x405c0fff","signatureHash32":"0x405c0fff91598cc673ae52d24daed516fbd72d66c67171ccefe437ba8cd12048"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0x0551e6700a0C7C5a1633E912710ED80c88FACC07"}