{"matchId":"28030785","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-04-17T07:37:28Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"361:8864:0:-:0;;;1088:113;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1151:11:0;;;;;1172:22;;;361:8864;;14:139:11;-1:-1:-1;;;;;97:31:11;;87:42;;77:70;;143:1;140;133:12;77:70;14:139;:::o;158:409::-;245:6;253;306:2;294:9;285:7;281:23;277:32;274:52;;;322:1;319;312:12;274:52;354:9;348:16;373:39;406:5;373:39;:::i;:::-;481:2;466:18;;460:25;431:5;;-1:-1:-1;494:41:11;460:25;494:41;:::i;:::-;554:7;544:17;;;158:409;;;;;:::o;:::-;361:8864:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220f518e3e2d38d2d4ad17600e523b2aafb0d72c7ab4f57d569cd0848b77e3b447f64736f6c63430008110033","offset":4793}},"transformations":[{"type":"insert","offset":4846,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000000000000000014aa86c5d3c41765bb24e11bd701"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"361:8864:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3292:3851;;;;;;;;;;-1:-1:-1;3292:3851:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8295:327;;;;;;;;;;-1:-1:-1;8295:327:0;;;;;:::i;:::-;;:::i;:::-;;403:29;;;;;;;;;;;;;;;;;;;;;;:::i;438:35::-;;;;;;;;;;;;;;;3292:3851;3355:12;3387:10;-1:-1:-1;;;;;3401:10:0;3387:24;;3379:61;;;;-1:-1:-1;;;3379:61:0;;2855:2:11;3379:61:0;;;2837:21:11;2894:2;2874:18;;;2867:30;-1:-1:-1;;;2913:18:11;;;2906:54;2977:18;;3379:61:0;;;;;;;;;3451:38;;;;;;;;-1:-1:-1;3451:38:0;;-1:-1:-1;;;;;3451:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;3451:38:0;;;;;;;;;;;;-1:-1:-1;;;3451:38:0;;;-1:-1:-1;;;;;3451:38:0;;;;;;;3746:31;;3776:1;3746:31;;;3765:7;3746:31;3637:141;;3727:2;3708:6;:13;;;-1:-1:-1;;;;;3692:31:0;:37;;3672:3;3646:6;:21;;;-1:-1:-1;;;;;3638:30:0;:37;;3637:93;:141;3616:172;;3595:193;;3942:21;3973:12;3988:10;3973:25;;4008:14;4025:6;:14;;;:21;;;4008:38;;4056:14;4073:6;:14;;;:21;;;4056:38;;4104:14;4121:6;:14;;;:21;;;4104:38;;4217:4;4211:11;4312:1;4307:3;4300:14;4406:6;4402:1;4397:3;4393:11;4386:27;4493:6;4488:2;4483:3;4479:12;4472:28;4567:6;4562:2;4557:3;4553:12;4546:28;4646:10;4640:3;4635;4631:13;4624:33;4800:2;4795:3;4790;4785;4782:1;4776:4;4769:5;4764:39;4839:7;4829:133;;4887:16;4884:1;4881;4866:38;4931:16;4928:1;4921:27;4829:133;-1:-1:-1;5062:10:0;5315:15;;;;5062:10;;-1:-1:-1;5215:3:0;5189:29;;;;5062:10;;5159:13;;5315:87;;5381:14;;;;:21;5315:87;;;5345:6;:14;;;:21;;;5315:87;5295:107;;5464:1;5455:6;:10;;;5451:808;;;-1:-1:-1;;;;;5485:16:0;;5481:768;;5628:37;;-1:-1:-1;;;5628:37:0;;5606:19;;-1:-1:-1;;;;;5635:4:0;5628:22;;;;:37;;5659:4;;5628:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5683:33;;-1:-1:-1;;;5683:33:0;;;;;3341:25:11;;;5606:59:0;;-1:-1:-1;5689:4:0;-1:-1:-1;;;;;5683:20:0;;;;3314:18:11;;5683:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5787:12;5805:10;-1:-1:-1;;;;;5805:15:0;5836:6;-1:-1:-1;;;;;5805:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5786:62;;;5874:7;5866:58;;;;-1:-1:-1;;;5866:58:0;;3789:2:11;5866:58:0;;;3771:21:11;3828:2;3808:18;;;3801:30;3867:34;3847:18;;;3840:62;-1:-1:-1;;;3918:18:11;;;3911:36;3964:19;;5866:58:0;3587:402:11;5866:58:0;5503:436;;5481:768;;;6054:14;;;;:21;6039:37;;:14;:37::i;:::-;6124:14;;;;:21;6094:82;;6148:10;-1:-1:-1;;;;;6094:82:0;;:22;:82::i;:::-;6212:14;;;;:21;6194:40;;:17;:40::i;:::-;6282:1;6273:6;:10;;;6269:228;;;6299:37;6314:6;:14;;;:21;;;6299:14;:37::i;:::-;6350:82;6380:6;:14;;;:21;;;6404:10;6424:6;-1:-1:-1;;;;;6350:82:0;:22;:82::i;:::-;6446:40;6464:6;:14;;;:21;;;6446:17;:40::i;:::-;6541:19;6563:6;:15;;;:87;;6629:6;:14;;;:21;;;6563:87;;;6593:14;;;;:21;6563:87;6541:109;;6660:20;6691:6;:15;;;:35;;6719:7;6720:6;6719:7;:::i;:::-;6691:35;;;6709:7;6710:6;6709:7;:::i;:::-;6660:67;-1:-1:-1;;;;;;6742:16:0;;;6738:379;;-1:-1:-1;;;;;6778:18:0;;6774:333;;6816:51;6826:11;6847:4;6854:12;6816:9;:51::i;:::-;6891:4;-1:-1:-1;;;;;6885:19:0;;6912:12;-1:-1:-1;;;;;6885:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6945:61;6975:4;6982:6;:9;;;6993:12;-1:-1:-1;;;;;6945:61:0;:22;:61::i;:::-;6774:333;;;7045:47;7055:11;7068:6;:9;;;7079:12;7045:9;:47::i;:::-;-1:-1:-1;;7127:9:0;;;;;;;;;-1:-1:-1;7127:9:0;;;3292:3851;-1:-1:-1;;;;;;;;;;;;3292:3851:0:o;8295:327::-;-1:-1:-1;;8484:14:0;8539:13;8526:27;8572:43;8583:2;8587:4;8593:8;8526:27;8572:10;:43::i;:::-;8410:212;8295:327;;;:::o;7200:214::-;7259:12;7277:10;-1:-1:-1;;;;;7277:15:0;7329:10;7341:5;7306:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7306:41:0;;;;;;;;;;;7277:80;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7258:99;;;7375:7;7367:40;;;;-1:-1:-1;;;7367:40:0;;4788:2:11;7367:40:0;;;4770:21:11;4827:2;4807:18;;;4800:30;-1:-1:-1;;;4846:18:11;;;4839:50;4906:18;;7367:40:0;4586:344:11;7367:40:0;7248:166;7200:214;:::o;1614:199:9:-;1701:52;1711:5;-1:-1:-1;;;1743:2:9;1747:5;1701:9;:52::i;:::-;1696:111;;1776:20;;-1:-1:-1;;;1776:20:9;;;;;;;;;;;1696:111;1614:199;;;:::o;7474:220:0:-;7536:12;7554:10;-1:-1:-1;;;;;7554:15:0;7606:10;7618:5;7583:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7583:41:0;;;;;;;;;;;7554:80;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7535:99;;;7652:7;7644:43;;;;-1:-1:-1;;;7644:43:0;;5137:2:11;7644:43:0;;;5119:21:11;5176:2;5156:18;;;5149:30;-1:-1:-1;;;5195:18:11;;;5188:53;5258:18;;7644:43:0;4935:347:11;7751:538:0;7930:4;7924:11;-1:-1:-1;;;7984:33:0;;8054:2;8050:14;;;8046:1;8037:11;;8030:35;8099:18;;;8094:2;8085:12;;8078:40;8156:3;8152:16;;;8147:2;8138:12;;8131:38;7854:10;;7839:12;;8218:2;7924:11;7839:12;7854:10;8197:5;8192:35;8182:91;;8257:1;8254;8247:12;8182:91;;7899:384;7751:538;;;:::o;1207:2003::-;1349:22;1373:13;1414:8;1390:71;;;;;;;;;;;;:::i;:::-;1348:113;;;;1472:17;1492:8;:42;;1520:14;;1492:42;;;1503:7;:14;;;1492:42;1472:62;-1:-1:-1;1545:20:0;-1:-1:-1;;;;;1579:16:0;;1575:187;;1626:37;;-1:-1:-1;;;1626:37:0;;-1:-1:-1;;;;;1633:4:0;1626:22;;;;:37;;1657:4;;1626:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1611:52;;1575:187;;;1709:42;;-1:-1:-1;;;1709:42:0;;-1:-1:-1;;;;;1709:27:0;;;;;:42;;1745:4;;1709:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1694:57;;1575:187;1795:1;1780:12;:16;1772:46;;;;-1:-1:-1;;;1772:46:0;;6423:2:11;1772:46:0;;;6405:21:11;6462:2;6442:18;;;6435:30;-1:-1:-1;;;6481:18:11;;;6474:47;6538:18;;1772:46:0;6221:341:11;1772:46:0;1863:12;1828:17;9157:14;;;9143:29;;1912:105;;566:23;1912:105;;;632:33;1912:105;2042:180;;;;;;;;-1:-1:-1;;;;;2042:180:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2042:180:0;;;;;;;;;-1:-1:-1;2028:194:0;;-1:-1:-1;;;;;;2028:194:0;;;;;;;;;;-1:-1:-1;2028:194:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2028:194:0;;-1:-1:-1;;;;;;2028:194:0;;;;-1:-1:-1;;;2028:194:0;;;;;;;-1:-1:-1;;;;;;;;2028:194:0;-1:-1:-1;;;2028:194:0;;;;;;;;;2283:31;;-1:-1:-1;;;2283:31:0;;;;2042:180;;-1:-1:-1;2296:10:0;2283:29;;;;;;:31;;;;-1:-1:-1;2283:31:0;;;;;;-1:-1:-1;2283:29:0;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2332:11:0;2325:18;;-1:-1:-1;;;;;;2325:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2325:18:0;;;2332:11;-1:-1:-1;;;;;;;;2430:26:0;;2429:44;2425:143;;-1:-1:-1;;;;;;2520:35:0;;2425:143;-1:-1:-1;;;;;2582:26:0;;;2578:626;;-1:-1:-1;;;;;2628:16:0;;;:45;;;;;2672:1;2648:21;:25;2628:45;2624:570;;;2694:12;2712;-1:-1:-1;;;;;2712:17:0;2758:21;2712:89;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2693:108;;;2827:7;2819:50;;;;-1:-1:-1;;;2819:50:0;;6769:2:11;2819:50:0;;;6751:21:11;6808:2;6788:18;;;6781:30;6847:32;6827:18;;;6820:60;6897:18;;2819:50:0;6567:354:11;2819:50:0;2675:209;2624:570;;;-1:-1:-1;;;;;2894:16:0;;;2890:304;;2952:80;;-1:-1:-1;;;2952:80:0;;2930:19;;-1:-1:-1;;;;;2952:27:0;;;;;:80;;3009:4;;2952:80;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2930:102;-1:-1:-1;3054:15:0;;3050:130;;3093:68;3123:9;3135:12;3149:11;3093:22;:68::i;:::-;2912:282;2890:304;1338:1872;;;;;;;1207:2003;;;;:::o;3534:683:9:-;3628:12;3779:4;3773:11;3811:8;3805:4;3798:22;3857:2;3850:4;3844;3840:15;3833:27;3897:6;3890:4;3884;3880:15;3873:31;3967:4;3962:3;3956:4;3950;3947:1;3940:5;3933;3928:44;3917:55;;;3988:7;3985:216;;;4021:16;4054:47;;;;4182:1;4178;4172:8;4169:15;4164:2;4146:16;4143:24;4139:46;4128:57;;4014:173;;4054:47;4097:1;4089:5;4077:18;4074:25;4063:36;;4014:173;;3985:216;3534:683;;;;;;:::o;14:180:11:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:11;;14:180;-1:-1:-1;14:180:11:o;199:250::-;284:1;294:113;308:6;305:1;302:13;294:113;;;384:11;;;378:18;365:11;;;358:39;330:2;323:10;294:113;;;-1:-1:-1;;441:1:11;423:16;;416:27;199:250::o;454:394::-;601:2;590:9;583:21;564:4;633:6;627:13;676:6;671:2;660:9;656:18;649:34;692:79;764:6;759:2;748:9;744:18;739:2;731:6;727:15;692:79;:::i;:::-;832:2;811:15;-1:-1:-1;;807:29:11;792:45;;;;839:2;788:54;;454:394;-1:-1:-1;;454:394:11:o;853:131::-;-1:-1:-1;;;;;928:31:11;;918:42;;908:70;;974:1;971;964:12;908:70;853:131;:::o;989:127::-;1050:10;1045:3;1041:20;1038:1;1031:31;1081:4;1078:1;1071:15;1105:4;1102:1;1095:15;1121:275;1192:2;1186:9;1257:2;1238:13;;-1:-1:-1;;1234:27:11;1222:40;;-1:-1:-1;;;;;1277:34:11;;1313:22;;;1274:62;1271:88;;;1339:18;;:::i;:::-;1375:2;1368:22;1121:275;;-1:-1:-1;1121:275:11:o;1401:1039::-;1487:6;1495;1503;1556:2;1544:9;1535:7;1531:23;1527:32;1524:52;;;1572:1;1569;1562:12;1524:52;1611:9;1598:23;1630:31;1655:5;1630:31;:::i;:::-;1680:5;-1:-1:-1;1704:2:11;1743:18;;;1730:32;1771:33;1730:32;1771:33;:::i;:::-;1823:7;-1:-1:-1;1881:2:11;1866:18;;1853:32;-1:-1:-1;;;;;1934:14:11;;;1931:34;;;1961:1;1958;1951:12;1931:34;1999:6;1988:9;1984:22;1974:32;;2044:7;2037:4;2033:2;2029:13;2025:27;2015:55;;2066:1;2063;2056:12;2015:55;2102:2;2089:16;2124:2;2120;2117:10;2114:36;;;2130:18;;:::i;:::-;2172:53;2215:2;2196:13;;-1:-1:-1;;2192:27:11;2188:36;;2172:53;:::i;:::-;2159:66;;2248:2;2241:5;2234:17;2288:7;2283:2;2278;2274;2270:11;2266:20;2263:33;2260:53;;;2309:1;2306;2299:12;2260:53;2364:2;2359;2355;2351:11;2346:2;2339:5;2335:14;2322:45;2408:1;2403:2;2398;2391:5;2387:14;2383:23;2376:34;;2429:5;2419:15;;;;;1401:1039;;;;;:::o;2445:203::-;-1:-1:-1;;;;;2609:32:11;;;;2591:51;;2579:2;2564:18;;2445:203::o;3006:184::-;3076:6;3129:2;3117:9;3108:7;3104:23;3100:32;3097:52;;;3145:1;3142;3135:12;3097:52;-1:-1:-1;3168:16:11;;3006:184;-1:-1:-1;3006:184:11:o;3994:295::-;4029:3;4073:2;4062:21;;;-1:-1:-1;;;4095:37:11;;4092:160;;4174:10;4169:3;4165:20;4162:1;4155:31;4209:4;4206:1;4199:15;4237:4;4234:1;4227:15;4092:160;4272:1;4268:15;;3994:295;-1:-1:-1;;3994:295:11:o;4294:287::-;4423:3;4461:6;4455:13;4477:66;4536:6;4531:3;4524:4;4516:6;4512:17;4477:66;:::i;:::-;4559:16;;;;;4294:287;-1:-1:-1;;4294:287:11:o;5287:929::-;5387:6;5395;5439:9;5430:7;5426:23;5469:3;5465:2;5461:12;5458:32;;;5486:1;5483;5476:12;5458:32;5510:4;5506:2;5502:13;5499:33;;;5528:1;5525;5518:12;5499:33;-1:-1:-1;5561:2:11;5555:9;5603:4;5591:17;;-1:-1:-1;;;;;5623:34:11;;5659:22;;;5620:62;5617:88;;;5685:18;;:::i;:::-;5721:2;5714:22;5758:16;;5783:31;5758:16;5783:31;:::i;:::-;5823:21;;5889:2;5874:18;;5868:25;5902:33;5868:25;5902:33;:::i;:::-;5963:2;5951:15;;5944:32;6030:2;6015:18;;;6009:25;5992:15;;;5985:50;6105:4;6090:20;;6084:27;5955:6;;-1:-1:-1;6149:15:11;;6142:23;6130:36;;6120:64;;6180:1;6177;6170:12;6120:64;6203:7;6193:17;;;5287:929;;;;;:::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220f518e3e2d38d2d4ad17600e523b2aafb0d72c7ab4f57d569cd0848b77e3b447f64736f6c63430008110033","offset":4507}},"immutableReferences":{"16":[{"start":191,"length":32},{"start":837,"length":32},{"start":980,"length":32},{"start":1612,"length":32},{"start":1740,"length":32},{"start":2639,"length":32}],"18":[{"start":256,"length":32},{"start":303,"length":32},{"start":608,"length":32},{"start":1084,"length":32},{"start":1333,"length":32},{"start":1437,"length":32},{"start":1872,"length":32},{"start":2190,"length":32},{"start":2493,"length":32},{"start":3201,"length":32}]},"transformations":[{"id":"16","type":"replace","offset":191,"reason":"immutable"},{"id":"16","type":"replace","offset":837,"reason":"immutable"},{"id":"16","type":"replace","offset":980,"reason":"immutable"},{"id":"16","type":"replace","offset":1612,"reason":"immutable"},{"id":"16","type":"replace","offset":1740,"reason":"immutable"},{"id":"16","type":"replace","offset":2639,"reason":"immutable"},{"id":"18","type":"replace","offset":256,"reason":"immutable"},{"id":"18","type":"replace","offset":303,"reason":"immutable"},{"id":"18","type":"replace","offset":608,"reason":"immutable"},{"id":"18","type":"replace","offset":1084,"reason":"immutable"},{"id":"18","type":"replace","offset":1333,"reason":"immutable"},{"id":"18","type":"replace","offset":1437,"reason":"immutable"},{"id":"18","type":"replace","offset":1872,"reason":"immutable"},{"id":"18","type":"replace","offset":2190,"reason":"immutable"},{"id":"18","type":"replace","offset":2493,"reason":"immutable"},{"id":"18","type":"replace","offset":3201,"reason":"immutable"}],"transformationValues":{"immutables":{"16":"0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","18":"0x00000000000000000000000000000000000014aa86c5d3c41765bb24e11bd701"}}},"deployment":{"transactionHash":"0x3568b694460d1a997c8da925d83c2435db52d455c0bb2636b8aa2dd66907bafe","blockNumber":"24268186","transactionIndex":"159","deployer":"0x399EfA78cAcD7784751CD9FBf2523eDf9EFDf6Ad"},"sources":{"contracts/8/adapter/EkuboV3Adapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\nimport \"../interfaces/IAdapter.sol\";\nimport \"../interfaces/IEkuboV3.sol\";\nimport \"../interfaces/IERC20.sol\";\nimport \"../libraries/SafeERC20.sol\";\nimport \"../interfaces/IWETH.sol\";\n\nusing PoolKeyLibrary for PoolKey;\n\n/// @title EkuboV3Adapter\n/// @notice Adapter for Ekubo V3 Protocol\ncontract EkuboV3Adapter is IAdapter {\n    address public immutable WETH;\n    address public immutable EKUBO_CORE;\n\n    address internal constant ETH = address(0);\n\n    uint96 constant MIN_SQRT_RATIO_RAW = 4611797791050542631 + 1;\n    uint96 constant MAX_SQRT_RATIO_RAW = 79227682466138141934206691491 - 1;\n\n    uint256 internal constant ORIGIN_PAYER =\n        0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\n    uint256 constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\n    struct SwapParams {\n        address to;\n        PoolKey poolKey;\n        int128 amount;\n        bool isToken1;\n        uint96 sqrtRatioLimit;\n    }\n\n    SwapParams private _swapParams;\n\n    constructor(address payable weth, address ekuboCore) {\n        WETH = weth;\n        EKUBO_CORE = ekuboCore;\n    }\n\n    function _ekuboSwap(\n        address to,\n        address,\n        bytes memory moreInfo,\n        uint256 payerOrigin\n    ) private {\n        (PoolKey memory poolKey, bool isToken1) = abi.decode(\n            moreInfo,\n            (PoolKey, bool)\n        );\n\n        address fromToken = isToken1 ? poolKey.token1 : poolKey.token0;\n\n        uint256 inputBalance;\n        if (fromToken == ETH) {\n            inputBalance = IERC20(WETH).balanceOf(address(this));\n        } else {\n            inputBalance = IERC20(fromToken).balanceOf(address(this));\n        }\n\n        require(inputBalance > 0, \"No tokens to swap\");\n        int128 swapAmount = int128(uint128(inputBalance));\n\n        uint96 sqrtRatioLimit = isPriceIncreasing(swapAmount, isToken1)\n            ? MAX_SQRT_RATIO_RAW\n            : MIN_SQRT_RATIO_RAW;\n\n        _swapParams = SwapParams({\n            to: to,\n            poolKey: poolKey,\n            amount: swapAmount,\n            isToken1: isToken1,\n            sqrtRatioLimit: sqrtRatioLimit\n        });\n\n        // lock() -> locked_6416899205() callback\n        IEkuboV3Core(EKUBO_CORE).lock();\n\n        delete _swapParams;\n\n        // Return back excess fromTokens\n        address _payerOrigin;\n        if ((payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            _payerOrigin = address(uint160(uint256(payerOrigin) & ADDRESS_MASK));\n        }\n\n        if (_payerOrigin != address(0)) {\n            if (fromToken == ETH && address(this).balance > 0) {\n                (bool success, ) = _payerOrigin.call{\n                    value: address(this).balance\n                }(\"\");\n                require(success, \"Transfer to payerOrigin failed\");\n            } else if (fromToken != ETH) {\n                uint256 leftBalance = IERC20(fromToken).balanceOf(\n                    address(this)\n                );\n                if (leftBalance > 0) {\n                    SafeERC20.safeTransfer(IERC20(fromToken), _payerOrigin, leftBalance);\n                }\n            }\n        }\n    }\n\n    /// @notice Lock callback - function name is mined for gas optimization\n    function locked_6416899205(uint256 /* id */) external returns (bytes memory) {\n        require(msg.sender == EKUBO_CORE, \"Only Ekubo Core can call\");\n\n        SwapParams memory params = _swapParams;\n\n        // Pack SwapParameters: sqrtRatioLimit(96) | amount(128) | isToken1(1) | skipAhead(31)\n        bytes32 swapParams = bytes32(\n            (uint256(params.sqrtRatioLimit) << 160) |\n            (uint256(uint128(params.amount)) << 32) |\n            (params.isToken1 ? (1 << 31) : 0)\n        );\n\n        // Call swap_6269342730 with selector = 0 (mined function)\n        // Must use assembly because Solidity would generate wrong selector\n        bytes32 balanceUpdate;\n        address core = EKUBO_CORE;\n        address token0 = params.poolKey.token0;\n        address token1 = params.poolKey.token1;\n        bytes32 config = params.poolKey.config;\n        \n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            \n            // selector = 0x00000000 (4 zero bytes)\n            mstore(ptr, 0)\n            \n            // token0 (32 bytes, ABI encoded)\n            mstore(add(ptr, 4), token0)\n            // token1 (32 bytes, ABI encoded)\n            mstore(add(ptr, 36), token1)\n            // config (32 bytes)\n            mstore(add(ptr, 68), config)\n            // swapParams (32 bytes)\n            mstore(add(ptr, 100), swapParams)\n            \n            // Call: 4 + 32*4 = 132 bytes, expect 64 bytes return\n            let success := call(gas(), core, 0, ptr, 132, ptr, 64)\n            \n            if iszero(success) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n            \n            // First 32 bytes of return is balanceUpdate\n            balanceUpdate := mload(ptr)\n        }\n\n        // Decode BalanceDelta (packed as: delta0 << 128 | delta1)\n        int128 delta0 = int128(int256(uint256(balanceUpdate) >> 128));\n        int128 delta1 = int128(int256(uint256(balanceUpdate)));\n\n        address fromToken = params.isToken1\n            ? params.poolKey.token1\n            : params.poolKey.token0;\n\n        // Handle debt (settle input)\n        if (delta0 > 0) {\n            if (fromToken == ETH) {\n                // Withdraw all WETH to ETH, but only transfer the exact debt amount\n                uint256 wethBalance = IERC20(WETH).balanceOf(address(this));\n                IWETH(WETH).withdraw(wethBalance);\n\n                // Only send the exact debt amount\n                (bool success, ) = EKUBO_CORE.call{value: uint128(delta0)}(\"\");\n                require(success, \"Transfer ETH debt to Ekubo Core failed\");\n            } else {\n                // ERC20: use startPayments -> transfer -> completePayments\n                _startPayments(params.poolKey.token0);\n                SafeERC20.safeTransfer(IERC20(params.poolKey.token0), EKUBO_CORE, uint128(delta0));\n                _completePayments(params.poolKey.token0);\n            }\n        }\n\n        if (delta1 > 0) {\n            _startPayments(params.poolKey.token1);\n            SafeERC20.safeTransfer(IERC20(params.poolKey.token1), EKUBO_CORE, uint128(delta1));\n            _completePayments(params.poolKey.token1);\n        }\n\n        // Withdraw output tokens\n        address outputToken = params.isToken1\n            ? params.poolKey.token0\n            : params.poolKey.token1;\n        uint128 outputAmount = uint128(params.isToken1 ? -delta0 : -delta1);\n\n        if (outputAmount > 0) {\n            if (outputToken == ETH) {\n                _withdraw(outputToken, address(this), outputAmount);\n                IWETH(WETH).deposit{value: outputAmount}();\n                SafeERC20.safeTransfer(IERC20(WETH), params.to, outputAmount);\n            } else {\n                _withdraw(outputToken, params.to, outputAmount);\n            }\n        }\n\n        return \"\";\n    }\n\n    /// @notice Start payment tracking for a token\n    function _startPayments(address token) internal {\n        (bool success, ) = EKUBO_CORE.call(\n            abi.encodeWithSelector(0xf9b6a796, token)\n        );\n        require(success, \"startPayments failed\");\n    }\n\n    /// @notice Complete payment tracking for a token\n    function _completePayments(address token) internal {\n        (bool success, ) = EKUBO_CORE.call(\n            abi.encodeWithSelector(0x12e103f1, token)\n        );\n        require(success, \"completePayments failed\");\n    }\n\n    /// @notice Call withdraw with packed calldata\n    function _withdraw(address token, address recipient, uint128 amount) internal {\n        address core = EKUBO_CORE;\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // selector: 0x3ccfd60b\n            mstore(ptr, shl(224, 0x3ccfd60b))\n            mstore(add(ptr, 4), shl(96, token))\n            mstore(add(ptr, 24), shl(96, recipient))\n            mstore(add(ptr, 44), shl(128, amount))\n            if iszero(call(gas(), core, 0, ptr, 60, 0, 0)) {\n                revert(0, 0)\n            }\n        }\n    }\n\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        uint256 payerOrigin;\n        assembly {\n            let size := calldatasize()\n            payerOrigin := calldataload(sub(size, 32))\n        }\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\n    }\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        uint256 payerOrigin;\n        assembly {\n            let size := calldatasize()\n            payerOrigin := calldataload(sub(size, 32))\n        }\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\n    }\n\n    function isPriceIncreasing(\n        int128 amount,\n        bool isToken1\n    ) private pure returns (bool increasing) {\n        assembly (\"memory-safe\") {\n            increasing := xor(isToken1, slt(amount, 0))\n        }\n    }\n\n    receive() external payable {}\n}\n"},"contracts/8/interfaces/IAdapter.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IAdapter {\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory data\n    ) external;\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory data\n    ) external;\n}\n"},"contracts/8/interfaces/IEkuboV3.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @notice Pool key structure for Ekubo V3\nstruct PoolKey {\n    address token0;\n    address token1;\n    bytes32 config;  // packed: extension(160) | fee(64) | poolTypeConfig(32)\n    // poolTypeConfig: bit31=isConcentrated, if concentrated: bits30-0=tickSpacing\n    //                 if stableswap: bits30-24=amplification, bits23-0=centerTick\n}\n\nlibrary PoolKeyLibrary {\n    function toPoolId(PoolKey memory self) internal pure returns (bytes32) {\n        return keccak256(abi.encode(self.token0, self.token1, self.config));\n    }\n}\n\n/// @notice Ekubo V3 Core interface\ninterface IEkuboV3Core {\n    /// @notice Acquire lock for flash accounting\n    function lock() external;\n\n    /// @notice Swap function - function name is mined to have selector = 0\n    function swap_6269342730(\n        address token0,\n        address token1,\n        bytes32 config,\n        bytes32 swapParams\n    ) external payable returns (bytes32 balanceUpdate, bytes32 poolState);\n\n    /// @notice Start payment tracking for a token\n    function startPayments() external;\n\n    /// @notice Complete payment tracking for a token  \n    function completePayments() external;\n\n    /// @notice Withdraw tokens from the core\n    function withdraw() external;\n}\n\n"},"contracts/8/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    event Approval(\n        address indexed owner,\n        address indexed spender,\n        uint256 value\n    );\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function name() external view returns (string memory);\n\n    function symbol() external view returns (string memory);\n\n    function decimals() external view returns (uint8);\n\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address owner) external view returns (uint256);\n\n    function allowance(address owner, address spender)\n        external\n        view\n        returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 value\n    ) external returns (bool);\n}\n"},"contracts/8/libraries/SafeERC20.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./SafeMath.sol\";\nimport \"./Address.sol\";\nimport \"./RevertReasonForwarder.sol\";\nimport \"../interfaces/IERC20.sol\";\nimport \"../interfaces/IERC20Permit.sol\";\nimport \"../interfaces/IDaiLikePermit.sol\";\n\n// File @1inch/solidity-utils/contracts/libraries/SafeERC20.sol@v2.1.1\n\nlibrary SafeERC20 {\n    error SafeTransferFailed();\n    error SafeTransferFromFailed();\n    error ForceApproveFailed();\n    error SafeIncreaseAllowanceFailed();\n    error SafeDecreaseAllowanceFailed();\n    error SafePermitBadLength();\n\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\n        bytes4 selector = token.transferFrom.selector;\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), from)\n            mstore(add(data, 0x24), to)\n            mstore(add(data, 0x44), amount)\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n        if (!success) revert SafeTransferFromFailed();\n    }\n\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\n            revert SafeTransferFailed();\n        }\n    }\n\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        forceApprove(token, spender, value);\n    }\n\n    // If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\n            if (!_makeCall(token, token.approve.selector, spender, 0) ||\n                !_makeCall(token, token.approve.selector, spender, value))\n            {\n                revert ForceApproveFailed();\n            }\n        }\n    }\n\n    \n\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\n        forceApprove(token, spender, allowance + value);\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\n        forceApprove(token, spender, allowance - value);\n    }\n\n    function safePermit(IERC20 token, bytes calldata permit) internal {\n        bool success;\n        if (permit.length == 32 * 7) {\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\n        } else if (permit.length == 32 * 8) {\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\n        } else {\n            revert SafePermitBadLength();\n        }\n        if (!success) RevertReasonForwarder.reRevert();\n    }\n\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns(bool success) {\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), to)\n            mstore(add(data, 0x24), amount)\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool success) {\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let len := add(4, args.length)\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            calldatacopy(add(data, 0x04), args.offset, args.length)\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n}\n\n\n"},"contracts/8/interfaces/IWETH.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IWETH {\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address account) external view returns (uint256);\n\n    function transfer(address recipient, uint256 amount)\n        external\n        returns (bool);\n\n    function allowance(address owner, address spender)\n        external\n        view\n        returns (uint256);\n\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    function transferFrom(\n        address src,\n        address dst,\n        uint256 wad\n    ) external returns (bool);\n\n    function deposit() external payable;\n\n    function withdraw(uint256 wad) external;\n}\n"},"contracts/8/libraries/SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary SafeMath {\n    uint256 constant WAD = 10**18;\n    uint256 constant RAY = 10**27;\n\n    function wad() public pure returns (uint256) {\n        return WAD;\n    }\n\n    function ray() public pure returns (uint256) {\n        return RAY;\n    }\n\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n\n        return c;\n    }\n\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, \"SafeMath: subtraction overflow\");\n    }\n\n    function sub(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        uint256 c = a - b;\n\n        return c;\n    }\n\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) {\n            return 0;\n        }\n\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n\n        return c;\n    }\n\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(a, b, \"SafeMath: division by zero\");\n    }\n\n    function div(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        // Solidity only automatically asserts when dividing by 0\n        require(b > 0, errorMessage);\n        uint256 c = a / b;\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n        return c;\n    }\n\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mod(a, b, \"SafeMath: modulo by zero\");\n    }\n\n    function mod(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        require(b != 0, errorMessage);\n        return a % b;\n    }\n\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a <= b ? a : b;\n    }\n\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    function sqrt(uint256 a) internal pure returns (uint256 b) {\n        if (a > 3) {\n            b = a;\n            uint256 x = a / 2 + 1;\n            while (x < b) {\n                b = x;\n                x = (a / x + x) / 2;\n            }\n        } else if (a != 0) {\n            b = 1;\n        }\n    }\n\n    function wmul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mul(a, b) / WAD;\n    }\n\n    function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, b), WAD / 2) / WAD;\n    }\n\n    function rmul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mul(a, b) / RAY;\n    }\n\n    function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, b), RAY / 2) / RAY;\n    }\n\n    function wdiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(mul(a, WAD), b);\n    }\n\n    function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, WAD), b / 2) / b;\n    }\n\n    function rdiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(mul(a, RAY), b);\n    }\n\n    function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, RAY), b / 2) / b;\n    }\n\n    function wpow(uint256 x, uint256 n) internal pure returns (uint256) {\n        uint256 result = WAD;\n        while (n > 0) {\n            if (n % 2 != 0) {\n                result = wmul(result, x);\n            }\n            x = wmul(x, x);\n            n /= 2;\n        }\n        return result;\n    }\n\n    function rpow(uint256 x, uint256 n) internal pure returns (uint256) {\n        uint256 result = RAY;\n        while (n > 0) {\n            if (n % 2 != 0) {\n                result = rmul(result, x);\n            }\n            x = rmul(x, x);\n            n /= 2;\n        }\n        return result;\n    }\n\n    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 quotient = div(a, b);\n        uint256 remainder = a - quotient * b;\n        if (remainder > 0) {\n            return quotient + 1;\n        } else {\n            return quotient;\n        }\n    }\n}\n"},"contracts/8/libraries/Address.sol":{"content":"/// SPDX-License-Identifier: MIT\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        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\n        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\n        // for accounts without code, i.e. `keccak256('')`\n        bytes32 codehash;\n        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            codehash := extcodehash(account)\n        }\n        return (codehash != accountHash && codehash != 0x0);\n    }\n\n    /**\n     * @dev Converts an `address` into `address payable`. Note that this is\n     * simply a type cast: the actual underlying value is not changed.\n     *\n     * _Available since v2.4.0._\n     */\n    function toPayable(address account)\n        internal\n        pure\n        returns (address payable)\n    {\n        return payable(account);\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     * _Available since v2.4.0._\n     */\n    function sendValue(address recipient, uint256 amount) internal {\n        require(\n            address(this).balance >= amount,\n            \"Address: insufficient balance\"\n        );\n\n        // solhint-disable-next-line avoid-call-value\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(\n            success,\n            \"Address: unable to send value, recipient may have reverted\"\n        );\n    }\n}\n"},"contracts/8/libraries/RevertReasonForwarder.sol":{"content":"/// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nlibrary RevertReasonForwarder {\n    function reRevert() internal pure {\n        // bubble up revert reason from latest external call\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let ptr := mload(0x40)\n            returndatacopy(ptr, 0, returndatasize())\n            revert(ptr, returndatasize())\n        }\n    }\n}"},"contracts/8/interfaces/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,\n     * given `owner`'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"contracts/8/interfaces/IDaiLikePermit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Interface for DAI-style permits\ninterface IDaiLikePermit {\n    function permit(\n        address holder,\n        address spender,\n        uint256 nonce,\n        uint256 expiry,\n        bool allowed,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.17+commit.8df45f5f","compilerSettings":{"viaIR":false,"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"runs":1,"enabled":true},"evmVersion":"london","remappings":["@ensdomains/=node_modules/@ensdomains/","@openzeppelin/=node_modules/@openzeppelin/","ds-test/=lib/forge-std/lib/ds-test/src/","eth-gas-reporter/=node_modules/eth-gas-reporter/","forge-std/=lib/forge-std/src/","hardhat/=node_modules/hardhat/","@dex/=contracts/8/","@uniswap/=node_modules/@uniswap/","@zetachain/=node_modules/@zetachain/"]},"name":"EkuboV3Adapter","fullyQualifiedName":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},"abi":[{"type":"constructor","inputs":[{"name":"weth","type":"address","internalType":"address payable"},{"name":"ekuboCore","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"SafeTransferFailed","type":"error","inputs":[]},{"name":"EKUBO_CORE","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"WETH","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"locked_6416899205","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"sellBase","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"sellQuote","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.17+commit.8df45f5f"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address payable","name":"weth","type":"address"},{"internalType":"address","name":"ekuboCore","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"SafeTransferFailed","type":"error"},{"inputs":[],"name":"EKUBO_CORE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"locked_6416899205","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellBase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellQuote","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{},"title":"EkuboV3Adapter","version":1},"userdoc":{"kind":"user","methods":{"locked_6416899205(uint256)":{"notice":"Lock callback - function name is mined for gas optimization"}},"notice":"Adapter for Ekubo V3 Protocol","version":1}},"settings":{"compilationTarget":{"contracts/8/adapter/EkuboV3Adapter.sol":"EkuboV3Adapter"},"evmVersion":"london","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":true,"runs":1},"remappings":[":@dex/=contracts/8/",":@ensdomains/=node_modules/@ensdomains/",":@openzeppelin/=node_modules/@openzeppelin/",":@uniswap/=node_modules/@uniswap/",":@zetachain/=node_modules/@zetachain/",":ds-test/=lib/forge-std/lib/ds-test/src/",":eth-gas-reporter/=node_modules/eth-gas-reporter/",":forge-std/=lib/forge-std/src/",":hardhat/=node_modules/hardhat/"]},"sources":{"contracts/8/adapter/EkuboV3Adapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\nimport \"../interfaces/IAdapter.sol\";\nimport \"../interfaces/IEkuboV3.sol\";\nimport \"../interfaces/IERC20.sol\";\nimport \"../libraries/SafeERC20.sol\";\nimport \"../interfaces/IWETH.sol\";\n\nusing PoolKeyLibrary for PoolKey;\n\n/// @title EkuboV3Adapter\n/// @notice Adapter for Ekubo V3 Protocol\ncontract EkuboV3Adapter is IAdapter {\n    address public immutable WETH;\n    address public immutable EKUBO_CORE;\n\n    address internal constant ETH = address(0);\n\n    uint96 constant MIN_SQRT_RATIO_RAW = 4611797791050542631 + 1;\n    uint96 constant MAX_SQRT_RATIO_RAW = 79227682466138141934206691491 - 1;\n\n    uint256 internal constant ORIGIN_PAYER =\n        0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\n    uint256 constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\n    struct SwapParams {\n        address to;\n        PoolKey poolKey;\n        int128 amount;\n        bool isToken1;\n        uint96 sqrtRatioLimit;\n    }\n\n    SwapParams private _swapParams;\n\n    constructor(address payable weth, address ekuboCore) {\n        WETH = weth;\n        EKUBO_CORE = ekuboCore;\n    }\n\n    function _ekuboSwap(\n        address to,\n        address,\n        bytes memory moreInfo,\n        uint256 payerOrigin\n    ) private {\n        (PoolKey memory poolKey, bool isToken1) = abi.decode(\n            moreInfo,\n            (PoolKey, bool)\n        );\n\n        address fromToken = isToken1 ? poolKey.token1 : poolKey.token0;\n\n        uint256 inputBalance;\n        if (fromToken == ETH) {\n            inputBalance = IERC20(WETH).balanceOf(address(this));\n        } else {\n            inputBalance = IERC20(fromToken).balanceOf(address(this));\n        }\n\n        require(inputBalance > 0, \"No tokens to swap\");\n        int128 swapAmount = int128(uint128(inputBalance));\n\n        uint96 sqrtRatioLimit = isPriceIncreasing(swapAmount, isToken1)\n            ? MAX_SQRT_RATIO_RAW\n            : MIN_SQRT_RATIO_RAW;\n\n        _swapParams = SwapParams({\n            to: to,\n            poolKey: poolKey,\n            amount: swapAmount,\n            isToken1: isToken1,\n            sqrtRatioLimit: sqrtRatioLimit\n        });\n\n        // lock() -> locked_6416899205() callback\n        IEkuboV3Core(EKUBO_CORE).lock();\n\n        delete _swapParams;\n\n        // Return back excess fromTokens\n        address _payerOrigin;\n        if ((payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            _payerOrigin = address(uint160(uint256(payerOrigin) & ADDRESS_MASK));\n        }\n\n        if (_payerOrigin != address(0)) {\n            if (fromToken == ETH && address(this).balance > 0) {\n                (bool success, ) = _payerOrigin.call{\n                    value: address(this).balance\n                }(\"\");\n                require(success, \"Transfer to payerOrigin failed\");\n            } else if (fromToken != ETH) {\n                uint256 leftBalance = IERC20(fromToken).balanceOf(\n                    address(this)\n                );\n                if (leftBalance > 0) {\n                    SafeERC20.safeTransfer(IERC20(fromToken), _payerOrigin, leftBalance);\n                }\n            }\n        }\n    }\n\n    /// @notice Lock callback - function name is mined for gas optimization\n    function locked_6416899205(uint256 /* id */) external returns (bytes memory) {\n        require(msg.sender == EKUBO_CORE, \"Only Ekubo Core can call\");\n\n        SwapParams memory params = _swapParams;\n\n        // Pack SwapParameters: sqrtRatioLimit(96) | amount(128) | isToken1(1) | skipAhead(31)\n        bytes32 swapParams = bytes32(\n            (uint256(params.sqrtRatioLimit) << 160) |\n            (uint256(uint128(params.amount)) << 32) |\n            (params.isToken1 ? (1 << 31) : 0)\n        );\n\n        // Call swap_6269342730 with selector = 0 (mined function)\n        // Must use assembly because Solidity would generate wrong selector\n        bytes32 balanceUpdate;\n        address core = EKUBO_CORE;\n        address token0 = params.poolKey.token0;\n        address token1 = params.poolKey.token1;\n        bytes32 config = params.poolKey.config;\n        \n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            \n            // selector = 0x00000000 (4 zero bytes)\n            mstore(ptr, 0)\n            \n            // token0 (32 bytes, ABI encoded)\n            mstore(add(ptr, 4), token0)\n            // token1 (32 bytes, ABI encoded)\n            mstore(add(ptr, 36), token1)\n            // config (32 bytes)\n            mstore(add(ptr, 68), config)\n            // swapParams (32 bytes)\n            mstore(add(ptr, 100), swapParams)\n            \n            // Call: 4 + 32*4 = 132 bytes, expect 64 bytes return\n            let success := call(gas(), core, 0, ptr, 132, ptr, 64)\n            \n            if iszero(success) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n            \n            // First 32 bytes of return is balanceUpdate\n            balanceUpdate := mload(ptr)\n        }\n\n        // Decode BalanceDelta (packed as: delta0 << 128 | delta1)\n        int128 delta0 = int128(int256(uint256(balanceUpdate) >> 128));\n        int128 delta1 = int128(int256(uint256(balanceUpdate)));\n\n        address fromToken = params.isToken1\n            ? params.poolKey.token1\n            : params.poolKey.token0;\n\n        // Handle debt (settle input)\n        if (delta0 > 0) {\n            if (fromToken == ETH) {\n                // Withdraw all WETH to ETH, but only transfer the exact debt amount\n                uint256 wethBalance = IERC20(WETH).balanceOf(address(this));\n                IWETH(WETH).withdraw(wethBalance);\n\n                // Only send the exact debt amount\n                (bool success, ) = EKUBO_CORE.call{value: uint128(delta0)}(\"\");\n                require(success, \"Transfer ETH debt to Ekubo Core failed\");\n            } else {\n                // ERC20: use startPayments -> transfer -> completePayments\n                _startPayments(params.poolKey.token0);\n                SafeERC20.safeTransfer(IERC20(params.poolKey.token0), EKUBO_CORE, uint128(delta0));\n                _completePayments(params.poolKey.token0);\n            }\n        }\n\n        if (delta1 > 0) {\n            _startPayments(params.poolKey.token1);\n            SafeERC20.safeTransfer(IERC20(params.poolKey.token1), EKUBO_CORE, uint128(delta1));\n            _completePayments(params.poolKey.token1);\n        }\n\n        // Withdraw output tokens\n        address outputToken = params.isToken1\n            ? params.poolKey.token0\n            : params.poolKey.token1;\n        uint128 outputAmount = uint128(params.isToken1 ? -delta0 : -delta1);\n\n        if (outputAmount > 0) {\n            if (outputToken == ETH) {\n                _withdraw(outputToken, address(this), outputAmount);\n                IWETH(WETH).deposit{value: outputAmount}();\n                SafeERC20.safeTransfer(IERC20(WETH), params.to, outputAmount);\n            } else {\n                _withdraw(outputToken, params.to, outputAmount);\n            }\n        }\n\n        return \"\";\n    }\n\n    /// @notice Start payment tracking for a token\n    function _startPayments(address token) internal {\n        (bool success, ) = EKUBO_CORE.call(\n            abi.encodeWithSelector(0xf9b6a796, token)\n        );\n        require(success, \"startPayments failed\");\n    }\n\n    /// @notice Complete payment tracking for a token\n    function _completePayments(address token) internal {\n        (bool success, ) = EKUBO_CORE.call(\n            abi.encodeWithSelector(0x12e103f1, token)\n        );\n        require(success, \"completePayments failed\");\n    }\n\n    /// @notice Call withdraw with packed calldata\n    function _withdraw(address token, address recipient, uint128 amount) internal {\n        address core = EKUBO_CORE;\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // selector: 0x3ccfd60b\n            mstore(ptr, shl(224, 0x3ccfd60b))\n            mstore(add(ptr, 4), shl(96, token))\n            mstore(add(ptr, 24), shl(96, recipient))\n            mstore(add(ptr, 44), shl(128, amount))\n            if iszero(call(gas(), core, 0, ptr, 60, 0, 0)) {\n                revert(0, 0)\n            }\n        }\n    }\n\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        uint256 payerOrigin;\n        assembly {\n            let size := calldatasize()\n            payerOrigin := calldataload(sub(size, 32))\n        }\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\n    }\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        uint256 payerOrigin;\n        assembly {\n            let size := calldatasize()\n            payerOrigin := calldataload(sub(size, 32))\n        }\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\n    }\n\n    function isPriceIncreasing(\n        int128 amount,\n        bool isToken1\n    ) private pure returns (bool increasing) {\n        assembly (\"memory-safe\") {\n            increasing := xor(isToken1, slt(amount, 0))\n        }\n    }\n\n    receive() external payable {}\n}\n","keccak256":"0x4d77a59b2b6c787f264ca52bab90e3f4d15ef25e338261ede23d7a019616d4e4","license":"MIT"},"contracts/8/interfaces/IAdapter.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IAdapter {\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory data\n    ) external;\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory data\n    ) external;\n}\n","keccak256":"0x8861a0548ae3a9b7467c3eb5fcd4c04bce00d58d2cb4eaedd520cf666989fc69","license":"MIT"},"contracts/8/interfaces/IDaiLikePermit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Interface for DAI-style permits\ninterface IDaiLikePermit {\n    function permit(\n        address holder,\n        address spender,\n        uint256 nonce,\n        uint256 expiry,\n        bool allowed,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n","keccak256":"0x480d32f19e542d9daa222cb703dd091d4eea3b534c45269fd1f04f8ba470cc44","license":"MIT"},"contracts/8/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    event Approval(\n        address indexed owner,\n        address indexed spender,\n        uint256 value\n    );\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function name() external view returns (string memory);\n\n    function symbol() external view returns (string memory);\n\n    function decimals() external view returns (uint8);\n\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address owner) external view returns (uint256);\n\n    function allowance(address owner, address spender)\n        external\n        view\n        returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 value\n    ) external returns (bool);\n}\n","keccak256":"0xc2d4e51a0477ae32fc24b7a10da9bc9f6b0754fee338c1b099e8335b8b2fb18c","license":"MIT"},"contracts/8/interfaces/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,\n     * given `owner`'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n","keccak256":"0x25ca4efda5b398358811f84a4b914a8f1f1cc0522870d5ac166543209220900e","license":"MIT"},"contracts/8/interfaces/IEkuboV3.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @notice Pool key structure for Ekubo V3\nstruct PoolKey {\n    address token0;\n    address token1;\n    bytes32 config;  // packed: extension(160) | fee(64) | poolTypeConfig(32)\n    // poolTypeConfig: bit31=isConcentrated, if concentrated: bits30-0=tickSpacing\n    //                 if stableswap: bits30-24=amplification, bits23-0=centerTick\n}\n\nlibrary PoolKeyLibrary {\n    function toPoolId(PoolKey memory self) internal pure returns (bytes32) {\n        return keccak256(abi.encode(self.token0, self.token1, self.config));\n    }\n}\n\n/// @notice Ekubo V3 Core interface\ninterface IEkuboV3Core {\n    /// @notice Acquire lock for flash accounting\n    function lock() external;\n\n    /// @notice Swap function - function name is mined to have selector = 0\n    function swap_6269342730(\n        address token0,\n        address token1,\n        bytes32 config,\n        bytes32 swapParams\n    ) external payable returns (bytes32 balanceUpdate, bytes32 poolState);\n\n    /// @notice Start payment tracking for a token\n    function startPayments() external;\n\n    /// @notice Complete payment tracking for a token  \n    function completePayments() external;\n\n    /// @notice Withdraw tokens from the core\n    function withdraw() external;\n}\n\n","keccak256":"0xcf0afa30b783db8c4810444c75bef6694a7bdb35eef1db74b4c3fd3b1c3b3849","license":"MIT"},"contracts/8/interfaces/IWETH.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IWETH {\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address account) external view returns (uint256);\n\n    function transfer(address recipient, uint256 amount)\n        external\n        returns (bool);\n\n    function allowance(address owner, address spender)\n        external\n        view\n        returns (uint256);\n\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    function transferFrom(\n        address src,\n        address dst,\n        uint256 wad\n    ) external returns (bool);\n\n    function deposit() external payable;\n\n    function withdraw(uint256 wad) external;\n}\n","keccak256":"0x7dc79bded17353823f20fb059c19d7d4e17fa726d90fb16e877d80955caedd61","license":"MIT"},"contracts/8/libraries/Address.sol":{"content":"/// SPDX-License-Identifier: MIT\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        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\n        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\n        // for accounts without code, i.e. `keccak256('')`\n        bytes32 codehash;\n        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            codehash := extcodehash(account)\n        }\n        return (codehash != accountHash && codehash != 0x0);\n    }\n\n    /**\n     * @dev Converts an `address` into `address payable`. Note that this is\n     * simply a type cast: the actual underlying value is not changed.\n     *\n     * _Available since v2.4.0._\n     */\n    function toPayable(address account)\n        internal\n        pure\n        returns (address payable)\n    {\n        return payable(account);\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     * _Available since v2.4.0._\n     */\n    function sendValue(address recipient, uint256 amount) internal {\n        require(\n            address(this).balance >= amount,\n            \"Address: insufficient balance\"\n        );\n\n        // solhint-disable-next-line avoid-call-value\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(\n            success,\n            \"Address: unable to send value, recipient may have reverted\"\n        );\n    }\n}\n","keccak256":"0x922cf77144f4af34623762e2efd1ea3e9e5f6041638ff4b195322d89b73241eb","license":"MIT"},"contracts/8/libraries/RevertReasonForwarder.sol":{"content":"/// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nlibrary RevertReasonForwarder {\n    function reRevert() internal pure {\n        // bubble up revert reason from latest external call\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let ptr := mload(0x40)\n            returndatacopy(ptr, 0, returndatasize())\n            revert(ptr, returndatasize())\n        }\n    }\n}","keccak256":"0x12d542c0a07c83175bc927b2ecd77dd9cf9d113e1f6d242a9886920cdc84e004","license":"MIT"},"contracts/8/libraries/SafeERC20.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./SafeMath.sol\";\nimport \"./Address.sol\";\nimport \"./RevertReasonForwarder.sol\";\nimport \"../interfaces/IERC20.sol\";\nimport \"../interfaces/IERC20Permit.sol\";\nimport \"../interfaces/IDaiLikePermit.sol\";\n\n// File @1inch/solidity-utils/contracts/libraries/SafeERC20.sol@v2.1.1\n\nlibrary SafeERC20 {\n    error SafeTransferFailed();\n    error SafeTransferFromFailed();\n    error ForceApproveFailed();\n    error SafeIncreaseAllowanceFailed();\n    error SafeDecreaseAllowanceFailed();\n    error SafePermitBadLength();\n\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\n        bytes4 selector = token.transferFrom.selector;\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), from)\n            mstore(add(data, 0x24), to)\n            mstore(add(data, 0x44), amount)\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n        if (!success) revert SafeTransferFromFailed();\n    }\n\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\n            revert SafeTransferFailed();\n        }\n    }\n\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        forceApprove(token, spender, value);\n    }\n\n    // If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\n            if (!_makeCall(token, token.approve.selector, spender, 0) ||\n                !_makeCall(token, token.approve.selector, spender, value))\n            {\n                revert ForceApproveFailed();\n            }\n        }\n    }\n\n    \n\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\n        forceApprove(token, spender, allowance + value);\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\n        forceApprove(token, spender, allowance - value);\n    }\n\n    function safePermit(IERC20 token, bytes calldata permit) internal {\n        bool success;\n        if (permit.length == 32 * 7) {\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\n        } else if (permit.length == 32 * 8) {\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\n        } else {\n            revert SafePermitBadLength();\n        }\n        if (!success) RevertReasonForwarder.reRevert();\n    }\n\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns(bool success) {\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), to)\n            mstore(add(data, 0x24), amount)\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool success) {\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let len := add(4, args.length)\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            calldatacopy(add(data, 0x04), args.offset, args.length)\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n}\n\n\n","keccak256":"0x6fb5661c7d83a1394d05cd20d69ede4337ae8e7f68db40b4548f0656d112ed17","license":"MIT"},"contracts/8/libraries/SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary SafeMath {\n    uint256 constant WAD = 10**18;\n    uint256 constant RAY = 10**27;\n\n    function wad() public pure returns (uint256) {\n        return WAD;\n    }\n\n    function ray() public pure returns (uint256) {\n        return RAY;\n    }\n\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n\n        return c;\n    }\n\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, \"SafeMath: subtraction overflow\");\n    }\n\n    function sub(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        uint256 c = a - b;\n\n        return c;\n    }\n\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) {\n            return 0;\n        }\n\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n\n        return c;\n    }\n\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(a, b, \"SafeMath: division by zero\");\n    }\n\n    function div(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        // Solidity only automatically asserts when dividing by 0\n        require(b > 0, errorMessage);\n        uint256 c = a / b;\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n        return c;\n    }\n\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mod(a, b, \"SafeMath: modulo by zero\");\n    }\n\n    function mod(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        require(b != 0, errorMessage);\n        return a % b;\n    }\n\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a <= b ? a : b;\n    }\n\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    function sqrt(uint256 a) internal pure returns (uint256 b) {\n        if (a > 3) {\n            b = a;\n            uint256 x = a / 2 + 1;\n            while (x < b) {\n                b = x;\n                x = (a / x + x) / 2;\n            }\n        } else if (a != 0) {\n            b = 1;\n        }\n    }\n\n    function wmul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mul(a, b) / WAD;\n    }\n\n    function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, b), WAD / 2) / WAD;\n    }\n\n    function rmul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mul(a, b) / RAY;\n    }\n\n    function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, b), RAY / 2) / RAY;\n    }\n\n    function wdiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(mul(a, WAD), b);\n    }\n\n    function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, WAD), b / 2) / b;\n    }\n\n    function rdiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(mul(a, RAY), b);\n    }\n\n    function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, RAY), b / 2) / b;\n    }\n\n    function wpow(uint256 x, uint256 n) internal pure returns (uint256) {\n        uint256 result = WAD;\n        while (n > 0) {\n            if (n % 2 != 0) {\n                result = wmul(result, x);\n            }\n            x = wmul(x, x);\n            n /= 2;\n        }\n        return result;\n    }\n\n    function rpow(uint256 x, uint256 n) internal pure returns (uint256) {\n        uint256 result = RAY;\n        while (n > 0) {\n            if (n % 2 != 0) {\n                result = rmul(result, x);\n            }\n            x = rmul(x, x);\n            n /= 2;\n        }\n        return result;\n    }\n\n    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 quotient = div(a, b);\n        uint256 remainder = a - quotient * b;\n        if (remainder > 0) {\n            return quotient + 1;\n        } else {\n            return quotient;\n        }\n    }\n}\n","keccak256":"0x71d16bf7d3101044d077f24e517d09d31d482830e807dc3b27c24926b0367b9f","license":"MIT"}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_int128":{"label":"int128","encoding":"inplace","numberOfBytes":"16"},"t_uint96":{"label":"uint96","encoding":"inplace","numberOfBytes":"12"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_struct(PoolKey)881_storage":{"label":"struct PoolKey","members":[{"slot":"0","type":"t_address","astId":876,"label":"token0","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"1","type":"t_address","astId":878,"label":"token1","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"2","type":"t_bytes32","astId":880,"label":"config","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"}],"encoding":"inplace","numberOfBytes":"96"},"t_struct(SwapParams)52_storage":{"label":"struct EkuboV3Adapter.SwapParams","members":[{"slot":"0","type":"t_address","astId":42,"label":"to","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"1","type":"t_struct(PoolKey)881_storage","astId":45,"label":"poolKey","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"4","type":"t_int128","astId":47,"label":"amount","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"4","type":"t_bool","astId":49,"label":"isToken1","offset":16,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"4","type":"t_uint96","astId":51,"label":"sqrtRatioLimit","offset":17,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"}],"encoding":"inplace","numberOfBytes":"160"}},"storage":[{"slot":"0","type":"t_struct(SwapParams)52_storage","astId":55,"label":"_swapParams","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"Adapter for Ekubo V3 Protocol","methods":{"locked_6416899205(uint256)":{"notice":"Lock callback - function name is mined for gas optimization"}},"version":1},"devdoc":{"kind":"dev","title":"EkuboV3Adapter","methods":{},"version":1},"sourceIds":{"contracts/8/interfaces/IWETH.sol":{"id":6},"contracts/8/interfaces/IERC20.sol":{"id":3},"contracts/8/libraries/Address.sol":{"id":7},"contracts/8/libraries/SafeMath.sol":{"id":10},"contracts/8/interfaces/IAdapter.sol":{"id":1},"contracts/8/interfaces/IEkuboV3.sol":{"id":5},"contracts/8/libraries/SafeERC20.sol":{"id":9},"contracts/8/adapter/EkuboV3Adapter.sol":{"id":0},"contracts/8/interfaces/IERC20Permit.sol":{"id":4},"contracts/8/interfaces/IDaiLikePermit.sol":{"id":2},"contracts/8/libraries/RevertReasonForwarder.sol":{"id":8}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/8/interfaces/IWETH.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IWETH {\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address account) external view returns (uint256);\n\n    function transfer(address recipient, uint256 amount)\n        external\n        returns (bool);\n\n    function allowance(address owner, address spender)\n        external\n        view\n        returns (uint256);\n\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    function transferFrom(\n        address src,\n        address dst,\n        uint256 wad\n    ) external returns (bool);\n\n    function deposit() external payable;\n\n    function withdraw(uint256 wad) external;\n}\n"},"contracts/8/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    event Approval(\n        address indexed owner,\n        address indexed spender,\n        uint256 value\n    );\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function name() external view returns (string memory);\n\n    function symbol() external view returns (string memory);\n\n    function decimals() external view returns (uint8);\n\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address owner) external view returns (uint256);\n\n    function allowance(address owner, address spender)\n        external\n        view\n        returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 value\n    ) external returns (bool);\n}\n"},"contracts/8/libraries/Address.sol":{"content":"/// SPDX-License-Identifier: MIT\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        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\n        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\n        // for accounts without code, i.e. `keccak256('')`\n        bytes32 codehash;\n        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            codehash := extcodehash(account)\n        }\n        return (codehash != accountHash && codehash != 0x0);\n    }\n\n    /**\n     * @dev Converts an `address` into `address payable`. Note that this is\n     * simply a type cast: the actual underlying value is not changed.\n     *\n     * _Available since v2.4.0._\n     */\n    function toPayable(address account)\n        internal\n        pure\n        returns (address payable)\n    {\n        return payable(account);\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     * _Available since v2.4.0._\n     */\n    function sendValue(address recipient, uint256 amount) internal {\n        require(\n            address(this).balance >= amount,\n            \"Address: insufficient balance\"\n        );\n\n        // solhint-disable-next-line avoid-call-value\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(\n            success,\n            \"Address: unable to send value, recipient may have reverted\"\n        );\n    }\n}\n"},"contracts/8/libraries/SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary SafeMath {\n    uint256 constant WAD = 10**18;\n    uint256 constant RAY = 10**27;\n\n    function wad() public pure returns (uint256) {\n        return WAD;\n    }\n\n    function ray() public pure returns (uint256) {\n        return RAY;\n    }\n\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n\n        return c;\n    }\n\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, \"SafeMath: subtraction overflow\");\n    }\n\n    function sub(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        uint256 c = a - b;\n\n        return c;\n    }\n\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) {\n            return 0;\n        }\n\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n\n        return c;\n    }\n\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(a, b, \"SafeMath: division by zero\");\n    }\n\n    function div(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        // Solidity only automatically asserts when dividing by 0\n        require(b > 0, errorMessage);\n        uint256 c = a / b;\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n        return c;\n    }\n\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mod(a, b, \"SafeMath: modulo by zero\");\n    }\n\n    function mod(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        require(b != 0, errorMessage);\n        return a % b;\n    }\n\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a <= b ? a : b;\n    }\n\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    function sqrt(uint256 a) internal pure returns (uint256 b) {\n        if (a > 3) {\n            b = a;\n            uint256 x = a / 2 + 1;\n            while (x < b) {\n                b = x;\n                x = (a / x + x) / 2;\n            }\n        } else if (a != 0) {\n            b = 1;\n        }\n    }\n\n    function wmul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mul(a, b) / WAD;\n    }\n\n    function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, b), WAD / 2) / WAD;\n    }\n\n    function rmul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mul(a, b) / RAY;\n    }\n\n    function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, b), RAY / 2) / RAY;\n    }\n\n    function wdiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(mul(a, WAD), b);\n    }\n\n    function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, WAD), b / 2) / b;\n    }\n\n    function rdiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(mul(a, RAY), b);\n    }\n\n    function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(mul(a, RAY), b / 2) / b;\n    }\n\n    function wpow(uint256 x, uint256 n) internal pure returns (uint256) {\n        uint256 result = WAD;\n        while (n > 0) {\n            if (n % 2 != 0) {\n                result = wmul(result, x);\n            }\n            x = wmul(x, x);\n            n /= 2;\n        }\n        return result;\n    }\n\n    function rpow(uint256 x, uint256 n) internal pure returns (uint256) {\n        uint256 result = RAY;\n        while (n > 0) {\n            if (n % 2 != 0) {\n                result = rmul(result, x);\n            }\n            x = rmul(x, x);\n            n /= 2;\n        }\n        return result;\n    }\n\n    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 quotient = div(a, b);\n        uint256 remainder = a - quotient * b;\n        if (remainder > 0) {\n            return quotient + 1;\n        } else {\n            return quotient;\n        }\n    }\n}\n"},"contracts/8/interfaces/IAdapter.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IAdapter {\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory data\n    ) external;\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory data\n    ) external;\n}\n"},"contracts/8/interfaces/IEkuboV3.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @notice Pool key structure for Ekubo V3\nstruct PoolKey {\n    address token0;\n    address token1;\n    bytes32 config;  // packed: extension(160) | fee(64) | poolTypeConfig(32)\n    // poolTypeConfig: bit31=isConcentrated, if concentrated: bits30-0=tickSpacing\n    //                 if stableswap: bits30-24=amplification, bits23-0=centerTick\n}\n\nlibrary PoolKeyLibrary {\n    function toPoolId(PoolKey memory self) internal pure returns (bytes32) {\n        return keccak256(abi.encode(self.token0, self.token1, self.config));\n    }\n}\n\n/// @notice Ekubo V3 Core interface\ninterface IEkuboV3Core {\n    /// @notice Acquire lock for flash accounting\n    function lock() external;\n\n    /// @notice Swap function - function name is mined to have selector = 0\n    function swap_6269342730(\n        address token0,\n        address token1,\n        bytes32 config,\n        bytes32 swapParams\n    ) external payable returns (bytes32 balanceUpdate, bytes32 poolState);\n\n    /// @notice Start payment tracking for a token\n    function startPayments() external;\n\n    /// @notice Complete payment tracking for a token  \n    function completePayments() external;\n\n    /// @notice Withdraw tokens from the core\n    function withdraw() external;\n}\n\n"},"contracts/8/libraries/SafeERC20.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./SafeMath.sol\";\nimport \"./Address.sol\";\nimport \"./RevertReasonForwarder.sol\";\nimport \"../interfaces/IERC20.sol\";\nimport \"../interfaces/IERC20Permit.sol\";\nimport \"../interfaces/IDaiLikePermit.sol\";\n\n// File @1inch/solidity-utils/contracts/libraries/SafeERC20.sol@v2.1.1\n\nlibrary SafeERC20 {\n    error SafeTransferFailed();\n    error SafeTransferFromFailed();\n    error ForceApproveFailed();\n    error SafeIncreaseAllowanceFailed();\n    error SafeDecreaseAllowanceFailed();\n    error SafePermitBadLength();\n\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\n        bytes4 selector = token.transferFrom.selector;\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), from)\n            mstore(add(data, 0x24), to)\n            mstore(add(data, 0x44), amount)\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n        if (!success) revert SafeTransferFromFailed();\n    }\n\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\n            revert SafeTransferFailed();\n        }\n    }\n\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        forceApprove(token, spender, value);\n    }\n\n    // If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\n            if (!_makeCall(token, token.approve.selector, spender, 0) ||\n                !_makeCall(token, token.approve.selector, spender, value))\n            {\n                revert ForceApproveFailed();\n            }\n        }\n    }\n\n    \n\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\n        forceApprove(token, spender, allowance + value);\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\n        forceApprove(token, spender, allowance - value);\n    }\n\n    function safePermit(IERC20 token, bytes calldata permit) internal {\n        bool success;\n        if (permit.length == 32 * 7) {\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\n        } else if (permit.length == 32 * 8) {\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\n        } else {\n            revert SafePermitBadLength();\n        }\n        if (!success) RevertReasonForwarder.reRevert();\n    }\n\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns(bool success) {\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), to)\n            mstore(add(data, 0x24), amount)\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool success) {\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let len := add(4, args.length)\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            calldatacopy(add(data, 0x04), args.offset, args.length)\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n}\n\n\n"},"contracts/8/adapter/EkuboV3Adapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\nimport \"../interfaces/IAdapter.sol\";\nimport \"../interfaces/IEkuboV3.sol\";\nimport \"../interfaces/IERC20.sol\";\nimport \"../libraries/SafeERC20.sol\";\nimport \"../interfaces/IWETH.sol\";\n\nusing PoolKeyLibrary for PoolKey;\n\n/// @title EkuboV3Adapter\n/// @notice Adapter for Ekubo V3 Protocol\ncontract EkuboV3Adapter is IAdapter {\n    address public immutable WETH;\n    address public immutable EKUBO_CORE;\n\n    address internal constant ETH = address(0);\n\n    uint96 constant MIN_SQRT_RATIO_RAW = 4611797791050542631 + 1;\n    uint96 constant MAX_SQRT_RATIO_RAW = 79227682466138141934206691491 - 1;\n\n    uint256 internal constant ORIGIN_PAYER =\n        0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\n    uint256 constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\n    struct SwapParams {\n        address to;\n        PoolKey poolKey;\n        int128 amount;\n        bool isToken1;\n        uint96 sqrtRatioLimit;\n    }\n\n    SwapParams private _swapParams;\n\n    constructor(address payable weth, address ekuboCore) {\n        WETH = weth;\n        EKUBO_CORE = ekuboCore;\n    }\n\n    function _ekuboSwap(\n        address to,\n        address,\n        bytes memory moreInfo,\n        uint256 payerOrigin\n    ) private {\n        (PoolKey memory poolKey, bool isToken1) = abi.decode(\n            moreInfo,\n            (PoolKey, bool)\n        );\n\n        address fromToken = isToken1 ? poolKey.token1 : poolKey.token0;\n\n        uint256 inputBalance;\n        if (fromToken == ETH) {\n            inputBalance = IERC20(WETH).balanceOf(address(this));\n        } else {\n            inputBalance = IERC20(fromToken).balanceOf(address(this));\n        }\n\n        require(inputBalance > 0, \"No tokens to swap\");\n        int128 swapAmount = int128(uint128(inputBalance));\n\n        uint96 sqrtRatioLimit = isPriceIncreasing(swapAmount, isToken1)\n            ? MAX_SQRT_RATIO_RAW\n            : MIN_SQRT_RATIO_RAW;\n\n        _swapParams = SwapParams({\n            to: to,\n            poolKey: poolKey,\n            amount: swapAmount,\n            isToken1: isToken1,\n            sqrtRatioLimit: sqrtRatioLimit\n        });\n\n        // lock() -> locked_6416899205() callback\n        IEkuboV3Core(EKUBO_CORE).lock();\n\n        delete _swapParams;\n\n        // Return back excess fromTokens\n        address _payerOrigin;\n        if ((payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            _payerOrigin = address(uint160(uint256(payerOrigin) & ADDRESS_MASK));\n        }\n\n        if (_payerOrigin != address(0)) {\n            if (fromToken == ETH && address(this).balance > 0) {\n                (bool success, ) = _payerOrigin.call{\n                    value: address(this).balance\n                }(\"\");\n                require(success, \"Transfer to payerOrigin failed\");\n            } else if (fromToken != ETH) {\n                uint256 leftBalance = IERC20(fromToken).balanceOf(\n                    address(this)\n                );\n                if (leftBalance > 0) {\n                    SafeERC20.safeTransfer(IERC20(fromToken), _payerOrigin, leftBalance);\n                }\n            }\n        }\n    }\n\n    /// @notice Lock callback - function name is mined for gas optimization\n    function locked_6416899205(uint256 /* id */) external returns (bytes memory) {\n        require(msg.sender == EKUBO_CORE, \"Only Ekubo Core can call\");\n\n        SwapParams memory params = _swapParams;\n\n        // Pack SwapParameters: sqrtRatioLimit(96) | amount(128) | isToken1(1) | skipAhead(31)\n        bytes32 swapParams = bytes32(\n            (uint256(params.sqrtRatioLimit) << 160) |\n            (uint256(uint128(params.amount)) << 32) |\n            (params.isToken1 ? (1 << 31) : 0)\n        );\n\n        // Call swap_6269342730 with selector = 0 (mined function)\n        // Must use assembly because Solidity would generate wrong selector\n        bytes32 balanceUpdate;\n        address core = EKUBO_CORE;\n        address token0 = params.poolKey.token0;\n        address token1 = params.poolKey.token1;\n        bytes32 config = params.poolKey.config;\n        \n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            \n            // selector = 0x00000000 (4 zero bytes)\n            mstore(ptr, 0)\n            \n            // token0 (32 bytes, ABI encoded)\n            mstore(add(ptr, 4), token0)\n            // token1 (32 bytes, ABI encoded)\n            mstore(add(ptr, 36), token1)\n            // config (32 bytes)\n            mstore(add(ptr, 68), config)\n            // swapParams (32 bytes)\n            mstore(add(ptr, 100), swapParams)\n            \n            // Call: 4 + 32*4 = 132 bytes, expect 64 bytes return\n            let success := call(gas(), core, 0, ptr, 132, ptr, 64)\n            \n            if iszero(success) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n            \n            // First 32 bytes of return is balanceUpdate\n            balanceUpdate := mload(ptr)\n        }\n\n        // Decode BalanceDelta (packed as: delta0 << 128 | delta1)\n        int128 delta0 = int128(int256(uint256(balanceUpdate) >> 128));\n        int128 delta1 = int128(int256(uint256(balanceUpdate)));\n\n        address fromToken = params.isToken1\n            ? params.poolKey.token1\n            : params.poolKey.token0;\n\n        // Handle debt (settle input)\n        if (delta0 > 0) {\n            if (fromToken == ETH) {\n                // Withdraw all WETH to ETH, but only transfer the exact debt amount\n                uint256 wethBalance = IERC20(WETH).balanceOf(address(this));\n                IWETH(WETH).withdraw(wethBalance);\n\n                // Only send the exact debt amount\n                (bool success, ) = EKUBO_CORE.call{value: uint128(delta0)}(\"\");\n                require(success, \"Transfer ETH debt to Ekubo Core failed\");\n            } else {\n                // ERC20: use startPayments -> transfer -> completePayments\n                _startPayments(params.poolKey.token0);\n                SafeERC20.safeTransfer(IERC20(params.poolKey.token0), EKUBO_CORE, uint128(delta0));\n                _completePayments(params.poolKey.token0);\n            }\n        }\n\n        if (delta1 > 0) {\n            _startPayments(params.poolKey.token1);\n            SafeERC20.safeTransfer(IERC20(params.poolKey.token1), EKUBO_CORE, uint128(delta1));\n            _completePayments(params.poolKey.token1);\n        }\n\n        // Withdraw output tokens\n        address outputToken = params.isToken1\n            ? params.poolKey.token0\n            : params.poolKey.token1;\n        uint128 outputAmount = uint128(params.isToken1 ? -delta0 : -delta1);\n\n        if (outputAmount > 0) {\n            if (outputToken == ETH) {\n                _withdraw(outputToken, address(this), outputAmount);\n                IWETH(WETH).deposit{value: outputAmount}();\n                SafeERC20.safeTransfer(IERC20(WETH), params.to, outputAmount);\n            } else {\n                _withdraw(outputToken, params.to, outputAmount);\n            }\n        }\n\n        return \"\";\n    }\n\n    /// @notice Start payment tracking for a token\n    function _startPayments(address token) internal {\n        (bool success, ) = EKUBO_CORE.call(\n            abi.encodeWithSelector(0xf9b6a796, token)\n        );\n        require(success, \"startPayments failed\");\n    }\n\n    /// @notice Complete payment tracking for a token\n    function _completePayments(address token) internal {\n        (bool success, ) = EKUBO_CORE.call(\n            abi.encodeWithSelector(0x12e103f1, token)\n        );\n        require(success, \"completePayments failed\");\n    }\n\n    /// @notice Call withdraw with packed calldata\n    function _withdraw(address token, address recipient, uint128 amount) internal {\n        address core = EKUBO_CORE;\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // selector: 0x3ccfd60b\n            mstore(ptr, shl(224, 0x3ccfd60b))\n            mstore(add(ptr, 4), shl(96, token))\n            mstore(add(ptr, 24), shl(96, recipient))\n            mstore(add(ptr, 44), shl(128, amount))\n            if iszero(call(gas(), core, 0, ptr, 60, 0, 0)) {\n                revert(0, 0)\n            }\n        }\n    }\n\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        uint256 payerOrigin;\n        assembly {\n            let size := calldatasize()\n            payerOrigin := calldataload(sub(size, 32))\n        }\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\n    }\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        uint256 payerOrigin;\n        assembly {\n            let size := calldatasize()\n            payerOrigin := calldataload(sub(size, 32))\n        }\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\n    }\n\n    function isPriceIncreasing(\n        int128 amount,\n        bool isToken1\n    ) private pure returns (bool increasing) {\n        assembly (\"memory-safe\") {\n            increasing := xor(isToken1, slt(amount, 0))\n        }\n    }\n\n    receive() external payable {}\n}\n"},"contracts/8/interfaces/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,\n     * given `owner`'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"contracts/8/interfaces/IDaiLikePermit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Interface for DAI-style permits\ninterface IDaiLikePermit {\n    function permit(\n        address holder,\n        address spender,\n        uint256 nonce,\n        uint256 expiry,\n        bool allowed,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n"},"contracts/8/libraries/RevertReasonForwarder.sol":{"content":"/// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nlibrary RevertReasonForwarder {\n    function reRevert() internal pure {\n        // bubble up revert reason from latest external call\n        /// @solidity memory-safe-assembly\n        assembly { // solhint-disable-line no-inline-assembly\n            let ptr := mload(0x40)\n            returndatacopy(ptr, 0, returndatasize())\n            revert(ptr, returndatasize())\n        }\n    }\n}"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"runs":1,"enabled":true},"evmVersion":"london","remappings":["@ensdomains/=node_modules/@ensdomains/","@openzeppelin/=node_modules/@openzeppelin/","ds-test/=lib/forge-std/lib/ds-test/src/","eth-gas-reporter/=node_modules/eth-gas-reporter/","forge-std/=lib/forge-std/src/","hardhat/=node_modules/hardhat/","@dex/=contracts/8/","@uniswap/=node_modules/@uniswap/","@zetachain/=node_modules/@zetachain/"]}},"stdJsonOutput":{"sources":{"contracts/8/interfaces/IWETH.sol":{"id":6},"contracts/8/interfaces/IERC20.sol":{"id":3},"contracts/8/libraries/Address.sol":{"id":7},"contracts/8/libraries/SafeMath.sol":{"id":10},"contracts/8/interfaces/IAdapter.sol":{"id":1},"contracts/8/interfaces/IEkuboV3.sol":{"id":5},"contracts/8/libraries/SafeERC20.sol":{"id":9},"contracts/8/adapter/EkuboV3Adapter.sol":{"id":0},"contracts/8/interfaces/IERC20Permit.sol":{"id":4},"contracts/8/interfaces/IDaiLikePermit.sol":{"id":2},"contracts/8/libraries/RevertReasonForwarder.sol":{"id":8}},"contracts":{"contracts/8/adapter/EkuboV3Adapter.sol":{"EkuboV3Adapter":{"abi":[{"type":"constructor","inputs":[{"name":"weth","type":"address","internalType":"address payable"},{"name":"ekuboCore","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"SafeTransferFailed","type":"error","inputs":[]},{"name":"EKUBO_CORE","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"WETH","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"locked_6416899205","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"sellBase","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"sellQuote","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"weth\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"ekuboCore\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"SafeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EKUBO_CORE\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WETH\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"locked_6416899205\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"moreInfo\",\"type\":\"bytes\"}],\"name\":\"sellBase\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"moreInfo\",\"type\":\"bytes\"}],\"name\":\"sellQuote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"title\":\"EkuboV3Adapter\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"locked_6416899205(uint256)\":{\"notice\":\"Lock callback - function name is mined for gas optimization\"}},\"notice\":\"Adapter for Ekubo V3 Protocol\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/8/adapter/EkuboV3Adapter.sol\":\"EkuboV3Adapter\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1},\"remappings\":[\":@dex/=contracts/8/\",\":@ensdomains/=node_modules/@ensdomains/\",\":@openzeppelin/=node_modules/@openzeppelin/\",\":@uniswap/=node_modules/@uniswap/\",\":@zetachain/=node_modules/@zetachain/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":eth-gas-reporter/=node_modules/eth-gas-reporter/\",\":forge-std/=lib/forge-std/src/\",\":hardhat/=node_modules/hardhat/\"]},\"sources\":{\"contracts/8/adapter/EkuboV3Adapter.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma abicoder v2;\\n\\nimport \\\"../interfaces/IAdapter.sol\\\";\\nimport \\\"../interfaces/IEkuboV3.sol\\\";\\nimport \\\"../interfaces/IERC20.sol\\\";\\nimport \\\"../libraries/SafeERC20.sol\\\";\\nimport \\\"../interfaces/IWETH.sol\\\";\\n\\nusing PoolKeyLibrary for PoolKey;\\n\\n/// @title EkuboV3Adapter\\n/// @notice Adapter for Ekubo V3 Protocol\\ncontract EkuboV3Adapter is IAdapter {\\n    address public immutable WETH;\\n    address public immutable EKUBO_CORE;\\n\\n    address internal constant ETH = address(0);\\n\\n    uint96 constant MIN_SQRT_RATIO_RAW = 4611797791050542631 + 1;\\n    uint96 constant MAX_SQRT_RATIO_RAW = 79227682466138141934206691491 - 1;\\n\\n    uint256 internal constant ORIGIN_PAYER =\\n        0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\\n    uint256 constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\\n\\n    struct SwapParams {\\n        address to;\\n        PoolKey poolKey;\\n        int128 amount;\\n        bool isToken1;\\n        uint96 sqrtRatioLimit;\\n    }\\n\\n    SwapParams private _swapParams;\\n\\n    constructor(address payable weth, address ekuboCore) {\\n        WETH = weth;\\n        EKUBO_CORE = ekuboCore;\\n    }\\n\\n    function _ekuboSwap(\\n        address to,\\n        address,\\n        bytes memory moreInfo,\\n        uint256 payerOrigin\\n    ) private {\\n        (PoolKey memory poolKey, bool isToken1) = abi.decode(\\n            moreInfo,\\n            (PoolKey, bool)\\n        );\\n\\n        address fromToken = isToken1 ? poolKey.token1 : poolKey.token0;\\n\\n        uint256 inputBalance;\\n        if (fromToken == ETH) {\\n            inputBalance = IERC20(WETH).balanceOf(address(this));\\n        } else {\\n            inputBalance = IERC20(fromToken).balanceOf(address(this));\\n        }\\n\\n        require(inputBalance > 0, \\\"No tokens to swap\\\");\\n        int128 swapAmount = int128(uint128(inputBalance));\\n\\n        uint96 sqrtRatioLimit = isPriceIncreasing(swapAmount, isToken1)\\n            ? MAX_SQRT_RATIO_RAW\\n            : MIN_SQRT_RATIO_RAW;\\n\\n        _swapParams = SwapParams({\\n            to: to,\\n            poolKey: poolKey,\\n            amount: swapAmount,\\n            isToken1: isToken1,\\n            sqrtRatioLimit: sqrtRatioLimit\\n        });\\n\\n        // lock() -> locked_6416899205() callback\\n        IEkuboV3Core(EKUBO_CORE).lock();\\n\\n        delete _swapParams;\\n\\n        // Return back excess fromTokens\\n        address _payerOrigin;\\n        if ((payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\\n            _payerOrigin = address(uint160(uint256(payerOrigin) & ADDRESS_MASK));\\n        }\\n\\n        if (_payerOrigin != address(0)) {\\n            if (fromToken == ETH && address(this).balance > 0) {\\n                (bool success, ) = _payerOrigin.call{\\n                    value: address(this).balance\\n                }(\\\"\\\");\\n                require(success, \\\"Transfer to payerOrigin failed\\\");\\n            } else if (fromToken != ETH) {\\n                uint256 leftBalance = IERC20(fromToken).balanceOf(\\n                    address(this)\\n                );\\n                if (leftBalance > 0) {\\n                    SafeERC20.safeTransfer(IERC20(fromToken), _payerOrigin, leftBalance);\\n                }\\n            }\\n        }\\n    }\\n\\n    /// @notice Lock callback - function name is mined for gas optimization\\n    function locked_6416899205(uint256 /* id */) external returns (bytes memory) {\\n        require(msg.sender == EKUBO_CORE, \\\"Only Ekubo Core can call\\\");\\n\\n        SwapParams memory params = _swapParams;\\n\\n        // Pack SwapParameters: sqrtRatioLimit(96) | amount(128) | isToken1(1) | skipAhead(31)\\n        bytes32 swapParams = bytes32(\\n            (uint256(params.sqrtRatioLimit) << 160) |\\n            (uint256(uint128(params.amount)) << 32) |\\n            (params.isToken1 ? (1 << 31) : 0)\\n        );\\n\\n        // Call swap_6269342730 with selector = 0 (mined function)\\n        // Must use assembly because Solidity would generate wrong selector\\n        bytes32 balanceUpdate;\\n        address core = EKUBO_CORE;\\n        address token0 = params.poolKey.token0;\\n        address token1 = params.poolKey.token1;\\n        bytes32 config = params.poolKey.config;\\n        \\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            \\n            // selector = 0x00000000 (4 zero bytes)\\n            mstore(ptr, 0)\\n            \\n            // token0 (32 bytes, ABI encoded)\\n            mstore(add(ptr, 4), token0)\\n            // token1 (32 bytes, ABI encoded)\\n            mstore(add(ptr, 36), token1)\\n            // config (32 bytes)\\n            mstore(add(ptr, 68), config)\\n            // swapParams (32 bytes)\\n            mstore(add(ptr, 100), swapParams)\\n            \\n            // Call: 4 + 32*4 = 132 bytes, expect 64 bytes return\\n            let success := call(gas(), core, 0, ptr, 132, ptr, 64)\\n            \\n            if iszero(success) {\\n                returndatacopy(0, 0, returndatasize())\\n                revert(0, returndatasize())\\n            }\\n            \\n            // First 32 bytes of return is balanceUpdate\\n            balanceUpdate := mload(ptr)\\n        }\\n\\n        // Decode BalanceDelta (packed as: delta0 << 128 | delta1)\\n        int128 delta0 = int128(int256(uint256(balanceUpdate) >> 128));\\n        int128 delta1 = int128(int256(uint256(balanceUpdate)));\\n\\n        address fromToken = params.isToken1\\n            ? params.poolKey.token1\\n            : params.poolKey.token0;\\n\\n        // Handle debt (settle input)\\n        if (delta0 > 0) {\\n            if (fromToken == ETH) {\\n                // Withdraw all WETH to ETH, but only transfer the exact debt amount\\n                uint256 wethBalance = IERC20(WETH).balanceOf(address(this));\\n                IWETH(WETH).withdraw(wethBalance);\\n\\n                // Only send the exact debt amount\\n                (bool success, ) = EKUBO_CORE.call{value: uint128(delta0)}(\\\"\\\");\\n                require(success, \\\"Transfer ETH debt to Ekubo Core failed\\\");\\n            } else {\\n                // ERC20: use startPayments -> transfer -> completePayments\\n                _startPayments(params.poolKey.token0);\\n                SafeERC20.safeTransfer(IERC20(params.poolKey.token0), EKUBO_CORE, uint128(delta0));\\n                _completePayments(params.poolKey.token0);\\n            }\\n        }\\n\\n        if (delta1 > 0) {\\n            _startPayments(params.poolKey.token1);\\n            SafeERC20.safeTransfer(IERC20(params.poolKey.token1), EKUBO_CORE, uint128(delta1));\\n            _completePayments(params.poolKey.token1);\\n        }\\n\\n        // Withdraw output tokens\\n        address outputToken = params.isToken1\\n            ? params.poolKey.token0\\n            : params.poolKey.token1;\\n        uint128 outputAmount = uint128(params.isToken1 ? -delta0 : -delta1);\\n\\n        if (outputAmount > 0) {\\n            if (outputToken == ETH) {\\n                _withdraw(outputToken, address(this), outputAmount);\\n                IWETH(WETH).deposit{value: outputAmount}();\\n                SafeERC20.safeTransfer(IERC20(WETH), params.to, outputAmount);\\n            } else {\\n                _withdraw(outputToken, params.to, outputAmount);\\n            }\\n        }\\n\\n        return \\\"\\\";\\n    }\\n\\n    /// @notice Start payment tracking for a token\\n    function _startPayments(address token) internal {\\n        (bool success, ) = EKUBO_CORE.call(\\n            abi.encodeWithSelector(0xf9b6a796, token)\\n        );\\n        require(success, \\\"startPayments failed\\\");\\n    }\\n\\n    /// @notice Complete payment tracking for a token\\n    function _completePayments(address token) internal {\\n        (bool success, ) = EKUBO_CORE.call(\\n            abi.encodeWithSelector(0x12e103f1, token)\\n        );\\n        require(success, \\\"completePayments failed\\\");\\n    }\\n\\n    /// @notice Call withdraw with packed calldata\\n    function _withdraw(address token, address recipient, uint128 amount) internal {\\n        address core = EKUBO_CORE;\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // selector: 0x3ccfd60b\\n            mstore(ptr, shl(224, 0x3ccfd60b))\\n            mstore(add(ptr, 4), shl(96, token))\\n            mstore(add(ptr, 24), shl(96, recipient))\\n            mstore(add(ptr, 44), shl(128, amount))\\n            if iszero(call(gas(), core, 0, ptr, 60, 0, 0)) {\\n                revert(0, 0)\\n            }\\n        }\\n    }\\n\\n    function sellBase(\\n        address to,\\n        address pool,\\n        bytes memory moreInfo\\n    ) external override {\\n        uint256 payerOrigin;\\n        assembly {\\n            let size := calldatasize()\\n            payerOrigin := calldataload(sub(size, 32))\\n        }\\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\\n    }\\n\\n    function sellQuote(\\n        address to,\\n        address pool,\\n        bytes memory moreInfo\\n    ) external override {\\n        uint256 payerOrigin;\\n        assembly {\\n            let size := calldatasize()\\n            payerOrigin := calldataload(sub(size, 32))\\n        }\\n        _ekuboSwap(to, pool, moreInfo, payerOrigin);\\n    }\\n\\n    function isPriceIncreasing(\\n        int128 amount,\\n        bool isToken1\\n    ) private pure returns (bool increasing) {\\n        assembly (\\\"memory-safe\\\") {\\n            increasing := xor(isToken1, slt(amount, 0))\\n        }\\n    }\\n\\n    receive() external payable {}\\n}\\n\",\"keccak256\":\"0x4d77a59b2b6c787f264ca52bab90e3f4d15ef25e338261ede23d7a019616d4e4\",\"license\":\"MIT\"},\"contracts/8/interfaces/IAdapter.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma abicoder v2;\\n\\ninterface IAdapter {\\n    function sellBase(\\n        address to,\\n        address pool,\\n        bytes memory data\\n    ) external;\\n\\n    function sellQuote(\\n        address to,\\n        address pool,\\n        bytes memory data\\n    ) external;\\n}\\n\",\"keccak256\":\"0x8861a0548ae3a9b7467c3eb5fcd4c04bce00d58d2cb4eaedd520cf666989fc69\",\"license\":\"MIT\"},\"contracts/8/interfaces/IDaiLikePermit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @title Interface for DAI-style permits\\ninterface IDaiLikePermit {\\n    function permit(\\n        address holder,\\n        address spender,\\n        uint256 nonce,\\n        uint256 expiry,\\n        bool allowed,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n}\\n\",\"keccak256\":\"0x480d32f19e542d9daa222cb703dd091d4eea3b534c45269fd1f04f8ba470cc44\",\"license\":\"MIT\"},\"contracts/8/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IERC20 {\\n    event Approval(\\n        address indexed owner,\\n        address indexed spender,\\n        uint256 value\\n    );\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    function name() external view returns (string memory);\\n\\n    function symbol() external view returns (string memory);\\n\\n    function decimals() external view returns (uint8);\\n\\n    function totalSupply() external view returns (uint256);\\n\\n    function balanceOf(address owner) external view returns (uint256);\\n\\n    function allowance(address owner, address spender)\\n        external\\n        view\\n        returns (uint256);\\n\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 value\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0xc2d4e51a0477ae32fc24b7a10da9bc9f6b0754fee338c1b099e8335b8b2fb18c\",\"license\":\"MIT\"},\"contracts/8/interfaces/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20Permit {\\n    /**\\n     * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,\\n     * given `owner`'s signed approval.\\n     *\\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n     * ordering also apply here.\\n     *\\n     * Emits an {Approval} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `deadline` must be a timestamp in the future.\\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n     * over the EIP712-formatted function arguments.\\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\\n     *\\n     * For more information on the signature format, see the\\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n     * section].\\n     */\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n\\n    /**\\n     * @dev Returns the current nonce for `owner`. This value must be\\n     * included whenever a signature is generated for {permit}.\\n     *\\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n     * prevents a signature from being used multiple times.\\n     */\\n    function nonces(address owner) external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x25ca4efda5b398358811f84a4b914a8f1f1cc0522870d5ac166543209220900e\",\"license\":\"MIT\"},\"contracts/8/interfaces/IEkuboV3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @notice Pool key structure for Ekubo V3\\nstruct PoolKey {\\n    address token0;\\n    address token1;\\n    bytes32 config;  // packed: extension(160) | fee(64) | poolTypeConfig(32)\\n    // poolTypeConfig: bit31=isConcentrated, if concentrated: bits30-0=tickSpacing\\n    //                 if stableswap: bits30-24=amplification, bits23-0=centerTick\\n}\\n\\nlibrary PoolKeyLibrary {\\n    function toPoolId(PoolKey memory self) internal pure returns (bytes32) {\\n        return keccak256(abi.encode(self.token0, self.token1, self.config));\\n    }\\n}\\n\\n/// @notice Ekubo V3 Core interface\\ninterface IEkuboV3Core {\\n    /// @notice Acquire lock for flash accounting\\n    function lock() external;\\n\\n    /// @notice Swap function - function name is mined to have selector = 0\\n    function swap_6269342730(\\n        address token0,\\n        address token1,\\n        bytes32 config,\\n        bytes32 swapParams\\n    ) external payable returns (bytes32 balanceUpdate, bytes32 poolState);\\n\\n    /// @notice Start payment tracking for a token\\n    function startPayments() external;\\n\\n    /// @notice Complete payment tracking for a token  \\n    function completePayments() external;\\n\\n    /// @notice Withdraw tokens from the core\\n    function withdraw() external;\\n}\\n\\n\",\"keccak256\":\"0xcf0afa30b783db8c4810444c75bef6694a7bdb35eef1db74b4c3fd3b1c3b3849\",\"license\":\"MIT\"},\"contracts/8/interfaces/IWETH.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma abicoder v2;\\n\\ninterface IWETH {\\n    function totalSupply() external view returns (uint256);\\n\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    function transfer(address recipient, uint256 amount)\\n        external\\n        returns (bool);\\n\\n    function allowance(address owner, address spender)\\n        external\\n        view\\n        returns (uint256);\\n\\n    function approve(address spender, uint256 amount) external returns (bool);\\n\\n    function transferFrom(\\n        address src,\\n        address dst,\\n        uint256 wad\\n    ) external returns (bool);\\n\\n    function deposit() external payable;\\n\\n    function withdraw(uint256 wad) external;\\n}\\n\",\"keccak256\":\"0x7dc79bded17353823f20fb059c19d7d4e17fa726d90fb16e877d80955caedd61\",\"license\":\"MIT\"},\"contracts/8/libraries/Address.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\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        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\\n        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\\n        // for accounts without code, i.e. `keccak256('')`\\n        bytes32 codehash;\\n        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\\n        // solhint-disable-next-line no-inline-assembly\\n        assembly {\\n            codehash := extcodehash(account)\\n        }\\n        return (codehash != accountHash && codehash != 0x0);\\n    }\\n\\n    /**\\n     * @dev Converts an `address` into `address payable`. Note that this is\\n     * simply a type cast: the actual underlying value is not changed.\\n     *\\n     * _Available since v2.4.0._\\n     */\\n    function toPayable(address account)\\n        internal\\n        pure\\n        returns (address payable)\\n    {\\n        return payable(account);\\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     * _Available since v2.4.0._\\n     */\\n    function sendValue(address recipient, uint256 amount) internal {\\n        require(\\n            address(this).balance >= amount,\\n            \\\"Address: insufficient balance\\\"\\n        );\\n\\n        // solhint-disable-next-line avoid-call-value\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(\\n            success,\\n            \\\"Address: unable to send value, recipient may have reverted\\\"\\n        );\\n    }\\n}\\n\",\"keccak256\":\"0x922cf77144f4af34623762e2efd1ea3e9e5f6041638ff4b195322d89b73241eb\",\"license\":\"MIT\"},\"contracts/8/libraries/RevertReasonForwarder.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nlibrary RevertReasonForwarder {\\n    function reRevert() internal pure {\\n        // bubble up revert reason from latest external call\\n        /// @solidity memory-safe-assembly\\n        assembly { // solhint-disable-line no-inline-assembly\\n            let ptr := mload(0x40)\\n            returndatacopy(ptr, 0, returndatasize())\\n            revert(ptr, returndatasize())\\n        }\\n    }\\n}\",\"keccak256\":\"0x12d542c0a07c83175bc927b2ecd77dd9cf9d113e1f6d242a9886920cdc84e004\",\"license\":\"MIT\"},\"contracts/8/libraries/SafeERC20.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./SafeMath.sol\\\";\\nimport \\\"./Address.sol\\\";\\nimport \\\"./RevertReasonForwarder.sol\\\";\\nimport \\\"../interfaces/IERC20.sol\\\";\\nimport \\\"../interfaces/IERC20Permit.sol\\\";\\nimport \\\"../interfaces/IDaiLikePermit.sol\\\";\\n\\n// File @1inch/solidity-utils/contracts/libraries/SafeERC20.sol@v2.1.1\\n\\nlibrary SafeERC20 {\\n    error SafeTransferFailed();\\n    error SafeTransferFromFailed();\\n    error ForceApproveFailed();\\n    error SafeIncreaseAllowanceFailed();\\n    error SafeDecreaseAllowanceFailed();\\n    error SafePermitBadLength();\\n\\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\\n        bytes4 selector = token.transferFrom.selector;\\n        bool success;\\n        /// @solidity memory-safe-assembly\\n        assembly { // solhint-disable-line no-inline-assembly\\n            let data := mload(0x40)\\n\\n            mstore(data, selector)\\n            mstore(add(data, 0x04), from)\\n            mstore(add(data, 0x24), to)\\n            mstore(add(data, 0x44), amount)\\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\\n            if success {\\n                switch returndatasize()\\n                case 0 { success := gt(extcodesize(token), 0) }\\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\\n            }\\n        }\\n        if (!success) revert SafeTransferFromFailed();\\n    }\\n\\n    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\\n            revert SafeTransferFailed();\\n        }\\n    }\\n\\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n        forceApprove(token, spender, value);\\n    }\\n\\n    // If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\\n            if (!_makeCall(token, token.approve.selector, spender, 0) ||\\n                !_makeCall(token, token.approve.selector, spender, value))\\n            {\\n                revert ForceApproveFailed();\\n            }\\n        }\\n    }\\n\\n    \\n\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 allowance = token.allowance(address(this), spender);\\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\\n        forceApprove(token, spender, allowance + value);\\n    }\\n\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 allowance = token.allowance(address(this), spender);\\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\\n        forceApprove(token, spender, allowance - value);\\n    }\\n\\n    function safePermit(IERC20 token, bytes calldata permit) internal {\\n        bool success;\\n        if (permit.length == 32 * 7) {\\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\\n        } else if (permit.length == 32 * 8) {\\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\\n        } else {\\n            revert SafePermitBadLength();\\n        }\\n        if (!success) RevertReasonForwarder.reRevert();\\n    }\\n\\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns(bool success) {\\n        /// @solidity memory-safe-assembly\\n        assembly { // solhint-disable-line no-inline-assembly\\n            let data := mload(0x40)\\n\\n            mstore(data, selector)\\n            mstore(add(data, 0x04), to)\\n            mstore(add(data, 0x24), amount)\\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\\n            if success {\\n                switch returndatasize()\\n                case 0 { success := gt(extcodesize(token), 0) }\\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\\n            }\\n        }\\n    }\\n\\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool success) {\\n        /// @solidity memory-safe-assembly\\n        assembly { // solhint-disable-line no-inline-assembly\\n            let len := add(4, args.length)\\n            let data := mload(0x40)\\n\\n            mstore(data, selector)\\n            calldatacopy(add(data, 0x04), args.offset, args.length)\\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\\n            if success {\\n                switch returndatasize()\\n                case 0 { success := gt(extcodesize(token), 0) }\\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\\n            }\\n        }\\n    }\\n}\\n\\n\\n\",\"keccak256\":\"0x6fb5661c7d83a1394d05cd20d69ede4337ae8e7f68db40b4548f0656d112ed17\",\"license\":\"MIT\"},\"contracts/8/libraries/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nlibrary SafeMath {\\n    uint256 constant WAD = 10**18;\\n    uint256 constant RAY = 10**27;\\n\\n    function wad() public pure returns (uint256) {\\n        return WAD;\\n    }\\n\\n    function ray() public pure returns (uint256) {\\n        return RAY;\\n    }\\n\\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n        uint256 c = a + b;\\n        require(c >= a, \\\"SafeMath: addition overflow\\\");\\n\\n        return c;\\n    }\\n\\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return sub(a, b, \\\"SafeMath: subtraction overflow\\\");\\n    }\\n\\n    function sub(\\n        uint256 a,\\n        uint256 b,\\n        string memory errorMessage\\n    ) internal pure returns (uint256) {\\n        require(b <= a, errorMessage);\\n        uint256 c = a - b;\\n\\n        return c;\\n    }\\n\\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n        // benefit is lost if 'b' is also tested.\\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n        if (a == 0) {\\n            return 0;\\n        }\\n\\n        uint256 c = a * b;\\n        require(c / a == b, \\\"SafeMath: multiplication overflow\\\");\\n\\n        return c;\\n    }\\n\\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return div(a, b, \\\"SafeMath: division by zero\\\");\\n    }\\n\\n    function div(\\n        uint256 a,\\n        uint256 b,\\n        string memory errorMessage\\n    ) internal pure returns (uint256) {\\n        // Solidity only automatically asserts when dividing by 0\\n        require(b > 0, errorMessage);\\n        uint256 c = a / b;\\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\\n\\n        return c;\\n    }\\n\\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return mod(a, b, \\\"SafeMath: modulo by zero\\\");\\n    }\\n\\n    function mod(\\n        uint256 a,\\n        uint256 b,\\n        string memory errorMessage\\n    ) internal pure returns (uint256) {\\n        require(b != 0, errorMessage);\\n        return a % b;\\n    }\\n\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a <= b ? a : b;\\n    }\\n\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a >= b ? a : b;\\n    }\\n\\n    function sqrt(uint256 a) internal pure returns (uint256 b) {\\n        if (a > 3) {\\n            b = a;\\n            uint256 x = a / 2 + 1;\\n            while (x < b) {\\n                b = x;\\n                x = (a / x + x) / 2;\\n            }\\n        } else if (a != 0) {\\n            b = 1;\\n        }\\n    }\\n\\n    function wmul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return mul(a, b) / WAD;\\n    }\\n\\n    function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return add(mul(a, b), WAD / 2) / WAD;\\n    }\\n\\n    function rmul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return mul(a, b) / RAY;\\n    }\\n\\n    function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return add(mul(a, b), RAY / 2) / RAY;\\n    }\\n\\n    function wdiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return div(mul(a, WAD), b);\\n    }\\n\\n    function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return add(mul(a, WAD), b / 2) / b;\\n    }\\n\\n    function rdiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return div(mul(a, RAY), b);\\n    }\\n\\n    function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return add(mul(a, RAY), b / 2) / b;\\n    }\\n\\n    function wpow(uint256 x, uint256 n) internal pure returns (uint256) {\\n        uint256 result = WAD;\\n        while (n > 0) {\\n            if (n % 2 != 0) {\\n                result = wmul(result, x);\\n            }\\n            x = wmul(x, x);\\n            n /= 2;\\n        }\\n        return result;\\n    }\\n\\n    function rpow(uint256 x, uint256 n) internal pure returns (uint256) {\\n        uint256 result = RAY;\\n        while (n > 0) {\\n            if (n % 2 != 0) {\\n                result = rmul(result, x);\\n            }\\n            x = rmul(x, x);\\n            n /= 2;\\n        }\\n        return result;\\n    }\\n\\n    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {\\n        uint256 quotient = div(a, b);\\n        uint256 remainder = a - quotient * b;\\n        if (remainder > 0) {\\n            return quotient + 1;\\n        } else {\\n            return quotient;\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x71d16bf7d3101044d077f24e517d09d31d482830e807dc3b27c24926b0367b9f\",\"license\":\"MIT\"}},\"version\":1}","userdoc":{"kind":"user","notice":"Adapter for Ekubo V3 Protocol","methods":{"locked_6416899205(uint256)":{"notice":"Lock callback - function name is mined for gas optimization"}},"version":1},"devdoc":{"kind":"dev","title":"EkuboV3Adapter","methods":{},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_int128":{"label":"int128","encoding":"inplace","numberOfBytes":"16"},"t_uint96":{"label":"uint96","encoding":"inplace","numberOfBytes":"12"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_struct(PoolKey)881_storage":{"label":"struct PoolKey","members":[{"slot":"0","type":"t_address","astId":876,"label":"token0","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"1","type":"t_address","astId":878,"label":"token1","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"2","type":"t_bytes32","astId":880,"label":"config","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"}],"encoding":"inplace","numberOfBytes":"96"},"t_struct(SwapParams)52_storage":{"label":"struct EkuboV3Adapter.SwapParams","members":[{"slot":"0","type":"t_address","astId":42,"label":"to","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"1","type":"t_struct(PoolKey)881_storage","astId":45,"label":"poolKey","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"4","type":"t_int128","astId":47,"label":"amount","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"4","type":"t_bool","astId":49,"label":"isToken1","offset":16,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"},{"slot":"4","type":"t_uint96","astId":51,"label":"sqrtRatioLimit","offset":17,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"}],"encoding":"inplace","numberOfBytes":"160"}},"storage":[{"slot":"0","type":"t_struct(SwapParams)52_storage","astId":55,"label":"_swapParams","offset":0,"contract":"contracts/8/adapter/EkuboV3Adapter.sol:EkuboV3Adapter"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"60c060405234801561001057600080fd5b506040516112ee3803806112ee83398101604081905261002f9161005e565b6001600160a01b039182166080521660a052610098565b6001600160a01b038116811461005b57600080fd5b50565b6000806040838503121561007157600080fd5b825161007c81610046565b602084015190925061008d81610046565b809150509250929050565b60805160a0516111d061011e600039600081816101000152818161012f015281816102600152818161043c015281816105350152818161059d015281816107500152818161088e015281816109bd0152610c8101526000818160bf01528181610345015281816103d40152818161064c015281816106cc0152610a4f01526111d06000f3fe6080604052600436106100495760003560e01c801561005557806330e6ae311461008b5780636f7929f21461008b578063ad5c4648146100ad578063bb6a797b146100ee57600080fd5b3661005057005b600080fd5b34801561006157600080fd5b50610075610070366004610f06565b610122565b6040516100829190610f43565b60405180910390f35b34801561009757600080fd5b506100ab6100a6366004610fd4565b610734565b005b3480156100b957600080fd5b506100e17f000000000000000000000000000000000000000000000000000000000000000081565b604051610082919061108d565b3480156100fa57600080fd5b506100e17f000000000000000000000000000000000000000000000000000000000000000081565b6060336001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161461019c5760405162461bcd60e51b815260206004820152601860248201527713db9b1e48115add589bc810dbdc994818d85b8818d85b1b60421b60448201526064015b60405180910390fd5b6040805160a081018252600080546001600160a01b0390811683528351606080820186526001548316825260025490921660208083019190915260035482870152840152600454600f81900b94840194909452600160801b840460ff161515908301819052600160881b9093046001600160601b03166080830152909161022457600061022a565b63800000005b63ffffffff16602083604001516001600160801b0316901b60a084608001516001600160601b0316901b171760001b90506000807f00000000000000000000000000000000000000000000000000000000000000009050600084602001516000015190506000856020015160200151905060008660200151604001519050604051600081528360048201528260248201528160448201528660648201526040816084836000895af1806102e1573d6000803e3d6000fd5b50516060880151909550608086901c9086906000906103055760208a01515161030f565b8960200151602001515b9050600083600f0b1315610572576001600160a01b03811661051a576040516370a0823160e01b81526000906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906370a082319061037a90309060040161108d565b602060405180830381865afa158015610397573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103bb91906110a1565b604051632e1a7d4d60e01b8152600481018290529091507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690632e1a7d4d90602401600060405180830381600087803b15801561042057600080fd5b505af1158015610434573d6000803e3d6000fd5b5050505060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316856001600160801b031660405160006040518083038185875af1925050503d80600081146104ae576040519150601f19603f3d011682016040523d82523d6000602084013e6104b3565b606091505b50509050806105135760405162461bcd60e51b815260206004820152602660248201527f5472616e7366657220455448206465627420746f20456b75626f20436f72652060448201526519985a5b195960d21b6064820152608401610193565b5050610572565b60208a0151516105299061074c565b60208a015151610563907f00000000000000000000000000000000000000000000000000000000000000006001600160801b038616610855565b60208a0151516105729061088a565b600082600f0b13156105dc5761058f8a602001516020015161074c565b6105cb8a60200151602001517f0000000000000000000000000000000000000000000000000000000000000000846001600160801b0316610855565b6105dc8a602001516020015161088a565b60008a606001516105f5578a60200151602001516105fc565b60208b0151515b905060008b6060015161061757610612846110ba565b610620565b610620856110ba565b90506001600160801b03811615610713576001600160a01b0382166107045761064a823083610992565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663d0e30db0826001600160801b03166040518263ffffffff1660e01b81526004016000604051808303818588803b1580156106ae57600080fd5b505af11580156106c2573d6000803e3d6000fd5b50505050506106ff7f00000000000000000000000000000000000000000000000000000000000000008d60000151836001600160801b0316610855565b610713565b610713828d6000015183610992565b50506040805160208101909152600081529c9b505050505050505050505050565b601f19360135610746848484846109f7565b50505050565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663f9b6a7968360405160240161078e919061108d565b6040516020818303038152906040529060e01b6020820180516001600160e01b0383818316178352505050506040516107c791906110eb565b6000604051808303816000865af19150503d8060008114610804576040519150601f19603f3d011682016040523d82523d6000602084013e610809565b606091505b50509050806108515760405162461bcd60e51b81526020600482015260146024820152731cdd185c9d14185e5b595b9d1cc819985a5b195960621b6044820152606401610193565b5050565b6108688363a9059cbb60e01b8484610eb2565b6108855760405163fb7f507960e01b815260040160405180910390fd5b505050565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166312e103f1836040516024016108cc919061108d565b6040516020818303038152906040529060e01b6020820180516001600160e01b03838183161783525050505060405161090591906110eb565b6000604051808303816000865af19150503d8060008114610942576040519150601f19603f3d011682016040523d82523d6000602084013e610947565b606091505b50509050806108515760405162461bcd60e51b815260206004820152601760248201527618dbdb5c1b195d1954185e5b595b9d1cc819985a5b1959604a1b6044820152606401610193565b604051633ccfd60b60e01b8152606084811b600483015283901b6018820152608082901b602c8201527f000000000000000000000000000000000000000000000000000000000000000090600080603c8382865af16109f057600080fd5b5050505050565b60008083806020019051810190610a0e9190611107565b91509150600081610a20578251610a26565b82602001515b905060006001600160a01b038216610acc576040516370a0823160e01b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906370a0823190610a8490309060040161108d565b602060405180830381865afa158015610aa1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ac591906110a1565b9050610b3c565b6040516370a0823160e01b81526001600160a01b038316906370a0823190610af890309060040161108d565b602060405180830381865afa158015610b15573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b3991906110a1565b90505b60008111610b805760405162461bcd60e51b815260206004820152601160248201527004e6f20746f6b656e7320746f207377617607c1b6044820152606401610193565b8060008082128518610b9a5767400065a8177fae28610ba8565b6bffff9a5889f795069a41a8a25b6040805160a0810182526001600160a01b038d811680835260208084018c9052600f88900b848601528a1515606085018190526001600160601b0387166080909501859052600080546001600160a01b031990811690941781558d51600180548616918716919091179055918d015160028054909416908516179092558b850151600355600480546001600160801b038a166001600160881b031990911617600160801b90930292909217600160881b600160e81b031916600160881b9094029390931781558351637c1e845d60e11b815293519495507f00000000000000000000000000000000000000000000000000000000000000009091169363f83d08ba9380830193929082900301818387803b158015610cc557600080fd5b505af1158015610cd9573d6000803e3d6000fd5b5050600080546001600160a01b0319908116825560018054821690556002805490911690556003819055600480546001600160e81b03191690559150506530d77d40f4cd60d21b650f2882bf0b3360d21b891601610d3d57506001600160a01b0387165b6001600160a01b03811615610ea5576001600160a01b038516158015610d635750600047115b15610e11576000816001600160a01b03164760405160006040518083038185875af1925050503d8060008114610db5576040519150601f19603f3d011682016040523d82523d6000602084013e610dba565b606091505b5050905080610e0b5760405162461bcd60e51b815260206004820152601e60248201527f5472616e7366657220746f2070617965724f726967696e206661696c656400006044820152606401610193565b50610ea5565b6001600160a01b03851615610ea5576040516370a0823160e01b81526000906001600160a01b038716906370a0823190610e4f90309060040161108d565b602060405180830381865afa158015610e6c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e9091906110a1565b90508015610ea357610ea3868383610855565b505b5050505050505050505050565b60006040518481528360048201528260248201526020600060448360008a5af19150508015610efe573d8015610ef457600160005114601f3d11169150610efc565b6000863b1191505b505b949350505050565b600060208284031215610f1857600080fd5b5035919050565b60005b83811015610f3a578181015183820152602001610f22565b50506000910152565b6020815260008251806020840152610f62816040850160208701610f1f565b601f01601f19169190910160400192915050565b6001600160a01b0381168114610f8b57600080fd5b50565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f191681016001600160401b0381118282101715610fcc57610fcc610f8e565b604052919050565b600080600060608486031215610fe957600080fd5b8335610ff481610f76565b925060208481013561100581610f76565b925060408501356001600160401b038082111561102157600080fd5b818701915087601f83011261103557600080fd5b81358181111561104757611047610f8e565b611059601f8201601f19168501610fa4565b9150808252888482850101111561106f57600080fd5b80848401858401376000848284010152508093505050509250925092565b6001600160a01b0391909116815260200190565b6000602082840312156110b357600080fd5b5051919050565b6000600f82900b6001607f1b81016110e257634e487b7160e01b600052601160045260246000fd5b60000392915050565b600082516110fd818460208701610f1f565b9190910192915050565b600080828403608081121561111b57600080fd5b606081121561112957600080fd5b50604051606081016001600160401b038111828210171561114c5761114c610f8e565b604052835161115a81610f76565b8152602084015161116a81610f76565b6020820152604084810151908201526060840151909250801515811461118f57600080fd5b80915050925092905056fea2646970667358221220f518e3e2d38d2d4ad17600e523b2aafb0d72c7ab4f57d569cd0848b77e3b447f64736f6c63430008110033","sourceMap":"361:8864:0:-:0;;;1088:113;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1151:11:0;;;;;1172:22;;;361:8864;;14:139:11;-1:-1:-1;;;;;97:31:11;;87:42;;77:70;;143:1;140;133:12;77:70;14:139;:::o;158:409::-;245:6;253;306:2;294:9;285:7;281:23;277:32;274:52;;;322:1;319;312:12;274:52;354:9;348:16;373:39;406:5;373:39;:::i;:::-;481:2;466:18;;460:25;431:5;;-1:-1:-1;494:41:11;460:25;494:41;:::i;:::-;554:7;544:17;;;158:409;;;;;:::o;:::-;361:8864:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"361:8864:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3292:3851;;;;;;;;;;-1:-1:-1;3292:3851:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8295:327;;;;;;;;;;-1:-1:-1;8295:327:0;;;;;:::i;:::-;;:::i;:::-;;403:29;;;;;;;;;;;;;;;;;;;;;;:::i;438:35::-;;;;;;;;;;;;;;;3292:3851;3355:12;3387:10;-1:-1:-1;;;;;3401:10:0;3387:24;;3379:61;;;;-1:-1:-1;;;3379:61:0;;2855:2:11;3379:61:0;;;2837:21:11;2894:2;2874:18;;;2867:30;-1:-1:-1;;;2913:18:11;;;2906:54;2977:18;;3379:61:0;;;;;;;;;3451:38;;;;;;;;-1:-1:-1;3451:38:0;;-1:-1:-1;;;;;3451:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;3451:38:0;;;;;;;;;;;;-1:-1:-1;;;3451:38:0;;;-1:-1:-1;;;;;3451:38:0;;;;;;;3746:31;;3776:1;3746:31;;;3765:7;3746:31;3637:141;;3727:2;3708:6;:13;;;-1:-1:-1;;;;;3692:31:0;:37;;3672:3;3646:6;:21;;;-1:-1:-1;;;;;3638:30:0;:37;;3637:93;:141;3616:172;;3595:193;;3942:21;3973:12;3988:10;3973:25;;4008:14;4025:6;:14;;;:21;;;4008:38;;4056:14;4073:6;:14;;;:21;;;4056:38;;4104:14;4121:6;:14;;;:21;;;4104:38;;4217:4;4211:11;4312:1;4307:3;4300:14;4406:6;4402:1;4397:3;4393:11;4386:27;4493:6;4488:2;4483:3;4479:12;4472:28;4567:6;4562:2;4557:3;4553:12;4546:28;4646:10;4640:3;4635;4631:13;4624:33;4800:2;4795:3;4790;4785;4782:1;4776:4;4769:5;4764:39;4839:7;4829:133;;4887:16;4884:1;4881;4866:38;4931:16;4928:1;4921:27;4829:133;-1:-1:-1;5062:10:0;5315:15;;;;5062:10;;-1:-1:-1;5215:3:0;5189:29;;;;5062:10;;5159:13;;5315:87;;5381:14;;;;:21;5315:87;;;5345:6;:14;;;:21;;;5315:87;5295:107;;5464:1;5455:6;:10;;;5451:808;;;-1:-1:-1;;;;;5485:16:0;;5481:768;;5628:37;;-1:-1:-1;;;5628:37:0;;5606:19;;-1:-1:-1;;;;;5635:4:0;5628:22;;;;:37;;5659:4;;5628:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5683:33;;-1:-1:-1;;;5683:33:0;;;;;3341:25:11;;;5606:59:0;;-1:-1:-1;5689:4:0;-1:-1:-1;;;;;5683:20:0;;;;3314:18:11;;5683:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5787:12;5805:10;-1:-1:-1;;;;;5805:15:0;5836:6;-1:-1:-1;;;;;5805:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5786:62;;;5874:7;5866:58;;;;-1:-1:-1;;;5866:58:0;;3789:2:11;5866:58:0;;;3771:21:11;3828:2;3808:18;;;3801:30;3867:34;3847:18;;;3840:62;-1:-1:-1;;;3918:18:11;;;3911:36;3964:19;;5866:58:0;3587:402:11;5866:58:0;5503:436;;5481:768;;;6054:14;;;;:21;6039:37;;:14;:37::i;:::-;6124:14;;;;:21;6094:82;;6148:10;-1:-1:-1;;;;;6094:82:0;;:22;:82::i;:::-;6212:14;;;;:21;6194:40;;:17;:40::i;:::-;6282:1;6273:6;:10;;;6269:228;;;6299:37;6314:6;:14;;;:21;;;6299:14;:37::i;:::-;6350:82;6380:6;:14;;;:21;;;6404:10;6424:6;-1:-1:-1;;;;;6350:82:0;:22;:82::i;:::-;6446:40;6464:6;:14;;;:21;;;6446:17;:40::i;:::-;6541:19;6563:6;:15;;;:87;;6629:6;:14;;;:21;;;6563:87;;;6593:14;;;;:21;6563:87;6541:109;;6660:20;6691:6;:15;;;:35;;6719:7;6720:6;6719:7;:::i;:::-;6691:35;;;6709:7;6710:6;6709:7;:::i;:::-;6660:67;-1:-1:-1;;;;;;6742:16:0;;;6738:379;;-1:-1:-1;;;;;6778:18:0;;6774:333;;6816:51;6826:11;6847:4;6854:12;6816:9;:51::i;:::-;6891:4;-1:-1:-1;;;;;6885:19:0;;6912:12;-1:-1:-1;;;;;6885:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6945:61;6975:4;6982:6;:9;;;6993:12;-1:-1:-1;;;;;6945:61:0;:22;:61::i;:::-;6774:333;;;7045:47;7055:11;7068:6;:9;;;7079:12;7045:9;:47::i;:::-;-1:-1:-1;;7127:9:0;;;;;;;;;-1:-1:-1;7127:9:0;;;3292:3851;-1:-1:-1;;;;;;;;;;;;3292:3851:0:o;8295:327::-;-1:-1:-1;;8484:14:0;8539:13;8526:27;8572:43;8583:2;8587:4;8593:8;8526:27;8572:10;:43::i;:::-;8410:212;8295:327;;;:::o;7200:214::-;7259:12;7277:10;-1:-1:-1;;;;;7277:15:0;7329:10;7341:5;7306:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7306:41:0;;;;;;;;;;;7277:80;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7258:99;;;7375:7;7367:40;;;;-1:-1:-1;;;7367:40:0;;4788:2:11;7367:40:0;;;4770:21:11;4827:2;4807:18;;;4800:30;-1:-1:-1;;;4846:18:11;;;4839:50;4906:18;;7367:40:0;4586:344:11;7367:40:0;7248:166;7200:214;:::o;1614:199:9:-;1701:52;1711:5;-1:-1:-1;;;1743:2:9;1747:5;1701:9;:52::i;:::-;1696:111;;1776:20;;-1:-1:-1;;;1776:20:9;;;;;;;;;;;1696:111;1614:199;;;:::o;7474:220:0:-;7536:12;7554:10;-1:-1:-1;;;;;7554:15:0;7606:10;7618:5;7583:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7583:41:0;;;;;;;;;;;7554:80;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7535:99;;;7652:7;7644:43;;;;-1:-1:-1;;;7644:43:0;;5137:2:11;7644:43:0;;;5119:21:11;5176:2;5156:18;;;5149:30;-1:-1:-1;;;5195:18:11;;;5188:53;5258:18;;7644:43:0;4935:347:11;7751:538:0;7930:4;7924:11;-1:-1:-1;;;7984:33:0;;8054:2;8050:14;;;8046:1;8037:11;;8030:35;8099:18;;;8094:2;8085:12;;8078:40;8156:3;8152:16;;;8147:2;8138:12;;8131:38;7854:10;;7839:12;;8218:2;7924:11;7839:12;7854:10;8197:5;8192:35;8182:91;;8257:1;8254;8247:12;8182:91;;7899:384;7751:538;;;:::o;1207:2003::-;1349:22;1373:13;1414:8;1390:71;;;;;;;;;;;;:::i;:::-;1348:113;;;;1472:17;1492:8;:42;;1520:14;;1492:42;;;1503:7;:14;;;1492:42;1472:62;-1:-1:-1;1545:20:0;-1:-1:-1;;;;;1579:16:0;;1575:187;;1626:37;;-1:-1:-1;;;1626:37:0;;-1:-1:-1;;;;;1633:4:0;1626:22;;;;:37;;1657:4;;1626:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1611:52;;1575:187;;;1709:42;;-1:-1:-1;;;1709:42:0;;-1:-1:-1;;;;;1709:27:0;;;;;:42;;1745:4;;1709:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1694:57;;1575:187;1795:1;1780:12;:16;1772:46;;;;-1:-1:-1;;;1772:46:0;;6423:2:11;1772:46:0;;;6405:21:11;6462:2;6442:18;;;6435:30;-1:-1:-1;;;6481:18:11;;;6474:47;6538:18;;1772:46:0;6221:341:11;1772:46:0;1863:12;1828:17;9157:14;;;9143:29;;1912:105;;566:23;1912:105;;;632:33;1912:105;2042:180;;;;;;;;-1:-1:-1;;;;;2042:180:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2042:180:0;;;;;;;;;-1:-1:-1;2028:194:0;;-1:-1:-1;;;;;;2028:194:0;;;;;;;;;;-1:-1:-1;2028:194:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2028:194:0;;-1:-1:-1;;;;;;2028:194:0;;;;-1:-1:-1;;;2028:194:0;;;;;;;-1:-1:-1;;;;;;;;2028:194:0;-1:-1:-1;;;2028:194:0;;;;;;;;;2283:31;;-1:-1:-1;;;2283:31:0;;;;2042:180;;-1:-1:-1;2296:10:0;2283:29;;;;;;:31;;;;-1:-1:-1;2283:31:0;;;;;;-1:-1:-1;2283:29:0;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2332:11:0;2325:18;;-1:-1:-1;;;;;;2325:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2325:18:0;;;2332:11;-1:-1:-1;;;;;;;;2430:26:0;;2429:44;2425:143;;-1:-1:-1;;;;;;2520:35:0;;2425:143;-1:-1:-1;;;;;2582:26:0;;;2578:626;;-1:-1:-1;;;;;2628:16:0;;;:45;;;;;2672:1;2648:21;:25;2628:45;2624:570;;;2694:12;2712;-1:-1:-1;;;;;2712:17:0;2758:21;2712:89;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2693:108;;;2827:7;2819:50;;;;-1:-1:-1;;;2819:50:0;;6769:2:11;2819:50:0;;;6751:21:11;6808:2;6788:18;;;6781:30;6847:32;6827:18;;;6820:60;6897:18;;2819:50:0;6567:354:11;2819:50:0;2675:209;2624:570;;;-1:-1:-1;;;;;2894:16:0;;;2890:304;;2952:80;;-1:-1:-1;;;2952:80:0;;2930:19;;-1:-1:-1;;;;;2952:27:0;;;;;:80;;3009:4;;2952:80;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2930:102;-1:-1:-1;3054:15:0;;3050:130;;3093:68;3123:9;3135:12;3149:11;3093:22;:68::i;:::-;2912:282;2890:304;1338:1872;;;;;;;1207:2003;;;;:::o;3534:683:9:-;3628:12;3779:4;3773:11;3811:8;3805:4;3798:22;3857:2;3850:4;3844;3840:15;3833:27;3897:6;3890:4;3884;3880:15;3873:31;3967:4;3962:3;3956:4;3950;3947:1;3940:5;3933;3928:44;3917:55;;;3988:7;3985:216;;;4021:16;4054:47;;;;4182:1;4178;4172:8;4169:15;4164:2;4146:16;4143:24;4139:46;4128:57;;4014:173;;4054:47;4097:1;4089:5;4077:18;4074:25;4063:36;;4014:173;;3985:216;3534:683;;;;;;:::o;14:180:11:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:11;;14:180;-1:-1:-1;14:180:11:o;199:250::-;284:1;294:113;308:6;305:1;302:13;294:113;;;384:11;;;378:18;365:11;;;358:39;330:2;323:10;294:113;;;-1:-1:-1;;441:1:11;423:16;;416:27;199:250::o;454:394::-;601:2;590:9;583:21;564:4;633:6;627:13;676:6;671:2;660:9;656:18;649:34;692:79;764:6;759:2;748:9;744:18;739:2;731:6;727:15;692:79;:::i;:::-;832:2;811:15;-1:-1:-1;;807:29:11;792:45;;;;839:2;788:54;;454:394;-1:-1:-1;;454:394:11:o;853:131::-;-1:-1:-1;;;;;928:31:11;;918:42;;908:70;;974:1;971;964:12;908:70;853:131;:::o;989:127::-;1050:10;1045:3;1041:20;1038:1;1031:31;1081:4;1078:1;1071:15;1105:4;1102:1;1095:15;1121:275;1192:2;1186:9;1257:2;1238:13;;-1:-1:-1;;1234:27:11;1222:40;;-1:-1:-1;;;;;1277:34:11;;1313:22;;;1274:62;1271:88;;;1339:18;;:::i;:::-;1375:2;1368:22;1121:275;;-1:-1:-1;1121:275:11:o;1401:1039::-;1487:6;1495;1503;1556:2;1544:9;1535:7;1531:23;1527:32;1524:52;;;1572:1;1569;1562:12;1524:52;1611:9;1598:23;1630:31;1655:5;1630:31;:::i;:::-;1680:5;-1:-1:-1;1704:2:11;1743:18;;;1730:32;1771:33;1730:32;1771:33;:::i;:::-;1823:7;-1:-1:-1;1881:2:11;1866:18;;1853:32;-1:-1:-1;;;;;1934:14:11;;;1931:34;;;1961:1;1958;1951:12;1931:34;1999:6;1988:9;1984:22;1974:32;;2044:7;2037:4;2033:2;2029:13;2025:27;2015:55;;2066:1;2063;2056:12;2015:55;2102:2;2089:16;2124:2;2120;2117:10;2114:36;;;2130:18;;:::i;:::-;2172:53;2215:2;2196:13;;-1:-1:-1;;2192:27:11;2188:36;;2172:53;:::i;:::-;2159:66;;2248:2;2241:5;2234:17;2288:7;2283:2;2278;2274;2270:11;2266:20;2263:33;2260:53;;;2309:1;2306;2299:12;2260:53;2364:2;2359;2355;2351:11;2346:2;2339:5;2335:14;2322:45;2408:1;2403:2;2398;2391:5;2387:14;2383:23;2376:34;;2429:5;2419:15;;;;;1401:1039;;;;;:::o;2445:203::-;-1:-1:-1;;;;;2609:32:11;;;;2591:51;;2579:2;2564:18;;2445:203::o;3006:184::-;3076:6;3129:2;3117:9;3108:7;3104:23;3100:32;3097:52;;;3145:1;3142;3135:12;3097:52;-1:-1:-1;3168:16:11;;3006:184;-1:-1:-1;3006:184:11:o;3994:295::-;4029:3;4073:2;4062:21;;;-1:-1:-1;;;4095:37:11;;4092:160;;4174:10;4169:3;4165:20;4162:1;4155:31;4209:4;4206:1;4199:15;4237:4;4234:1;4227:15;4092:160;4272:1;4268:15;;3994:295;-1:-1:-1;;3994:295:11:o;4294:287::-;4423:3;4461:6;4455:13;4477:66;4536:6;4531:3;4524:4;4516:6;4512:17;4477:66;:::i;:::-;4559:16;;;;;4294:287;-1:-1:-1;;4294:287:11:o;5287:929::-;5387:6;5395;5439:9;5430:7;5426:23;5469:3;5465:2;5461:12;5458:32;;;5486:1;5483;5476:12;5458:32;5510:4;5506:2;5502:13;5499:33;;;5528:1;5525;5518:12;5499:33;-1:-1:-1;5561:2:11;5555:9;5603:4;5591:17;;-1:-1:-1;;;;;5623:34:11;;5659:22;;;5620:62;5617:88;;;5685:18;;:::i;:::-;5721:2;5714:22;5758:16;;5783:31;5758:16;5783:31;:::i;:::-;5823:21;;5889:2;5874:18;;5868:25;5902:33;5868:25;5902:33;:::i;:::-;5963:2;5951:15;;5944:32;6030:2;6015:18;;;6009:25;5992:15;;;5985:50;6105:4;6090:20;;6084:27;5955:6;;-1:-1:-1;6149:15:11;;6142:23;6130:36;;6120:64;;6180:1;6177;6170:12;6120:64;6203:7;6193:17;;;5287:929;;;;;:::o","linkReferences":{},"immutableReferences":{"16":[{"start":191,"length":32},{"start":837,"length":32},{"start":980,"length":32},{"start":1612,"length":32},{"start":1740,"length":32},{"start":2639,"length":32}],"18":[{"start":256,"length":32},{"start":303,"length":32},{"start":608,"length":32},{"start":1084,"length":32},{"start":1333,"length":32},{"start":1437,"length":32},{"start":1872,"length":32},{"start":2190,"length":32},{"start":2493,"length":32},{"start":3201,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"EKUBO_CORE()","signatureHash4":"0xbb6a797b","signatureHash32":"0xbb6a797bcf8a90d190dffa5a01e78e63ef819b09cdd6d3a754c0a459d63286ea"},{"signature":"locked_6416899205(uint256)","signatureHash4":"0x00000000","signatureHash32":"0x00000000f5b8d75f20c6266fc5518dec572fd04b54a029f03adf07f867d4c273"},{"signature":"sellBase(address,address,bytes)","signatureHash4":"0x30e6ae31","signatureHash32":"0x30e6ae317bb74e054afcab0bd57887675415dfd395c5c8a31736e196757b1e81"},{"signature":"sellQuote(address,address,bytes)","signatureHash4":"0x6f7929f2","signatureHash32":"0x6f7929f2b01195712498d48a0811ef40554ee216f994a893f4b2ce9624a6eca8"},{"signature":"WETH()","signatureHash4":"0xad5c4648","signatureHash32":"0xad5c46488b7de578b546a5d35cea48a937114e7ed63179543cd1f8e1899a1241"}],"event":[],"error":[{"signature":"SafeTransferFailed()","signatureHash4":"0xfb7f5079","signatureHash32":"0xfb7f50796995f43b6f601c7bdc661fff3554a3197898a14efb94c31f671088ce"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x7f608464a43cb144d42c8Cb9779A22DebcF00Aa9"}