{"matchId":"58747000","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-07T12:49:48Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"3363:11368:92:-:0;;;;;;;;;;;;;-1:-1:-1;;3363:11368:92;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;-1:-1:-1;;;;;3363:11368:92;;;5392:19;3363:11368;;;;5447:19;3363:11368;;5494:12;;3363:11368;5516:12;3363:11368;;;;;;;;5494:12;3363:11368;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;-1:-1:-1;3363:11368:92;;;;;;-1:-1:-1;3363:11368:92;;;;;-1:-1:-1;3363:11368:92;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220c0f252b028b6c0e65974e5d3a097627861ea7e86530861d92c4f6803c125d79064736f6c63430008140033","offset":5018}},"transformations":[{"type":"insert","offset":5071,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x00000000000000000000000000000000000014aa86c5d3c41765bb24e11bd701000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"3363:11368:92:-:0;;;;;;;;;;-1:-1:-1;3363:11368:92;;;;;;;;;;;;;;5808:4;;3363:11368;5794:10;:18;:40;;;;;3363:11368;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;5794:40;5830:4;;;3363:11368;5794:10;5816:18;5794:40;;;3363:11368;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3486:29;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;;;;;;-1:-1:-1;;3363:11368:92;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3363:11368:92;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;6248:11;3363:11368;;-1:-1:-1;3363:11368:92;;;;-1:-1:-1;;;6274:46:92;;6314:4;3363:11368;6274:46;;3363:11368;;;;;;;;;;-1:-1:-1;;;;;3363:11368:92;6274:46;;;;;;;;;;;6248:93;;;;6359:12;;;:62;;;6248:93;3363:11368;;;;;;6527:9;3363:11368;;;;;6503:84;;3363:11368;;;;;;6503:84;;3363:11368;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;3363:11368:92;;;;6774:4;6751:36;-1:-1:-1;;;;;3363:11368:92;;;;6842:4;6819:36;-1:-1:-1;;;;;3363:11368:92;;;;;;7068:26;3363:11368;;;;-1:-1:-1;;;;;3363:11368:92;;;;;7158:28;;3363:11368;;7202:16;;3363:11368;7202:16;;7154:223;;7572:42;;;;5296:29;7572:42;;7670:33;;;;5296:29;7670:33;;3363:11368;;;;;;;-1:-1:-1;;;7804:35:92;;-1:-1:-1;;;;;3363:11368:92;;;;;7804:35;;3363:11368;;;;;;;;;;7804:35;;;;;;;;;;;7670:33;3363:11368;;;;;;;;;;;8088:75;;3363:11368;;;;;;;;3744:10;;3363:11368;;3744:10;;3363:11368;5296:29;3363:11368;5296:29;;4124:10;5296:29;;;3363:11368;5296:29;;7563:91;:141;3363:11368;3744:10;;3363:11368;3744:10;;3363:11368;3744:10;;;3363:11368;;;;;;;;;3744:10;;3363:11368;;3744:10;;3363:11368;;8088:75;;3363:11368;;;;;;;;;;;;;;;;;;;8028:149;3363:11368;8028:149;;3363:11368;;;;3744:10;;;3363:11368;3744:10;;;;:::i;:::-;8028:149;;;;;;;;;;;;:::i;:::-;8005:182;:4;;;:182;;;;:::i;:::-;8201:3;;8197:122;;8964:21;;8999:12;8995:143;;7670:33;-1:-1:-1;3363:11368:92;;;;;;;-1:-1:-1;;;9453:35:92;;-1:-1:-1;;;;;3363:11368:92;;;;;9453:35;;3363:11368;;;;;;;;;;;9453:35;;;;;;;;;;;7670:33;3744:10;;;;;;;;;;9518:13;;3744:10;;3363:11368;;;;;;;;3744:10;3363:11368;;-1:-1:-1;;;3744:10:92;;3363:11368;;3744:10;;;;3363:11368;3744:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;3744:10;3363:11368;;3744:10;;-1:-1:-1;;;3744:10:92;;;3363:11368;3744:10;3363:11368;;3744:10;9453:35;;;3363:11368;9453:35;;3363:11368;9453:35;;;;;;3363:11368;9453:35;;;:::i;:::-;;;3363:11368;;;;;9453:35;;;3363:11368;;;;9453:35;;;-1:-1:-1;9453:35:92;;;3363:11368;;;;;;;;;8995:143;9034:4;3363:11368;-1:-1:-1;;;;;3363:11368:92;;9027:39;;;;;3363:11368;;;;;;;;;;;;;9027:39;;;;;;;;;;8995:143;3363:11368;;;9118:8;3363:11368;;;;;;9118:8;;:::i;:::-;8995:143;;;;9027:39;;;;;;;:::i;:::-;3363:11368;;9027:39;;;;;3363:11368;;;;9027:39;3363:11368;;;;;;;;;9027:39;3363:11368;;;8197:122;3363:11368;8220:89;;;;;3363:11368;3744:10;;;3363:11368;;;;;;;;7804:35;;;;3363:11368;7804:35;;3363:11368;7804:35;;;;;;3363:11368;7804:35;;;:::i;:::-;;;3363:11368;;;;;7804:35;;;;;;;-1:-1:-1;7804:35:92;;;3363:11368;;;;;;;;;7670:33;;;;;7572:42;5230:19;7572:42;;;7154:223;-1:-1:-1;;;;;3363:11368:92;7239:28;3363:11368;;;7283:15;3363:11368;7235:142;7154:223;;7235:142;3363:11368;;-1:-1:-1;;;7329:37:92;;3363:11368;;7329:37;;3363:11368;;;;;;;;;;;;;7329:37;3363:11368;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;6819:36;-1:-1:-1;;;;;3363:11368:92;;6819:36;;6751;-1:-1:-1;;;;;3363:11368:92;;6751:36;;3363:11368;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;6359:62;6375:46;6403:16;6375:46;;;6359:62;;6274:46;;;3363:11368;6274:46;;3363:11368;6274:46;;;;;;3363:11368;6274:46;;;:::i;:::-;;;3363:11368;;;;;6274:46;;;;;;-1:-1:-1;6274:46:92;;6248:93;;;;3363:11368;;;;;;;;;;;;;;;;;;;3605:29;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;;;;;;-1:-1:-1;;3363:11368:92;;;;9986:4;-1:-1:-1;;;;;3363:11368:92;9972:10;:18;3363:11368;;;;10247:2;3363:11368;;;;;-1:-1:-1;;3363:11368:92;;;;10247:2;3363:11368;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;:::i;:::-;;;;3744:10;;3363:11368;;;;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;10527:64;;;;;-1:-1:-1;;;;;3363:11368:92;;;10247:2;10527:64;;3363:11368;;;3944:10;;;3363:11368;;;;3944:10;;;3363:11368;;;;3944:10;;;3363:11368;;;;;10527:64;3363:11368;3944:10;;;10527:64;;;;;;;;;;:::i;:::-;3363:11368;10504:97;;10527:64;;9986:4;;10504:97;;;;:::i;:::-;10474:127;10615:3;;10474:127;10615:3;:22;;3363:11368;10615:62;;;3363:11368;10611:667;;;3363:11368;11291:3;11287:122;;3363:11368;;;11426:16;4389:10;;3363:11368;11707:78;;3363:11368;;;;;-1:-1:-1;;;;;3363:11368:92;;;;;12000:26;3363:11368;;12000:26;3363:11368;;;-1:-1:-1;;;;;3363:11368:92;;;12000:26;3363:11368;;;;;-1:-1:-1;;;;;;3363:11368:92;;12055:26;3363:11368;;;;;12108:26;;3363:11368;;;;;12162:26;;;3363:11368;;;;12206:11;:27;;;12162:26;4389:10;;;3363:11368;;;;;-1:-1:-1;;4389:10:92;;;;;;3363:11368;;;12526:16;;4389:10;;12591:4;;;:::i;:::-;-1:-1:-1;;;;;3363:11368:92;;14265:19;:40;;;;14295:4;;;14265:40;3363:11368;;14369:56;3363:11368;14369:56;;3363:11368;;;;3744:10;;4124;;;;3363:11368;4124:10;;10247:2;4124:10;;;3363:11368;4124:10;;;;;;3363:11368;;;4124:10;-1:-1:-1;;;;;4124:10:92;;3363:11368;4124:10;;;;;;14369:56;;;;;;:::i;:::-;14346:89;9986:4;;;14346:89;;;;:::i;:::-;14449:3;;14445:122;;14577:146;;;14265:40;3363:11368;;;;;12805:94;;;14577:146;14623:4;;-1:-1:-1;;;;;3363:11368:92;;14616:37;;;;;3363:11368;;;;;;;;;;;;;;;14616:37;;;;;;;;;3363:11368;14616:37;;;14577:146;-1:-1:-1;14667:45:92;;3363:11368;-1:-1:-1;;;;;3363:11368:92;;;;14667:45;:::i;:::-;14577:146;;;14616:37;;;14667:45;14616:37;;;;;:::i;:::-;;;;;;;;3363:11368;;;;;;;;;14616:37;3363:11368;;;14265:40;3363:11368;;-1:-1:-1;;;;;3363:11368:92;;14265:40;;4389:10;3363:11368;;-1:-1:-1;;;4389:10:92;;3363:11368;;4389:10;;;;10247:2;4389:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4389:10;3363:11368;;4389:10;;-1:-1:-1;;;3744:10:92;;;3363:11368;3744:10;10247:2;3744:10;;4389;3363:11368;;-1:-1:-1;;;4389:10:92;;3363:11368;;4389:10;;;;10247:2;4389:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4389:10;3363:11368;;4389:10;12206:27;3363:11368;;;;;12221:12;12206:27;;12162:26;;;;;;12108;;;;;12055;-1:-1:-1;;;;;3363:11368:92;;12055:26;-1:-1:-1;12055:26:92;;12000;-1:-1:-1;;;;;3363:11368:92;;;12000:26;;4389:10;3363:11368;;-1:-1:-1;;;4389:10:92;;3363:11368;;4389:10;;;;10247:2;4389:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4389:10;3363:11368;;4389:10;10611:667;3363:11368;;;;;;;;;;11125:46;;;3363:11368;;;4971:10;10247:2;11125:46;;3363:11368;10247:2;11125:46;;;;;:::i;:::-;3363:11368;;;-1:-1:-1;;;;;3363:11368:92;;;;11193:42;;3363:11368;;;3944:10;;;3363:11368;;;;;;3944:10;;;3363:11368;;;3944:10;;;3363:11368;4389:10;;11087:166;;11193:42;3363:11368;;3944:10;;4389;3944;11193:42;3363:11368;;11087:166;;;4389:10;3363:11368;11087:166;;4389:10;;;:::i;:::-;;;:::i;11087:166::-;11060:207;9986:4;;;11060:207;;;;:::i;:::-;11048:219;10611:667;;10615:62;3363:11368;;;3944:10;;;;-1:-1:-1;;;;;;5296:29:92;;;-1:-1:-1;3363:11368:92;3944:10;;;;10615:62;-1:-1:-1;;;;;;;;5296:29:92;-1:-1:-1;;;10641:36:92;10615:62;;;3944:10;-1:-1:-1;;;;;;3363:11368:92;3944:10;;;;3363:11368;3944:10;5296:29;;;3944:10;;;-1:-1:-1;3944:10:92;;;;10615:22;3363:11368;;;10622:15;;-1:-1:-1;10615:22:92;;3363:11368;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;10527:64;;;3363:11368;;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o;:::-;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o;:::-;;;;;;10527:64;3363:11368;-1:-1:-1;;3363:11368:92;;;;:::o;:::-;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o;3744:10::-;;3363:11368;;3744:10;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3363:11368;;;;;;;:::i;:::-;3744:10;;;-1:-1:-1;3744:10:92;;;;:::o;:::-;;;:::o;652:438:10:-;3363:11368:92;;-1:-1:-1;;;878:45:10;;;;;;-1:-1:-1;;;;;3363:11368:92;;;878:45:10;;;3363:11368:92;;;;;;;;;878:45:10;;;652:438;3363:11368:92;;;;;;;;;;;;;;-1:-1:-1;867:57:10;;;;;;;;;;;;;:::i;:::-;955;;;;652:438;3363:11368:92;;;;;652:438:10:o;3363:11368:92:-;;;-1:-1:-1;;;3363:11368:92;;878:45:10;3363:11368:92;;;;;878:45:10;3363:11368:92;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;955:57:10;3363:11368:92;;;;;967:16:10;;;:44;;;;;955:57;;;;;;;;967:44;987:24;;;;;878:45;987:24;;;3363:11368:92;;;;878:45:10;987:24;3363:11368:92;3744:10;;;;3363:11368;;;;967:44:10;;;;;;12954:900:92;;13038:1;;-1:-1:-1;;;;;3363:11368:92;;;;13021:19;;13017:364;;13552:4;;3363:11368;;;13562:49;;;;;;3363:11368;;;13562:49;;;;;;;;3363:11368;13562:49;;;;;;:::i;:::-;13552:60;;;;;;;;:::i;:::-;;4005:10;;;13709:6;;;;;;;;:::i;:::-;3363:11368;;;13562:49;13746:52;;3363:11368;;;;13746:52;;;;;3363:11368;13746:52;;;;;;:::i;:::-;13736:63;;;;;;:::i;:::-;;4069:10;;;12954:900;:::o;4069:10::-;;3363:11368;4069:10;3363:11368;;;;;;4069:10;;13562:49;4069:10;;;;;;3363:11368;4069:10;3363:11368;;;4069:10;;4005;3363:11368;;-1:-1:-1;;;4005:10:92;;13562:49;4005:10;;;;;;;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4005:10;;;;13017:364;13222:4;;;;;3363:11368;13215:29;;;;;3363:11368;;;;;;;;;;;;;13215:29;;;;;;3363:11368;13215:29;;;;;;;;13017:364;13274:4;;;;;;:28;;;;:::i;:::-;;3363:11368;;;13364:7::o;3363:11368::-;;;-1:-1:-1;;;3363:11368:92;;;13215:29;3363:11368;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;13215:29;;;;:::i;:::-;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220c0f252b028b6c0e65974e5d3a097627861ea7e86530861d92c4f6803c125d79064736f6c63430008140033","offset":4623}},"immutableReferences":{"16564":[{"start":37,"length":32},{"start":261,"length":32},{"start":1191,"length":32},{"start":2174,"length":32},{"start":2387,"length":32},{"start":2735,"length":32},{"start":3365,"length":32},{"start":4119,"length":32},{"start":4501,"length":32}],"16567":[{"start":152,"length":32},{"start":777,"length":32},{"start":825,"length":32},{"start":1484,"length":32},{"start":2106,"length":32},{"start":2800,"length":32},{"start":4414,"length":32}]},"transformations":[{"id":"16564","type":"replace","offset":37,"reason":"immutable"},{"id":"16567","type":"replace","offset":152,"reason":"immutable"},{"id":"16564","type":"replace","offset":261,"reason":"immutable"},{"id":"16567","type":"replace","offset":777,"reason":"immutable"},{"id":"16567","type":"replace","offset":825,"reason":"immutable"},{"id":"16564","type":"replace","offset":1191,"reason":"immutable"},{"id":"16567","type":"replace","offset":1484,"reason":"immutable"},{"id":"16567","type":"replace","offset":2106,"reason":"immutable"},{"id":"16564","type":"replace","offset":2174,"reason":"immutable"},{"id":"16564","type":"replace","offset":2387,"reason":"immutable"},{"id":"16564","type":"replace","offset":2735,"reason":"immutable"},{"id":"16567","type":"replace","offset":2800,"reason":"immutable"},{"id":"16564","type":"replace","offset":3365,"reason":"immutable"},{"id":"16564","type":"replace","offset":4119,"reason":"immutable"},{"id":"16567","type":"replace","offset":4414,"reason":"immutable"},{"id":"16564","type":"replace","offset":4501,"reason":"immutable"}],"transformationValues":{"immutables":{"16564":"0x00000000000000000000000000000000000014aa86c5d3c41765bb24e11bd701","16567":"0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"}}},"deployment":{"transactionHash":"0x8d08f4582b3087e2acfe1b9a2f6b578c59e53710d92f31d73ef75d757a7aea31","blockNumber":"25796190","transactionIndex":"335","deployer":"0x1F39F9A60164D439Cf68a422265d575477337583"},"sources":{"@uniswap/lib/contracts/libraries/TransferHelper.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-or-later\n\npragma solidity >=0.6.0;\n\n// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false\nlibrary TransferHelper {\n    function safeApprove(\n        address token,\n        address to,\n        uint256 value\n    ) internal {\n        // bytes4(keccak256(bytes('approve(address,uint256)')));\n        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));\n        require(\n            success && (data.length == 0 || abi.decode(data, (bool))),\n            'TransferHelper::safeApprove: approve failed'\n        );\n    }\n\n    function safeTransfer(\n        address token,\n        address to,\n        uint256 value\n    ) internal {\n        // bytes4(keccak256(bytes('transfer(address,uint256)')));\n        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));\n        require(\n            success && (data.length == 0 || abi.decode(data, (bool))),\n            'TransferHelper::safeTransfer: transfer failed'\n        );\n    }\n\n    function safeTransferFrom(\n        address token,\n        address from,\n        address to,\n        uint256 value\n    ) internal {\n        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));\n        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));\n        require(\n            success && (data.length == 0 || abi.decode(data, (bool))),\n            'TransferHelper::transferFrom: transferFrom failed'\n        );\n    }\n\n    function safeTransferETH(address to, uint256 value) internal {\n        (bool success, ) = to.call{value: value}(new bytes(0));\n        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');\n    }\n}\n"},"contracts/router/interfaces/ISwapHandler.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity 0.8.20;\n\ninterface ISwapHandler {\n    struct PathDescription {\n        address srcToken;\n        address dstToken;\n        address pairAddr;\n        uint256 fee;\n        uint256 srcAmount;\n        uint256 dstMinAmount;\n        uint256 feeSrc;\n        uint256 feeDst;\n        uint256 liquidityType;\n        bytes data;\n    }\n\n    function executeSwap(\n        PathDescription memory path,\n        uint256 amount,\n        address from,\n        address to\n    ) external returns (uint256 amountOut);\n}"},"contracts/router/modules/EkuboSwapHandler.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity 0.8.20;\n\nimport \"@uniswap/lib/contracts/libraries/TransferHelper.sol\";\nimport \"../interfaces/ISwapHandler.sol\";\nimport \"../../shared/interfaces/IERC20.sol\";\n\ninterface IWETH9 {\n    function deposit() external payable;\n    function withdraw(uint256) external;\n}\n\n/**\n * @title EkuboSwapHandler — Ekubo_V3 (liquidityType 33)\n *\n * Ekubo keeps every pool inside one Core singleton. There is NO usable public\n * router: `Router.sol` exists in Ekubo's repo but is not deployed on mainnet,\n * and every live integrator (0x Settler, CoW, 1inch) locks Core directly from\n * its own executor. So does this handler.\n *\n * The flow is the standard singleton lock/callback, but Ekubo is aggressively\n * gas-golfed: two of its entrypoints have vanity names chosen so their selector\n * is literally 0x00000000, and they take NO abi arguments — Core reads them\n * straight out of calldata. Everything below is ported from Ekubo's own source\n * (github.com/EkuboProtocol/evm-contracts).\n *\n *   1. call Core `lock()` (0xf83d08ba) with our payload appended RAW\n *   2. Core calls back `locked_6416899205(uint256 id)` — selector 0x00000000 —\n *      with our payload at msg.data[36:]\n *   3. inside, call Core `swap_6269342730()` — also selector 0x00000000 — with\n *      exactly 132 bytes: selector ++ token0 ++ token1 ++ config ++ params\n *   4. settle: startPayments -> transfer -> completePayments for the input,\n *      then withdraw the output straight to `to`\n *\n * `params` is a PACKED bytes32 (Ekubo's SwapParameters), not four words:\n *   [255:160] sqrtRatioLimit (uint96 float)\n *   [159:32]  amount (int128; > 0 = exact-in)\n *   [31]      isToken1\n *   [30:0]    skipAhead\n *\n * `path.data` carries the PoolKey remainder: abi.encode(token0, token1, config).\n * The pool cannot be identified without it — `config` packs\n * extension(20B)++fee(uint64)++typeConfig(4B) and is NOT derivable from the\n * token pair.\n *\n * FORWARD-ONLY EXTENSIONS (Ve33). Some extensions refuse a direct Core.swap\n * (beforeSwap reverts SwapMustHappenThroughForward) and require the swap to be\n * forwarded to them via Core.forward(extension) so they can account their own\n * fee. The locker detects that exact revert and re-issues the same payload\n * through forward; deltas/settlement are identical afterwards. Robinhood:\n * 27 of the 30 live Ekubo pools are Ve33 pools.\n *\n * NATIVE ETH. Ekubo denotes native ETH as address(0), and a THIRD of its\n * mainnet pools are native-paired, so they are served rather than skipped. Our\n * route steps are WETH-normalised, so this handler bridges the two:\n *   - paying native  : unwrap WETH, then send ETH to Core — its `receive()`\n *                      credits the locker's debt (no startPayments dance)\n *   - receiving native: `withdraw` with token address(0) sends real ETH, so we\n *                      take it here, wrap it, and forward WETH to `to`\n * The route never sees anything but WETH.\n *\n * Slippage: no per-hop bound is imposed here — the sqrtRatioLimit is set to the\n * extreme of the swap direction, exactly the uni_v4 model. Safety is the\n * whole-route minReturn enforced by NonLinearSwapModule. We do require a FULL\n * fill (see executeSwap) so a liquidity shortfall reverts loudly instead of\n * silently leaving unspent input dust in the handler.\n */\ncontract EkuboSwapHandler is ISwapHandler {\n    /// Ekubo Core singleton. Immutable — nothing can repoint execution.\n    address public immutable core;\n    /// Canonical WETH, for bridging native-ETH pools to our WETH-normalised steps.\n    address public immutable weth;\n\n    /// Core `lock()`. Payload is appended raw after these 4 bytes.\n    bytes4 private constant SEL_LOCK = 0xf83d08ba;\n    /// Both `locked_6416899205(uint256)` and `swap_6269342730()` — vanity names\n    /// picked so the selector is zero. Verified with `cast sig`.\n    bytes4 private constant SEL_ZERO = 0x00000000;\n    bytes4 private constant SEL_START_PAYMENTS = 0xf9b6a796;\n    bytes4 private constant SEL_COMPLETE_PAYMENTS = 0x12e103f1;\n    bytes4 private constant SEL_WITHDRAW = 0x3ccfd60b;\n    /// Core `forward(address to)`: hands the lock context to an extension for\n    /// the duration of the call; any calldata after the address is passed to\n    /// the forwardee raw (IFlashAccountant.forward).\n    bytes4 private constant SEL_FORWARD = 0x101e8952;\n    /// `SwapMustHappenThroughForward()` — raised by Ekubo's forward-only\n    /// extensions (Ve33 on Robinhood: ve(3,3) dynamic voter fees, Core fee 0)\n    /// from beforeSwap when a locker calls Core.swap directly. Those pools are\n    /// swapped by forwarding the (PoolKey, SwapParameters) payload to the\n    /// extension instead; it performs the Core swap as the temporary locker,\n    /// adds its fee to the returned deltas and saves the fee in Core against\n    /// our lock, so settlement below is unchanged.\n    bytes4 private constant ERR_SWAP_MUST_FORWARD = 0x0ad27a39;\n\n    /// Ekubo sqrt-ratio bounds in its uint96 FLOAT form (MIN/MAX_SQRT_RATIO_RAW\n    /// in src/types/sqrtRatio.sol). Selling token0 pushes price down (MIN);\n    /// selling token1 pushes it up (MAX).\n    uint96 private constant MIN_SQRT_RATIO = 4611797791050542631;\n    uint96 private constant MAX_SQRT_RATIO = 79227682466138141934206691491;\n\n    constructor(address _core, address _weth) {\n        require(_core != address(0), \"Ekubo: core 0\");\n        require(_weth != address(0), \"Ekubo: weth 0\");\n        core = _core;\n        weth = _weth;\n    }\n\n    /// Only Core (withdrawing native output) and WETH (on unwrap) ever send ETH\n    /// here. Anything else is a mistake, so reject it rather than silently\n    /// absorbing funds the next swap would sweep.\n    receive() external payable {\n        require(msg.sender == core || msg.sender == weth, \"Ekubo: unexpected ETH\");\n    }\n\n    function executeSwap(\n        PathDescription memory path,\n        uint256 amount,\n        address /* from */,\n        address to\n    ) external override returns (uint256 amountOut) {\n        // amount == 0 -> use what the module just transferred in (the repo-wide\n        // pass-0 convention; also what makes fee-on-transfer intermediates work).\n        uint256 amountIn = amount == 0\n            ? IERC20(path.srcToken).balanceOf(address(this))\n            : amount;\n        require(amountIn > 0 && amountIn <= uint256(uint128(type(int128).max)), \"Ekubo: amountIn\");\n\n        (address token0, address token1, bytes32 config) = abi.decode(\n            path.data,\n            (address, address, bytes32)\n        );\n\n        // Ekubo's address(0) is our WETH. Alias for direction detection only —\n        // the pool key itself keeps address(0).\n        address routeToken0 = token0 == address(0) ? weth : token0;\n        address routeToken1 = token1 == address(0) ? weth : token1;\n        // A WETH/native pool would alias both sides to WETH and make the\n        // direction undecidable. Ekubo has no such pool today; refuse rather\n        // than guess if one ever appears.\n        require(routeToken0 != routeToken1, \"Ekubo: ambiguous pool\");\n\n        bool isToken1;\n        if (path.srcToken == routeToken0) {\n            isToken1 = false;\n        } else if (path.srcToken == routeToken1) {\n            isToken1 = true;\n        } else {\n            revert(\"Ekubo: srcToken not in pool\");\n        }\n\n        // Pack SwapParameters. amountIn < 2^127 (checked above) so bit 159 — the\n        // int128 sign bit — is clear, i.e. this is an exact-INPUT swap.\n        uint256 params = (uint256(isToken1 ? MAX_SQRT_RATIO : MIN_SQRT_RATIO) << 160) |\n            (amountIn << 32) |\n            (isToken1 ? (uint256(1) << 31) : 0);\n        // skipAhead (bits [30:0]) stays 0: no tick-bitmap skipping.\n\n        uint256 balBefore = IERC20(path.dstToken).balanceOf(to);\n\n        // Acquire the lock. Core appends nothing of its own — our payload comes\n        // back verbatim in the callback.\n        (bool ok, bytes memory ret) = core.call(\n            abi.encodePacked(\n                SEL_LOCK,\n                abi.encode(token0, token1, config, bytes32(params), isToken1, to, amountIn)\n            )\n        );\n        if (!ok) {\n            assembly (\"memory-safe\") {\n                revert(add(ret, 32), mload(ret))\n            }\n        }\n\n        // Sweep any native ETH left over once the lock closes. Observed on\n        // live BoostedFees-extension pools: Core returns a small amount to the\n        // locker beyond the settled deltas (~0.000577 ETH on a 0.1 WETH swap).\n        // Leaving it here would be a slow leak — the module passes amount=0 and\n        // handlers spend their own balance, so the next swap through this\n        // handler would silently pick it up and hand it to an unrelated user.\n        // Wrapping it to `to` keeps the value with the trade that produced it,\n        // and keeps this contract balance-free between calls.\n        uint256 residual = address(this).balance;\n        if (residual > 0) {\n            IWETH9(weth).deposit{value: residual}();\n            TransferHelper.safeTransfer(weth, to, residual);\n        }\n\n        // Measure what the recipient actually received rather than trusting the\n        // packed deltas (and their sign convention) a second time. Deliberately\n        // after the sweep: when dstToken IS WETH the swept amount is genuinely\n        // part of the output and must be counted.\n        amountOut = IERC20(path.dstToken).balanceOf(to) - balBefore;\n        require(amountOut > 0, \"Ekubo: no output\");\n    }\n\n    /**\n     * Core's lock callback. Selector is 0x00000000 by construction — solc\n     * derives it from this exact function name, same as Ekubo's own contracts.\n     *\n     * Only reachable from Core, and Core only ever calls back the address that\n     * called `lock()` — which is this contract, from executeSwap above.\n     */\n    function locked_6416899205(uint256 /* id */) external {\n        require(msg.sender == core, \"Ekubo: not core\");\n\n        (\n            address token0,\n            address token1,\n            bytes32 config,\n            bytes32 params,\n            bool isToken1,\n            address to,\n            uint256 amountIn\n        ) = abi.decode(msg.data[36:], (address, address, bytes32, bytes32, bool, address, uint256));\n\n        // swap_6269342730(): no abi args, Core reads 132 bytes of raw calldata.\n        // abi.encodeWithSelector gives exactly selector + 4 words.\n        (bool ok, bytes memory ret) = core.call(\n            abi.encodeWithSelector(SEL_ZERO, token0, token1, config, params)\n        );\n        if (!ok && ret.length == 4 && bytes4(ret) == ERR_SWAP_MUST_FORWARD) {\n            // Forward-only extension: same four words, delivered through the\n            // extension (first 20 bytes of the packed config word). The failed\n            // direct call changed nothing — beforeSwap reverted before Core\n            // touched any state — so the lock is intact.\n            address extension = address(bytes20(config));\n            (ok, ret) = core.call(\n                abi.encodePacked(\n                    abi.encodeWithSelector(SEL_FORWARD, extension),\n                    abi.encode(token0, token1, config, params)\n                )\n            );\n        }\n        if (!ok) {\n            assembly (\"memory-safe\") {\n                revert(add(ret, 32), mload(ret))\n            }\n        }\n        require(ret.length >= 32, \"Ekubo: swap return\");\n\n        // Returns balanceUpdate ++ stateAfter. balanceUpdate packs two int128\n        // deltas: delta0 in the high half, delta1 in the low half. POSITIVE =\n        // we owe Core; NEGATIVE = Core owes us.\n        bytes32 update;\n        assembly (\"memory-safe\") {\n            update := mload(add(ret, 32))\n        }\n        int128 delta0 = int128(uint128(uint256(update) >> 128));\n        int128 delta1 = int128(uint128(uint256(update)));\n\n        // Pool-space tokens: address(0) here means native ETH.\n        address tokenIn = isToken1 ? token1 : token0;\n        address tokenOut = isToken1 ? token0 : token1;\n        int128 deltaIn = isToken1 ? delta1 : delta0;\n        int128 deltaOut = isToken1 ? delta0 : delta1;\n        require(deltaIn > 0 && deltaOut < 0, \"Ekubo: deltas\");\n\n        uint256 owed = uint256(uint128(deltaIn));\n        uint128 received = uint128(-deltaOut);\n\n        // A short fill would leave unspent input sitting in the handler, which\n        // the next swap through this handler would sweep. Reject it instead.\n        require(owed == amountIn, \"Ekubo: partial fill\");\n\n        _pay(tokenIn, owed);\n        _collect(tokenOut, to, received);\n\n        // Raw-return the output amount; Core passes lock() returndata straight\n        // through to executeSwap (which cross-checks it against balances).\n        assembly (\"memory-safe\") {\n            mstore(0, received)\n            return(0, 32)\n        }\n    }\n\n    /// Settle the input side of the swap.\n    function _pay(address token, uint256 amount) private {\n        if (token == address(0)) {\n            // Native: the module handed us WETH, so unwrap and send real ETH.\n            // Core's receive() credits the locker's debt — no startPayments.\n            IWETH9(weth).withdraw(amount);\n            (bool sent, ) = core.call{value: amount}(\"\");\n            require(sent, \"Ekubo: native pay\");\n            return;\n        }\n\n        // ERC20: startPayments(token) -> transfer -> completePayments(token).\n        // Both take the token list abi-encoded after the selector.\n        (bool ok, ) = core.call(abi.encodeWithSelector(SEL_START_PAYMENTS, token));\n        require(ok, \"Ekubo: startPayments\");\n\n        TransferHelper.safeTransfer(token, core, amount);\n\n        (ok, ) = core.call(abi.encodeWithSelector(SEL_COMPLETE_PAYMENTS, token));\n        require(ok, \"Ekubo: completePayments\");\n    }\n\n    /// Take the output side and deliver it to `to` as an ERC20.\n    /// withdraw() takes PACKED args, not abi-encoded:\n    /// selector ++ token(20) ++ recipient(20) ++ amount(16) = 60 bytes.\n    function _collect(address token, address to, uint128 amount) private {\n        // Native output arrives as real ETH, so take it here and wrap it —\n        // the route expects WETH.\n        address recipient = token == address(0) ? address(this) : to;\n\n        (bool ok, bytes memory ret) = core.call(\n            abi.encodePacked(SEL_WITHDRAW, token, recipient, amount)\n        );\n        if (!ok) {\n            assembly (\"memory-safe\") {\n                revert(add(ret, 32), mload(ret))\n            }\n        }\n\n        if (token == address(0)) {\n            IWETH9(weth).deposit{value: amount}();\n            TransferHelper.safeTransfer(weth, to, amount);\n        }\n    }\n}\n"},"contracts/shared/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\ninterface IERC20 {\n    event Approval(address indexed owner, address indexed spender, uint value);\n    event Transfer(address indexed from, address indexed to, uint value);\n\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function decimals() external view returns (uint8);\n    function totalSupply() external view returns (uint);\n    function balanceOf(address owner) external view returns (uint);\n    function allowance(address owner, address spender) external view returns (uint);\n\n    function approve(address spender, uint value) external returns (bool);\n    function transfer(address to, uint value) external returns (bool);\n    function transferFrom(address from, address to, uint value) external returns (bool);\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.20+commit.a1b79de6","compilerSettings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"},"name":"EkuboSwapHandler","fullyQualifiedName":"contracts/router/modules/EkuboSwapHandler.sol:EkuboSwapHandler"},"abi":[{"type":"constructor","inputs":[{"name":"_core","type":"address","internalType":"address"},{"name":"_weth","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"core","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"executeSwap","type":"function","inputs":[{"name":"path","type":"tuple","components":[{"name":"srcToken","type":"address","internalType":"address"},{"name":"dstToken","type":"address","internalType":"address"},{"name":"pairAddr","type":"address","internalType":"address"},{"name":"fee","type":"uint256","internalType":"uint256"},{"name":"srcAmount","type":"uint256","internalType":"uint256"},{"name":"dstMinAmount","type":"uint256","internalType":"uint256"},{"name":"feeSrc","type":"uint256","internalType":"uint256"},{"name":"feeDst","type":"uint256","internalType":"uint256"},{"name":"liquidityType","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct ISwapHandler.PathDescription"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"locked_6416899205","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"weth","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.20+commit.a1b79de6"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_core","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"core","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"srcToken","type":"address"},{"internalType":"address","name":"dstToken","type":"address"},{"internalType":"address","name":"pairAddr","type":"address"},{"internalType":"uint256","name":"fee","type":"uint256"},{"internalType":"uint256","name":"srcAmount","type":"uint256"},{"internalType":"uint256","name":"dstMinAmount","type":"uint256"},{"internalType":"uint256","name":"feeSrc","type":"uint256"},{"internalType":"uint256","name":"feeDst","type":"uint256"},{"internalType":"uint256","name":"liquidityType","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ISwapHandler.PathDescription","name":"path","type":"tuple"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"to","type":"address"}],"name":"executeSwap","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"locked_6416899205","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{},"title":"EkuboSwapHandler — Ekubo_V3 (liquidityType 33) Ekubo keeps every pool inside one Core singleton. There is NO usable public router: `Router.sol` exists in Ekubo's repo but is not deployed on mainnet, and every live integrator (0x Settler, CoW, 1inch) locks Core directly from its own executor. So does this handler. The flow is the standard singleton lock/callback, but Ekubo is aggressively gas-golfed: two of its entrypoints have vanity names chosen so their selector is literally 0x00000000, and they take NO abi arguments — Core reads them straight out of calldata. Everything below is ported from Ekubo's own source (github.com/EkuboProtocol/evm-contracts).   1. call Core `lock()` (0xf83d08ba) with our payload appended RAW   2. Core calls back `locked_6416899205(uint256 id)` — selector 0x00000000 —      with our payload at msg.data[36:]   3. inside, call Core `swap_6269342730()` — also selector 0x00000000 — with      exactly 132 bytes: selector ++ token0 ++ token1 ++ config ++ params   4. settle: startPayments -> transfer -> completePayments for the input,      then withdraw the output straight to `to` `params` is a PACKED bytes32 (Ekubo's SwapParameters), not four words:   [255:160] sqrtRatioLimit (uint96 float)   [159:32]  amount (int128; > 0 = exact-in)   [31]      isToken1   [30:0]    skipAhead `path.data` carries the PoolKey remainder: abi.encode(token0, token1, config). The pool cannot be identified without it — `config` packs extension(20B)++fee(uint64)++typeConfig(4B) and is NOT derivable from the token pair. FORWARD-ONLY EXTENSIONS (Ve33). Some extensions refuse a direct Core.swap (beforeSwap reverts SwapMustHappenThroughForward) and require the swap to be forwarded to them via Core.forward(extension) so they can account their own fee. The locker detects that exact revert and re-issues the same payload through forward; deltas/settlement are identical afterwards. Robinhood: 27 of the 30 live Ekubo pools are Ve33 pools. NATIVE ETH. Ekubo denotes native ETH as address(0), and a THIRD of its mainnet pools are native-paired, so they are served rather than skipped. Our route steps are WETH-normalised, so this handler bridges the two:   - paying native  : unwrap WETH, then send ETH to Core — its `receive()`                      credits the locker's debt (no startPayments dance)   - receiving native: `withdraw` with token address(0) sends real ETH, so we                      take it here, wrap it, and forward WETH to `to` The route never sees anything but WETH. Slippage: no per-hop bound is imposed here — the sqrtRatioLimit is set to the extreme of the swap direction, exactly the uni_v4 model. Safety is the whole-route minReturn enforced by NonLinearSwapModule. We do require a FULL fill (see executeSwap) so a liquidity shortfall reverts loudly instead of silently leaving unspent input dust in the handler.","version":1},"userdoc":{"kind":"user","methods":{"core()":{"notice":"Ekubo Core singleton. Immutable — nothing can repoint execution."},"locked_6416899205(uint256)":{"notice":"Core's lock callback. Selector is 0x00000000 by construction — solc derives it from this exact function name, same as Ekubo's own contracts. Only reachable from Core, and Core only ever calls back the address that called `lock()` — which is this contract, from executeSwap above."},"weth()":{"notice":"Canonical WETH, for bridging native-ETH pools to our WETH-normalised steps."}},"version":1}},"settings":{"compilationTarget":{"contracts/router/modules/EkuboSwapHandler.sol":"EkuboSwapHandler"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[],"viaIR":true},"sources":{"@uniswap/lib/contracts/libraries/TransferHelper.sol":{"keccak256":"0xaff99b54915f57e2a4e71b8d15afd4ee425410e5a6f45c07517ae1beb806f8bd","license":"GPL-3.0-or-later","urls":["bzz-raw://15432ec031f4cfa6709921289e198b030a0c5eac75b5a3e0eb64827a2b3b5595","dweb:/ipfs/QmZvR1KuuDvuzXFiADCngTKyMCTy31uhq9U6CazP59B55j"]},"contracts/router/interfaces/ISwapHandler.sol":{"keccak256":"0x7e91bb2f6bd2f6ba2695a6b5ac5a81fe21c684e6a5baf891ab057ced0887dd3d","license":"UNLICENSED","urls":["bzz-raw://f1a099cd81aaaffdfd6c0512642e5f384f6360d156304c9284e464b82645e9f7","dweb:/ipfs/QmThPAbNRRbHgcvbwhCsBJNH4TyZLPoN65mwHdwKmtPeUm"]},"contracts/router/modules/EkuboSwapHandler.sol":{"keccak256":"0x9c90a2f686a6250f9d4c5a21cb99c7d0626cca68ce225db290470b81855f1fa0","license":"UNLICENSED","urls":["bzz-raw://a5b6fea307a78c994a4bf4b426fe7a2e88c1ef2f4a103b7cb65f22af59e8daef","dweb:/ipfs/QmRYpGBTo9tCdF69zuNVXcKdi9TBqTrDCKVuvQ6iT4LhVZ"]},"contracts/shared/interfaces/IERC20.sol":{"keccak256":"0xc4f0e42d0c0eb999269c077c701429df73fec85186af9fb679a4a066696bd61c","license":"GPL-2.0-or-later","urls":["bzz-raw://eae31c1b3c171df901662b7870251725670d823b764054521b8e71de52162208","dweb:/ipfs/QmWrWFCYy6fxzyKcj16QDKHyNoBwR5umb8LBPLJgiYR2Ms"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{"core()":{"notice":"Ekubo Core singleton. Immutable — nothing can repoint execution."},"weth()":{"notice":"Canonical WETH, for bridging native-ETH pools to our WETH-normalised steps."},"locked_6416899205(uint256)":{"notice":"Core's lock callback. Selector is 0x00000000 by construction — solc derives it from this exact function name, same as Ekubo's own contracts. Only reachable from Core, and Core only ever calls back the address that called `lock()` — which is this contract, from executeSwap above."}},"version":1},"devdoc":{"kind":"dev","title":"EkuboSwapHandler — Ekubo_V3 (liquidityType 33) Ekubo keeps every pool inside one Core singleton. There is NO usable public router: `Router.sol` exists in Ekubo's repo but is not deployed on mainnet, and every live integrator (0x Settler, CoW, 1inch) locks Core directly from its own executor. So does this handler. The flow is the standard singleton lock/callback, but Ekubo is aggressively gas-golfed: two of its entrypoints have vanity names chosen so their selector is literally 0x00000000, and they take NO abi arguments — Core reads them straight out of calldata. Everything below is ported from Ekubo's own source (github.com/EkuboProtocol/evm-contracts).   1. call Core `lock()` (0xf83d08ba) with our payload appended RAW   2. Core calls back `locked_6416899205(uint256 id)` — selector 0x00000000 —      with our payload at msg.data[36:]   3. inside, call Core `swap_6269342730()` — also selector 0x00000000 — with      exactly 132 bytes: selector ++ token0 ++ token1 ++ config ++ params   4. settle: startPayments -> transfer -> completePayments for the input,      then withdraw the output straight to `to` `params` is a PACKED bytes32 (Ekubo's SwapParameters), not four words:   [255:160] sqrtRatioLimit (uint96 float)   [159:32]  amount (int128; > 0 = exact-in)   [31]      isToken1   [30:0]    skipAhead `path.data` carries the PoolKey remainder: abi.encode(token0, token1, config). The pool cannot be identified without it — `config` packs extension(20B)++fee(uint64)++typeConfig(4B) and is NOT derivable from the token pair. FORWARD-ONLY EXTENSIONS (Ve33). Some extensions refuse a direct Core.swap (beforeSwap reverts SwapMustHappenThroughForward) and require the swap to be forwarded to them via Core.forward(extension) so they can account their own fee. The locker detects that exact revert and re-issues the same payload through forward; deltas/settlement are identical afterwards. Robinhood: 27 of the 30 live Ekubo pools are Ve33 pools. NATIVE ETH. Ekubo denotes native ETH as address(0), and a THIRD of its mainnet pools are native-paired, so they are served rather than skipped. Our route steps are WETH-normalised, so this handler bridges the two:   - paying native  : unwrap WETH, then send ETH to Core — its `receive()`                      credits the locker's debt (no startPayments dance)   - receiving native: `withdraw` with token address(0) sends real ETH, so we                      take it here, wrap it, and forward WETH to `to` The route never sees anything but WETH. Slippage: no per-hop bound is imposed here — the sqrtRatioLimit is set to the extreme of the swap direction, exactly the uni_v4 model. Safety is the whole-route minReturn enforced by NonLinearSwapModule. We do require a FULL fill (see executeSwap) so a liquidity shortfall reverts loudly instead of silently leaving unspent input dust in the handler.","methods":{},"version":1},"sourceIds":{"contracts/shared/interfaces/IERC20.sol":{"id":140},"contracts/router/interfaces/ISwapHandler.sol":{"id":75},"contracts/router/modules/EkuboSwapHandler.sol":{"id":92},"@uniswap/lib/contracts/libraries/TransferHelper.sol":{"id":10}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/shared/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\ninterface IERC20 {\n    event Approval(address indexed owner, address indexed spender, uint value);\n    event Transfer(address indexed from, address indexed to, uint value);\n\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function decimals() external view returns (uint8);\n    function totalSupply() external view returns (uint);\n    function balanceOf(address owner) external view returns (uint);\n    function allowance(address owner, address spender) external view returns (uint);\n\n    function approve(address spender, uint value) external returns (bool);\n    function transfer(address to, uint value) external returns (bool);\n    function transferFrom(address from, address to, uint value) external returns (bool);\n}"},"contracts/router/interfaces/ISwapHandler.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity 0.8.20;\n\ninterface ISwapHandler {\n    struct PathDescription {\n        address srcToken;\n        address dstToken;\n        address pairAddr;\n        uint256 fee;\n        uint256 srcAmount;\n        uint256 dstMinAmount;\n        uint256 feeSrc;\n        uint256 feeDst;\n        uint256 liquidityType;\n        bytes data;\n    }\n\n    function executeSwap(\n        PathDescription memory path,\n        uint256 amount,\n        address from,\n        address to\n    ) external returns (uint256 amountOut);\n}"},"contracts/router/modules/EkuboSwapHandler.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity 0.8.20;\n\nimport \"@uniswap/lib/contracts/libraries/TransferHelper.sol\";\nimport \"../interfaces/ISwapHandler.sol\";\nimport \"../../shared/interfaces/IERC20.sol\";\n\ninterface IWETH9 {\n    function deposit() external payable;\n    function withdraw(uint256) external;\n}\n\n/**\n * @title EkuboSwapHandler — Ekubo_V3 (liquidityType 33)\n *\n * Ekubo keeps every pool inside one Core singleton. There is NO usable public\n * router: `Router.sol` exists in Ekubo's repo but is not deployed on mainnet,\n * and every live integrator (0x Settler, CoW, 1inch) locks Core directly from\n * its own executor. So does this handler.\n *\n * The flow is the standard singleton lock/callback, but Ekubo is aggressively\n * gas-golfed: two of its entrypoints have vanity names chosen so their selector\n * is literally 0x00000000, and they take NO abi arguments — Core reads them\n * straight out of calldata. Everything below is ported from Ekubo's own source\n * (github.com/EkuboProtocol/evm-contracts).\n *\n *   1. call Core `lock()` (0xf83d08ba) with our payload appended RAW\n *   2. Core calls back `locked_6416899205(uint256 id)` — selector 0x00000000 —\n *      with our payload at msg.data[36:]\n *   3. inside, call Core `swap_6269342730()` — also selector 0x00000000 — with\n *      exactly 132 bytes: selector ++ token0 ++ token1 ++ config ++ params\n *   4. settle: startPayments -> transfer -> completePayments for the input,\n *      then withdraw the output straight to `to`\n *\n * `params` is a PACKED bytes32 (Ekubo's SwapParameters), not four words:\n *   [255:160] sqrtRatioLimit (uint96 float)\n *   [159:32]  amount (int128; > 0 = exact-in)\n *   [31]      isToken1\n *   [30:0]    skipAhead\n *\n * `path.data` carries the PoolKey remainder: abi.encode(token0, token1, config).\n * The pool cannot be identified without it — `config` packs\n * extension(20B)++fee(uint64)++typeConfig(4B) and is NOT derivable from the\n * token pair.\n *\n * FORWARD-ONLY EXTENSIONS (Ve33). Some extensions refuse a direct Core.swap\n * (beforeSwap reverts SwapMustHappenThroughForward) and require the swap to be\n * forwarded to them via Core.forward(extension) so they can account their own\n * fee. The locker detects that exact revert and re-issues the same payload\n * through forward; deltas/settlement are identical afterwards. Robinhood:\n * 27 of the 30 live Ekubo pools are Ve33 pools.\n *\n * NATIVE ETH. Ekubo denotes native ETH as address(0), and a THIRD of its\n * mainnet pools are native-paired, so they are served rather than skipped. Our\n * route steps are WETH-normalised, so this handler bridges the two:\n *   - paying native  : unwrap WETH, then send ETH to Core — its `receive()`\n *                      credits the locker's debt (no startPayments dance)\n *   - receiving native: `withdraw` with token address(0) sends real ETH, so we\n *                      take it here, wrap it, and forward WETH to `to`\n * The route never sees anything but WETH.\n *\n * Slippage: no per-hop bound is imposed here — the sqrtRatioLimit is set to the\n * extreme of the swap direction, exactly the uni_v4 model. Safety is the\n * whole-route minReturn enforced by NonLinearSwapModule. We do require a FULL\n * fill (see executeSwap) so a liquidity shortfall reverts loudly instead of\n * silently leaving unspent input dust in the handler.\n */\ncontract EkuboSwapHandler is ISwapHandler {\n    /// Ekubo Core singleton. Immutable — nothing can repoint execution.\n    address public immutable core;\n    /// Canonical WETH, for bridging native-ETH pools to our WETH-normalised steps.\n    address public immutable weth;\n\n    /// Core `lock()`. Payload is appended raw after these 4 bytes.\n    bytes4 private constant SEL_LOCK = 0xf83d08ba;\n    /// Both `locked_6416899205(uint256)` and `swap_6269342730()` — vanity names\n    /// picked so the selector is zero. Verified with `cast sig`.\n    bytes4 private constant SEL_ZERO = 0x00000000;\n    bytes4 private constant SEL_START_PAYMENTS = 0xf9b6a796;\n    bytes4 private constant SEL_COMPLETE_PAYMENTS = 0x12e103f1;\n    bytes4 private constant SEL_WITHDRAW = 0x3ccfd60b;\n    /// Core `forward(address to)`: hands the lock context to an extension for\n    /// the duration of the call; any calldata after the address is passed to\n    /// the forwardee raw (IFlashAccountant.forward).\n    bytes4 private constant SEL_FORWARD = 0x101e8952;\n    /// `SwapMustHappenThroughForward()` — raised by Ekubo's forward-only\n    /// extensions (Ve33 on Robinhood: ve(3,3) dynamic voter fees, Core fee 0)\n    /// from beforeSwap when a locker calls Core.swap directly. Those pools are\n    /// swapped by forwarding the (PoolKey, SwapParameters) payload to the\n    /// extension instead; it performs the Core swap as the temporary locker,\n    /// adds its fee to the returned deltas and saves the fee in Core against\n    /// our lock, so settlement below is unchanged.\n    bytes4 private constant ERR_SWAP_MUST_FORWARD = 0x0ad27a39;\n\n    /// Ekubo sqrt-ratio bounds in its uint96 FLOAT form (MIN/MAX_SQRT_RATIO_RAW\n    /// in src/types/sqrtRatio.sol). Selling token0 pushes price down (MIN);\n    /// selling token1 pushes it up (MAX).\n    uint96 private constant MIN_SQRT_RATIO = 4611797791050542631;\n    uint96 private constant MAX_SQRT_RATIO = 79227682466138141934206691491;\n\n    constructor(address _core, address _weth) {\n        require(_core != address(0), \"Ekubo: core 0\");\n        require(_weth != address(0), \"Ekubo: weth 0\");\n        core = _core;\n        weth = _weth;\n    }\n\n    /// Only Core (withdrawing native output) and WETH (on unwrap) ever send ETH\n    /// here. Anything else is a mistake, so reject it rather than silently\n    /// absorbing funds the next swap would sweep.\n    receive() external payable {\n        require(msg.sender == core || msg.sender == weth, \"Ekubo: unexpected ETH\");\n    }\n\n    function executeSwap(\n        PathDescription memory path,\n        uint256 amount,\n        address /* from */,\n        address to\n    ) external override returns (uint256 amountOut) {\n        // amount == 0 -> use what the module just transferred in (the repo-wide\n        // pass-0 convention; also what makes fee-on-transfer intermediates work).\n        uint256 amountIn = amount == 0\n            ? IERC20(path.srcToken).balanceOf(address(this))\n            : amount;\n        require(amountIn > 0 && amountIn <= uint256(uint128(type(int128).max)), \"Ekubo: amountIn\");\n\n        (address token0, address token1, bytes32 config) = abi.decode(\n            path.data,\n            (address, address, bytes32)\n        );\n\n        // Ekubo's address(0) is our WETH. Alias for direction detection only —\n        // the pool key itself keeps address(0).\n        address routeToken0 = token0 == address(0) ? weth : token0;\n        address routeToken1 = token1 == address(0) ? weth : token1;\n        // A WETH/native pool would alias both sides to WETH and make the\n        // direction undecidable. Ekubo has no such pool today; refuse rather\n        // than guess if one ever appears.\n        require(routeToken0 != routeToken1, \"Ekubo: ambiguous pool\");\n\n        bool isToken1;\n        if (path.srcToken == routeToken0) {\n            isToken1 = false;\n        } else if (path.srcToken == routeToken1) {\n            isToken1 = true;\n        } else {\n            revert(\"Ekubo: srcToken not in pool\");\n        }\n\n        // Pack SwapParameters. amountIn < 2^127 (checked above) so bit 159 — the\n        // int128 sign bit — is clear, i.e. this is an exact-INPUT swap.\n        uint256 params = (uint256(isToken1 ? MAX_SQRT_RATIO : MIN_SQRT_RATIO) << 160) |\n            (amountIn << 32) |\n            (isToken1 ? (uint256(1) << 31) : 0);\n        // skipAhead (bits [30:0]) stays 0: no tick-bitmap skipping.\n\n        uint256 balBefore = IERC20(path.dstToken).balanceOf(to);\n\n        // Acquire the lock. Core appends nothing of its own — our payload comes\n        // back verbatim in the callback.\n        (bool ok, bytes memory ret) = core.call(\n            abi.encodePacked(\n                SEL_LOCK,\n                abi.encode(token0, token1, config, bytes32(params), isToken1, to, amountIn)\n            )\n        );\n        if (!ok) {\n            assembly (\"memory-safe\") {\n                revert(add(ret, 32), mload(ret))\n            }\n        }\n\n        // Sweep any native ETH left over once the lock closes. Observed on\n        // live BoostedFees-extension pools: Core returns a small amount to the\n        // locker beyond the settled deltas (~0.000577 ETH on a 0.1 WETH swap).\n        // Leaving it here would be a slow leak — the module passes amount=0 and\n        // handlers spend their own balance, so the next swap through this\n        // handler would silently pick it up and hand it to an unrelated user.\n        // Wrapping it to `to` keeps the value with the trade that produced it,\n        // and keeps this contract balance-free between calls.\n        uint256 residual = address(this).balance;\n        if (residual > 0) {\n            IWETH9(weth).deposit{value: residual}();\n            TransferHelper.safeTransfer(weth, to, residual);\n        }\n\n        // Measure what the recipient actually received rather than trusting the\n        // packed deltas (and their sign convention) a second time. Deliberately\n        // after the sweep: when dstToken IS WETH the swept amount is genuinely\n        // part of the output and must be counted.\n        amountOut = IERC20(path.dstToken).balanceOf(to) - balBefore;\n        require(amountOut > 0, \"Ekubo: no output\");\n    }\n\n    /**\n     * Core's lock callback. Selector is 0x00000000 by construction — solc\n     * derives it from this exact function name, same as Ekubo's own contracts.\n     *\n     * Only reachable from Core, and Core only ever calls back the address that\n     * called `lock()` — which is this contract, from executeSwap above.\n     */\n    function locked_6416899205(uint256 /* id */) external {\n        require(msg.sender == core, \"Ekubo: not core\");\n\n        (\n            address token0,\n            address token1,\n            bytes32 config,\n            bytes32 params,\n            bool isToken1,\n            address to,\n            uint256 amountIn\n        ) = abi.decode(msg.data[36:], (address, address, bytes32, bytes32, bool, address, uint256));\n\n        // swap_6269342730(): no abi args, Core reads 132 bytes of raw calldata.\n        // abi.encodeWithSelector gives exactly selector + 4 words.\n        (bool ok, bytes memory ret) = core.call(\n            abi.encodeWithSelector(SEL_ZERO, token0, token1, config, params)\n        );\n        if (!ok && ret.length == 4 && bytes4(ret) == ERR_SWAP_MUST_FORWARD) {\n            // Forward-only extension: same four words, delivered through the\n            // extension (first 20 bytes of the packed config word). The failed\n            // direct call changed nothing — beforeSwap reverted before Core\n            // touched any state — so the lock is intact.\n            address extension = address(bytes20(config));\n            (ok, ret) = core.call(\n                abi.encodePacked(\n                    abi.encodeWithSelector(SEL_FORWARD, extension),\n                    abi.encode(token0, token1, config, params)\n                )\n            );\n        }\n        if (!ok) {\n            assembly (\"memory-safe\") {\n                revert(add(ret, 32), mload(ret))\n            }\n        }\n        require(ret.length >= 32, \"Ekubo: swap return\");\n\n        // Returns balanceUpdate ++ stateAfter. balanceUpdate packs two int128\n        // deltas: delta0 in the high half, delta1 in the low half. POSITIVE =\n        // we owe Core; NEGATIVE = Core owes us.\n        bytes32 update;\n        assembly (\"memory-safe\") {\n            update := mload(add(ret, 32))\n        }\n        int128 delta0 = int128(uint128(uint256(update) >> 128));\n        int128 delta1 = int128(uint128(uint256(update)));\n\n        // Pool-space tokens: address(0) here means native ETH.\n        address tokenIn = isToken1 ? token1 : token0;\n        address tokenOut = isToken1 ? token0 : token1;\n        int128 deltaIn = isToken1 ? delta1 : delta0;\n        int128 deltaOut = isToken1 ? delta0 : delta1;\n        require(deltaIn > 0 && deltaOut < 0, \"Ekubo: deltas\");\n\n        uint256 owed = uint256(uint128(deltaIn));\n        uint128 received = uint128(-deltaOut);\n\n        // A short fill would leave unspent input sitting in the handler, which\n        // the next swap through this handler would sweep. Reject it instead.\n        require(owed == amountIn, \"Ekubo: partial fill\");\n\n        _pay(tokenIn, owed);\n        _collect(tokenOut, to, received);\n\n        // Raw-return the output amount; Core passes lock() returndata straight\n        // through to executeSwap (which cross-checks it against balances).\n        assembly (\"memory-safe\") {\n            mstore(0, received)\n            return(0, 32)\n        }\n    }\n\n    /// Settle the input side of the swap.\n    function _pay(address token, uint256 amount) private {\n        if (token == address(0)) {\n            // Native: the module handed us WETH, so unwrap and send real ETH.\n            // Core's receive() credits the locker's debt — no startPayments.\n            IWETH9(weth).withdraw(amount);\n            (bool sent, ) = core.call{value: amount}(\"\");\n            require(sent, \"Ekubo: native pay\");\n            return;\n        }\n\n        // ERC20: startPayments(token) -> transfer -> completePayments(token).\n        // Both take the token list abi-encoded after the selector.\n        (bool ok, ) = core.call(abi.encodeWithSelector(SEL_START_PAYMENTS, token));\n        require(ok, \"Ekubo: startPayments\");\n\n        TransferHelper.safeTransfer(token, core, amount);\n\n        (ok, ) = core.call(abi.encodeWithSelector(SEL_COMPLETE_PAYMENTS, token));\n        require(ok, \"Ekubo: completePayments\");\n    }\n\n    /// Take the output side and deliver it to `to` as an ERC20.\n    /// withdraw() takes PACKED args, not abi-encoded:\n    /// selector ++ token(20) ++ recipient(20) ++ amount(16) = 60 bytes.\n    function _collect(address token, address to, uint128 amount) private {\n        // Native output arrives as real ETH, so take it here and wrap it —\n        // the route expects WETH.\n        address recipient = token == address(0) ? address(this) : to;\n\n        (bool ok, bytes memory ret) = core.call(\n            abi.encodePacked(SEL_WITHDRAW, token, recipient, amount)\n        );\n        if (!ok) {\n            assembly (\"memory-safe\") {\n                revert(add(ret, 32), mload(ret))\n            }\n        }\n\n        if (token == address(0)) {\n            IWETH9(weth).deposit{value: amount}();\n            TransferHelper.safeTransfer(weth, to, amount);\n        }\n    }\n}\n"},"@uniswap/lib/contracts/libraries/TransferHelper.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-or-later\n\npragma solidity >=0.6.0;\n\n// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false\nlibrary TransferHelper {\n    function safeApprove(\n        address token,\n        address to,\n        uint256 value\n    ) internal {\n        // bytes4(keccak256(bytes('approve(address,uint256)')));\n        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));\n        require(\n            success && (data.length == 0 || abi.decode(data, (bool))),\n            'TransferHelper::safeApprove: approve failed'\n        );\n    }\n\n    function safeTransfer(\n        address token,\n        address to,\n        uint256 value\n    ) internal {\n        // bytes4(keccak256(bytes('transfer(address,uint256)')));\n        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));\n        require(\n            success && (data.length == 0 || abi.decode(data, (bool))),\n            'TransferHelper::safeTransfer: transfer failed'\n        );\n    }\n\n    function safeTransferFrom(\n        address token,\n        address from,\n        address to,\n        uint256 value\n    ) internal {\n        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));\n        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));\n        require(\n            success && (data.length == 0 || abi.decode(data, (bool))),\n            'TransferHelper::transferFrom: transferFrom failed'\n        );\n    }\n\n    function safeTransferETH(address to, uint256 value) internal {\n        (bool success, ) = to.call{value: value}(new bytes(0));\n        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"}},"stdJsonOutput":{"sources":{"contracts/shared/interfaces/IERC20.sol":{"id":140},"contracts/router/interfaces/ISwapHandler.sol":{"id":75},"contracts/router/modules/EkuboSwapHandler.sol":{"id":92},"@uniswap/lib/contracts/libraries/TransferHelper.sol":{"id":10}},"contracts":{"contracts/router/modules/EkuboSwapHandler.sol":{"EkuboSwapHandler":{"abi":[{"type":"constructor","inputs":[{"name":"_core","type":"address","internalType":"address"},{"name":"_weth","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"core","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"executeSwap","type":"function","inputs":[{"name":"path","type":"tuple","components":[{"name":"srcToken","type":"address","internalType":"address"},{"name":"dstToken","type":"address","internalType":"address"},{"name":"pairAddr","type":"address","internalType":"address"},{"name":"fee","type":"uint256","internalType":"uint256"},{"name":"srcAmount","type":"uint256","internalType":"uint256"},{"name":"dstMinAmount","type":"uint256","internalType":"uint256"},{"name":"feeSrc","type":"uint256","internalType":"uint256"},{"name":"feeDst","type":"uint256","internalType":"uint256"},{"name":"liquidityType","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct ISwapHandler.PathDescription"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"locked_6416899205","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"weth","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_core\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_weth\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"core\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"srcToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"dstToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"pairAddr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"srcAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"dstMinAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeSrc\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeDst\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidityType\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"struct ISwapHandler.PathDescription\",\"name\":\"path\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"executeSwap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"locked_6416899205\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"weth\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"title\":\"EkuboSwapHandler — Ekubo_V3 (liquidityType 33) Ekubo keeps every pool inside one Core singleton. There is NO usable public router: `Router.sol` exists in Ekubo's repo but is not deployed on mainnet, and every live integrator (0x Settler, CoW, 1inch) locks Core directly from its own executor. So does this handler. The flow is the standard singleton lock/callback, but Ekubo is aggressively gas-golfed: two of its entrypoints have vanity names chosen so their selector is literally 0x00000000, and they take NO abi arguments — Core reads them straight out of calldata. Everything below is ported from Ekubo's own source (github.com/EkuboProtocol/evm-contracts).   1. call Core `lock()` (0xf83d08ba) with our payload appended RAW   2. Core calls back `locked_6416899205(uint256 id)` — selector 0x00000000 —      with our payload at msg.data[36:]   3. inside, call Core `swap_6269342730()` — also selector 0x00000000 — with      exactly 132 bytes: selector ++ token0 ++ token1 ++ config ++ params   4. settle: startPayments -> transfer -> completePayments for the input,      then withdraw the output straight to `to` `params` is a PACKED bytes32 (Ekubo's SwapParameters), not four words:   [255:160] sqrtRatioLimit (uint96 float)   [159:32]  amount (int128; > 0 = exact-in)   [31]      isToken1   [30:0]    skipAhead `path.data` carries the PoolKey remainder: abi.encode(token0, token1, config). The pool cannot be identified without it — `config` packs extension(20B)++fee(uint64)++typeConfig(4B) and is NOT derivable from the token pair. FORWARD-ONLY EXTENSIONS (Ve33). Some extensions refuse a direct Core.swap (beforeSwap reverts SwapMustHappenThroughForward) and require the swap to be forwarded to them via Core.forward(extension) so they can account their own fee. The locker detects that exact revert and re-issues the same payload through forward; deltas/settlement are identical afterwards. Robinhood: 27 of the 30 live Ekubo pools are Ve33 pools. NATIVE ETH. Ekubo denotes native ETH as address(0), and a THIRD of its mainnet pools are native-paired, so they are served rather than skipped. Our route steps are WETH-normalised, so this handler bridges the two:   - paying native  : unwrap WETH, then send ETH to Core — its `receive()`                      credits the locker's debt (no startPayments dance)   - receiving native: `withdraw` with token address(0) sends real ETH, so we                      take it here, wrap it, and forward WETH to `to` The route never sees anything but WETH. Slippage: no per-hop bound is imposed here — the sqrtRatioLimit is set to the extreme of the swap direction, exactly the uni_v4 model. Safety is the whole-route minReturn enforced by NonLinearSwapModule. We do require a FULL fill (see executeSwap) so a liquidity shortfall reverts loudly instead of silently leaving unspent input dust in the handler.\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"core()\":{\"notice\":\"Ekubo Core singleton. Immutable — nothing can repoint execution.\"},\"locked_6416899205(uint256)\":{\"notice\":\"Core's lock callback. Selector is 0x00000000 by construction — solc derives it from this exact function name, same as Ekubo's own contracts. Only reachable from Core, and Core only ever calls back the address that called `lock()` — which is this contract, from executeSwap above.\"},\"weth()\":{\"notice\":\"Canonical WETH, for bridging native-ETH pools to our WETH-normalised steps.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/router/modules/EkuboSwapHandler.sol\":\"EkuboSwapHandler\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@uniswap/lib/contracts/libraries/TransferHelper.sol\":{\"keccak256\":\"0xaff99b54915f57e2a4e71b8d15afd4ee425410e5a6f45c07517ae1beb806f8bd\",\"license\":\"GPL-3.0-or-later\",\"urls\":[\"bzz-raw://15432ec031f4cfa6709921289e198b030a0c5eac75b5a3e0eb64827a2b3b5595\",\"dweb:/ipfs/QmZvR1KuuDvuzXFiADCngTKyMCTy31uhq9U6CazP59B55j\"]},\"contracts/router/interfaces/ISwapHandler.sol\":{\"keccak256\":\"0x7e91bb2f6bd2f6ba2695a6b5ac5a81fe21c684e6a5baf891ab057ced0887dd3d\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://f1a099cd81aaaffdfd6c0512642e5f384f6360d156304c9284e464b82645e9f7\",\"dweb:/ipfs/QmThPAbNRRbHgcvbwhCsBJNH4TyZLPoN65mwHdwKmtPeUm\"]},\"contracts/router/modules/EkuboSwapHandler.sol\":{\"keccak256\":\"0x9c90a2f686a6250f9d4c5a21cb99c7d0626cca68ce225db290470b81855f1fa0\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://a5b6fea307a78c994a4bf4b426fe7a2e88c1ef2f4a103b7cb65f22af59e8daef\",\"dweb:/ipfs/QmRYpGBTo9tCdF69zuNVXcKdi9TBqTrDCKVuvQ6iT4LhVZ\"]},\"contracts/shared/interfaces/IERC20.sol\":{\"keccak256\":\"0xc4f0e42d0c0eb999269c077c701429df73fec85186af9fb679a4a066696bd61c\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://eae31c1b3c171df901662b7870251725670d823b764054521b8e71de52162208\",\"dweb:/ipfs/QmWrWFCYy6fxzyKcj16QDKHyNoBwR5umb8LBPLJgiYR2Ms\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{"core()":{"notice":"Ekubo Core singleton. Immutable — nothing can repoint execution."},"weth()":{"notice":"Canonical WETH, for bridging native-ETH pools to our WETH-normalised steps."},"locked_6416899205(uint256)":{"notice":"Core's lock callback. Selector is 0x00000000 by construction — solc derives it from this exact function name, same as Ekubo's own contracts. Only reachable from Core, and Core only ever calls back the address that called `lock()` — which is this contract, from executeSwap above."}},"version":1},"devdoc":{"kind":"dev","title":"EkuboSwapHandler — Ekubo_V3 (liquidityType 33) Ekubo keeps every pool inside one Core singleton. There is NO usable public router: `Router.sol` exists in Ekubo's repo but is not deployed on mainnet, and every live integrator (0x Settler, CoW, 1inch) locks Core directly from its own executor. So does this handler. The flow is the standard singleton lock/callback, but Ekubo is aggressively gas-golfed: two of its entrypoints have vanity names chosen so their selector is literally 0x00000000, and they take NO abi arguments — Core reads them straight out of calldata. Everything below is ported from Ekubo's own source (github.com/EkuboProtocol/evm-contracts).   1. call Core `lock()` (0xf83d08ba) with our payload appended RAW   2. Core calls back `locked_6416899205(uint256 id)` — selector 0x00000000 —      with our payload at msg.data[36:]   3. inside, call Core `swap_6269342730()` — also selector 0x00000000 — with      exactly 132 bytes: selector ++ token0 ++ token1 ++ config ++ params   4. settle: startPayments -> transfer -> completePayments for the input,      then withdraw the output straight to `to` `params` is a PACKED bytes32 (Ekubo's SwapParameters), not four words:   [255:160] sqrtRatioLimit (uint96 float)   [159:32]  amount (int128; > 0 = exact-in)   [31]      isToken1   [30:0]    skipAhead `path.data` carries the PoolKey remainder: abi.encode(token0, token1, config). The pool cannot be identified without it — `config` packs extension(20B)++fee(uint64)++typeConfig(4B) and is NOT derivable from the token pair. FORWARD-ONLY EXTENSIONS (Ve33). Some extensions refuse a direct Core.swap (beforeSwap reverts SwapMustHappenThroughForward) and require the swap to be forwarded to them via Core.forward(extension) so they can account their own fee. The locker detects that exact revert and re-issues the same payload through forward; deltas/settlement are identical afterwards. Robinhood: 27 of the 30 live Ekubo pools are Ve33 pools. NATIVE ETH. Ekubo denotes native ETH as address(0), and a THIRD of its mainnet pools are native-paired, so they are served rather than skipped. Our route steps are WETH-normalised, so this handler bridges the two:   - paying native  : unwrap WETH, then send ETH to Core — its `receive()`                      credits the locker's debt (no startPayments dance)   - receiving native: `withdraw` with token address(0) sends real ETH, so we                      take it here, wrap it, and forward WETH to `to` The route never sees anything but WETH. Slippage: no per-hop bound is imposed here — the sqrtRatioLimit is set to the extreme of the swap direction, exactly the uni_v4 model. Safety is the whole-route minReturn enforced by NonLinearSwapModule. We do require a FULL fill (see executeSwap) so a liquidity shortfall reverts loudly instead of silently leaving unspent input dust in the handler.","methods":{},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"3363:11368:92:-:0;;;;;;;;;;;;;-1:-1:-1;;3363:11368:92;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;-1:-1:-1;;;;;3363:11368:92;;;5392:19;3363:11368;;;;5447:19;3363:11368;;5494:12;;3363:11368;5516:12;3363:11368;;;;;;;;5494:12;3363:11368;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;-1:-1:-1;3363:11368:92;;;;;;-1:-1:-1;3363:11368:92;;;;;-1:-1:-1;3363:11368:92;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"3363:11368:92:-:0;;;;;;;;;;-1:-1:-1;3363:11368:92;;;;;;;;;;;;;;5808:4;;3363:11368;5794:10;:18;:40;;;;;3363:11368;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;5794:40;5830:4;;;3363:11368;5794:10;5816:18;5794:40;;;3363:11368;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3486:29;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;;;;;;-1:-1:-1;;3363:11368:92;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3363:11368:92;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;6248:11;3363:11368;;-1:-1:-1;3363:11368:92;;;;-1:-1:-1;;;6274:46:92;;6314:4;3363:11368;6274:46;;3363:11368;;;;;;;;;;-1:-1:-1;;;;;3363:11368:92;6274:46;;;;;;;;;;;6248:93;;;;6359:12;;;:62;;;6248:93;3363:11368;;;;;;6527:9;3363:11368;;;;;6503:84;;3363:11368;;;;;;6503:84;;3363:11368;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;3363:11368:92;;;;6774:4;6751:36;-1:-1:-1;;;;;3363:11368:92;;;;6842:4;6819:36;-1:-1:-1;;;;;3363:11368:92;;;;;;7068:26;3363:11368;;;;-1:-1:-1;;;;;3363:11368:92;;;;;7158:28;;3363:11368;;7202:16;;3363:11368;7202:16;;7154:223;;7572:42;;;;5296:29;7572:42;;7670:33;;;;5296:29;7670:33;;3363:11368;;;;;;;-1:-1:-1;;;7804:35:92;;-1:-1:-1;;;;;3363:11368:92;;;;;7804:35;;3363:11368;;;;;;;;;;7804:35;;;;;;;;;;;7670:33;3363:11368;;;;;;;;;;;8088:75;;3363:11368;;;;;;;;3744:10;;3363:11368;;3744:10;;3363:11368;5296:29;3363:11368;5296:29;;4124:10;5296:29;;;3363:11368;5296:29;;7563:91;:141;3363:11368;3744:10;;3363:11368;3744:10;;3363:11368;3744:10;;;3363:11368;;;;;;;;;3744:10;;3363:11368;;3744:10;;3363:11368;;8088:75;;3363:11368;;;;;;;;;;;;;;;;;;;8028:149;3363:11368;8028:149;;3363:11368;;;;3744:10;;;3363:11368;3744:10;;;;:::i;:::-;8028:149;;;;;;;;;;;;:::i;:::-;8005:182;:4;;;:182;;;;:::i;:::-;8201:3;;8197:122;;8964:21;;8999:12;8995:143;;7670:33;-1:-1:-1;3363:11368:92;;;;;;;-1:-1:-1;;;9453:35:92;;-1:-1:-1;;;;;3363:11368:92;;;;;9453:35;;3363:11368;;;;;;;;;;;9453:35;;;;;;;;;;;7670:33;3744:10;;;;;;;;;;9518:13;;3744:10;;3363:11368;;;;;;;;3744:10;3363:11368;;-1:-1:-1;;;3744:10:92;;3363:11368;;3744:10;;;;3363:11368;3744:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;3744:10;3363:11368;;3744:10;;-1:-1:-1;;;3744:10:92;;;3363:11368;3744:10;3363:11368;;3744:10;9453:35;;;3363:11368;9453:35;;3363:11368;9453:35;;;;;;3363:11368;9453:35;;;:::i;:::-;;;3363:11368;;;;;9453:35;;;3363:11368;;;;9453:35;;;-1:-1:-1;9453:35:92;;;3363:11368;;;;;;;;;8995:143;9034:4;3363:11368;-1:-1:-1;;;;;3363:11368:92;;9027:39;;;;;3363:11368;;;;;;;;;;;;;9027:39;;;;;;;;;;8995:143;3363:11368;;;9118:8;3363:11368;;;;;;9118:8;;:::i;:::-;8995:143;;;;9027:39;;;;;;;:::i;:::-;3363:11368;;9027:39;;;;;3363:11368;;;;9027:39;3363:11368;;;;;;;;;9027:39;3363:11368;;;8197:122;3363:11368;8220:89;;;;;3363:11368;3744:10;;;3363:11368;;;;;;;;7804:35;;;;3363:11368;7804:35;;3363:11368;7804:35;;;;;;3363:11368;7804:35;;;:::i;:::-;;;3363:11368;;;;;7804:35;;;;;;;-1:-1:-1;7804:35:92;;;3363:11368;;;;;;;;;7670:33;;;;;7572:42;5230:19;7572:42;;;7154:223;-1:-1:-1;;;;;3363:11368:92;7239:28;3363:11368;;;7283:15;3363:11368;7235:142;7154:223;;7235:142;3363:11368;;-1:-1:-1;;;7329:37:92;;3363:11368;;7329:37;;3363:11368;;;;;;;;;;;;;7329:37;3363:11368;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;6819:36;-1:-1:-1;;;;;3363:11368:92;;6819:36;;6751;-1:-1:-1;;;;;3363:11368:92;;6751:36;;3363:11368;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;6359:62;6375:46;6403:16;6375:46;;;6359:62;;6274:46;;;3363:11368;6274:46;;3363:11368;6274:46;;;;;;3363:11368;6274:46;;;:::i;:::-;;;3363:11368;;;;;6274:46;;;;;;-1:-1:-1;6274:46:92;;6248:93;;;;3363:11368;;;;;;;;;;;;;;;;;;;3605:29;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;;;;;;-1:-1:-1;;3363:11368:92;;;;9986:4;-1:-1:-1;;;;;3363:11368:92;9972:10;:18;3363:11368;;;;10247:2;3363:11368;;;;;-1:-1:-1;;3363:11368:92;;;;10247:2;3363:11368;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;:::i;:::-;;;;3744:10;;3363:11368;;;;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;;;;10527:64;;;;;-1:-1:-1;;;;;3363:11368:92;;;10247:2;10527:64;;3363:11368;;;3944:10;;;3363:11368;;;;3944:10;;;3363:11368;;;;3944:10;;;3363:11368;;;;;10527:64;3363:11368;3944:10;;;10527:64;;;;;;;;;;:::i;:::-;3363:11368;10504:97;;10527:64;;9986:4;;10504:97;;;;:::i;:::-;10474:127;10615:3;;10474:127;10615:3;:22;;3363:11368;10615:62;;;3363:11368;10611:667;;;3363:11368;11291:3;11287:122;;3363:11368;;;11426:16;4389:10;;3363:11368;11707:78;;3363:11368;;;;;-1:-1:-1;;;;;3363:11368:92;;;;;12000:26;3363:11368;;12000:26;3363:11368;;;-1:-1:-1;;;;;3363:11368:92;;;12000:26;3363:11368;;;;;-1:-1:-1;;;;;;3363:11368:92;;12055:26;3363:11368;;;;;12108:26;;3363:11368;;;;;12162:26;;;3363:11368;;;;12206:11;:27;;;12162:26;4389:10;;;3363:11368;;;;;-1:-1:-1;;4389:10:92;;;;;;3363:11368;;;12526:16;;4389:10;;12591:4;;;:::i;:::-;-1:-1:-1;;;;;3363:11368:92;;14265:19;:40;;;;14295:4;;;14265:40;3363:11368;;14369:56;3363:11368;14369:56;;3363:11368;;;;3744:10;;4124;;;;3363:11368;4124:10;;10247:2;4124:10;;;3363:11368;4124:10;;;;;;3363:11368;;;4124:10;-1:-1:-1;;;;;4124:10:92;;3363:11368;4124:10;;;;;;14369:56;;;;;;:::i;:::-;14346:89;9986:4;;;14346:89;;;;:::i;:::-;14449:3;;14445:122;;14577:146;;;14265:40;3363:11368;;;;;12805:94;;;14577:146;14623:4;;-1:-1:-1;;;;;3363:11368:92;;14616:37;;;;;3363:11368;;;;;;;;;;;;;;;14616:37;;;;;;;;;3363:11368;14616:37;;;14577:146;-1:-1:-1;14667:45:92;;3363:11368;-1:-1:-1;;;;;3363:11368:92;;;;14667:45;:::i;:::-;14577:146;;;14616:37;;;14667:45;14616:37;;;;;:::i;:::-;;;;;;;;3363:11368;;;;;;;;;14616:37;3363:11368;;;14265:40;3363:11368;;-1:-1:-1;;;;;3363:11368:92;;14265:40;;4389:10;3363:11368;;-1:-1:-1;;;4389:10:92;;3363:11368;;4389:10;;;;10247:2;4389:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4389:10;3363:11368;;4389:10;;-1:-1:-1;;;3744:10:92;;;3363:11368;3744:10;10247:2;3744:10;;4389;3363:11368;;-1:-1:-1;;;4389:10:92;;3363:11368;;4389:10;;;;10247:2;4389:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4389:10;3363:11368;;4389:10;12206:27;3363:11368;;;;;12221:12;12206:27;;12162:26;;;;;;12108;;;;;12055;-1:-1:-1;;;;;3363:11368:92;;12055:26;-1:-1:-1;12055:26:92;;12000;-1:-1:-1;;;;;3363:11368:92;;;12000:26;;4389:10;3363:11368;;-1:-1:-1;;;4389:10:92;;3363:11368;;4389:10;;;;10247:2;4389:10;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4389:10;3363:11368;;4389:10;10611:667;3363:11368;;;;;;;;;;11125:46;;;3363:11368;;;4971:10;10247:2;11125:46;;3363:11368;10247:2;11125:46;;;;;:::i;:::-;3363:11368;;;-1:-1:-1;;;;;3363:11368:92;;;;11193:42;;3363:11368;;;3944:10;;;3363:11368;;;;;;3944:10;;;3363:11368;;;3944:10;;;3363:11368;4389:10;;11087:166;;11193:42;3363:11368;;3944:10;;4389;3944;11193:42;3363:11368;;11087:166;;;4389:10;3363:11368;11087:166;;4389:10;;;:::i;:::-;;;:::i;11087:166::-;11060:207;9986:4;;;11060:207;;;;:::i;:::-;11048:219;10611:667;;10615:62;3363:11368;;;3944:10;;;;-1:-1:-1;;;;;;5296:29:92;;;-1:-1:-1;3363:11368:92;3944:10;;;;10615:62;-1:-1:-1;;;;;;;;5296:29:92;-1:-1:-1;;;10641:36:92;10615:62;;;3944:10;-1:-1:-1;;;;;;3363:11368:92;3944:10;;;;3363:11368;3944:10;5296:29;;;3944:10;;;-1:-1:-1;3944:10:92;;;;10615:22;3363:11368;;;10622:15;;-1:-1:-1;10615:22:92;;3363:11368;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;10527:64;;;3363:11368;;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o;:::-;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o;:::-;;;;;;10527:64;3363:11368;-1:-1:-1;;3363:11368:92;;;;:::o;:::-;;;-1:-1:-1;;;;;3363:11368:92;;;;;;:::o;3744:10::-;;3363:11368;;3744:10;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3363:11368;;;;;;;:::i;:::-;3744:10;;;-1:-1:-1;3744:10:92;;;;:::o;:::-;;;:::o;652:438:10:-;3363:11368:92;;-1:-1:-1;;;878:45:10;;;;;;-1:-1:-1;;;;;3363:11368:92;;;878:45:10;;;3363:11368:92;;;;;;;;;878:45:10;;;652:438;3363:11368:92;;;;;;;;;;;;;;-1:-1:-1;867:57:10;;;;;;;;;;;;;:::i;:::-;955;;;;652:438;3363:11368:92;;;;;652:438:10:o;3363:11368:92:-;;;-1:-1:-1;;;3363:11368:92;;878:45:10;3363:11368:92;;;;;878:45:10;3363:11368:92;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;955:57:10;3363:11368:92;;;;;967:16:10;;;:44;;;;;955:57;;;;;;;;967:44;987:24;;;;;878:45;987:24;;;3363:11368:92;;;;878:45:10;987:24;3363:11368:92;3744:10;;;;3363:11368;;;;967:44:10;;;;;;12954:900:92;;13038:1;;-1:-1:-1;;;;;3363:11368:92;;;;13021:19;;13017:364;;13552:4;;3363:11368;;;13562:49;;;;;;3363:11368;;;13562:49;;;;;;;;3363:11368;13562:49;;;;;;:::i;:::-;13552:60;;;;;;;;:::i;:::-;;4005:10;;;13709:6;;;;;;;;:::i;:::-;3363:11368;;;13562:49;13746:52;;3363:11368;;;;13746:52;;;;;3363:11368;13746:52;;;;;;:::i;:::-;13736:63;;;;;;:::i;:::-;;4069:10;;;12954:900;:::o;4069:10::-;;3363:11368;4069:10;3363:11368;;;;;;4069:10;;13562:49;4069:10;;;;;;3363:11368;4069:10;3363:11368;;;4069:10;;4005;3363:11368;;-1:-1:-1;;;4005:10:92;;13562:49;4005:10;;;;;;;;3363:11368;-1:-1:-1;;;3363:11368:92;;;4005:10;;;;13017:364;13222:4;;;;;3363:11368;13215:29;;;;;3363:11368;;;;;;;;;;;;;13215:29;;;;;;3363:11368;13215:29;;;;;;;;13017:364;13274:4;;;;;;:28;;;;:::i;:::-;;3363:11368;;;13364:7::o;3363:11368::-;;;-1:-1:-1;;;3363:11368:92;;;13215:29;3363:11368;;;;;;;;-1:-1:-1;;;3363:11368:92;;;;;;;13215:29;;;;:::i;:::-;;;","linkReferences":{},"immutableReferences":{"16564":[{"start":37,"length":32},{"start":261,"length":32},{"start":1191,"length":32},{"start":2174,"length":32},{"start":2387,"length":32},{"start":2735,"length":32},{"start":3365,"length":32},{"start":4119,"length":32},{"start":4501,"length":32}],"16567":[{"start":152,"length":32},{"start":777,"length":32},{"start":825,"length":32},{"start":1484,"length":32},{"start":2106,"length":32},{"start":2800,"length":32},{"start":4414,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"core()","signatureHash4":"0xf2f4eb26","signatureHash32":"0xf2f4eb266c1410ab85e588db2511aa954e60c3c01704b351499b55bcb681a087"},{"signature":"executeSwap((address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes),uint256,address,address)","signatureHash4":"0x7101eb82","signatureHash32":"0x7101eb824290b8d69de55bc175fcd2571622e9d4efd84458597c33ed0562056f"},{"signature":"locked_6416899205(uint256)","signatureHash4":"0x00000000","signatureHash32":"0x00000000f5b8d75f20c6266fc5518dec572fd04b54a029f03adf07f867d4c273"},{"signature":"weth()","signatureHash4":"0x3fc8cef3","signatureHash32":"0x3fc8cef3584510d52761a06b1790c486c391517f6e5b3918a42917c24e69d082"}],"event":[],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x2a9C887D5Eaa5524877D88D886629DC96EceEe66"}