{"matchId":"2031313","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2024-08-08T14:25:35Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"503:3012:6:-:0;;;898:177;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1014:15;1031:5;1050:54:0;1103:1;1058:41;1050:54;:::i;:::-;-1:-1:-1;;;;;;;;;;;1018:87:0;1011:95;;;;:::i;:::-;1116:39;1134:6;1142:5;1149;1116:17;:39::i;:::-;-1:-1:-1;1048:20:6::1;::::0;-1:-1:-1;1061:6:6;1048:12:::1;:20::i;:::-;898:177:::0;;;503:3012;;2122:295:1;2260:29;2271:17;2260:10;:29::i;:::-;2317:1;2303:4;:11;:15;:28;;;;2322:9;2303:28;2299:112;;;2347:53;2376:17;2395:4;2347:28;;;;;:53;;:::i;:::-;;2299:112;2122:295;;;:::o;4843:135::-;4907:35;4920:11;:9;:11::i;:::-;4907:35;;;-1:-1:-1;;;;;2238:15:7;;;2220:34;;2290:15;;;2285:2;2270:18;;2263:43;2155:18;4907:35:1;;;;;;;4952:19;4962:8;4952:9;:19::i;:::-;4843:135;:::o;1836:152::-;1902:37;1921:17;1902:18;:37::i;:::-;1954:27;;-1:-1:-1;;;;;1954:27:1;;;;;;;;1836:152;:::o;6223:198:4:-;6306:12;6337:77;6358:6;6366:4;6337:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6330:84;6223:198;-1:-1:-1;;;6223:198:4:o;4327:122:1:-;4371:7;4397:39;-1:-1:-1;;;;;;;;;;;4424:11:1;;4397:26;;;;;:39;;:::i;:::-;:45;-1:-1:-1;;;;;4397:45:1;;4327:122;-1:-1:-1;4327:122:1:o;4531:201::-;-1:-1:-1;;;;;4594:22:1;;4586:73;;;;-1:-1:-1;;;4586:73:1;;2519:2:7;4586:73:1;;;2501:21:7;2558:2;2538:18;;;2531:30;2597:34;2577:18;;;2570:62;-1:-1:-1;;;2648:18:7;;;2641:36;2694:19;;4586:73:1;;;;;;;;;4717:8;4669:39;-1:-1:-1;;;;;;;;;;;4696:11:1;;4669:26;;;;;:39;;:::i;:::-;:56;;-1:-1:-1;;;;;;4669:56:1;-1:-1:-1;;;;;4669:56:1;;;;;;;;;;-1:-1:-1;4531:201:1:o;1471:259::-;1552:37;1571:17;1552:18;;;;;:37;;:::i;:::-;1544:95;;;;-1:-1:-1;;;1544:95:1;;2926:2:7;1544:95:1;;;2908:21:7;2965:2;2945:18;;;2938:30;3004:34;2984:18;;;2977:62;-1:-1:-1;;;3055:18:7;;;3048:43;3108:19;;1544:95:1;2724:409:7;1544:95:1;1706:17;1649:48;-1:-1:-1;;;;;;;;;;;1676:20:1;;1649:26;;;;;:48;;:::i;6607:387:4:-;6748:12;1087:20;;6772:69;;;;-1:-1:-1;;;6772:69:4;;3340:2:7;6772:69:4;;;3322:21:7;3379:2;3359:18;;;3352:30;3418:34;3398:18;;;3391:62;-1:-1:-1;;;3469:18:7;;;3462:36;3515:19;;6772:69:4;3138:402:7;6772:69:4;6853:12;6867:23;6894:6;-1:-1:-1;;;;;6894:19:4;6914:4;6894:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6852:67:4;;-1:-1:-1;6852:67:4;-1:-1:-1;6936:51:4;6852:67;;6974:12;6936:16;:51::i;:::-;6929:58;6607:387;-1:-1:-1;;;;;;6607:387:4:o;1599:147:5:-;1726:4;1599:147::o;771:377:4:-;1087:20;1133:8;;;771:377::o;7214:692::-;7360:12;7388:7;7384:516;;;-1:-1:-1;7418:10:4;7411:17;;7384:516;7529:17;;:21;7525:365;;7723:10;7717:17;7783:15;7770:10;7766:2;7762:19;7755:44;7525:365;7862:12;7855:20;;-1:-1:-1;;;7855:20:4;;;;;;;;:::i;14:177:7:-;93:13;;-1:-1:-1;;;;;135:31:7;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:127::-;257:10;252:3;248:20;245:1;238:31;288:4;285:1;278:15;312:4;309:1;302:15;328:258;400:1;410:113;424:6;421:1;418:13;410:113;;;500:11;;;494:18;481:11;;;474:39;446:2;439:10;410:113;;;541:6;538:1;535:13;532:48;;;-1:-1:-1;;576:1:7;558:16;;551:27;328:258::o;591:1053::-;688:6;696;704;757:2;745:9;736:7;732:23;728:32;725:52;;;773:1;770;763:12;725:52;796:40;826:9;796:40;:::i;:::-;786:50;;855:49;900:2;889:9;885:18;855:49;:::i;:::-;948:2;933:18;;927:25;845:59;;-1:-1:-1;;;;;;1001:14:7;;;998:34;;;1028:1;1025;1018:12;998:34;1066:6;1055:9;1051:22;1041:32;;1111:7;1104:4;1100:2;1096:13;1092:27;1082:55;;1133:1;1130;1123:12;1082:55;1162:2;1156:9;1184:2;1180;1177:10;1174:36;;;1190:18;;:::i;:::-;1265:2;1259:9;1233:2;1319:13;;-1:-1:-1;;1315:22:7;;;1339:2;1311:31;1307:40;1295:53;;;1363:18;;;1383:22;;;1360:46;1357:72;;;1409:18;;:::i;:::-;1449:10;1445:2;1438:22;1484:2;1476:6;1469:18;1524:7;1519:2;1514;1510;1506:11;1502:20;1499:33;1496:53;;;1545:1;1542;1535:12;1496:53;1558:55;1610:2;1605;1597:6;1593:15;1588:2;1584;1580:11;1558:55;:::i;:::-;1632:6;1622:16;;;;;;;591:1053;;;;;:::o;1649:222::-;1689:4;1717:1;1714;1711:8;1708:131;;;1761:10;1756:3;1752:20;1749:1;1742:31;1796:4;1793:1;1786:15;1824:4;1821:1;1814:15;1708:131;-1:-1:-1;1856:9:7;;1649:222::o;1876:127::-;1937:10;1932:3;1928:20;1925:1;1918:31;1968:4;1965:1;1958:15;1992:4;1989:1;1982:15;3545:274;3674:3;3712:6;3706:13;3728:53;3774:6;3769:3;3762:4;3754:6;3750:17;3728:53;:::i;:::-;3797:16;;;;;3545:274;-1:-1:-1;;3545:274:7:o;3824:383::-;3973:2;3962:9;3955:21;3936:4;4005:6;3999:13;4048:6;4043:2;4032:9;4028:18;4021:34;4064:66;4123:6;4118:2;4107:9;4103:18;4098:2;4090:6;4086:15;4064:66;:::i;:::-;4191:2;4170:15;-1:-1:-1;;4166:29:7;4151:45;;;;4198:2;4147:54;;3824:383;-1:-1:-1;;3824:383:7:o;:::-;503:3012:6;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220ade03cff1c9d244e08e70c5b2d5e8730ac8f46a200881491c3de7035ba41b8df64736f6c63430008090033","offset":4051}},"transformations":[{"type":"insert","offset":4207,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x0000000000000000000000006f6541c2203196feedd14cd2c09550da1cbeda310000000000000000000000008ea83ad72396f1e0cd2f8e72b1461db8eb6af7b500000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"503:3012:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2884:11:2;:9;:11::i;:::-;503:3012:6;;2661:11:2;:9;:11::i;1479:110:6:-;;;;;;;;;;;;;:::i;:::-;;;179:14:7;;172:22;154:41;;142:2;127:18;1479:110:6;;;;;;;;2292:120;;;;;;;;;;-1:-1:-1;2292:120:6;;;;;:::i;:::-;;:::i;2055:106::-;;;;;;;;;;-1:-1:-1;2055:106:6;;;;;:::i;:::-;;:::i;1136:94::-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;739:32:7;;;721:51;;709:2;694:18;1136:94:6;575:203:7;1295:109:6;;;;;;;;;;;;;:::i;1712:240::-;;;;;;;;;;;;;:::i;2840:238::-;;;;;;;;;;-1:-1:-1;2840:238:6;;;;;:::i;:::-;;:::i;2308:110:2:-;2383:28;2393:17;:15;:17::i;:::-;2383:9;:28::i;:::-;2308:110::o;1479::6:-;1534:4;;1557:11;:9;:11::i;:::-;-1:-1:-1;;;;;1557:25:6;;1550:32;;1479:110;:::o;2292:120::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;2375:30:::1;2386:18;2375:10;:30::i;:::-;3219:214:::0;2292:120;:::o;2055:106::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;2131:23:::1;2144:9;2131:12;:23::i;1136:94::-:0;1186:7;1212:11;:9;:11::i;:::-;1205:18;;1136:94;:::o;1295:109::-;1354:7;1380:17;:15;:17::i;1712:240::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;1766:17:::1;1786:11;:9;:11::i;:::-;4061:66:1;1807:58:6::0;;-1:-1:-1;;;;;;1807:58:6::1;::::0;;1880:35:::1;::::0;;-1:-1:-1;;;;;2378:15:7;;2360:34;;1863:1:6::1;2425:2:7::0;2410:18;;2403:43;1880:35:6;;1766:31;;-1:-1:-1;1880:35:6::1;::::0;;;;;;;;;::::1;1930:15;::::0;::::1;::::0;;;::::1;1756:196;3219:214:::0;1712:240::o;2840:238::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;3006:65:::1;3024:18;3044:14;3060:10;3006:17;:65::i;:::-;3219:214:::0;2840:238;;;:::o;6223:198:4:-;6306:12;6337:77;6358:6;6366:4;6337:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6330:84;6223:198;-1:-1:-1;;;6223:198:4:o;1599:147:5:-;1726:4;1599:147::o;771:377:4:-;1087:20;1133:8;;;771:377::o;1240:140:0:-;1307:12;1338:35;:33;:35::i;934:895:2:-;1272:14;1269:1;1266;1253:34;1486:1;1483;1467:14;1464:1;1448:14;1441:5;1428:60;1562:16;1559:1;1556;1541:38;1600:6;1667:66;;;;1782:16;1779:1;1772:27;1667:66;1702:16;1699:1;1692:27;1593:220;;;934:895;:::o;4327:122:1:-;4371:7;4061:66;4397:39;:45;-1:-1:-1;;;;;4397:45:1;;4327:122;-1:-1:-1;4327:122:1:o;1836:152::-;1902:37;1921:17;1902:18;:37::i;:::-;1954:27;;-1:-1:-1;;;;;1954:27:1;;;;;;;;1836:152;:::o;4843:135::-;4907:35;4920:11;:9;:11::i;:::-;4907:35;;;-1:-1:-1;;;;;2378:15:7;;;2360:34;;2430:15;;;2425:2;2410:18;;2403:43;2295:18;4907:35:1;;;;;;;4952:19;4962:8;4952:9;:19::i;:::-;4843:135;:::o;2122:295::-;2260:29;2271:17;2260:10;:29::i;:::-;2317:1;2303:4;:11;:15;:28;;;;2322:9;2303:28;2299:112;;;2347:53;2376:17;2395:4;2347:28;:53::i;6607:387:4:-;6748:12;1087:20;;6772:69;;;;-1:-1:-1;;;6772:69:4;;2659:2:7;6772:69:4;;;2641:21:7;2698:2;2678:18;;;2671:30;2737:34;2717:18;;;2710:62;-1:-1:-1;;;2788:18:7;;;2781:36;2834:19;;6772:69:4;;;;;;;;;6853:12;6867:23;6894:6;-1:-1:-1;;;;;6894:19:4;6914:4;6894:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6852:67;;;;6936:51;6953:7;6962:10;6974:12;6936:16;:51::i;:::-;6929:58;6607:387;-1:-1:-1;;;;;;6607:387:4:o;1240:140:1:-;1293:7;969:66;1319:48;1599:147:5;1471:259:1;1087:20:4;;1544:95:1;;;;-1:-1:-1;;;1544:95:1;;3608:2:7;1544:95:1;;;3590:21:7;3647:2;3627:18;;;3620:30;3686:34;3666:18;;;3659:62;-1:-1:-1;;;3737:18:7;;;3730:43;3790:19;;1544:95:1;3406:409:7;1544:95:1;1706:17;969:66;1649:48;:74;;-1:-1:-1;;;;;;1649:74:1;-1:-1:-1;;;;;1649:74:1;;;;;;;;;;-1:-1:-1;1471:259:1:o;4531:201::-;-1:-1:-1;;;;;4594:22:1;;4586:73;;;;-1:-1:-1;;;4586:73:1;;4022:2:7;4586:73:1;;;4004:21:7;4061:2;4041:18;;;4034:30;4100:34;4080:18;;;4073:62;-1:-1:-1;;;4151:18:7;;;4144:36;4197:19;;4586:73:1;3820:402:7;4586:73:1;4717:8;4061:66;4669:39;1599:147:5;7214:692:4;7360:12;7388:7;7384:516;;;-1:-1:-1;7418:10:4;7411:17;;7384:516;7529:17;;:21;7525:365;;7723:10;7717:17;7783:15;7770:10;7766:2;7762:19;7755:44;7525:365;7862:12;7855:20;;-1:-1:-1;;;7855:20:4;;;;;;;;:::i;206:173:7:-;274:20;;-1:-1:-1;;;;;323:31:7;;313:42;;303:70;;369:1;366;359:12;303:70;206:173;;;:::o;384:186::-;443:6;496:2;484:9;475:7;471:23;467:32;464:52;;;512:1;509;502:12;464:52;535:29;554:9;535:29;:::i;783:127::-;844:10;839:3;835:20;832:1;825:31;875:4;872:1;865:15;899:4;896:1;889:15;915:160;980:20;;1036:13;;1029:21;1019:32;;1009:60;;1065:1;1062;1055:12;1080:1063;1163:6;1171;1179;1232:2;1220:9;1211:7;1207:23;1203:32;1200:52;;;1248:1;1245;1238:12;1200:52;1271:29;1290:9;1271:29;:::i;:::-;1261:39;;1351:2;1340:9;1336:18;1323:32;1374:18;1415:2;1407:6;1404:14;1401:34;;;1431:1;1428;1421:12;1401:34;1469:6;1458:9;1454:22;1444:32;;1514:7;1507:4;1503:2;1499:13;1495:27;1485:55;;1536:1;1533;1526:12;1485:55;1572:2;1559:16;1594:2;1590;1587:10;1584:36;;;1600:18;;:::i;:::-;1675:2;1669:9;1643:2;1729:13;;-1:-1:-1;;1725:22:7;;;1749:2;1721:31;1717:40;1705:53;;;1773:18;;;1793:22;;;1770:46;1767:72;;;1819:18;;:::i;:::-;1859:10;1855:2;1848:22;1894:2;1886:6;1879:18;1934:7;1929:2;1924;1920;1916:11;1912:20;1909:33;1906:53;;;1955:1;1952;1945:12;1906:53;2011:2;2006;2002;1998:11;1993:2;1985:6;1981:15;1968:46;2056:1;2051:2;2046;2038:6;2034:15;2030:24;2023:35;2077:6;2067:16;;;;;;;2102:35;2133:2;2122:9;2118:18;2102:35;:::i;:::-;2092:45;;1080:1063;;;;;:::o;2864:258::-;2936:1;2946:113;2960:6;2957:1;2954:13;2946:113;;;3036:11;;;3030:18;3017:11;;;3010:39;2982:2;2975:10;2946:113;;;3077:6;3074:1;3071:13;3068:48;;;-1:-1:-1;;3112:1:7;3094:16;;3087:27;2864:258::o;3127:274::-;3256:3;3294:6;3288:13;3310:53;3356:6;3351:3;3344:4;3336:6;3332:17;3310:53;:::i;:::-;3379:16;;;;;3127:274;-1:-1:-1;;3127:274:7:o;4227:383::-;4376:2;4365:9;4358:21;4339:4;4408:6;4402:13;4451:6;4446:2;4435:9;4431:18;4424:34;4467:66;4526:6;4521:2;4510:9;4506:18;4501:2;4493:6;4489:15;4467:66;:::i;:::-;4594:2;4573:15;-1:-1:-1;;4569:29:7;4554:45;;;;4601:2;4550:54;;4227:383;-1:-1:-1;;4227:383:7:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220ade03cff1c9d244e08e70c5b2d5e8730ac8f46a200881491c3de7035ba41b8df64736f6c63430008090033","offset":2444}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x98c2170be034f750f5006cb69ea0aeeaf0858b11f6324ee53d582fa4dd49bc1a","blockNumber":"17172547","transactionIndex":"35","deployer":"0x8Ea83AD72396f1E0cD2f8E72b1461db8Eb6aF7B5"},"sources":{"contracts/0.8.9/proxy/OssifiableProxy.sol":{"content":"// SPDX-FileCopyrightText: 2023 Lido <info@lido.fi>\n// SPDX-License-Identifier: GPL-3.0\n\n/* See contracts/COMPILERS.md */\npragma solidity 0.8.9;\n\nimport {Address} from \"@openzeppelin/contracts-v4.4/utils/Address.sol\";\nimport {StorageSlot} from \"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol\";\nimport {ERC1967Proxy} from \"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol\";\n\n/// @notice An ossifiable proxy contract. Extends the ERC1967Proxy contract by\n///     adding admin functionality\ncontract OssifiableProxy is ERC1967Proxy {\n    /// @dev Initializes the upgradeable proxy with the initial implementation and admin\n    /// @param implementation_ Address of the implementation\n    /// @param admin_ Address of the admin of the proxy\n    /// @param data_ Data used in a delegate call to implementation. The delegate call will be\n    ///     skipped if the data is empty bytes\n    constructor(\n        address implementation_,\n        address admin_,\n        bytes memory data_\n    ) ERC1967Proxy(implementation_, data_) {\n        _changeAdmin(admin_);\n    }\n\n    /// @notice Returns the current admin of the proxy\n    function proxy__getAdmin() external view returns (address) {\n        return _getAdmin();\n    }\n\n    /// @notice Returns the current implementation address\n    function proxy__getImplementation() external view returns (address) {\n        return _implementation();\n    }\n\n    /// @notice Returns whether the implementation is locked forever\n    function proxy__getIsOssified() external view returns (bool) {\n        return _getAdmin() == address(0);\n    }\n\n    /// @notice Allows to transfer admin rights to zero address and prevent future\n    ///     upgrades of the proxy\n    function proxy__ossify() external onlyAdmin {\n        address prevAdmin = _getAdmin();\n        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = address(0);\n        emit AdminChanged(prevAdmin, address(0));\n        emit ProxyOssified();\n    }\n\n    /// @notice Changes the admin of the proxy\n    /// @param newAdmin_ Address of the new admin\n    function proxy__changeAdmin(address newAdmin_) external onlyAdmin {\n        _changeAdmin(newAdmin_);\n    }\n\n    /// @notice Upgrades the implementation of the proxy\n    /// @param newImplementation_ Address of the new implementation\n    function proxy__upgradeTo(address newImplementation_) external onlyAdmin {\n        _upgradeTo(newImplementation_);\n    }\n\n    /// @notice Upgrades the proxy to a new implementation, optionally performing an additional\n    ///     setup call.\n    /// @param newImplementation_ Address of the new implementation\n    /// @param setupCalldata_ Data for the setup call. The call is skipped if setupCalldata_ is\n    ///     empty and forceCall_ is false\n    /// @param forceCall_ Forces make delegate call to the implementation even with empty data_\n    function proxy__upgradeToAndCall(\n        address newImplementation_,\n        bytes memory setupCalldata_,\n        bool forceCall_\n    ) external onlyAdmin {\n        _upgradeToAndCall(newImplementation_, setupCalldata_, forceCall_);\n    }\n\n    /// @dev Validates that proxy is not ossified and that method is called by the admin\n    ///     of the proxy\n    modifier onlyAdmin() {\n        address admin = _getAdmin();\n        if (admin == address(0)) {\n            revert ProxyIsOssified();\n        }\n        if (admin != msg.sender) {\n            revert NotAdmin();\n        }\n        _;\n    }\n\n    event ProxyOssified();\n\n    error NotAdmin();\n    error ProxyIsOssified();\n}\n"},"@openzeppelin/contracts-v4.4/proxy/Proxy.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internall call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internall call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overriden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"},"@openzeppelin/contracts-v4.4/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        assembly {\n            size := extcodesize(account)\n        }\n        return size > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCall(target, data, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length > 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                revert(errorMessage);\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n}\n"},"@openzeppelin/contracts-v4.4/proxy/beacon/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n    /**\n     * @dev Must return an address that can be used as a delegate call target.\n     *\n     * {BeaconProxy} will check that this address is a contract.\n     */\n    function implementation() external view returns (address);\n}\n"},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Proxy.sol\";\nimport \"./ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n */\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\n    /**\n     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n     *\n     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n     * function call, and allows initializating the storage of the proxy like a Solidity constructor.\n     */\n    constructor(address _logic, bytes memory _data) payable {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        _upgradeToAndCall(_logic, _data, false);\n    }\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function _implementation() internal view virtual override returns (address impl) {\n        return ERC1967Upgrade._getImplementation();\n    }\n}\n"},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Upgrade.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n    // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function _getImplementation() internal view returns (address) {\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 implementation slot.\n     */\n    function _setImplementation(address newImplementation) private {\n        require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n    }\n\n    /**\n     * @dev Perform implementation upgrade\n     *\n     * Emits an {Upgraded} event.\n     */\n    function _upgradeTo(address newImplementation) internal {\n        _setImplementation(newImplementation);\n        emit Upgraded(newImplementation);\n    }\n\n    /**\n     * @dev Perform implementation upgrade with additional setup call.\n     *\n     * Emits an {Upgraded} event.\n     */\n    function _upgradeToAndCall(\n        address newImplementation,\n        bytes memory data,\n        bool forceCall\n    ) internal {\n        _upgradeTo(newImplementation);\n        if (data.length > 0 || forceCall) {\n            Address.functionDelegateCall(newImplementation, data);\n        }\n    }\n\n    /**\n     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n     *\n     * Emits an {Upgraded} event.\n     */\n    function _upgradeToAndCallSecure(\n        address newImplementation,\n        bytes memory data,\n        bool forceCall\n    ) internal {\n        address oldImplementation = _getImplementation();\n\n        // Initial upgrade and setup call\n        _setImplementation(newImplementation);\n        if (data.length > 0 || forceCall) {\n            Address.functionDelegateCall(newImplementation, data);\n        }\n\n        // Perform rollback test if not already in progress\n        StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);\n        if (!rollbackTesting.value) {\n            // Trigger rollback using upgradeTo from the new implementation\n            rollbackTesting.value = true;\n            Address.functionDelegateCall(\n                newImplementation,\n                abi.encodeWithSignature(\"upgradeTo(address)\", oldImplementation)\n            );\n            rollbackTesting.value = false;\n            // Check rollback was effective\n            require(oldImplementation == _getImplementation(), \"ERC1967Upgrade: upgrade breaks further upgrades\");\n            // Finally reset to the new implementation and log the upgrade\n            _upgradeTo(newImplementation);\n        }\n    }\n\n    /**\n     * @dev Storage slot with the admin of the contract.\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\n\n    /**\n     * @dev Returns the current admin.\n     */\n    function _getAdmin() internal view returns (address) {\n        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {AdminChanged} event.\n     */\n    function _changeAdmin(address newAdmin) internal {\n        emit AdminChanged(_getAdmin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n     */\n    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n    /**\n     * @dev Emitted when the beacon is upgraded.\n     */\n    event BeaconUpgraded(address indexed beacon);\n\n    /**\n     * @dev Returns the current beacon.\n     */\n    function _getBeacon() internal view returns (address) {\n        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new beacon in the EIP1967 beacon slot.\n     */\n    function _setBeacon(address newBeacon) private {\n        require(Address.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n        require(\n            Address.isContract(IBeacon(newBeacon).implementation()),\n            \"ERC1967: beacon implementation is not a contract\"\n        );\n        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n    }\n\n    /**\n     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n     *\n     * Emits a {BeaconUpgraded} event.\n     */\n    function _upgradeBeaconToAndCall(\n        address newBeacon,\n        bytes memory data,\n        bool forceCall\n    ) internal {\n        _setBeacon(newBeacon);\n        emit BeaconUpgraded(newBeacon);\n        if (data.length > 0 || forceCall) {\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.9+commit.e5eed63a","compilerSettings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"istanbul","remappings":[]},"name":"OssifiableProxy","fullyQualifiedName":"contracts/0.8.9/proxy/OssifiableProxy.sol:OssifiableProxy"},"abi":[{"type":"constructor","inputs":[{"name":"implementation_","type":"address","internalType":"address"},{"name":"admin_","type":"address","internalType":"address"},{"name":"data_","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"NotAdmin","type":"error","inputs":[]},{"name":"ProxyIsOssified","type":"error","inputs":[]},{"name":"AdminChanged","type":"event","inputs":[{"name":"previousAdmin","type":"address","indexed":false,"internalType":"address"},{"name":"newAdmin","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"BeaconUpgraded","type":"event","inputs":[{"name":"beacon","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ProxyOssified","type":"event","inputs":[],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"type":"fallback","stateMutability":"payable"},{"name":"proxy__changeAdmin","type":"function","inputs":[{"name":"newAdmin_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxy__getAdmin","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxy__getImplementation","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxy__getIsOssified","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"proxy__ossify","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxy__upgradeTo","type":"function","inputs":[{"name":"newImplementation_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxy__upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation_","type":"address","internalType":"address"},{"name":"setupCalldata_","type":"bytes","internalType":"bytes"},{"name":"forceCall_","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.9+commit.e5eed63a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"implementation_","type":"address"},{"internalType":"address","name":"admin_","type":"address"},{"internalType":"bytes","name":"data_","type":"bytes"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"NotAdmin","type":"error"},{"inputs":[],"name":"ProxyIsOssified","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[],"name":"ProxyOssified","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"newAdmin_","type":"address"}],"name":"proxy__changeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proxy__getAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxy__getImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxy__getIsOssified","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxy__ossify","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation_","type":"address"}],"name":"proxy__upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation_","type":"address"},{"internalType":"bytes","name":"setupCalldata_","type":"bytes"},{"internalType":"bool","name":"forceCall_","type":"bool"}],"name":"proxy__upgradeToAndCall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{"constructor":{"details":"Initializes the upgradeable proxy with the initial implementation and admin","params":{"admin_":"Address of the admin of the proxy","data_":"Data used in a delegate call to implementation. The delegate call will be     skipped if the data is empty bytes","implementation_":"Address of the implementation"}},"proxy__changeAdmin(address)":{"params":{"newAdmin_":"Address of the new admin"}},"proxy__upgradeTo(address)":{"params":{"newImplementation_":"Address of the new implementation"}},"proxy__upgradeToAndCall(address,bytes,bool)":{"params":{"forceCall_":"Forces make delegate call to the implementation even with empty data_","newImplementation_":"Address of the new implementation","setupCalldata_":"Data for the setup call. The call is skipped if setupCalldata_ is     empty and forceCall_ is false"}}},"version":1},"userdoc":{"kind":"user","methods":{"proxy__changeAdmin(address)":{"notice":"Changes the admin of the proxy"},"proxy__getAdmin()":{"notice":"Returns the current admin of the proxy"},"proxy__getImplementation()":{"notice":"Returns the current implementation address"},"proxy__getIsOssified()":{"notice":"Returns whether the implementation is locked forever"},"proxy__ossify()":{"notice":"Allows to transfer admin rights to zero address and prevent future     upgrades of the proxy"},"proxy__upgradeTo(address)":{"notice":"Upgrades the implementation of the proxy"},"proxy__upgradeToAndCall(address,bytes,bool)":{"notice":"Upgrades the proxy to a new implementation, optionally performing an additional     setup call."}},"notice":"An ossifiable proxy contract. Extends the ERC1967Proxy contract by     adding admin functionality","version":1}},"settings":{"compilationTarget":{"contracts/0.8.9/proxy/OssifiableProxy.sol":"OssifiableProxy"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol":{"keccak256":"0x6309f9f39dc6f4f45a24f296543867aa358e32946cd6b2874627a996d606b3a0","license":"MIT","urls":["bzz-raw://4f5abfc32db1d44fd3d38d902879eaeaad827781bb9f954d3ccb8639c55db3c0","dweb:/ipfs/QmVSkxFgWphaUx6w9XdvgwJJuxABdpuVQEbABbRmzd3XFc"]},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Upgrade.sol":{"keccak256":"0x5f4c3eed093dfb0e4e20c1c102d2f2c6894a972f454adb308511a0afb37e6f79","license":"MIT","urls":["bzz-raw://833509a221a8d8dace9e028ac40e95c941b4c91b5dcbe921988578c48dc72e81","dweb:/ipfs/QmX3V2Uk7VU9ARiKHLFGQW5RL6sZS74TrjpSuSPkyRgK2D"]},"@openzeppelin/contracts-v4.4/proxy/Proxy.sol":{"keccak256":"0xab2556b154ceb1a11e456f2827ca8f6f65242b1b2fcc00268ab6d38fc6e64bbd","license":"MIT","urls":["bzz-raw://5823895b53df825121a25dd11a73eb4595c24d20a11c5013e6dda6fd0cd53463","dweb:/ipfs/QmbD8ozmp9DHQ8Es4ZRUKYz8KZSGnwBnVyHmJ9Yf7rYSoZ"]},"@openzeppelin/contracts-v4.4/proxy/beacon/IBeacon.sol":{"keccak256":"0xd50a3421ac379ccb1be435fa646d66a65c986b4924f0849839f08692f39dde61","license":"MIT","urls":["bzz-raw://ada1e030c0231db8d143b44ce92b4d1158eedb087880cad6d8cc7bd7ebe7b354","dweb:/ipfs/QmWZ2NHZweRpz1U9GF6R1h65ri76dnX7fNxLBeM2t5N5Ce"]},"@openzeppelin/contracts-v4.4/utils/Address.sol":{"keccak256":"0x51b758a8815ecc9596c66c37d56b1d33883a444631a3f916b9fe65cb863ef7c4","license":"MIT","urls":["bzz-raw://997ca03557985b3c6f9143a18b6c3a710b3bc1c7f189ee956d305a966ecfb922","dweb:/ipfs/QmQaD3Wb62F88SHqmpLttvF6wKuPDQep2LLUcKPekeRzvz"]},"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol":{"keccak256":"0xfe1b7a9aa2a530a9e705b220e26cd584e2fbdc9602a3a1066032b12816b46aca","license":"MIT","urls":["bzz-raw://dbaba7fe0fe556cc5ed291e03d271fd27d395250141ecfb57a4b30d528958ff9","dweb:/ipfs/QmWT653X2DyZo8nqEcmFe3yTkrCJv3ptbZLhbgLU3y6abe"]},"contracts/0.8.9/proxy/OssifiableProxy.sol":{"keccak256":"0x7d5c1d0ba899644454d2c808b6847ad0e5c5cd72c9d1a71953c6e456013adbe2","license":"GPL-3.0","urls":["bzz-raw://30be63d03f0bc683fdf9a0c1ffc335d414cc0277d88a5518566c885453542239","dweb:/ipfs/QmQ9c76TysW7tDBjS3vGiZ4QzP3u5atp2ScV9ojBuHjKX5"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"An ossifiable proxy contract. Extends the ERC1967Proxy contract by     adding admin functionality","methods":{"proxy__ossify()":{"notice":"Allows to transfer admin rights to zero address and prevent future     upgrades of the proxy"},"proxy__getAdmin()":{"notice":"Returns the current admin of the proxy"},"proxy__getIsOssified()":{"notice":"Returns whether the implementation is locked forever"},"proxy__upgradeTo(address)":{"notice":"Upgrades the implementation of the proxy"},"proxy__getImplementation()":{"notice":"Returns the current implementation address"},"proxy__changeAdmin(address)":{"notice":"Changes the admin of the proxy"},"proxy__upgradeToAndCall(address,bytes,bool)":{"notice":"Upgrades the proxy to a new implementation, optionally performing an additional     setup call."}},"version":1},"devdoc":{"kind":"dev","methods":{"constructor":{"params":{"data_":"Data used in a delegate call to implementation. The delegate call will be     skipped if the data is empty bytes","admin_":"Address of the admin of the proxy","implementation_":"Address of the implementation"},"details":"Initializes the upgradeable proxy with the initial implementation and admin"},"proxy__upgradeTo(address)":{"params":{"newImplementation_":"Address of the new implementation"}},"proxy__changeAdmin(address)":{"params":{"newAdmin_":"Address of the new admin"}},"proxy__upgradeToAndCall(address,bytes,bool)":{"params":{"forceCall_":"Forces make delegate call to the implementation even with empty data_","setupCalldata_":"Data for the setup call. The call is skipped if setupCalldata_ is     empty and forceCall_ is false","newImplementation_":"Address of the new implementation"}}},"version":1},"sourceIds":{"contracts/0.8.9/proxy/OssifiableProxy.sol":{"id":6},"@openzeppelin/contracts-v4.4/proxy/Proxy.sol":{"id":2},"@openzeppelin/contracts-v4.4/utils/Address.sol":{"id":4},"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol":{"id":5},"@openzeppelin/contracts-v4.4/proxy/beacon/IBeacon.sol":{"id":3},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol":{"id":0},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Upgrade.sol":{"id":1}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/0.8.9/proxy/OssifiableProxy.sol":{"content":"// SPDX-FileCopyrightText: 2023 Lido <info@lido.fi>\n// SPDX-License-Identifier: GPL-3.0\n\n/* See contracts/COMPILERS.md */\npragma solidity 0.8.9;\n\nimport {Address} from \"@openzeppelin/contracts-v4.4/utils/Address.sol\";\nimport {StorageSlot} from \"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol\";\nimport {ERC1967Proxy} from \"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol\";\n\n/// @notice An ossifiable proxy contract. Extends the ERC1967Proxy contract by\n///     adding admin functionality\ncontract OssifiableProxy is ERC1967Proxy {\n    /// @dev Initializes the upgradeable proxy with the initial implementation and admin\n    /// @param implementation_ Address of the implementation\n    /// @param admin_ Address of the admin of the proxy\n    /// @param data_ Data used in a delegate call to implementation. The delegate call will be\n    ///     skipped if the data is empty bytes\n    constructor(\n        address implementation_,\n        address admin_,\n        bytes memory data_\n    ) ERC1967Proxy(implementation_, data_) {\n        _changeAdmin(admin_);\n    }\n\n    /// @notice Returns the current admin of the proxy\n    function proxy__getAdmin() external view returns (address) {\n        return _getAdmin();\n    }\n\n    /// @notice Returns the current implementation address\n    function proxy__getImplementation() external view returns (address) {\n        return _implementation();\n    }\n\n    /// @notice Returns whether the implementation is locked forever\n    function proxy__getIsOssified() external view returns (bool) {\n        return _getAdmin() == address(0);\n    }\n\n    /// @notice Allows to transfer admin rights to zero address and prevent future\n    ///     upgrades of the proxy\n    function proxy__ossify() external onlyAdmin {\n        address prevAdmin = _getAdmin();\n        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = address(0);\n        emit AdminChanged(prevAdmin, address(0));\n        emit ProxyOssified();\n    }\n\n    /// @notice Changes the admin of the proxy\n    /// @param newAdmin_ Address of the new admin\n    function proxy__changeAdmin(address newAdmin_) external onlyAdmin {\n        _changeAdmin(newAdmin_);\n    }\n\n    /// @notice Upgrades the implementation of the proxy\n    /// @param newImplementation_ Address of the new implementation\n    function proxy__upgradeTo(address newImplementation_) external onlyAdmin {\n        _upgradeTo(newImplementation_);\n    }\n\n    /// @notice Upgrades the proxy to a new implementation, optionally performing an additional\n    ///     setup call.\n    /// @param newImplementation_ Address of the new implementation\n    /// @param setupCalldata_ Data for the setup call. The call is skipped if setupCalldata_ is\n    ///     empty and forceCall_ is false\n    /// @param forceCall_ Forces make delegate call to the implementation even with empty data_\n    function proxy__upgradeToAndCall(\n        address newImplementation_,\n        bytes memory setupCalldata_,\n        bool forceCall_\n    ) external onlyAdmin {\n        _upgradeToAndCall(newImplementation_, setupCalldata_, forceCall_);\n    }\n\n    /// @dev Validates that proxy is not ossified and that method is called by the admin\n    ///     of the proxy\n    modifier onlyAdmin() {\n        address admin = _getAdmin();\n        if (admin == address(0)) {\n            revert ProxyIsOssified();\n        }\n        if (admin != msg.sender) {\n            revert NotAdmin();\n        }\n        _;\n    }\n\n    event ProxyOssified();\n\n    error NotAdmin();\n    error ProxyIsOssified();\n}\n"},"@openzeppelin/contracts-v4.4/proxy/Proxy.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internall call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internall call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overriden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"},"@openzeppelin/contracts-v4.4/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        assembly {\n            size := extcodesize(account)\n        }\n        return size > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCall(target, data, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length > 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                revert(errorMessage);\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly {\n            r.slot := slot\n        }\n    }\n}\n"},"@openzeppelin/contracts-v4.4/proxy/beacon/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n    /**\n     * @dev Must return an address that can be used as a delegate call target.\n     *\n     * {BeaconProxy} will check that this address is a contract.\n     */\n    function implementation() external view returns (address);\n}\n"},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Proxy.sol\";\nimport \"./ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n */\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\n    /**\n     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n     *\n     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n     * function call, and allows initializating the storage of the proxy like a Solidity constructor.\n     */\n    constructor(address _logic, bytes memory _data) payable {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        _upgradeToAndCall(_logic, _data, false);\n    }\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function _implementation() internal view virtual override returns (address impl) {\n        return ERC1967Upgrade._getImplementation();\n    }\n}\n"},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Upgrade.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n    // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function _getImplementation() internal view returns (address) {\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 implementation slot.\n     */\n    function _setImplementation(address newImplementation) private {\n        require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n    }\n\n    /**\n     * @dev Perform implementation upgrade\n     *\n     * Emits an {Upgraded} event.\n     */\n    function _upgradeTo(address newImplementation) internal {\n        _setImplementation(newImplementation);\n        emit Upgraded(newImplementation);\n    }\n\n    /**\n     * @dev Perform implementation upgrade with additional setup call.\n     *\n     * Emits an {Upgraded} event.\n     */\n    function _upgradeToAndCall(\n        address newImplementation,\n        bytes memory data,\n        bool forceCall\n    ) internal {\n        _upgradeTo(newImplementation);\n        if (data.length > 0 || forceCall) {\n            Address.functionDelegateCall(newImplementation, data);\n        }\n    }\n\n    /**\n     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n     *\n     * Emits an {Upgraded} event.\n     */\n    function _upgradeToAndCallSecure(\n        address newImplementation,\n        bytes memory data,\n        bool forceCall\n    ) internal {\n        address oldImplementation = _getImplementation();\n\n        // Initial upgrade and setup call\n        _setImplementation(newImplementation);\n        if (data.length > 0 || forceCall) {\n            Address.functionDelegateCall(newImplementation, data);\n        }\n\n        // Perform rollback test if not already in progress\n        StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);\n        if (!rollbackTesting.value) {\n            // Trigger rollback using upgradeTo from the new implementation\n            rollbackTesting.value = true;\n            Address.functionDelegateCall(\n                newImplementation,\n                abi.encodeWithSignature(\"upgradeTo(address)\", oldImplementation)\n            );\n            rollbackTesting.value = false;\n            // Check rollback was effective\n            require(oldImplementation == _getImplementation(), \"ERC1967Upgrade: upgrade breaks further upgrades\");\n            // Finally reset to the new implementation and log the upgrade\n            _upgradeTo(newImplementation);\n        }\n    }\n\n    /**\n     * @dev Storage slot with the admin of the contract.\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\n\n    /**\n     * @dev Returns the current admin.\n     */\n    function _getAdmin() internal view returns (address) {\n        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {AdminChanged} event.\n     */\n    function _changeAdmin(address newAdmin) internal {\n        emit AdminChanged(_getAdmin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n     */\n    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n    /**\n     * @dev Emitted when the beacon is upgraded.\n     */\n    event BeaconUpgraded(address indexed beacon);\n\n    /**\n     * @dev Returns the current beacon.\n     */\n    function _getBeacon() internal view returns (address) {\n        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new beacon in the EIP1967 beacon slot.\n     */\n    function _setBeacon(address newBeacon) private {\n        require(Address.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n        require(\n            Address.isContract(IBeacon(newBeacon).implementation()),\n            \"ERC1967: beacon implementation is not a contract\"\n        );\n        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n    }\n\n    /**\n     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n     *\n     * Emits a {BeaconUpgraded} event.\n     */\n    function _upgradeBeaconToAndCall(\n        address newBeacon,\n        bytes memory data,\n        bool forceCall\n    ) internal {\n        _setBeacon(newBeacon);\n        emit BeaconUpgraded(newBeacon);\n        if (data.length > 0 || forceCall) {\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n        }\n    }\n}\n"}},"language":"Solidity","settings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"istanbul","remappings":[]}},"stdJsonOutput":{"sources":{"contracts/0.8.9/proxy/OssifiableProxy.sol":{"id":6},"@openzeppelin/contracts-v4.4/proxy/Proxy.sol":{"id":2},"@openzeppelin/contracts-v4.4/utils/Address.sol":{"id":4},"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol":{"id":5},"@openzeppelin/contracts-v4.4/proxy/beacon/IBeacon.sol":{"id":3},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol":{"id":0},"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Upgrade.sol":{"id":1}},"contracts":{"contracts/0.8.9/proxy/OssifiableProxy.sol":{"OssifiableProxy":{"abi":[{"type":"constructor","inputs":[{"name":"implementation_","type":"address","internalType":"address"},{"name":"admin_","type":"address","internalType":"address"},{"name":"data_","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"NotAdmin","type":"error","inputs":[]},{"name":"ProxyIsOssified","type":"error","inputs":[]},{"name":"AdminChanged","type":"event","inputs":[{"name":"previousAdmin","type":"address","indexed":false,"internalType":"address"},{"name":"newAdmin","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"BeaconUpgraded","type":"event","inputs":[{"name":"beacon","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ProxyOssified","type":"event","inputs":[],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"type":"fallback","stateMutability":"payable"},{"name":"proxy__changeAdmin","type":"function","inputs":[{"name":"newAdmin_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxy__getAdmin","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxy__getImplementation","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxy__getIsOssified","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"proxy__ossify","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxy__upgradeTo","type":"function","inputs":[{"name":"newImplementation_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxy__upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation_","type":"address","internalType":"address"},{"name":"setupCalldata_","type":"bytes","internalType":"bytes"},{"name":"forceCall_","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data_\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ProxyIsOssified\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"ProxyOssified\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAdmin_\",\"type\":\"address\"}],\"name\":\"proxy__changeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxy__getAdmin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxy__getImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxy__getIsOssified\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxy__ossify\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation_\",\"type\":\"address\"}],\"name\":\"proxy__upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation_\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"setupCalldata_\",\"type\":\"bytes\"},{\"internalType\":\"bool\",\"name\":\"forceCall_\",\"type\":\"bool\"}],\"name\":\"proxy__upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"constructor\":{\"details\":\"Initializes the upgradeable proxy with the initial implementation and admin\",\"params\":{\"admin_\":\"Address of the admin of the proxy\",\"data_\":\"Data used in a delegate call to implementation. The delegate call will be     skipped if the data is empty bytes\",\"implementation_\":\"Address of the implementation\"}},\"proxy__changeAdmin(address)\":{\"params\":{\"newAdmin_\":\"Address of the new admin\"}},\"proxy__upgradeTo(address)\":{\"params\":{\"newImplementation_\":\"Address of the new implementation\"}},\"proxy__upgradeToAndCall(address,bytes,bool)\":{\"params\":{\"forceCall_\":\"Forces make delegate call to the implementation even with empty data_\",\"newImplementation_\":\"Address of the new implementation\",\"setupCalldata_\":\"Data for the setup call. The call is skipped if setupCalldata_ is     empty and forceCall_ is false\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"proxy__changeAdmin(address)\":{\"notice\":\"Changes the admin of the proxy\"},\"proxy__getAdmin()\":{\"notice\":\"Returns the current admin of the proxy\"},\"proxy__getImplementation()\":{\"notice\":\"Returns the current implementation address\"},\"proxy__getIsOssified()\":{\"notice\":\"Returns whether the implementation is locked forever\"},\"proxy__ossify()\":{\"notice\":\"Allows to transfer admin rights to zero address and prevent future     upgrades of the proxy\"},\"proxy__upgradeTo(address)\":{\"notice\":\"Upgrades the implementation of the proxy\"},\"proxy__upgradeToAndCall(address,bytes,bool)\":{\"notice\":\"Upgrades the proxy to a new implementation, optionally performing an additional     setup call.\"}},\"notice\":\"An ossifiable proxy contract. Extends the ERC1967Proxy contract by     adding admin functionality\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/0.8.9/proxy/OssifiableProxy.sol\":\"OssifiableProxy\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Proxy.sol\":{\"keccak256\":\"0x6309f9f39dc6f4f45a24f296543867aa358e32946cd6b2874627a996d606b3a0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4f5abfc32db1d44fd3d38d902879eaeaad827781bb9f954d3ccb8639c55db3c0\",\"dweb:/ipfs/QmVSkxFgWphaUx6w9XdvgwJJuxABdpuVQEbABbRmzd3XFc\"]},\"@openzeppelin/contracts-v4.4/proxy/ERC1967/ERC1967Upgrade.sol\":{\"keccak256\":\"0x5f4c3eed093dfb0e4e20c1c102d2f2c6894a972f454adb308511a0afb37e6f79\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://833509a221a8d8dace9e028ac40e95c941b4c91b5dcbe921988578c48dc72e81\",\"dweb:/ipfs/QmX3V2Uk7VU9ARiKHLFGQW5RL6sZS74TrjpSuSPkyRgK2D\"]},\"@openzeppelin/contracts-v4.4/proxy/Proxy.sol\":{\"keccak256\":\"0xab2556b154ceb1a11e456f2827ca8f6f65242b1b2fcc00268ab6d38fc6e64bbd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5823895b53df825121a25dd11a73eb4595c24d20a11c5013e6dda6fd0cd53463\",\"dweb:/ipfs/QmbD8ozmp9DHQ8Es4ZRUKYz8KZSGnwBnVyHmJ9Yf7rYSoZ\"]},\"@openzeppelin/contracts-v4.4/proxy/beacon/IBeacon.sol\":{\"keccak256\":\"0xd50a3421ac379ccb1be435fa646d66a65c986b4924f0849839f08692f39dde61\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ada1e030c0231db8d143b44ce92b4d1158eedb087880cad6d8cc7bd7ebe7b354\",\"dweb:/ipfs/QmWZ2NHZweRpz1U9GF6R1h65ri76dnX7fNxLBeM2t5N5Ce\"]},\"@openzeppelin/contracts-v4.4/utils/Address.sol\":{\"keccak256\":\"0x51b758a8815ecc9596c66c37d56b1d33883a444631a3f916b9fe65cb863ef7c4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://997ca03557985b3c6f9143a18b6c3a710b3bc1c7f189ee956d305a966ecfb922\",\"dweb:/ipfs/QmQaD3Wb62F88SHqmpLttvF6wKuPDQep2LLUcKPekeRzvz\"]},\"@openzeppelin/contracts-v4.4/utils/StorageSlot.sol\":{\"keccak256\":\"0xfe1b7a9aa2a530a9e705b220e26cd584e2fbdc9602a3a1066032b12816b46aca\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://dbaba7fe0fe556cc5ed291e03d271fd27d395250141ecfb57a4b30d528958ff9\",\"dweb:/ipfs/QmWT653X2DyZo8nqEcmFe3yTkrCJv3ptbZLhbgLU3y6abe\"]},\"contracts/0.8.9/proxy/OssifiableProxy.sol\":{\"keccak256\":\"0x7d5c1d0ba899644454d2c808b6847ad0e5c5cd72c9d1a71953c6e456013adbe2\",\"license\":\"GPL-3.0\",\"urls\":[\"bzz-raw://30be63d03f0bc683fdf9a0c1ffc335d414cc0277d88a5518566c885453542239\",\"dweb:/ipfs/QmQ9c76TysW7tDBjS3vGiZ4QzP3u5atp2ScV9ojBuHjKX5\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"An ossifiable proxy contract. Extends the ERC1967Proxy contract by     adding admin functionality","methods":{"proxy__ossify()":{"notice":"Allows to transfer admin rights to zero address and prevent future     upgrades of the proxy"},"proxy__getAdmin()":{"notice":"Returns the current admin of the proxy"},"proxy__getIsOssified()":{"notice":"Returns whether the implementation is locked forever"},"proxy__upgradeTo(address)":{"notice":"Upgrades the implementation of the proxy"},"proxy__getImplementation()":{"notice":"Returns the current implementation address"},"proxy__changeAdmin(address)":{"notice":"Changes the admin of the proxy"},"proxy__upgradeToAndCall(address,bytes,bool)":{"notice":"Upgrades the proxy to a new implementation, optionally performing an additional     setup call."}},"version":1},"devdoc":{"kind":"dev","methods":{"constructor":{"params":{"data_":"Data used in a delegate call to implementation. The delegate call will be     skipped if the data is empty bytes","admin_":"Address of the admin of the proxy","implementation_":"Address of the implementation"},"details":"Initializes the upgradeable proxy with the initial implementation and admin"},"proxy__upgradeTo(address)":{"params":{"newImplementation_":"Address of the new implementation"}},"proxy__changeAdmin(address)":{"params":{"newAdmin_":"Address of the new admin"}},"proxy__upgradeToAndCall(address,bytes,bool)":{"params":{"forceCall_":"Forces make delegate call to the implementation even with empty data_","setupCalldata_":"Data for the setup call. The call is skipped if setupCalldata_ is     empty and forceCall_ is false","newImplementation_":"Address of the new implementation"}}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"503:3012:6:-:0;;;898:177;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1014:15;1031:5;1050:54:0;1103:1;1058:41;1050:54;:::i;:::-;-1:-1:-1;;;;;;;;;;;1018:87:0;1011:95;;;;:::i;:::-;1116:39;1134:6;1142:5;1149;1116:17;:39::i;:::-;-1:-1:-1;1048:20:6::1;::::0;-1:-1:-1;1061:6:6;1048:12:::1;:20::i;:::-;898:177:::0;;;503:3012;;2122:295:1;2260:29;2271:17;2260:10;:29::i;:::-;2317:1;2303:4;:11;:15;:28;;;;2322:9;2303:28;2299:112;;;2347:53;2376:17;2395:4;2347:28;;;;;:53;;:::i;:::-;;2299:112;2122:295;;;:::o;4843:135::-;4907:35;4920:11;:9;:11::i;:::-;4907:35;;;-1:-1:-1;;;;;2238:15:7;;;2220:34;;2290:15;;;2285:2;2270:18;;2263:43;2155:18;4907:35:1;;;;;;;4952:19;4962:8;4952:9;:19::i;:::-;4843:135;:::o;1836:152::-;1902:37;1921:17;1902:18;:37::i;:::-;1954:27;;-1:-1:-1;;;;;1954:27:1;;;;;;;;1836:152;:::o;6223:198:4:-;6306:12;6337:77;6358:6;6366:4;6337:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6330:84;6223:198;-1:-1:-1;;;6223:198:4:o;4327:122:1:-;4371:7;4397:39;-1:-1:-1;;;;;;;;;;;4424:11:1;;4397:26;;;;;:39;;:::i;:::-;:45;-1:-1:-1;;;;;4397:45:1;;4327:122;-1:-1:-1;4327:122:1:o;4531:201::-;-1:-1:-1;;;;;4594:22:1;;4586:73;;;;-1:-1:-1;;;4586:73:1;;2519:2:7;4586:73:1;;;2501:21:7;2558:2;2538:18;;;2531:30;2597:34;2577:18;;;2570:62;-1:-1:-1;;;2648:18:7;;;2641:36;2694:19;;4586:73:1;;;;;;;;;4717:8;4669:39;-1:-1:-1;;;;;;;;;;;4696:11:1;;4669:26;;;;;:39;;:::i;:::-;:56;;-1:-1:-1;;;;;;4669:56:1;-1:-1:-1;;;;;4669:56:1;;;;;;;;;;-1:-1:-1;4531:201:1:o;1471:259::-;1552:37;1571:17;1552:18;;;;;:37;;:::i;:::-;1544:95;;;;-1:-1:-1;;;1544:95:1;;2926:2:7;1544:95:1;;;2908:21:7;2965:2;2945:18;;;2938:30;3004:34;2984:18;;;2977:62;-1:-1:-1;;;3055:18:7;;;3048:43;3108:19;;1544:95:1;2724:409:7;1544:95:1;1706:17;1649:48;-1:-1:-1;;;;;;;;;;;1676:20:1;;1649:26;;;;;:48;;:::i;6607:387:4:-;6748:12;1087:20;;6772:69;;;;-1:-1:-1;;;6772:69:4;;3340:2:7;6772:69:4;;;3322:21:7;3379:2;3359:18;;;3352:30;3418:34;3398:18;;;3391:62;-1:-1:-1;;;3469:18:7;;;3462:36;3515:19;;6772:69:4;3138:402:7;6772:69:4;6853:12;6867:23;6894:6;-1:-1:-1;;;;;6894:19:4;6914:4;6894:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6852:67:4;;-1:-1:-1;6852:67:4;-1:-1:-1;6936:51:4;6852:67;;6974:12;6936:16;:51::i;:::-;6929:58;6607:387;-1:-1:-1;;;;;;6607:387:4:o;1599:147:5:-;1726:4;1599:147::o;771:377:4:-;1087:20;1133:8;;;771:377::o;7214:692::-;7360:12;7388:7;7384:516;;;-1:-1:-1;7418:10:4;7411:17;;7384:516;7529:17;;:21;7525:365;;7723:10;7717:17;7783:15;7770:10;7766:2;7762:19;7755:44;7525:365;7862:12;7855:20;;-1:-1:-1;;;7855:20:4;;;;;;;;:::i;14:177:7:-;93:13;;-1:-1:-1;;;;;135:31:7;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:127::-;257:10;252:3;248:20;245:1;238:31;288:4;285:1;278:15;312:4;309:1;302:15;328:258;400:1;410:113;424:6;421:1;418:13;410:113;;;500:11;;;494:18;481:11;;;474:39;446:2;439:10;410:113;;;541:6;538:1;535:13;532:48;;;-1:-1:-1;;576:1:7;558:16;;551:27;328:258::o;591:1053::-;688:6;696;704;757:2;745:9;736:7;732:23;728:32;725:52;;;773:1;770;763:12;725:52;796:40;826:9;796:40;:::i;:::-;786:50;;855:49;900:2;889:9;885:18;855:49;:::i;:::-;948:2;933:18;;927:25;845:59;;-1:-1:-1;;;;;;1001:14:7;;;998:34;;;1028:1;1025;1018:12;998:34;1066:6;1055:9;1051:22;1041:32;;1111:7;1104:4;1100:2;1096:13;1092:27;1082:55;;1133:1;1130;1123:12;1082:55;1162:2;1156:9;1184:2;1180;1177:10;1174:36;;;1190:18;;:::i;:::-;1265:2;1259:9;1233:2;1319:13;;-1:-1:-1;;1315:22:7;;;1339:2;1311:31;1307:40;1295:53;;;1363:18;;;1383:22;;;1360:46;1357:72;;;1409:18;;:::i;:::-;1449:10;1445:2;1438:22;1484:2;1476:6;1469:18;1524:7;1519:2;1514;1510;1506:11;1502:20;1499:33;1496:53;;;1545:1;1542;1535:12;1496:53;1558:55;1610:2;1605;1597:6;1593:15;1588:2;1584;1580:11;1558:55;:::i;:::-;1632:6;1622:16;;;;;;;591:1053;;;;;:::o;1649:222::-;1689:4;1717:1;1714;1711:8;1708:131;;;1761:10;1756:3;1752:20;1749:1;1742:31;1796:4;1793:1;1786:15;1824:4;1821:1;1814:15;1708:131;-1:-1:-1;1856:9:7;;1649:222::o;1876:127::-;1937:10;1932:3;1928:20;1925:1;1918:31;1968:4;1965:1;1958:15;1992:4;1989:1;1982:15;3545:274;3674:3;3712:6;3706:13;3728:53;3774:6;3769:3;3762:4;3754:6;3750:17;3728:53;:::i;:::-;3797:16;;;;;3545:274;-1:-1:-1;;3545:274:7:o;3824:383::-;3973:2;3962:9;3955:21;3936:4;4005:6;3999:13;4048:6;4043:2;4032:9;4028:18;4021:34;4064:66;4123:6;4118:2;4107:9;4103:18;4098:2;4090:6;4086:15;4064:66;:::i;:::-;4191:2;4170:15;-1:-1:-1;;4166:29:7;4151:45;;;;4198:2;4147:54;;3824:383;-1:-1:-1;;3824:383:7:o;:::-;503:3012:6;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"503:3012:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2884:11:2;:9;:11::i;:::-;503:3012:6;;2661:11:2;:9;:11::i;1479:110:6:-;;;;;;;;;;;;;:::i;:::-;;;179:14:7;;172:22;154:41;;142:2;127:18;1479:110:6;;;;;;;;2292:120;;;;;;;;;;-1:-1:-1;2292:120:6;;;;;:::i;:::-;;:::i;2055:106::-;;;;;;;;;;-1:-1:-1;2055:106:6;;;;;:::i;:::-;;:::i;1136:94::-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;739:32:7;;;721:51;;709:2;694:18;1136:94:6;575:203:7;1295:109:6;;;;;;;;;;;;;:::i;1712:240::-;;;;;;;;;;;;;:::i;2840:238::-;;;;;;;;;;-1:-1:-1;2840:238:6;;;;;:::i;:::-;;:::i;2308:110:2:-;2383:28;2393:17;:15;:17::i;:::-;2383:9;:28::i;:::-;2308:110::o;1479::6:-;1534:4;;1557:11;:9;:11::i;:::-;-1:-1:-1;;;;;1557:25:6;;1550:32;;1479:110;:::o;2292:120::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;2375:30:::1;2386:18;2375:10;:30::i;:::-;3219:214:::0;2292:120;:::o;2055:106::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;2131:23:::1;2144:9;2131:12;:23::i;1136:94::-:0;1186:7;1212:11;:9;:11::i;:::-;1205:18;;1136:94;:::o;1295:109::-;1354:7;1380:17;:15;:17::i;1712:240::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;1766:17:::1;1786:11;:9;:11::i;:::-;4061:66:1;1807:58:6::0;;-1:-1:-1;;;;;;1807:58:6::1;::::0;;1880:35:::1;::::0;;-1:-1:-1;;;;;2378:15:7;;2360:34;;1863:1:6::1;2425:2:7::0;2410:18;;2403:43;1880:35:6;;1766:31;;-1:-1:-1;1880:35:6::1;::::0;;;;;;;;;::::1;1930:15;::::0;::::1;::::0;;;::::1;1756:196;3219:214:::0;1712:240::o;2840:238::-;3229:13;3245:11;:9;:11::i;:::-;3229:27;-1:-1:-1;;;;;;3270:19:6;;3266:74;;3312:17;;-1:-1:-1;;;3312:17:6;;;;;;;;;;;3266:74;-1:-1:-1;;;;;3353:19:6;;3362:10;3353:19;3349:67;;3395:10;;-1:-1:-1;;;3395:10:6;;;;;;;;;;;3349:67;3006:65:::1;3024:18;3044:14;3060:10;3006:17;:65::i;:::-;3219:214:::0;2840:238;;;:::o;6223:198:4:-;6306:12;6337:77;6358:6;6366:4;6337:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6330:84;6223:198;-1:-1:-1;;;6223:198:4:o;1599:147:5:-;1726:4;1599:147::o;771:377:4:-;1087:20;1133:8;;;771:377::o;1240:140:0:-;1307:12;1338:35;:33;:35::i;934:895:2:-;1272:14;1269:1;1266;1253:34;1486:1;1483;1467:14;1464:1;1448:14;1441:5;1428:60;1562:16;1559:1;1556;1541:38;1600:6;1667:66;;;;1782:16;1779:1;1772:27;1667:66;1702:16;1699:1;1692:27;1593:220;;;934:895;:::o;4327:122:1:-;4371:7;4061:66;4397:39;:45;-1:-1:-1;;;;;4397:45:1;;4327:122;-1:-1:-1;4327:122:1:o;1836:152::-;1902:37;1921:17;1902:18;:37::i;:::-;1954:27;;-1:-1:-1;;;;;1954:27:1;;;;;;;;1836:152;:::o;4843:135::-;4907:35;4920:11;:9;:11::i;:::-;4907:35;;;-1:-1:-1;;;;;2378:15:7;;;2360:34;;2430:15;;;2425:2;2410:18;;2403:43;2295:18;4907:35:1;;;;;;;4952:19;4962:8;4952:9;:19::i;:::-;4843:135;:::o;2122:295::-;2260:29;2271:17;2260:10;:29::i;:::-;2317:1;2303:4;:11;:15;:28;;;;2322:9;2303:28;2299:112;;;2347:53;2376:17;2395:4;2347:28;:53::i;6607:387:4:-;6748:12;1087:20;;6772:69;;;;-1:-1:-1;;;6772:69:4;;2659:2:7;6772:69:4;;;2641:21:7;2698:2;2678:18;;;2671:30;2737:34;2717:18;;;2710:62;-1:-1:-1;;;2788:18:7;;;2781:36;2834:19;;6772:69:4;;;;;;;;;6853:12;6867:23;6894:6;-1:-1:-1;;;;;6894:19:4;6914:4;6894:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6852:67;;;;6936:51;6953:7;6962:10;6974:12;6936:16;:51::i;:::-;6929:58;6607:387;-1:-1:-1;;;;;;6607:387:4:o;1240:140:1:-;1293:7;969:66;1319:48;1599:147:5;1471:259:1;1087:20:4;;1544:95:1;;;;-1:-1:-1;;;1544:95:1;;3608:2:7;1544:95:1;;;3590:21:7;3647:2;3627:18;;;3620:30;3686:34;3666:18;;;3659:62;-1:-1:-1;;;3737:18:7;;;3730:43;3790:19;;1544:95:1;3406:409:7;1544:95:1;1706:17;969:66;1649:48;:74;;-1:-1:-1;;;;;;1649:74:1;-1:-1:-1;;;;;1649:74:1;;;;;;;;;;-1:-1:-1;1471:259:1:o;4531:201::-;-1:-1:-1;;;;;4594:22:1;;4586:73;;;;-1:-1:-1;;;4586:73:1;;4022:2:7;4586:73:1;;;4004:21:7;4061:2;4041:18;;;4034:30;4100:34;4080:18;;;4073:62;-1:-1:-1;;;4151:18:7;;;4144:36;4197:19;;4586:73:1;3820:402:7;4586:73:1;4717:8;4061:66;4669:39;1599:147:5;7214:692:4;7360:12;7388:7;7384:516;;;-1:-1:-1;7418:10:4;7411:17;;7384:516;7529:17;;:21;7525:365;;7723:10;7717:17;7783:15;7770:10;7766:2;7762:19;7755:44;7525:365;7862:12;7855:20;;-1:-1:-1;;;7855:20:4;;;;;;;;:::i;206:173:7:-;274:20;;-1:-1:-1;;;;;323:31:7;;313:42;;303:70;;369:1;366;359:12;303:70;206:173;;;:::o;384:186::-;443:6;496:2;484:9;475:7;471:23;467:32;464:52;;;512:1;509;502:12;464:52;535:29;554:9;535:29;:::i;783:127::-;844:10;839:3;835:20;832:1;825:31;875:4;872:1;865:15;899:4;896:1;889:15;915:160;980:20;;1036:13;;1029:21;1019:32;;1009:60;;1065:1;1062;1055:12;1080:1063;1163:6;1171;1179;1232:2;1220:9;1211:7;1207:23;1203:32;1200:52;;;1248:1;1245;1238:12;1200:52;1271:29;1290:9;1271:29;:::i;:::-;1261:39;;1351:2;1340:9;1336:18;1323:32;1374:18;1415:2;1407:6;1404:14;1401:34;;;1431:1;1428;1421:12;1401:34;1469:6;1458:9;1454:22;1444:32;;1514:7;1507:4;1503:2;1499:13;1495:27;1485:55;;1536:1;1533;1526:12;1485:55;1572:2;1559:16;1594:2;1590;1587:10;1584:36;;;1600:18;;:::i;:::-;1675:2;1669:9;1643:2;1729:13;;-1:-1:-1;;1725:22:7;;;1749:2;1721:31;1717:40;1705:53;;;1773:18;;;1793:22;;;1770:46;1767:72;;;1819:18;;:::i;:::-;1859:10;1855:2;1848:22;1894:2;1886:6;1879:18;1934:7;1929:2;1924;1920;1916:11;1912:20;1909:33;1906:53;;;1955:1;1952;1945:12;1906:53;2011:2;2006;2002;1998:11;1993:2;1985:6;1981:15;1968:46;2056:1;2051:2;2046;2038:6;2034:15;2030:24;2023:35;2077:6;2067:16;;;;;;;2102:35;2133:2;2122:9;2118:18;2102:35;:::i;:::-;2092:45;;1080:1063;;;;;:::o;2864:258::-;2936:1;2946:113;2960:6;2957:1;2954:13;2946:113;;;3036:11;;;3030:18;3017:11;;;3010:39;2982:2;2975:10;2946:113;;;3077:6;3074:1;3071:13;3068:48;;;-1:-1:-1;;3112:1:7;3094:16;;3087:27;2864:258::o;3127:274::-;3256:3;3294:6;3288:13;3310:53;3356:6;3351:3;3344:4;3336:6;3332:17;3310:53;:::i;:::-;3379:16;;;;;3127:274;-1:-1:-1;;3127:274:7:o;4227:383::-;4376:2;4365:9;4358:21;4339:4;4408:6;4402:13;4451:6;4446:2;4435:9;4431:18;4424:34;4467:66;4526:6;4521:2;4510:9;4506:18;4501:2;4493:6;4489:15;4467:66;:::i;:::-;4594:2;4573:15;-1:-1:-1;;4569:29:7;4554:45;;;;4601:2;4550:54;;4227:383;-1:-1:-1;;4227:383:7:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"proxy__changeAdmin(address)","signatureHash4":"0x773f5be8","signatureHash32":"0x773f5be8903bef35c456e48a67988cef2b51624babde137922c896a4d0bc3ef8"},{"signature":"proxy__getAdmin()","signatureHash4":"0x916f1fd7","signatureHash32":"0x916f1fd780f54030798f168a90c52f8c11745507f805ac23868912cb7155c19e"},{"signature":"proxy__getImplementation()","signatureHash4":"0xad729a71","signatureHash32":"0xad729a719b54bd6e154b9994e46786584fcd6f3131c4377480c983ddbc3dcd25"},{"signature":"proxy__getIsOssified()","signatureHash4":"0x13351258","signatureHash32":"0x13351258ba61e4e0652999e322dd716a2db736727b3df3da3e07c6e2b506b4fb"},{"signature":"proxy__ossify()","signatureHash4":"0xadcbc237","signatureHash32":"0xadcbc2370199ef924b7236ad065ff6536f4858b9fac3de74e766e40aa478f8b1"},{"signature":"proxy__upgradeTo(address)","signatureHash4":"0x3ebdd0eb","signatureHash32":"0x3ebdd0eb52f9526a0ef2fed81096b3d44dd4e5bac80941168176ca56e49eb1a3"},{"signature":"proxy__upgradeToAndCall(address,bytes,bool)","signatureHash4":"0xd2f6ed4d","signatureHash32":"0xd2f6ed4d5c6688ae10680c79a702ef17a1e37340767b5565f3865a4f158da5c0"}],"event":[{"signature":"AdminChanged(address,address)","signatureHash4":"0x7e644d79","signatureHash32":"0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f"},{"signature":"BeaconUpgraded(address)","signatureHash4":"0x1cf3b03a","signatureHash32":"0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e"},{"signature":"ProxyOssified()","signatureHash4":"0x158b2048","signatureHash32":"0x158b204828f9326d9bb3c2be9336986c14911b4a72b93d1801f207aac3c68b9f"},{"signature":"Upgraded(address)","signatureHash4":"0xbc7cd75a","signatureHash32":"0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b"}],"error":[{"signature":"NotAdmin()","signatureHash4":"0x7bfa4b9f","signatureHash32":"0x7bfa4b9fb0cd3687c1f539f384b3f3f258f2c9aa9186353d0815413b508ed97d"},{"signature":"ProxyIsOssified()","signatureHash4":"0xb83646a9","signatureHash32":"0xb83646a9d887a13e3504b80e6fc8c97e1475f79679d792a5e9876345013e0e5d"}]},"proxyResolution":{"isProxy":true,"proxyType":"EIP1967Proxy","implementations":[{"address":"0xE42C659Dc09109566720EA8b2De186c2Be7D94D9","name":"WithdrawalQueueERC721"}]},"match":"exact_match","chainId":"1","address":"0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1"}