{"matchId":"51416651","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-09-21T08:55:06Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"793:2310:1:-:0;;;867:166;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1129:11:0;;;;;1150:29;;;;;1189;;;793:2310:1;;14:131:12;-1:-1:-1;;;;;89:31:12;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:519::-;238:6;246;254;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;355:9;349:16;374:31;399:5;374:31;:::i;:::-;474:2;459:18;;453:25;424:5;;-1:-1:-1;487:33:12;453:25;487:33;:::i;:::-;591:2;576:18;;570:25;539:7;;-1:-1:-1;604:33:12;570:25;604:33;:::i;:::-;656:7;646:17;;;150:519;;;;;:::o;:::-;793:2310:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212206e2fcb6532f4127736ce7de5d33f592bb9d0d70a09d99ce531afcb367b77273d64736f6c63430008110033","offset":3271}},"transformations":[{"type":"insert","offset":3324,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000000000000000000000000000000000001000276a3000000000000000000000000fffd8963efd1fc6a506488495d951d5263988d26"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"793:2310:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6014:12:0;793:2310:1;;;6113:13:0;793:2310:1;6123:1:0;793:2310:1;;6113:13:0;:::i;:::-;6102:50;;;;;;;:::i;:::-;6038:114;;;;;;6162:56;6185:12;6199;6213:4;6162:22;:56::i;:::-;-1:-1:-1;;6466:9:0;;;;;;;;;-1:-1:-1;6466:9:0;;-1:-1:-1;2657:206:1;;;;;;:::i;:::-;;:::i;:::-;;1231:157:0;;;;;;:::i;:::-;;:::i;804:39::-;;;;;;;;-1:-1:-1;;;;;3510:32:12;;;3492:51;;3480:2;3465:18;804:39:0;;;;;;;724:29;;;;;759:39;;;;;3086:889;3248:1;3232:12;:17;;:38;;;;;3269:1;3253:12;:17;;3232:38;3228:91;;;3293:15;;-1:-1:-1;;;3293:15:0;;;;;;;;;;;3228:91;3329:15;3346:16;3390:4;3366:70;;;;;;;;;;;;:::i;:::-;3328:108;;-1:-1:-1;3328:108:0;-1:-1:-1;3328:108:0;;-1:-1:-1;;;;;3519:15:0;;;;;;;3515:81;;;3570:6;3515:81;3606:17;3625:19;3663:1;3648:12;:16;:132;;3749:7;-1:-1:-1;;;;;3738:18:0;:8;-1:-1:-1;;;;;3738:18:0;;3766:12;3648:132;;;3690:8;-1:-1:-1;;;;;3680:18:0;:7;-1:-1:-1;;;;;3680:18:0;;3708:12;3648:132;3605:175;;;;3794:12;3790:179;;;3822:52;3826:7;3843:4;3850:10;3862:11;3822:3;:52::i;:::-;3790:179;;;3905:53;3909:8;3927:4;3934:10;3946:11;3905:3;:53::i;:::-;3218:757;;;;;;3086:889;;;:::o;2657:206:1:-;2800:56;2823:12;2837;2851:4;;2800:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2800:22:1;;-1:-1:-1;;;2800:56:1:i;:::-;2657:206;;;;:::o;1231:157:0:-;1356:25;1362:2;1366:4;1372:8;1356:5;:25::i;:::-;1231:157;;;:::o;4734:542::-;4915:4;-1:-1:-1;;;;;4906:13:0;:5;-1:-1:-1;;;;;4906:13:0;;:47;;;;;4948:5;4923:21;:30;;4906:47;4902:368;;;4975:4;-1:-1:-1;;;;;4969:19:0;;4996:5;4969:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5018:38:0;;-1:-1:-1;;;5018:38:0;;-1:-1:-1;;;;;4360:32:12;;;5018:38:0;;;4342:51:12;4409:18;;;4402:34;;;5024:4:0;5018:20;;-1:-1:-1;5018:20:0;;-1:-1:-1;4315:18:12;;;-1:-1:-1;5018:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;4902:368;;;5133:4;-1:-1:-1;;;;;5116:22:0;;;5112:158;;5154:55;5184:5;5192:9;5203:5;5154:22;:55::i;:::-;5112:158;;;5247:12;;-1:-1:-1;;;5247:12:0;;;;;;;;;;;1558:269;1642:15;1659:17;1704:8;1680:72;;;;;;;;;;;;:::i;:::-;1641:111;;;;1762:58;1777:2;1781:4;1787:7;1796:4;1802:17;-1:-1:-1;;5448:14:0;5705:13;5692:27;;5282:453;1802:17;1762:14;:58::i;:::-;1631:196;;1558:269;;;:::o;1614:199:10:-;1701:52;1711:5;-1:-1:-1;;;1743:2:10;1747:5;1701:9;:52::i;:::-;1696:111;;1776:20;;-1:-1:-1;;;1776:20:10;;;;;;;;;;;1833:1183:0;2006:17;2025:15;2068:4;2044:70;;;;;;;;;;;;:::i;:::-;2145:42;;-1:-1:-1;;;2145:42:0;;2181:4;2145:42;;;3492:51:12;2005:109:0;;-1:-1:-1;2005:109:0;-1:-1:-1;2124:18:0;;-1:-1:-1;;;;;2145:27:0;;;;;3465:18:12;;2145:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2124:63;;2197:15;2227:7;-1:-1:-1;;;;;2215:19:0;:9;-1:-1:-1;;;;;2215:19:0;;2197:37;;2292:4;-1:-1:-1;;;;;2285:17:0;;2316:2;2332:10;2363;2388:7;-1:-1:-1;;;;;2388:12:0;2399:1;2388:12;:111;;2492:7;2388:111;;;2420:10;:52;;2454:18;2471:1;2454:14;:18;:::i;:::-;2420:52;;;2433:18;:14;2450:1;2433:18;:::i;:::-;2513:4;2285:242;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;2625:20;-1:-1:-1;;;489:66:0;2660:11;:26;2659:44;2655:143;;-1:-1:-1;;;;;;2750:35:0;;2655:143;2824:42;;-1:-1:-1;;;2824:42:0;;2860:4;2824:42;;;3492:51:12;2807:14:0;;-1:-1:-1;;;;;2824:27:0;;;;;3465:18:12;;2824:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2807:59;;2889:1;2880:6;:10;:40;;;;-1:-1:-1;;;;;;2894:26:0;;;;2880:40;2876:134;;;2936:63;2966:9;2978:12;2992:6;2936:22;:63::i;:::-;1995:1021;;;;;;1833:1183;;;;;:::o;3534:683:10:-;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:331:12:-;119:9;130;172:8;160:10;157:24;154:44;;;194:1;191;184:12;154:44;223:6;213:8;210:20;207:40;;;243:1;240;233:12;207:40;-1:-1:-1;;269:23:12;;;314:25;;;;;-1:-1:-1;14:331:12:o;350:127::-;411:10;406:3;402:20;399:1;392:31;442:4;439:1;432:15;466:4;463:1;456:15;482:275;553:2;547:9;618:2;599:13;;-1:-1:-1;;595:27:12;583:40;;653:18;638:34;;674:22;;;635:62;632:88;;;700:18;;:::i;:::-;736:2;729:22;482:275;;-1:-1:-1;482:275:12:o;762:186::-;810:4;843:18;835:6;832:30;829:56;;;865:18;;:::i;:::-;-1:-1:-1;931:2:12;910:15;-1:-1:-1;;906:29:12;937:4;902:40;;762:186::o;953:462::-;995:5;1048:3;1041:4;1033:6;1029:17;1025:27;1015:55;;1066:1;1063;1056:12;1015:55;1102:6;1089:20;1133:48;1149:31;1177:2;1149:31;:::i;:::-;1133:48;:::i;:::-;1206:2;1197:7;1190:19;1252:3;1245:4;1240:2;1232:6;1228:15;1224:26;1221:35;1218:55;;;1269:1;1266;1259:12;1218:55;1334:2;1327:4;1319:6;1315:17;1308:4;1299:7;1295:18;1282:55;1382:1;1357:16;;;1375:4;1353:27;1346:38;;;;1361:7;953:462;-1:-1:-1;;;953:462:12:o;1420:454::-;1504:6;1512;1520;1573:2;1561:9;1552:7;1548:23;1544:32;1541:52;;;1589:1;1586;1579:12;1541:52;1625:9;1612:23;1602:33;;1682:2;1671:9;1667:18;1654:32;1644:42;;1737:2;1726:9;1722:18;1709:32;1764:18;1756:6;1753:30;1750:50;;;1796:1;1793;1786:12;1750:50;1819:49;1860:7;1851:6;1840:9;1836:22;1819:49;:::i;:::-;1809:59;;;1420:454;;;;;:::o;1879:725::-;1965:6;1973;1981;1989;2042:2;2030:9;2021:7;2017:23;2013:32;2010:52;;;2058:1;2055;2048:12;2010:52;2094:9;2081:23;2071:33;;2151:2;2140:9;2136:18;2123:32;2113:42;;2206:2;2195:9;2191:18;2178:32;2229:18;2270:2;2262:6;2259:14;2256:34;;;2286:1;2283;2276:12;2256:34;2324:6;2313:9;2309:22;2299:32;;2369:7;2362:4;2358:2;2354:13;2350:27;2340:55;;2391:1;2388;2381:12;2340:55;2431:2;2418:16;2457:2;2449:6;2446:14;2443:34;;;2473:1;2470;2463:12;2443:34;2518:7;2513:2;2504:6;2500:2;2496:15;2492:24;2489:37;2486:57;;;2539:1;2536;2529:12;2486:57;1879:725;;;;-1:-1:-1;;2570:2:12;2562:11;;-1:-1:-1;;;1879:725:12:o;2609:131::-;-1:-1:-1;;;;;2684:31:12;;2674:42;;2664:70;;2730:1;2727;2720:12;2664:70;2609:131;:::o;2745:596::-;2831:6;2839;2847;2900:2;2888:9;2879:7;2875:23;2871:32;2868:52;;;2916:1;2913;2906:12;2868:52;2955:9;2942:23;2974:31;2999:5;2974:31;:::i;:::-;3024:5;-1:-1:-1;3081:2:12;3066:18;;3053:32;3094:33;3053:32;3094:33;:::i;:::-;3146:7;-1:-1:-1;3204:2:12;3189:18;;3176:32;3231:18;3220:30;;3217:50;;;3263:1;3260;3253:12;3762:401;3857:6;3865;3918:2;3906:9;3897:7;3893:23;3889:32;3886:52;;;3934:1;3931;3924:12;3886:52;3966:9;3960:16;3985:31;4010:5;3985:31;:::i;:::-;4085:2;4070:18;;4064:25;4035:5;;-1:-1:-1;4098:33:12;4064:25;4098:33;:::i;:::-;4150:7;4140:17;;;3762:401;;;;;:::o;4447:277::-;4514:6;4567:2;4555:9;4546:7;4542:23;4538:32;4535:52;;;4583:1;4580;4573:12;4535:52;4615:9;4609:16;4668:5;4661:13;4654:21;4647:5;4644:32;4634:60;;4690:1;4687;4680:12;4634:60;4713:5;4447:277;-1:-1:-1;;;4447:277:12:o;4729:250::-;4814:1;4824:113;4838:6;4835:1;4832:13;4824:113;;;4914:11;;;4908:18;4895:11;;;4888:39;4860:2;4853:10;4824:113;;;-1:-1:-1;;4971:1:12;4953:16;;4946:27;4729:250::o;4984:775::-;5072:6;5080;5133:2;5121:9;5112:7;5108:23;5104:32;5101:52;;;5149:1;5146;5139:12;5101:52;5181:9;5175:16;5200:31;5225:5;5200:31;:::i;:::-;5299:2;5284:18;;5278:25;5250:5;;-1:-1:-1;5326:18:12;5315:30;;5312:50;;;5358:1;5355;5348:12;5312:50;5381:22;;5434:4;5426:13;;5422:27;-1:-1:-1;5412:55:12;;5463:1;5460;5453:12;5412:55;5492:2;5486:9;5517:48;5533:31;5561:2;5533:31;:::i;5517:48::-;5588:2;5581:5;5574:17;5628:7;5623:2;5618;5614;5610:11;5606:20;5603:33;5600:53;;;5649:1;5646;5639:12;5600:53;5662:67;5726:2;5721;5714:5;5710:14;5705:2;5701;5697:11;5662:67;:::i;:::-;5748:5;5738:15;;;;;4984:775;;;;;:::o;5764:184::-;5834:6;5887:2;5875:9;5866:7;5862:23;5858:32;5855:52;;;5903:1;5900;5893:12;5855:52;-1:-1:-1;5926:16:12;;5764:184;-1:-1:-1;5764:184:12:o;5953:127::-;6014:10;6009:3;6005:20;6002:1;5995:31;6045:4;6042:1;6035:15;6069:4;6066:1;6059:15;6085:185;-1:-1:-1;;;;;6206:10:12;;;6194;;;6190:27;;6229:12;;;6226:38;;;6244:18;;:::i;:::-;6226:38;6085:185;;;;:::o;6275:182::-;-1:-1:-1;;;;;6382:10:12;;;6394;;;6378:27;;6417:11;;;6414:37;;;6431:18;;:::i;6462:747::-;6676:4;6722:1;6718;6713:3;6709:11;6705:19;6763:2;6755:6;6751:15;6740:9;6733:34;6817:6;6810:14;6803:22;6798:2;6787:9;6783:18;6776:50;6862:6;6857:2;6846:9;6842:18;6835:34;6917:2;6909:6;6905:15;6900:2;6889:9;6885:18;6878:43;;6958:3;6952;6941:9;6937:19;6930:32;6991:6;6985:13;7035:6;7029:3;7018:9;7014:19;7007:35;7051:80;7124:6;7118:3;7107:9;7103:19;7098:2;7090:6;7086:15;7051:80;:::i;:::-;7192:2;7171:15;-1:-1:-1;;7167:29:12;7152:45;;;;7199:3;7148:55;;6462:747;-1:-1:-1;;;;;;6462:747:12:o;7214:243::-;7291:6;7299;7352:2;7340:9;7331:7;7327:23;7323:32;7320:52;;;7368:1;7365;7358:12;7320:52;-1:-1:-1;;7391:16:12;;7447:2;7432:18;;;7426:25;7391:16;;7426:25;;-1:-1:-1;7214:243:12:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212206e2fcb6532f4127736ce7de5d33f592bb9d0d70a09d99ce531afcb367b77273d64736f6c63430008110033","offset":3012}},"immutableReferences":{"22":[{"start":389,"length":32},{"start":762,"length":32},{"start":832,"length":32},{"start":981,"length":32}],"24":[{"start":428,"length":32},{"start":1524,"length":32}],"26":[{"start":322,"length":32},{"start":1478,"length":32}]},"transformations":[{"id":"26","type":"replace","offset":322,"reason":"immutable"},{"id":"22","type":"replace","offset":389,"reason":"immutable"},{"id":"24","type":"replace","offset":428,"reason":"immutable"},{"id":"22","type":"replace","offset":762,"reason":"immutable"},{"id":"22","type":"replace","offset":832,"reason":"immutable"},{"id":"22","type":"replace","offset":981,"reason":"immutable"},{"id":"26","type":"replace","offset":1478,"reason":"immutable"},{"id":"24","type":"replace","offset":1524,"reason":"immutable"}],"transformationValues":{"immutables":{"22":"0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","24":"0x00000000000000000000000000000000000000000000000000000001000276a3","26":"0x000000000000000000000000fffd8963efd1fc6a506488495d951d5263988d26"}}},"deployment":{"transactionHash":"0xa7bfa8f733aa346045f02e14f6fef391eac6bdd63c0d72cacc536dffa68fce3b","blockNumber":"22565505","transactionIndex":"147","deployer":"0xB2c945372e33a8BF4629370eEB3B86e06539C17b"},"sources":{"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol":{"content":"// SPDX-License-Identifier: MIT\n// solhint-disable\npragma solidity ^0.8.0;\nimport {BaseUniversalUniswapV3Adaptor} from \"./BaseUniversalUniswapV3Adaptor.sol\";\n\n/**\n * @title UniversalUniswapV3Adaptor\n * @notice Base contract for Universal Uniswap V3 Adapter implementation\n * @dev This contract serves as the foundation for adapting various Uniswap V3-like DEX protocols\n *\n * Supported DEX Protocols:\n * 1. Uniswap V3 Family:\n *    - Uniswap V3\n *    - Sheepdex\n *\n * 2. Algebra Family:\n *    - CamelotV3\n *    - KimV4\n *    - ThenaV2\n *    - Quickswapv3\n *    - HerculesV3\n *    - ZyberV3\n *\n * 3. Other V3-like DEXs:\n *    - Agni\n *    - FusionX\n *    - RamsesV2 (including NileCL)\n *    - Xei\n *    - PancakeV3\n *    - FireflyV3\n *\n * @custom:security-contact security@yourprotocol.com\n */\ncontract UniversalUniswapV3Adaptor is BaseUniversalUniswapV3Adaptor {\n    constructor(\n        address weth,\n        uint160 minSqrtRatio,\n        uint160 maxSqrtRatio\n    ) BaseUniversalUniswapV3Adaptor(weth, minSqrtRatio, maxSqrtRatio) {}\n\n    // Uniswap V3 callback(\n    // Sheepdex,\n    // etc.)\n    function uniswapV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // Agni callback\n    function agniSwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // Algebra/Algebra-like callback (\n    // CamelotV3,\n    // KimV4,\n    // ThenaV2,\n    // Quickswapv3,\n    // HerculesV3,\n    // ZyberV3,\n    // etc.)\n    function algebraSwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // FusionX callback\n    function fusionXV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // RamsesV2 callback(\n    // NileCL,\n    // etc.)\n    function ramsesV2SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // Xei callback\n    function xeiV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // PancakeV3 callback\n    function pancakeV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // FireflyV3 callback\n    function fireflyV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n}\n"},"contracts/8/adapter/TemplateAdaptor/BaseUniversalUniswapV3Adaptor.sol":{"content":"// SPDX-License-Identifier: MIT\n// solhint-disable\npragma solidity ^0.8.0;\n\nimport {IAdapter} from \"../../interfaces/IAdapter.sol\";\nimport {IERC20} from \"../../interfaces/IERC20.sol\";\nimport {SafeERC20} from \"../../libraries/SafeERC20.sol\";\nimport {IWETH} from \"../../interfaces/IWETH.sol\";\nimport {IUniV3} from \"../../interfaces/IUniV3.sol\";\n/// @dev specific flag for refund logic, \"0x3ca20afc\" is flexible and also used for commission, \"ccc\" mean refund\nuint256 constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\nuint256 constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\nabstract contract BaseUniversalUniswapV3Adaptor is IAdapter {\n    address public immutable WETH;\n    uint160 public immutable MIN_SQRT_RATIO;\n    uint160 public immutable MAX_SQRT_RATIO;\n\n    /// @notice throw error when amount is not positive\n    error InvalidAmount();\n    /// @notice throw error when payer is not the contract itself or value is not required\n    error InvalidPay();\n\n    constructor(address weth, uint160 minSqrtRatio, uint160 maxSqrtRatio) {\n        WETH = weth;\n        MIN_SQRT_RATIO = minSqrtRatio;\n        MAX_SQRT_RATIO = maxSqrtRatio;\n    }\n\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        _sell(to, pool, moreInfo);\n    }\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        _sell(to, pool, moreInfo);\n    }\n\n    function _sell(address to, address pool, bytes memory moreInfo) internal {\n        (uint160 sqrtX96, bytes memory data) = abi.decode(\n            moreInfo,\n            (uint160, bytes)\n        );\n        _uniswapV3Swap(to, pool, sqrtX96, data, _getPayerOrigin());\n    }\n\n    function _uniswapV3Swap(\n        address to,\n        address pool,\n        uint160 sqrtX96,\n        bytes memory data,\n        uint256 payerOrigin\n    ) internal {\n        (address fromToken, address toToken) = abi.decode(\n            data,\n            (address, address)\n        );\n        uint256 sellAmount = IERC20(fromToken).balanceOf(address(this));\n        bool zeroForOne = fromToken < toToken;\n        // Call the pool's swap function\n        IUniV3(pool).swap(\n            to,\n            zeroForOne,\n            int256(sellAmount),\n            sqrtX96 == 0\n                ? (zeroForOne ? MIN_SQRT_RATIO + 1 : MAX_SQRT_RATIO - 1)\n                : sqrtX96,\n            data\n        );\n        /// @notice Refund logic: if there is leftover fromToken, refund to payerOrigin\n        address _payerOrigin;\n        if ((payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            _payerOrigin = address(uint160(uint256(payerOrigin) & ADDRESS_MASK));\n        }\n        uint256 amount = IERC20(fromToken).balanceOf(address(this));\n        if (amount > 0 && _payerOrigin != address(0)) {\n            SafeERC20.safeTransfer(IERC20(fromToken), _payerOrigin, amount);\n        }\n    }\n\n    // Common internal callback logic for all V3-like protocols\n    function _universalSwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes memory data\n    ) internal {\n        if (amount0Delta <= 0 && amount1Delta <= 0) {\n            revert InvalidAmount();\n        }\n        (address tokenIn, address tokenOut) = abi.decode(\n            data,\n            (address, address)\n        );\n        address tokenA = tokenIn;\n        address tokenB = tokenOut;\n        if (tokenA > tokenB) {\n            (tokenA, tokenB) = (tokenB, tokenA);\n        }\n        (bool isExactInput, uint256 amountToPay) = amount0Delta > 0\n            ? (tokenIn < tokenOut, uint256(amount0Delta))\n            : (tokenOut < tokenIn, uint256(amount1Delta));\n        if (isExactInput) {\n            pay(tokenIn, address(this), msg.sender, amountToPay);\n        } else {\n            pay(tokenOut, address(this), msg.sender, amountToPay);\n        }\n    }\n\n    /// @notice Internal function to handle token payments during swaps\n    /// @dev This function handles two types of payments:\n    ///      1. WETH payments: If the token is WETH and contract has enough ETH balance,\n    ///         it will wrap ETH to WETH and transfer to recipient\n    ///      2. ERC20 payments: If the payer is the contract itself, it will transfer\n    ///         the ERC20 tokens directly to the recipient\n    /// @param token The token address to pay with (WETH or ERC20)\n    /// @param payer The address that should pay the tokens\n    /// @param recipient The address that should receive the tokens\n    /// @param value The amount of tokens to pay\n    /// @custom:error InvalidPay Thrown when payer is not the contract itself\n    function pay(\n        address token,\n        address payer,\n        address recipient,\n        uint256 value\n    ) internal {\n        /// @notice pay with WETH\n        if (token == WETH && address(this).balance >= value) {\n            IWETH(WETH).deposit{value: value}();\n            IWETH(WETH).transfer(recipient, value);\n            /// @notice pay with ERC20\n        } else if (payer == address(this)) {\n            SafeERC20.safeTransfer(IERC20(token), recipient, value);\n        } else {\n            revert InvalidPay();\n        }\n    }\n\n    function _getPayerOrigin() internal pure returns (uint256 payerOrigin) {\n        assembly {\n            // Get the total size of the calldata\n            let size := calldatasize()\n            // Load the last 32 bytes of the calldata, which is assumed to contain the payer origin\n            // Assumption: The calldata is structured such that the payer origin is always at the end\n            payerOrigin := calldataload(sub(size, 32))\n        }\n    }\n\n    // Fallback function to handle unexpected V3-like callbacks.\n    // It expects calldata matching the (int256 amount0Delta, int256 amount1Delta, bytes memory data) signature\n    // after the 4-byte function selector.\n    fallback(bytes calldata _calldata) external returns (bytes memory) {\n        (int256 amount0Delta, int256 amount1Delta, bytes memory data) = abi.decode(_calldata[4:], (int256, int256, bytes));\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n\n        // Uniswap V3 callbacks typically do not return values.\n        // Returning empty bytes is standard for fallbacks that successfully handle a call\n        // but don't have a specific return value defined by an interface.\n        return bytes(\"\");\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/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/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/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/IUniV3.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IUniV3 {\n    function swap(\n        address recipient,\n        bool zeroForOne,\n        int256 amountSpecified,\n        uint160 sqrtPriceLimitX96,\n        bytes calldata data\n    ) external returns (int256 amount0, int256 amount1);\n\n    function slot0()\n        external\n        view\n        returns (\n            uint160 sqrtPriceX96,\n            int24 tick,\n            uint16 observationIndex,\n            uint16 observationCardinality,\n            uint16 observationCardinalityNext,\n            uint8 feeProtocol,\n            bool unlocked\n        );\n\n    function token0() external view returns (address);\n\n    function token1() external view returns (address);\n\n    /// @notice The pool's fee in hundredths of a bip, i.e. 1e-6\n    /// @return The fee\n    function fee() external view returns (uint24);\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/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/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/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"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.17+commit.8df45f5f","compilerSettings":{"libraries":{},"optimizer":{"runs":200,"enabled":true}},"name":"UniversalUniswapV3Adaptor","fullyQualifiedName":"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol:UniversalUniswapV3Adaptor"},"abi":[{"type":"constructor","inputs":[{"name":"weth","type":"address","internalType":"address"},{"name":"minSqrtRatio","type":"uint160","internalType":"uint160"},{"name":"maxSqrtRatio","type":"uint160","internalType":"uint160"}],"stateMutability":"nonpayable"},{"name":"InvalidAmount","type":"error","inputs":[]},{"name":"InvalidPay","type":"error","inputs":[]},{"name":"SafeTransferFailed","type":"error","inputs":[]},{"type":"fallback","stateMutability":"nonpayable"},{"name":"MAX_SQRT_RATIO","type":"function","inputs":[],"outputs":[{"name":"","type":"uint160","internalType":"uint160"}],"stateMutability":"view"},{"name":"MIN_SQRT_RATIO","type":"function","inputs":[],"outputs":[{"name":"","type":"uint160","internalType":"uint160"}],"stateMutability":"view"},{"name":"WETH","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"agniSwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"algebraSwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"fireflyV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"fusionXV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pancakeV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"ramsesV2SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"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"},{"name":"uniswapV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"xeiV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.17+commit.8df45f5f"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"weth","type":"address"},{"internalType":"uint160","name":"minSqrtRatio","type":"uint160"},{"internalType":"uint160","name":"maxSqrtRatio","type":"uint160"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidPay","type":"error"},{"inputs":[],"name":"SafeTransferFailed","type":"error"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"MAX_SQRT_RATIO","outputs":[{"internalType":"uint160","name":"","type":"uint160"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_SQRT_RATIO","outputs":[{"internalType":"uint160","name":"","type":"uint160"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"agniSwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"algebraSwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"fireflyV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"fusionXV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"pancakeV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"ramsesV2SwapCallback","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":"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"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"xeiV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"custom:security-contact":"security@yourprotocol.com","details":"This contract serves as the foundation for adapting various Uniswap V3-like DEX protocols Supported DEX Protocols: 1. Uniswap V3 Family:    - Uniswap V3    - Sheepdex 2. Algebra Family:    - CamelotV3    - KimV4    - ThenaV2    - Quickswapv3    - HerculesV3    - ZyberV3 3. Other V3-like DEXs:    - Agni    - FusionX    - RamsesV2 (including NileCL)    - Xei    - PancakeV3    - FireflyV3","kind":"dev","methods":{},"title":"UniversalUniswapV3Adaptor","version":1},"userdoc":{"errors":{"InvalidAmount()":[{"notice":"throw error when amount is not positive"}],"InvalidPay()":[{"notice":"throw error when payer is not the contract itself or value is not required"}]},"kind":"user","methods":{},"notice":"Base contract for Universal Uniswap V3 Adapter implementation","version":1}},"settings":{"compilationTarget":{"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol":"UniversalUniswapV3Adaptor"},"evmVersion":"london","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"contracts/8/adapter/TemplateAdaptor/BaseUniversalUniswapV3Adaptor.sol":{"keccak256":"0x3feefbb37a4eee6a1345335f33b58f2e83db02413db723fed2f5141cae3d8165","license":"MIT","urls":["bzz-raw://6543f5c2866abc1e41354a1d6e9f9c88671f9a9758b344ae58da13b1ded97fe8","dweb:/ipfs/QmfH4NqWAfXypf98KhJcPT9Cakm2YisDDNEmDShPGLG2gm"]},"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol":{"keccak256":"0x075316aa2a951a89e96a0af2350540777ab606c3dcae98bc7693c9f925eb17db","license":"MIT","urls":["bzz-raw://2d7f8a0638f1e86755d79181ed6e51b213c079cdbae71ddb15c404927dba97ab","dweb:/ipfs/QmWMHRJAjXtsZZFtA5kpKgiu5jaYHXEr6TTcdgoWCEiF89"]},"contracts/8/interfaces/IAdapter.sol":{"keccak256":"0x8861a0548ae3a9b7467c3eb5fcd4c04bce00d58d2cb4eaedd520cf666989fc69","license":"MIT","urls":["bzz-raw://118733596fa2a3ad4c310c9fa2bae239d2daebdaffbe9518e248564c93339025","dweb:/ipfs/QmWyJPwYzW2mQFdP7bemhEpkGTrZy9oCus5fHPEcFnH4uC"]},"contracts/8/interfaces/IDaiLikePermit.sol":{"keccak256":"0x480d32f19e542d9daa222cb703dd091d4eea3b534c45269fd1f04f8ba470cc44","license":"MIT","urls":["bzz-raw://3a140269977a9ead684809df7f29ecc3b15bc98a94e1b19799cc247b8f006fcd","dweb:/ipfs/QmVgYfTVtfaUqjTkbzHe8G7ZJEhEcJqLvgGBhDLwuYfEUd"]},"contracts/8/interfaces/IERC20.sol":{"keccak256":"0xc2d4e51a0477ae32fc24b7a10da9bc9f6b0754fee338c1b099e8335b8b2fb18c","license":"MIT","urls":["bzz-raw://82f3ee0b162cf1bc9a9bfdbb24ac75af5cb2865f2183a857b53590c5ad5ab1eb","dweb:/ipfs/QmYGEwymZyHHRU4wKbXMbXwV2tVWYSVLkr1AvnhwcuSVmy"]},"contracts/8/interfaces/IERC20Permit.sol":{"keccak256":"0x25ca4efda5b398358811f84a4b914a8f1f1cc0522870d5ac166543209220900e","license":"MIT","urls":["bzz-raw://e17f726455864c6b0c14bb7dc842716b488d093de8805027728a6bfe5c4d9f7d","dweb:/ipfs/QmUfVkVkfTBnzBvjCU6ig1e9AoLyZhLfiKJxh51pu3s6Q1"]},"contracts/8/interfaces/IUniV3.sol":{"keccak256":"0x2e4f6a760cf0327cd1d1137c054e18194739b1b727b2733f3be4befdb707f0d4","license":"MIT","urls":["bzz-raw://c4a58969dceb7f930696da70cfa044e2cadf444aba12a601f1420c1ffd71109e","dweb:/ipfs/Qmf3gKajta4dcmcdPbJXYRY3J1QZ7WmagsgRkK8rmSfy5T"]},"contracts/8/interfaces/IWETH.sol":{"keccak256":"0x7dc79bded17353823f20fb059c19d7d4e17fa726d90fb16e877d80955caedd61","license":"MIT","urls":["bzz-raw://e68128f5861e8a9239e490b4f52300e8afe8f532e56bc9e42314e05579307909","dweb:/ipfs/QmSJWjomYU9uSm5GJxU3Cw32cC2th1kUDbPe5T8WNwzGqY"]},"contracts/8/libraries/Address.sol":{"keccak256":"0x922cf77144f4af34623762e2efd1ea3e9e5f6041638ff4b195322d89b73241eb","license":"MIT","urls":["bzz-raw://023e997fa9125e9733f8510916a89c2c0879a186189a0a458fcf8249d1bfc5df","dweb:/ipfs/QmaDUQvtQbBMbf5TY2ZXBrMAPDhzqMLQ4bUKVsdnV5RBnT"]},"contracts/8/libraries/RevertReasonForwarder.sol":{"keccak256":"0x12d542c0a07c83175bc927b2ecd77dd9cf9d113e1f6d242a9886920cdc84e004","license":"MIT","urls":["bzz-raw://0cda9f3b320ff838c7eaa579980203ab10d53ae56fc4b1b87e202a88a642f849","dweb:/ipfs/QmTVqFy9ADmp51CKR7wEif332Vh2FNjLZKY9KRVAtomzVT"]},"contracts/8/libraries/SafeERC20.sol":{"keccak256":"0x6fb5661c7d83a1394d05cd20d69ede4337ae8e7f68db40b4548f0656d112ed17","license":"MIT","urls":["bzz-raw://59bd76fd98e228d49f4f5172e033d4b7b0d89ca9e6bbcbea797d5da023b28124","dweb:/ipfs/QmY4Qg3U789ajRT5vyMLuuEK8x3zuPVzJoEymvtYzhLBaJ"]},"contracts/8/libraries/SafeMath.sol":{"keccak256":"0x71d16bf7d3101044d077f24e517d09d31d482830e807dc3b27c24926b0367b9f","license":"MIT","urls":["bzz-raw://292b9a002462c9402aa17b7740a41776cff5e16aa506bc3c138b1a3be39e9e39","dweb:/ipfs/QmUHUPA8k1vMYv4PG9t8BrVBngkp7HKQrG15QsYDAaVeUk"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"InvalidPay()":[{"notice":"throw error when payer is not the contract itself or value is not required"}],"InvalidAmount()":[{"notice":"throw error when amount is not positive"}]},"notice":"Base contract for Universal Uniswap V3 Adapter implementation","methods":{},"version":1},"devdoc":{"kind":"dev","title":"UniversalUniswapV3Adaptor","details":"This contract serves as the foundation for adapting various Uniswap V3-like DEX protocols Supported DEX Protocols: 1. Uniswap V3 Family:    - Uniswap V3    - Sheepdex 2. Algebra Family:    - CamelotV3    - KimV4    - ThenaV2    - Quickswapv3    - HerculesV3    - ZyberV3 3. Other V3-like DEXs:    - Agni    - FusionX    - RamsesV2 (including NileCL)    - Xei    - PancakeV3    - FireflyV3","methods":{},"version":1,"custom:security-contact":"security@yourprotocol.com"},"sourceIds":{"contracts/8/interfaces/IWETH.sol":{"id":7},"contracts/8/interfaces/IERC20.sol":{"id":4},"contracts/8/interfaces/IUniV3.sol":{"id":6},"contracts/8/libraries/Address.sol":{"id":8},"contracts/8/libraries/SafeMath.sol":{"id":11},"contracts/8/interfaces/IAdapter.sol":{"id":2},"contracts/8/libraries/SafeERC20.sol":{"id":10},"contracts/8/interfaces/IERC20Permit.sol":{"id":5},"contracts/8/interfaces/IDaiLikePermit.sol":{"id":3},"contracts/8/libraries/RevertReasonForwarder.sol":{"id":9},"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol":{"id":1},"contracts/8/adapter/TemplateAdaptor/BaseUniversalUniswapV3Adaptor.sol":{"id":0}},"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/interfaces/IUniV3.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IUniV3 {\n    function swap(\n        address recipient,\n        bool zeroForOne,\n        int256 amountSpecified,\n        uint160 sqrtPriceLimitX96,\n        bytes calldata data\n    ) external returns (int256 amount0, int256 amount1);\n\n    function slot0()\n        external\n        view\n        returns (\n            uint160 sqrtPriceX96,\n            int24 tick,\n            uint16 observationIndex,\n            uint16 observationCardinality,\n            uint16 observationCardinalityNext,\n            uint8 feeProtocol,\n            bool unlocked\n        );\n\n    function token0() external view returns (address);\n\n    function token1() external view returns (address);\n\n    /// @notice The pool's fee in hundredths of a bip, i.e. 1e-6\n    /// @return The fee\n    function fee() external view returns (uint24);\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/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/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}"},"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol":{"content":"// SPDX-License-Identifier: MIT\n// solhint-disable\npragma solidity ^0.8.0;\nimport {BaseUniversalUniswapV3Adaptor} from \"./BaseUniversalUniswapV3Adaptor.sol\";\n\n/**\n * @title UniversalUniswapV3Adaptor\n * @notice Base contract for Universal Uniswap V3 Adapter implementation\n * @dev This contract serves as the foundation for adapting various Uniswap V3-like DEX protocols\n *\n * Supported DEX Protocols:\n * 1. Uniswap V3 Family:\n *    - Uniswap V3\n *    - Sheepdex\n *\n * 2. Algebra Family:\n *    - CamelotV3\n *    - KimV4\n *    - ThenaV2\n *    - Quickswapv3\n *    - HerculesV3\n *    - ZyberV3\n *\n * 3. Other V3-like DEXs:\n *    - Agni\n *    - FusionX\n *    - RamsesV2 (including NileCL)\n *    - Xei\n *    - PancakeV3\n *    - FireflyV3\n *\n * @custom:security-contact security@yourprotocol.com\n */\ncontract UniversalUniswapV3Adaptor is BaseUniversalUniswapV3Adaptor {\n    constructor(\n        address weth,\n        uint160 minSqrtRatio,\n        uint160 maxSqrtRatio\n    ) BaseUniversalUniswapV3Adaptor(weth, minSqrtRatio, maxSqrtRatio) {}\n\n    // Uniswap V3 callback(\n    // Sheepdex,\n    // etc.)\n    function uniswapV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // Agni callback\n    function agniSwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // Algebra/Algebra-like callback (\n    // CamelotV3,\n    // KimV4,\n    // ThenaV2,\n    // Quickswapv3,\n    // HerculesV3,\n    // ZyberV3,\n    // etc.)\n    function algebraSwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // FusionX callback\n    function fusionXV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // RamsesV2 callback(\n    // NileCL,\n    // etc.)\n    function ramsesV2SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // Xei callback\n    function xeiV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // PancakeV3 callback\n    function pancakeV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n\n    // FireflyV3 callback\n    function fireflyV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external {\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n    }\n}\n"},"contracts/8/adapter/TemplateAdaptor/BaseUniversalUniswapV3Adaptor.sol":{"content":"// SPDX-License-Identifier: MIT\n// solhint-disable\npragma solidity ^0.8.0;\n\nimport {IAdapter} from \"../../interfaces/IAdapter.sol\";\nimport {IERC20} from \"../../interfaces/IERC20.sol\";\nimport {SafeERC20} from \"../../libraries/SafeERC20.sol\";\nimport {IWETH} from \"../../interfaces/IWETH.sol\";\nimport {IUniV3} from \"../../interfaces/IUniV3.sol\";\n/// @dev specific flag for refund logic, \"0x3ca20afc\" is flexible and also used for commission, \"ccc\" mean refund\nuint256 constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\nuint256 constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\nabstract contract BaseUniversalUniswapV3Adaptor is IAdapter {\n    address public immutable WETH;\n    uint160 public immutable MIN_SQRT_RATIO;\n    uint160 public immutable MAX_SQRT_RATIO;\n\n    /// @notice throw error when amount is not positive\n    error InvalidAmount();\n    /// @notice throw error when payer is not the contract itself or value is not required\n    error InvalidPay();\n\n    constructor(address weth, uint160 minSqrtRatio, uint160 maxSqrtRatio) {\n        WETH = weth;\n        MIN_SQRT_RATIO = minSqrtRatio;\n        MAX_SQRT_RATIO = maxSqrtRatio;\n    }\n\n    function sellBase(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        _sell(to, pool, moreInfo);\n    }\n\n    function sellQuote(\n        address to,\n        address pool,\n        bytes memory moreInfo\n    ) external override {\n        _sell(to, pool, moreInfo);\n    }\n\n    function _sell(address to, address pool, bytes memory moreInfo) internal {\n        (uint160 sqrtX96, bytes memory data) = abi.decode(\n            moreInfo,\n            (uint160, bytes)\n        );\n        _uniswapV3Swap(to, pool, sqrtX96, data, _getPayerOrigin());\n    }\n\n    function _uniswapV3Swap(\n        address to,\n        address pool,\n        uint160 sqrtX96,\n        bytes memory data,\n        uint256 payerOrigin\n    ) internal {\n        (address fromToken, address toToken) = abi.decode(\n            data,\n            (address, address)\n        );\n        uint256 sellAmount = IERC20(fromToken).balanceOf(address(this));\n        bool zeroForOne = fromToken < toToken;\n        // Call the pool's swap function\n        IUniV3(pool).swap(\n            to,\n            zeroForOne,\n            int256(sellAmount),\n            sqrtX96 == 0\n                ? (zeroForOne ? MIN_SQRT_RATIO + 1 : MAX_SQRT_RATIO - 1)\n                : sqrtX96,\n            data\n        );\n        /// @notice Refund logic: if there is leftover fromToken, refund to payerOrigin\n        address _payerOrigin;\n        if ((payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            _payerOrigin = address(uint160(uint256(payerOrigin) & ADDRESS_MASK));\n        }\n        uint256 amount = IERC20(fromToken).balanceOf(address(this));\n        if (amount > 0 && _payerOrigin != address(0)) {\n            SafeERC20.safeTransfer(IERC20(fromToken), _payerOrigin, amount);\n        }\n    }\n\n    // Common internal callback logic for all V3-like protocols\n    function _universalSwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes memory data\n    ) internal {\n        if (amount0Delta <= 0 && amount1Delta <= 0) {\n            revert InvalidAmount();\n        }\n        (address tokenIn, address tokenOut) = abi.decode(\n            data,\n            (address, address)\n        );\n        address tokenA = tokenIn;\n        address tokenB = tokenOut;\n        if (tokenA > tokenB) {\n            (tokenA, tokenB) = (tokenB, tokenA);\n        }\n        (bool isExactInput, uint256 amountToPay) = amount0Delta > 0\n            ? (tokenIn < tokenOut, uint256(amount0Delta))\n            : (tokenOut < tokenIn, uint256(amount1Delta));\n        if (isExactInput) {\n            pay(tokenIn, address(this), msg.sender, amountToPay);\n        } else {\n            pay(tokenOut, address(this), msg.sender, amountToPay);\n        }\n    }\n\n    /// @notice Internal function to handle token payments during swaps\n    /// @dev This function handles two types of payments:\n    ///      1. WETH payments: If the token is WETH and contract has enough ETH balance,\n    ///         it will wrap ETH to WETH and transfer to recipient\n    ///      2. ERC20 payments: If the payer is the contract itself, it will transfer\n    ///         the ERC20 tokens directly to the recipient\n    /// @param token The token address to pay with (WETH or ERC20)\n    /// @param payer The address that should pay the tokens\n    /// @param recipient The address that should receive the tokens\n    /// @param value The amount of tokens to pay\n    /// @custom:error InvalidPay Thrown when payer is not the contract itself\n    function pay(\n        address token,\n        address payer,\n        address recipient,\n        uint256 value\n    ) internal {\n        /// @notice pay with WETH\n        if (token == WETH && address(this).balance >= value) {\n            IWETH(WETH).deposit{value: value}();\n            IWETH(WETH).transfer(recipient, value);\n            /// @notice pay with ERC20\n        } else if (payer == address(this)) {\n            SafeERC20.safeTransfer(IERC20(token), recipient, value);\n        } else {\n            revert InvalidPay();\n        }\n    }\n\n    function _getPayerOrigin() internal pure returns (uint256 payerOrigin) {\n        assembly {\n            // Get the total size of the calldata\n            let size := calldatasize()\n            // Load the last 32 bytes of the calldata, which is assumed to contain the payer origin\n            // Assumption: The calldata is structured such that the payer origin is always at the end\n            payerOrigin := calldataload(sub(size, 32))\n        }\n    }\n\n    // Fallback function to handle unexpected V3-like callbacks.\n    // It expects calldata matching the (int256 amount0Delta, int256 amount1Delta, bytes memory data) signature\n    // after the 4-byte function selector.\n    fallback(bytes calldata _calldata) external returns (bytes memory) {\n        (int256 amount0Delta, int256 amount1Delta, bytes memory data) = abi.decode(_calldata[4:], (int256, int256, bytes));\n        _universalSwapCallback(amount0Delta, amount1Delta, data);\n\n        // Uniswap V3 callbacks typically do not return values.\n        // Returning empty bytes is standard for fallbacks that successfully handle a call\n        // but don't have a specific return value defined by an interface.\n        return bytes(\"\");\n    }\n}\n"}},"language":"Solidity","settings":{"libraries":{},"optimizer":{"runs":200,"enabled":true}}},"stdJsonOutput":{"sources":{"contracts/8/interfaces/IWETH.sol":{"id":7},"contracts/8/interfaces/IERC20.sol":{"id":4},"contracts/8/interfaces/IUniV3.sol":{"id":6},"contracts/8/libraries/Address.sol":{"id":8},"contracts/8/libraries/SafeMath.sol":{"id":11},"contracts/8/interfaces/IAdapter.sol":{"id":2},"contracts/8/libraries/SafeERC20.sol":{"id":10},"contracts/8/interfaces/IERC20Permit.sol":{"id":5},"contracts/8/interfaces/IDaiLikePermit.sol":{"id":3},"contracts/8/libraries/RevertReasonForwarder.sol":{"id":9},"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol":{"id":1},"contracts/8/adapter/TemplateAdaptor/BaseUniversalUniswapV3Adaptor.sol":{"id":0}},"contracts":{"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol":{"UniversalUniswapV3Adaptor":{"abi":[{"type":"constructor","inputs":[{"name":"weth","type":"address","internalType":"address"},{"name":"minSqrtRatio","type":"uint160","internalType":"uint160"},{"name":"maxSqrtRatio","type":"uint160","internalType":"uint160"}],"stateMutability":"nonpayable"},{"name":"InvalidAmount","type":"error","inputs":[]},{"name":"InvalidPay","type":"error","inputs":[]},{"name":"SafeTransferFailed","type":"error","inputs":[]},{"type":"fallback","stateMutability":"nonpayable"},{"name":"MAX_SQRT_RATIO","type":"function","inputs":[],"outputs":[{"name":"","type":"uint160","internalType":"uint160"}],"stateMutability":"view"},{"name":"MIN_SQRT_RATIO","type":"function","inputs":[],"outputs":[{"name":"","type":"uint160","internalType":"uint160"}],"stateMutability":"view"},{"name":"WETH","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"agniSwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"algebraSwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"fireflyV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"fusionXV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pancakeV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"ramsesV2SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"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"},{"name":"uniswapV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"xeiV3SwapCallback","type":"function","inputs":[{"name":"amount0Delta","type":"int256","internalType":"int256"},{"name":"amount1Delta","type":"int256","internalType":"int256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"weth\",\"type\":\"address\"},{\"internalType\":\"uint160\",\"name\":\"minSqrtRatio\",\"type\":\"uint160\"},{\"internalType\":\"uint160\",\"name\":\"maxSqrtRatio\",\"type\":\"uint160\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"InvalidAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidPay\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SafeTransferFailed\",\"type\":\"error\"},{\"stateMutability\":\"nonpayable\",\"type\":\"fallback\"},{\"inputs\":[],\"name\":\"MAX_SQRT_RATIO\",\"outputs\":[{\"internalType\":\"uint160\",\"name\":\"\",\"type\":\"uint160\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MIN_SQRT_RATIO\",\"outputs\":[{\"internalType\":\"uint160\",\"name\":\"\",\"type\":\"uint160\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WETH\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"agniSwapCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"algebraSwapCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"fireflyV3SwapCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"fusionXV3SwapCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"pancakeV3SwapCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ramsesV2SwapCallback\",\"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\":\"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\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"uniswapV3SwapCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"amount0Delta\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1Delta\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"xeiV3SwapCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"custom:security-contact\":\"security@yourprotocol.com\",\"details\":\"This contract serves as the foundation for adapting various Uniswap V3-like DEX protocols Supported DEX Protocols: 1. Uniswap V3 Family:    - Uniswap V3    - Sheepdex 2. Algebra Family:    - CamelotV3    - KimV4    - ThenaV2    - Quickswapv3    - HerculesV3    - ZyberV3 3. Other V3-like DEXs:    - Agni    - FusionX    - RamsesV2 (including NileCL)    - Xei    - PancakeV3    - FireflyV3\",\"kind\":\"dev\",\"methods\":{},\"title\":\"UniversalUniswapV3Adaptor\",\"version\":1},\"userdoc\":{\"errors\":{\"InvalidAmount()\":[{\"notice\":\"throw error when amount is not positive\"}],\"InvalidPay()\":[{\"notice\":\"throw error when payer is not the contract itself or value is not required\"}]},\"kind\":\"user\",\"methods\":{},\"notice\":\"Base contract for Universal Uniswap V3 Adapter implementation\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol\":\"UniversalUniswapV3Adaptor\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/8/adapter/TemplateAdaptor/BaseUniversalUniswapV3Adaptor.sol\":{\"keccak256\":\"0x3feefbb37a4eee6a1345335f33b58f2e83db02413db723fed2f5141cae3d8165\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6543f5c2866abc1e41354a1d6e9f9c88671f9a9758b344ae58da13b1ded97fe8\",\"dweb:/ipfs/QmfH4NqWAfXypf98KhJcPT9Cakm2YisDDNEmDShPGLG2gm\"]},\"contracts/8/adapter/TemplateAdaptor/UniversalUniswapV3Adaptor.sol\":{\"keccak256\":\"0x075316aa2a951a89e96a0af2350540777ab606c3dcae98bc7693c9f925eb17db\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2d7f8a0638f1e86755d79181ed6e51b213c079cdbae71ddb15c404927dba97ab\",\"dweb:/ipfs/QmWMHRJAjXtsZZFtA5kpKgiu5jaYHXEr6TTcdgoWCEiF89\"]},\"contracts/8/interfaces/IAdapter.sol\":{\"keccak256\":\"0x8861a0548ae3a9b7467c3eb5fcd4c04bce00d58d2cb4eaedd520cf666989fc69\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://118733596fa2a3ad4c310c9fa2bae239d2daebdaffbe9518e248564c93339025\",\"dweb:/ipfs/QmWyJPwYzW2mQFdP7bemhEpkGTrZy9oCus5fHPEcFnH4uC\"]},\"contracts/8/interfaces/IDaiLikePermit.sol\":{\"keccak256\":\"0x480d32f19e542d9daa222cb703dd091d4eea3b534c45269fd1f04f8ba470cc44\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3a140269977a9ead684809df7f29ecc3b15bc98a94e1b19799cc247b8f006fcd\",\"dweb:/ipfs/QmVgYfTVtfaUqjTkbzHe8G7ZJEhEcJqLvgGBhDLwuYfEUd\"]},\"contracts/8/interfaces/IERC20.sol\":{\"keccak256\":\"0xc2d4e51a0477ae32fc24b7a10da9bc9f6b0754fee338c1b099e8335b8b2fb18c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://82f3ee0b162cf1bc9a9bfdbb24ac75af5cb2865f2183a857b53590c5ad5ab1eb\",\"dweb:/ipfs/QmYGEwymZyHHRU4wKbXMbXwV2tVWYSVLkr1AvnhwcuSVmy\"]},\"contracts/8/interfaces/IERC20Permit.sol\":{\"keccak256\":\"0x25ca4efda5b398358811f84a4b914a8f1f1cc0522870d5ac166543209220900e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e17f726455864c6b0c14bb7dc842716b488d093de8805027728a6bfe5c4d9f7d\",\"dweb:/ipfs/QmUfVkVkfTBnzBvjCU6ig1e9AoLyZhLfiKJxh51pu3s6Q1\"]},\"contracts/8/interfaces/IUniV3.sol\":{\"keccak256\":\"0x2e4f6a760cf0327cd1d1137c054e18194739b1b727b2733f3be4befdb707f0d4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c4a58969dceb7f930696da70cfa044e2cadf444aba12a601f1420c1ffd71109e\",\"dweb:/ipfs/Qmf3gKajta4dcmcdPbJXYRY3J1QZ7WmagsgRkK8rmSfy5T\"]},\"contracts/8/interfaces/IWETH.sol\":{\"keccak256\":\"0x7dc79bded17353823f20fb059c19d7d4e17fa726d90fb16e877d80955caedd61\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e68128f5861e8a9239e490b4f52300e8afe8f532e56bc9e42314e05579307909\",\"dweb:/ipfs/QmSJWjomYU9uSm5GJxU3Cw32cC2th1kUDbPe5T8WNwzGqY\"]},\"contracts/8/libraries/Address.sol\":{\"keccak256\":\"0x922cf77144f4af34623762e2efd1ea3e9e5f6041638ff4b195322d89b73241eb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://023e997fa9125e9733f8510916a89c2c0879a186189a0a458fcf8249d1bfc5df\",\"dweb:/ipfs/QmaDUQvtQbBMbf5TY2ZXBrMAPDhzqMLQ4bUKVsdnV5RBnT\"]},\"contracts/8/libraries/RevertReasonForwarder.sol\":{\"keccak256\":\"0x12d542c0a07c83175bc927b2ecd77dd9cf9d113e1f6d242a9886920cdc84e004\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0cda9f3b320ff838c7eaa579980203ab10d53ae56fc4b1b87e202a88a642f849\",\"dweb:/ipfs/QmTVqFy9ADmp51CKR7wEif332Vh2FNjLZKY9KRVAtomzVT\"]},\"contracts/8/libraries/SafeERC20.sol\":{\"keccak256\":\"0x6fb5661c7d83a1394d05cd20d69ede4337ae8e7f68db40b4548f0656d112ed17\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://59bd76fd98e228d49f4f5172e033d4b7b0d89ca9e6bbcbea797d5da023b28124\",\"dweb:/ipfs/QmY4Qg3U789ajRT5vyMLuuEK8x3zuPVzJoEymvtYzhLBaJ\"]},\"contracts/8/libraries/SafeMath.sol\":{\"keccak256\":\"0x71d16bf7d3101044d077f24e517d09d31d482830e807dc3b27c24926b0367b9f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://292b9a002462c9402aa17b7740a41776cff5e16aa506bc3c138b1a3be39e9e39\",\"dweb:/ipfs/QmUHUPA8k1vMYv4PG9t8BrVBngkp7HKQrG15QsYDAaVeUk\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"InvalidPay()":[{"notice":"throw error when payer is not the contract itself or value is not required"}],"InvalidAmount()":[{"notice":"throw error when amount is not positive"}]},"notice":"Base contract for Universal Uniswap V3 Adapter implementation","methods":{},"version":1},"devdoc":{"kind":"dev","title":"UniversalUniswapV3Adaptor","details":"This contract serves as the foundation for adapting various Uniswap V3-like DEX protocols Supported DEX Protocols: 1. Uniswap V3 Family:    - Uniswap V3    - Sheepdex 2. Algebra Family:    - CamelotV3    - KimV4    - ThenaV2    - Quickswapv3    - HerculesV3    - ZyberV3 3. Other V3-like DEXs:    - Agni    - FusionX    - RamsesV2 (including NileCL)    - Xei    - PancakeV3    - FireflyV3","methods":{},"version":1,"custom:security-contact":"security@yourprotocol.com"},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"793:2310:1:-:0;;;867:166;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1129:11:0;;;;;1150:29;;;;;1189;;;793:2310:1;;14:131:12;-1:-1:-1;;;;;89:31:12;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:519::-;238:6;246;254;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;355:9;349:16;374:31;399:5;374:31;:::i;:::-;474:2;459:18;;453:25;424:5;;-1:-1:-1;487:33:12;453:25;487:33;:::i;:::-;591:2;576:18;;570:25;539:7;;-1:-1:-1;604:33:12;570:25;604:33;:::i;:::-;656:7;646:17;;;150:519;;;;;:::o;:::-;793:2310:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"793:2310:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6014:12:0;793:2310:1;;;6113:13:0;793:2310:1;6123:1:0;793:2310:1;;6113:13:0;:::i;:::-;6102:50;;;;;;;:::i;:::-;6038:114;;;;;;6162:56;6185:12;6199;6213:4;6162:22;:56::i;:::-;-1:-1:-1;;6466:9:0;;;;;;;;;-1:-1:-1;6466:9:0;;-1:-1:-1;2657:206:1;;;;;;:::i;:::-;;:::i;:::-;;1231:157:0;;;;;;:::i;:::-;;:::i;804:39::-;;;;;;;;-1:-1:-1;;;;;3510:32:12;;;3492:51;;3480:2;3465:18;804:39:0;;;;;;;724:29;;;;;759:39;;;;;3086:889;3248:1;3232:12;:17;;:38;;;;;3269:1;3253:12;:17;;3232:38;3228:91;;;3293:15;;-1:-1:-1;;;3293:15:0;;;;;;;;;;;3228:91;3329:15;3346:16;3390:4;3366:70;;;;;;;;;;;;:::i;:::-;3328:108;;-1:-1:-1;3328:108:0;-1:-1:-1;3328:108:0;;-1:-1:-1;;;;;3519:15:0;;;;;;;3515:81;;;3570:6;3515:81;3606:17;3625:19;3663:1;3648:12;:16;:132;;3749:7;-1:-1:-1;;;;;3738:18:0;:8;-1:-1:-1;;;;;3738:18:0;;3766:12;3648:132;;;3690:8;-1:-1:-1;;;;;3680:18:0;:7;-1:-1:-1;;;;;3680:18:0;;3708:12;3648:132;3605:175;;;;3794:12;3790:179;;;3822:52;3826:7;3843:4;3850:10;3862:11;3822:3;:52::i;:::-;3790:179;;;3905:53;3909:8;3927:4;3934:10;3946:11;3905:3;:53::i;:::-;3218:757;;;;;;3086:889;;;:::o;2657:206:1:-;2800:56;2823:12;2837;2851:4;;2800:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2800:22:1;;-1:-1:-1;;;2800:56:1:i;:::-;2657:206;;;;:::o;1231:157:0:-;1356:25;1362:2;1366:4;1372:8;1356:5;:25::i;:::-;1231:157;;;:::o;4734:542::-;4915:4;-1:-1:-1;;;;;4906:13:0;:5;-1:-1:-1;;;;;4906:13:0;;:47;;;;;4948:5;4923:21;:30;;4906:47;4902:368;;;4975:4;-1:-1:-1;;;;;4969:19:0;;4996:5;4969:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5018:38:0;;-1:-1:-1;;;5018:38:0;;-1:-1:-1;;;;;4360:32:12;;;5018:38:0;;;4342:51:12;4409:18;;;4402:34;;;5024:4:0;5018:20;;-1:-1:-1;5018:20:0;;-1:-1:-1;4315:18:12;;;-1:-1:-1;5018:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;4902:368;;;5133:4;-1:-1:-1;;;;;5116:22:0;;;5112:158;;5154:55;5184:5;5192:9;5203:5;5154:22;:55::i;:::-;5112:158;;;5247:12;;-1:-1:-1;;;5247:12:0;;;;;;;;;;;1558:269;1642:15;1659:17;1704:8;1680:72;;;;;;;;;;;;:::i;:::-;1641:111;;;;1762:58;1777:2;1781:4;1787:7;1796:4;1802:17;-1:-1:-1;;5448:14:0;5705:13;5692:27;;5282:453;1802:17;1762:14;:58::i;:::-;1631:196;;1558:269;;;:::o;1614:199:10:-;1701:52;1711:5;-1:-1:-1;;;1743:2:10;1747:5;1701:9;:52::i;:::-;1696:111;;1776:20;;-1:-1:-1;;;1776:20:10;;;;;;;;;;;1833:1183:0;2006:17;2025:15;2068:4;2044:70;;;;;;;;;;;;:::i;:::-;2145:42;;-1:-1:-1;;;2145:42:0;;2181:4;2145:42;;;3492:51:12;2005:109:0;;-1:-1:-1;2005:109:0;-1:-1:-1;2124:18:0;;-1:-1:-1;;;;;2145:27:0;;;;;3465:18:12;;2145:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2124:63;;2197:15;2227:7;-1:-1:-1;;;;;2215:19:0;:9;-1:-1:-1;;;;;2215:19:0;;2197:37;;2292:4;-1:-1:-1;;;;;2285:17:0;;2316:2;2332:10;2363;2388:7;-1:-1:-1;;;;;2388:12:0;2399:1;2388:12;:111;;2492:7;2388:111;;;2420:10;:52;;2454:18;2471:1;2454:14;:18;:::i;:::-;2420:52;;;2433:18;:14;2450:1;2433:18;:::i;:::-;2513:4;2285:242;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;2625:20;-1:-1:-1;;;489:66:0;2660:11;:26;2659:44;2655:143;;-1:-1:-1;;;;;;2750:35:0;;2655:143;2824:42;;-1:-1:-1;;;2824:42:0;;2860:4;2824:42;;;3492:51:12;2807:14:0;;-1:-1:-1;;;;;2824:27:0;;;;;3465:18:12;;2824:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2807:59;;2889:1;2880:6;:10;:40;;;;-1:-1:-1;;;;;;2894:26:0;;;;2880:40;2876:134;;;2936:63;2966:9;2978:12;2992:6;2936:22;:63::i;:::-;1995:1021;;;;;;1833:1183;;;;;:::o;3534:683:10:-;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:331:12:-;119:9;130;172:8;160:10;157:24;154:44;;;194:1;191;184:12;154:44;223:6;213:8;210:20;207:40;;;243:1;240;233:12;207:40;-1:-1:-1;;269:23:12;;;314:25;;;;;-1:-1:-1;14:331:12:o;350:127::-;411:10;406:3;402:20;399:1;392:31;442:4;439:1;432:15;466:4;463:1;456:15;482:275;553:2;547:9;618:2;599:13;;-1:-1:-1;;595:27:12;583:40;;653:18;638:34;;674:22;;;635:62;632:88;;;700:18;;:::i;:::-;736:2;729:22;482:275;;-1:-1:-1;482:275:12:o;762:186::-;810:4;843:18;835:6;832:30;829:56;;;865:18;;:::i;:::-;-1:-1:-1;931:2:12;910:15;-1:-1:-1;;906:29:12;937:4;902:40;;762:186::o;953:462::-;995:5;1048:3;1041:4;1033:6;1029:17;1025:27;1015:55;;1066:1;1063;1056:12;1015:55;1102:6;1089:20;1133:48;1149:31;1177:2;1149:31;:::i;:::-;1133:48;:::i;:::-;1206:2;1197:7;1190:19;1252:3;1245:4;1240:2;1232:6;1228:15;1224:26;1221:35;1218:55;;;1269:1;1266;1259:12;1218:55;1334:2;1327:4;1319:6;1315:17;1308:4;1299:7;1295:18;1282:55;1382:1;1357:16;;;1375:4;1353:27;1346:38;;;;1361:7;953:462;-1:-1:-1;;;953:462:12:o;1420:454::-;1504:6;1512;1520;1573:2;1561:9;1552:7;1548:23;1544:32;1541:52;;;1589:1;1586;1579:12;1541:52;1625:9;1612:23;1602:33;;1682:2;1671:9;1667:18;1654:32;1644:42;;1737:2;1726:9;1722:18;1709:32;1764:18;1756:6;1753:30;1750:50;;;1796:1;1793;1786:12;1750:50;1819:49;1860:7;1851:6;1840:9;1836:22;1819:49;:::i;:::-;1809:59;;;1420:454;;;;;:::o;1879:725::-;1965:6;1973;1981;1989;2042:2;2030:9;2021:7;2017:23;2013:32;2010:52;;;2058:1;2055;2048:12;2010:52;2094:9;2081:23;2071:33;;2151:2;2140:9;2136:18;2123:32;2113:42;;2206:2;2195:9;2191:18;2178:32;2229:18;2270:2;2262:6;2259:14;2256:34;;;2286:1;2283;2276:12;2256:34;2324:6;2313:9;2309:22;2299:32;;2369:7;2362:4;2358:2;2354:13;2350:27;2340:55;;2391:1;2388;2381:12;2340:55;2431:2;2418:16;2457:2;2449:6;2446:14;2443:34;;;2473:1;2470;2463:12;2443:34;2518:7;2513:2;2504:6;2500:2;2496:15;2492:24;2489:37;2486:57;;;2539:1;2536;2529:12;2486:57;1879:725;;;;-1:-1:-1;;2570:2:12;2562:11;;-1:-1:-1;;;1879:725:12:o;2609:131::-;-1:-1:-1;;;;;2684:31:12;;2674:42;;2664:70;;2730:1;2727;2720:12;2664:70;2609:131;:::o;2745:596::-;2831:6;2839;2847;2900:2;2888:9;2879:7;2875:23;2871:32;2868:52;;;2916:1;2913;2906:12;2868:52;2955:9;2942:23;2974:31;2999:5;2974:31;:::i;:::-;3024:5;-1:-1:-1;3081:2:12;3066:18;;3053:32;3094:33;3053:32;3094:33;:::i;:::-;3146:7;-1:-1:-1;3204:2:12;3189:18;;3176:32;3231:18;3220:30;;3217:50;;;3263:1;3260;3253:12;3762:401;3857:6;3865;3918:2;3906:9;3897:7;3893:23;3889:32;3886:52;;;3934:1;3931;3924:12;3886:52;3966:9;3960:16;3985:31;4010:5;3985:31;:::i;:::-;4085:2;4070:18;;4064:25;4035:5;;-1:-1:-1;4098:33:12;4064:25;4098:33;:::i;:::-;4150:7;4140:17;;;3762:401;;;;;:::o;4447:277::-;4514:6;4567:2;4555:9;4546:7;4542:23;4538:32;4535:52;;;4583:1;4580;4573:12;4535:52;4615:9;4609:16;4668:5;4661:13;4654:21;4647:5;4644:32;4634:60;;4690:1;4687;4680:12;4634:60;4713:5;4447:277;-1:-1:-1;;;4447:277:12:o;4729:250::-;4814:1;4824:113;4838:6;4835:1;4832:13;4824:113;;;4914:11;;;4908:18;4895:11;;;4888:39;4860:2;4853:10;4824:113;;;-1:-1:-1;;4971:1:12;4953:16;;4946:27;4729:250::o;4984:775::-;5072:6;5080;5133:2;5121:9;5112:7;5108:23;5104:32;5101:52;;;5149:1;5146;5139:12;5101:52;5181:9;5175:16;5200:31;5225:5;5200:31;:::i;:::-;5299:2;5284:18;;5278:25;5250:5;;-1:-1:-1;5326:18:12;5315:30;;5312:50;;;5358:1;5355;5348:12;5312:50;5381:22;;5434:4;5426:13;;5422:27;-1:-1:-1;5412:55:12;;5463:1;5460;5453:12;5412:55;5492:2;5486:9;5517:48;5533:31;5561:2;5533:31;:::i;5517:48::-;5588:2;5581:5;5574:17;5628:7;5623:2;5618;5614;5610:11;5606:20;5603:33;5600:53;;;5649:1;5646;5639:12;5600:53;5662:67;5726:2;5721;5714:5;5710:14;5705:2;5701;5697:11;5662:67;:::i;:::-;5748:5;5738:15;;;;;4984:775;;;;;:::o;5764:184::-;5834:6;5887:2;5875:9;5866:7;5862:23;5858:32;5855:52;;;5903:1;5900;5893:12;5855:52;-1:-1:-1;5926:16:12;;5764:184;-1:-1:-1;5764:184:12:o;5953:127::-;6014:10;6009:3;6005:20;6002:1;5995:31;6045:4;6042:1;6035:15;6069:4;6066:1;6059:15;6085:185;-1:-1:-1;;;;;6206:10:12;;;6194;;;6190:27;;6229:12;;;6226:38;;;6244:18;;:::i;:::-;6226:38;6085:185;;;;:::o;6275:182::-;-1:-1:-1;;;;;6382:10:12;;;6394;;;6378:27;;6417:11;;;6414:37;;;6431:18;;:::i;6462:747::-;6676:4;6722:1;6718;6713:3;6709:11;6705:19;6763:2;6755:6;6751:15;6740:9;6733:34;6817:6;6810:14;6803:22;6798:2;6787:9;6783:18;6776:50;6862:6;6857:2;6846:9;6842:18;6835:34;6917:2;6909:6;6905:15;6900:2;6889:9;6885:18;6878:43;;6958:3;6952;6941:9;6937:19;6930:32;6991:6;6985:13;7035:6;7029:3;7018:9;7014:19;7007:35;7051:80;7124:6;7118:3;7107:9;7103:19;7098:2;7090:6;7086:15;7051:80;:::i;:::-;7192:2;7171:15;-1:-1:-1;;7167:29:12;7152:45;;;;7199:3;7148:55;;6462:747;-1:-1:-1;;;;;;6462:747:12:o;7214:243::-;7291:6;7299;7352:2;7340:9;7331:7;7327:23;7323:32;7320:52;;;7368:1;7365;7358:12;7320:52;-1:-1:-1;;7391:16:12;;7447:2;7432:18;;;7426:25;7391:16;;7426:25;;-1:-1:-1;7214:243:12:o","linkReferences":{},"immutableReferences":{"22":[{"start":389,"length":32},{"start":762,"length":32},{"start":832,"length":32},{"start":981,"length":32}],"24":[{"start":428,"length":32},{"start":1524,"length":32}],"26":[{"start":322,"length":32},{"start":1478,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"agniSwapCallback(int256,int256,bytes)","signatureHash4":"0x5bee97a3","signatureHash32":"0x5bee97a3e21ac9fc6093fef9815138daa5a2594df3700a29979a2f2d6375c4f3"},{"signature":"algebraSwapCallback(int256,int256,bytes)","signatureHash4":"0x2c8958f6","signatureHash32":"0x2c8958f68df94d02a95e5f45440ae10801a4d2b22262720b22f7b9fe432e7666"},{"signature":"fireflyV3SwapCallback(int256,int256,bytes)","signatureHash4":"0xdcbf3bf0","signatureHash32":"0xdcbf3bf00ce083a9b6803e268658fe681750235ac0890faa563615647b3a631b"},{"signature":"fusionXV3SwapCallback(int256,int256,bytes)","signatureHash4":"0xae067e0f","signatureHash32":"0xae067e0f556a7b11ed1542fcbe9f9edafbc1dc6e8de5751020713e142239b69d"},{"signature":"MAX_SQRT_RATIO()","signatureHash4":"0x6d2cc304","signatureHash32":"0x6d2cc30490a2ebe5dc8f0e4e3be3a2ac9f139769e8de4b51c9112643de09a9a6"},{"signature":"MIN_SQRT_RATIO()","signatureHash4":"0xee8847ff","signatureHash32":"0xee8847ffe12d01cb8a399a793b38e7340c0d113eba4cc08bc30e767be66f0cdf"},{"signature":"pancakeV3SwapCallback(int256,int256,bytes)","signatureHash4":"0x23a69e75","signatureHash32":"0x23a69e75c6b3da149d115d1d92bd5ec776610591e8f01b1c49e06ca7960e1c86"},{"signature":"ramsesV2SwapCallback(int256,int256,bytes)","signatureHash4":"0x654b6487","signatureHash32":"0x654b6487bddcdcc990d67fd3fc5075d6c4988ea24d070b443027c29967f2eb8a"},{"signature":"sellBase(address,address,bytes)","signatureHash4":"0x30e6ae31","signatureHash32":"0x30e6ae317bb74e054afcab0bd57887675415dfd395c5c8a31736e196757b1e81"},{"signature":"sellQuote(address,address,bytes)","signatureHash4":"0x6f7929f2","signatureHash32":"0x6f7929f2b01195712498d48a0811ef40554ee216f994a893f4b2ce9624a6eca8"},{"signature":"uniswapV3SwapCallback(int256,int256,bytes)","signatureHash4":"0xfa461e33","signatureHash32":"0xfa461e33028c3f5ba6fd24f0f40b936af65270d771ddf3e963f1798ed73aadc4"},{"signature":"WETH()","signatureHash4":"0xad5c4648","signatureHash32":"0xad5c46488b7de578b546a5d35cea48a937114e7ed63179543cd1f8e1899a1241"},{"signature":"xeiV3SwapCallback(int256,int256,bytes)","signatureHash4":"0x86cbcd52","signatureHash32":"0x86cbcd525aa617feb9d7ffce85adc6ad597107a679e3e8a8e7425edcc72a1e2f"}],"event":[],"error":[{"signature":"InvalidAmount()","signatureHash4":"0x2c5211c6","signatureHash32":"0x2c5211c6cb73b16841677a034781e8336d18ce66df858e54153c86854e11f7b8"},{"signature":"InvalidPay()","signatureHash4":"0x273fa35b","signatureHash32":"0x273fa35bbde50dc8d213d94faa85c32b2a2ebfd5fbbbfba17a719a5716f29ea3"},{"signature":"SafeTransferFailed()","signatureHash4":"0xfb7f5079","signatureHash32":"0xfb7f50796995f43b6f601c7bdc661fff3554a3197898a14efb94c31f671088ce"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x6747BcaF9bD5a5F0758Cbe08903490E45DdfACB5"}