{"matchId":"51413125","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-09-21T07:50:22Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"215:4261:6:-:0;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"0x6080604052600436101561001a575b3615610018575f80fd5b005b5f3560e01c806301f9f42314610079578063346387bf146100745780637cbb0c4f1461006f57806383d1eb841461006a57806391c9d3f6146100655763ffa1ad740361000e576104b2565b610435565b6103a6565b610319565b61027b565b6101003660031901126101215760043561009281610125565b6024359061009f82610125565b604435906100ac82610125565b6100b461015f565b6084356100bf610136565b9060c4356001600160401b038111610121576100df9036906004016101ce565b9260e435956001600160401b0387116101215761011d9761010761010d983690600401610214565b966104ee565b6040519081529081906020820190565b0390f35b5f80fd5b6001600160a01b0381160361012157565b60a4359061014382610125565b565b60c4359061014382610125565b60e4359061014382610125565b6064359061014382610125565b6044359061014382610125565b634e487b7160e01b5f52604160045260245ffd5b90601f801991011681019081106001600160401b038211176101ae57604052565b610179565b6001600160401b0381116101ae57601f01601f191660200190565b81601f82011215610121578035906101e5826101b3565b926101f3604051948561018d565b8284526020838301011161012157815f926020809301838601378301015290565b9080601f83011215610121578135916001600160401b0383116101ae578260051b9060405193610247602084018661018d565b845260208085019282010192831161012157602001905b82821061026b5750505090565b813581526020918201910161025e565b6101403660031901126101215760043561029481610125565b602435906102a182610125565b6102a961016c565b906102b261015f565b60843560a4356102c0610145565b906102c9610152565b92610104356001600160401b038111610121576102ea9036906004016101ce565b9461012435976001600160401b0389116101215761011d9961031361010d9a3690600401610214565b9861052e565b34610121576060366003190112610121576004356001600160401b038111610121576103499036906004016101ce565b602435906001600160401b0382116101215761037a6040916103716020943690600401610214565b6044359161059a565b815192839181835280519182918282860152018484015e5f828201840152601f01601f19168101030190f35b60e0366003190112610121576004356103be81610125565b602435906103cb82610125565b604435906103d882610125565b6064356084356103e781610125565b60a4356001600160401b038111610121576104069036906004016101ce565b9160c435946001600160401b0386116101215761011d9661042e61010d973690600401610214565b95806104ee565b60c03660031901126101215760043561044d81610125565b6024359061045a82610125565b60443561046681610125565b6064356084356001600160401b038111610121576104889036906004016101ce565b9160a435946001600160401b038611610121576104ac610018963690600401610214565b946105f5565b34610121575f36600319011261012157602060405160058152f35b919082039182116104da57565b634e487b7160e01b5f52601160045260245ffd5b95610526959461050d9361052b999361050788886106c4565b996105f5565b61052161051a30836106c4565b8383610761565b6106c4565b6104cd565b90565b979861052b9961052195610526999597946105539461054d8b8b6106c4565b9c6105f5565b61055d30856106c4565b9181151580610591575b610575575b50508383610761565b6105838261058a93946104cd565b9085610761565b5f8061056c565b50818311610567565b918151915f5b8381106105ae575050505090565b600101600581901b82015185016024018390526105a0565b3d156105f0573d906105d7826101b3565b916105e5604051938461018d565b82523d5f602084013e565b606090565b93949190918381516106b2575b50506001600160a01b03811673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee0361067157505080340361065b57505f9182915b6020825192019034905af161064a6105c6565b90156106535750565b602081519101fd5b635928816d60e11b5f526004523460245260445ffd5b9391939290923461069a575f9485946106959261069083303384610804565b610848565b610637565b635928816d60e11b5f9081526004523460245260445ffd5b6106bc918761059a565b505f83610602565b6001600160a01b031673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee81036106ed57503190565b6040516370a0823160e01b81526001600160a01b039092166004830152602090829060249082905afa908115610756575f91610727575090565b90506020813d60201161074e575b816107426020938361018d565b81010312610121575190565b3d9150610735565b6040513d5f823e3d90fd5b9091906001600160a01b03811673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee036107c257505f80808093855af16107996105c6565b50156107a25750565b6339f1c8d960e01b5f9081526001600160a01b0391909116600452602490fd5b60405163a9059cbb60e01b60208201526001600160a01b0393909316602484015260448084019290925290825261014391906107ff60648361018d565b610918565b6040516323b872dd60e01b60208201526001600160a01b039283166024820152929091166044830152606480830193909352918152610143916107ff60848361018d565b60405163095ea7b360e01b60208083019182526001600160a01b0385166024840152604480840196909652948252929390925f9061088760648661018d565b84519082855af15f51903d816108ec575b501590505b6108a657505050565b60405163095ea7b360e01b60208201526001600160a01b039390931660248401525f6044808501919091528352610143926107ff906108e660648261018d565b82610918565b1515905061090c575061089d6001600160a01b0382163b15155b5f610898565b600161089d9114610906565b905f602091828151910182855af115610756575f513d61096757506001600160a01b0381163b155b6109475750565b635274afe760e01b5f9081526001600160a01b0391909116600452602490fd5b6001141561094056","recompiledBytecode":"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","sourceMap":"215:4261:6:-:0;;;;;;;;;-1:-1:-1;215:4261:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;:::i;:::-;;;;;:::i;:::-;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;:::o;:::-;;;;;;;:::i;:::-;:::o;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;:::o;:::-;;:::i;:::-;-1:-1:-1;;;;;215:4261:6;;;;;;-1:-1:-1;;215:4261:6;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;215:4261:6;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;:::i;:::-;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;-1:-1:-1;;215:4261:6;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;215:4261:6;;;;;;;;-1:-1:-1;;215:4261:6;;;;;;;;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;2375:77;215:4261;;;;;;:::i;:::-;2375:77;;;:::i;215:4261::-;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;-1:-1:-1;;215:4261:6;;;;;;;309:1;215:4261;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;1453:628;;1996:28;1453:628;;1880:8;1453:628;2046:28;1453:628;;1792:28;;;;:::i;:::-;1880:8;;:::i;:::-;1929:33;;1956:4;1929:33;;:::i;:::-;;;;:::i;:::-;1996:28;:::i;:::-;2046;:::i;:::-;1453:628;:::o;509:938::-;;;1412:28;509:938;1319:9;509:938;1362:28;509:938;;;;1004:8;509:938;916:28;;;;:::i;:::-;1004:8;;:::i;:::-;1035:33;1062:4;1035:33;;:::i;:::-;1082:16;;;;:44;;;509:938;1078:202;;509:938;1319:9;;;;;:::i;1078:202::-;1156:24;;1227:3;1156:24;;;:::i;:::-;1227:3;;;:::i;:::-;1078:202;;;;1082:44;1102:24;;;;1082:44;;2465:488;;215:4261;;2694:232;;;;;;;;2935:11;;;;2465:488;:::o;2694:232::-;;;;;;;;;;;;;;;;;;;347:50;;;;;;;;;;:::i;:::-;215:4261;;;;;;;:::i;:::-;347:50;;;-1:-1:-1;347:50:6;;;;:::o;:::-;215:4261;347:50;:::o;2959:859::-;;;;;;215:4261;;;3188:64;;2959:859;-1:-1:-1;;;;;;;215:4261:6;;354:42;3266:15;354:42;;3301:9;;;;:21;3297:69;;3262:330;3211:1;3262:330;;;;3641:38;;;;;3662:9;;3641:38;;;;;:::i;:::-;3693:8;;3689:123;;2959:859;:::o;3689:123::-;3641:38;3717:85;;;;;3297:69;-1:-1:-1;;;3211:1:6;3331:35;;215:4261;3301:9;347:50;215:4261;347:50;3211:1;3331:35;3262:330;3401:9;;;;;;;3397:55;;3211:1;;;;3572:8;;3518;3511:4;;3491:10;3511:4;3518:8;:::i;:::-;3572;:::i;:::-;3262:330;;3397:55;-1:-1:-1;;;3211:1:6;3424:28;;;;215:4261;3401:9;347:50;215:4261;347:50;3211:1;3331:35;3188:64;3214:38;;;;:::i;:::-;;3188:64;;;;4190:248;-1:-1:-1;;;;;215:4261:6;354:42;4349:13;;354:42;;4377:15;;4190:248;:::o;4349:82::-;215:4261;;-1:-1:-1;;;4407:24:6;;-1:-1:-1;;;;;215:4261:6;;;4407:24;;;215:4261;;;;;4407:24;;215:4261;;4407:24;;;;;;;-1:-1:-1;4407:24:6;;;4349:82;4190:248;:::o;4407:24::-;;;215:4261;4407:24;;215:4261;4407:24;;;;;;215:4261;4407:24;;;:::i;:::-;;;215:4261;;;;;4190:248;:::o;4407:24::-;;;-1:-1:-1;4407:24:6;;;215:4261;;;-1:-1:-1;215:4261:6;;;;;3828:356;;;;-1:-1:-1;;;;;215:4261:6;;354:42;3960:13;354:42;;4007:34;;;;;;;;;;;:::i;:::-;;4059:8;4055:45;;3956:222;3828:356::o;4055:45::-;-1:-1:-1;;;4007:34:6;4076:24;;;-1:-1:-1;;;;;215:4261:6;;;;4076:24;215:4261;;;4076:24;3956:222;215:4261;;-1:-1:-1;;;1328:43:4;;;;-1:-1:-1;;;;;215:4261:6;;;;1328:43:4;;;215:4261:6;;;;;;;;;1328:43:4;;;;;215:4261:6;1328:43:4;215:4261:6;;1328:43:4;:::i;:::-;;:::i;1618:188::-;215:4261:6;;-1:-1:-1;;;1745:53:4;;;;-1:-1:-1;;;;;215:4261:6;;;1745:53:4;;;215:4261:6;;;;;;;;;;;;;;;;;1745:53:4;;;;;;;215:4261:6;1745:53:4;:::i;4400:380::-;215:4261:6;;-1:-1:-1;;;4515:47:4;;;;;;;-1:-1:-1;;;;;215:4261:6;;4515:47:4;;;215:4261:6;;;;;;;;;4515:47:4;;;215:4261:6;;;;-1:-1:-1;;4515:47:4;215:4261:6;;4515:47:4;:::i;:::-;9086:199;;;;;;;-1:-1:-1;9086:199:4;;;;9301:80;;4400:380;-1:-1:-1;4577:45:4;;-1:-1:-1;4577:45:4;4573:201;;4400:380;;;:::o;4573:201::-;215:4261:6;;-1:-1:-1;;;4515:47:4;4665:43;;;-1:-1:-1;;;;;215:4261:6;;;;4515:47:4;4665:43;;215:4261:6;-1:-1:-1;215:4261:6;;;;;;;;4665:43:4;;4750:12;;4665:43;;;215:4261:6;;4665:43:4;:::i;:::-;;;:::i;9301:80::-;9313:15;;;-1:-1:-1;9313:15:4;;-1:-1:-1;4577:45:4;-1:-1:-1;;;;;215:4261:6;;9331:26:4;:30;;9313:67;9301:80;;;9313:67;9379:1;4577:45;9364:16;;9313:67;;7686:720;;-1:-1:-1;7823:421:4;7686:720;7823:421;;;;;;;;;;;;-1:-1:-1;7823:421:4;;8258:15;;-1:-1:-1;;;;;;215:4261:6;;8276:26:4;:31;8258:68;8254:146;;7686:720;:::o;8254:146::-;-1:-1:-1;;;;8349:40:4;;;-1:-1:-1;;;;;215:4261:6;;;;8349:40:4;215:4261:6;;;8349:40:4;8258:68;8325:1;8310:16;;8258:68;","linkReferences":{},"cborAuxdata":{},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x76b6ce7c5f175b7834e46369f9c345e9c8489ca70c885a4d07408174b80fe97a","blockNumber":"22441107","transactionIndex":"20","deployer":"0x826e0BB2276271eFdF2a500597f37b94f6c153bA"},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            // bubble errors\n            if iszero(success) {\n                let ptr := mload(0x40)\n                returndatacopy(ptr, 0, returndatasize())\n                revert(ptr, returndatasize())\n            }\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        bool success;\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"src/helpers/SwapHelpers.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport { IERC20, SafeERC20 } from \"openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol\";\n\n/**\n * @notice Helper contract to update swap data on-chain\n */\ncontract SwapHelpers {\n    using SafeERC20 for IERC20;\n\n    uint256 public constant VERSION = 5;\n    IERC20 private constant _ETH = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);\n\n    error IncorrectValue(uint256 expected, uint256 actual);\n    error TransferFailed(address receiver);\n\n    function swapWithLimit(\n        address primary,\n        address operator,\n        IERC20 tokenIn,\n        IERC20 tokenOut,\n        uint256 amountIn,\n        uint256 maxAmountOut,\n        address receiver,\n        address feeReceiver,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        public\n        payable\n        returns (uint256 amountOut)\n    {\n        uint256 balanceBefore = _balance(tokenOut, receiver);\n        _swap(primary, operator, tokenIn, amountIn, data, pointers);\n        amountOut = _balance(tokenOut, address(this));\n        if (maxAmountOut > 0 && amountOut > maxAmountOut) {\n            uint256 fee = amountOut - maxAmountOut;\n            _transfer(tokenOut, feeReceiver, fee);\n            amountOut = maxAmountOut;\n        }\n        _transfer(tokenOut, receiver, amountOut);\n        uint256 balanceAfter = _balance(tokenOut, receiver);\n        amountOut = balanceAfter - balanceBefore;\n    }\n\n    function swap(\n        address primary,\n        address operator,\n        IERC20 tokenIn,\n        IERC20 tokenOut,\n        uint256 amountIn,\n        address receiver,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        public\n        payable\n        returns (uint256 amountOut)\n    {\n        uint256 balanceBefore = _balance(tokenOut, receiver);\n        _swap(primary, operator, tokenIn, amountIn, data, pointers);\n        _transfer(tokenOut, receiver, _balance(tokenOut, address(this)));\n        uint256 balanceAfter = _balance(tokenOut, receiver);\n        amountOut = balanceAfter - balanceBefore;\n    }\n\n    function swap(\n        address primary,\n        IERC20 tokenIn,\n        IERC20 tokenOut,\n        uint256 amountIn,\n        address receiver,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        external\n        payable\n        returns (uint256)\n    {\n        return swap(primary, primary, tokenIn, tokenOut, amountIn, receiver, data, pointers);\n    }\n\n    function insertAmount(\n        bytes memory data,\n        uint256[] memory pointers,\n        uint256 amount\n    )\n        public\n        pure\n        returns (bytes memory)\n    {\n        uint256 length = pointers.length;\n        assembly {\n            for { let i := 0 } lt(i, length) { i := add(i, 1) } {\n                let pointer := mload(add(pointers, mul(32, add(i, 1))))\n                mstore(add(data, add(36, pointer)), amount)\n            }\n        }\n        return data;\n    }\n\n    function _swap(\n        address primary,\n        address operator,\n        IERC20 tokenIn,\n        uint256 amountIn,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        public\n        payable\n    {\n        if (pointers.length != 0) insertAmount(data, pointers, amountIn);\n        if (tokenIn == _ETH) {\n            if (msg.value != amountIn) revert IncorrectValue(amountIn, msg.value);\n        } else {\n            if (msg.value != 0) revert IncorrectValue(0, msg.value);\n            tokenIn.safeTransferFrom(msg.sender, address(this), amountIn);\n            tokenIn.forceApprove(operator, amountIn);\n        }\n        (bool success, bytes memory response) = primary.call{ value: msg.value }(data);\n        if (!success) {\n            assembly {\n                revert(add(response, 0x20), mload(response))\n            }\n        }\n    }\n    \n    function _transfer(\n        IERC20 token,\n        address receiver,\n        uint256 amount\n    )\n        internal\n    {\n        if (token == _ETH) {\n            (bool success,) = receiver.call{ value: amount }(\"\");\n            if (!success) revert TransferFailed(receiver);\n        } else {\n            token.safeTransfer(receiver, amount);\n        }\n    }\n\n    function _balance(\n        IERC20 token,\n        address account\n    )\n        internal\n        view\n        returns (uint256 balance)\n    {\n        balance = token == _ETH\n            ? account.balance\n            : token.balanceOf(account);\n    }\n\n    receive() external payable { }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/","@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/","@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/","@uniswap/v4-core/=lib/v4-core/","@uniswap/v4-periphery/=lib/v4-periphery/","devtools/=lib/devtools/packages/toolbox-foundry/src/","ds-test/=lib/forge-std/lib/ds-test/src/","enso-weiroll/=lib/enso-weiroll/contracts/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","layerzero-v2/=lib/layerzero-v2/","openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/","safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/","safe-tools/=lib/safe-tools/src/","solady/=lib/solady/src/","solmate/=lib/solady/lib/solmate/src/","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/","hardhat/=lib/v4-core/node_modules/hardhat/","permit2/=lib/v4-periphery/lib/permit2/","v4-core/=lib/v4-core/src/","v4-periphery/=lib/v4-periphery/"]},"name":"SwapHelpers","fullyQualifiedName":"src/helpers/SwapHelpers.sol:SwapHelpers"},"abi":[{"name":"IncorrectValue","type":"error","inputs":[{"name":"expected","type":"uint256","internalType":"uint256"},{"name":"actual","type":"uint256","internalType":"uint256"}]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"TransferFailed","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"_swap","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[],"stateMutability":"payable"},{"name":"insertAmount","type":"function","inputs":[{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"swap","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"tokenOut","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"swap","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"tokenOut","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"swapWithLimit","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"tokenOut","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"maxAmountOut","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"feeReceiver","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"expected","type":"uint256"},{"internalType":"uint256","name":"actual","type":"uint256"}],"name":"IncorrectValue","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"primary","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256[]","name":"pointers","type":"uint256[]"}],"name":"_swap","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256[]","name":"pointers","type":"uint256[]"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"insertAmount","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"primary","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC20","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256[]","name":"pointers","type":"uint256[]"}],"name":"swap","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"primary","type":"address"},{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC20","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256[]","name":"pointers","type":"uint256[]"}],"name":"swap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"primary","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC20","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"maxAmountOut","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"feeReceiver","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256[]","name":"pointers","type":"uint256[]"}],"name":"swapWithLimit","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"errors":{"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"notice":"Helper contract to update swap data on-chain","version":1}},"settings":{"compilationTarget":{"src/helpers/SwapHelpers.sol":"SwapHelpers"},"evmVersion":"cancun","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@ensdomains/=lib/v4-core/node_modules/@ensdomains/",":@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/",":@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/",":@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/",":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/",":@uniswap/v4-core/=lib/v4-core/",":@uniswap/v4-periphery/=lib/v4-periphery/",":devtools/=lib/devtools/packages/toolbox-foundry/src/",":ds-test/=lib/forge-std/lib/ds-test/src/",":enso-weiroll/=lib/enso-weiroll/contracts/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":hardhat/=lib/v4-core/node_modules/hardhat/",":layerzero-v2/=lib/layerzero-v2/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",":permit2/=lib/v4-periphery/lib/permit2/",":safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/",":safe-tools/=lib/safe-tools/src/",":solady/=lib/solady/src/",":solmate/=lib/solady/lib/solmate/src/",":v4-core/=lib/v4-core/src/",":v4-periphery/=lib/v4-periphery/"],"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"keccak256":"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7","license":"MIT","urls":["bzz-raw://da62d6be1f5c6edf577f0cb45666a8aa9c2086a4bac87d95d65f02e2f4c36a4b","dweb:/ipfs/QmNkpvBpoCMvX8JwAFNSc5XxJ2q5BXJpL5L1txb4QkqVFF"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"keccak256":"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724","license":"MIT","urls":["bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a","dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"keccak256":"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c","license":"MIT","urls":["bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba","dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1"]},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"keccak256":"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7","license":"MIT","urls":["bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db","dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"]},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0x4ea01544758fd2c7045961904686bfe232d2220a04ecaa2d6b08dac17827febf","license":"MIT","urls":["bzz-raw://fabe6bef5167ae741dd8c22d7f81d3f9120bd61b290762a2e8f176712567d329","dweb:/ipfs/QmSnEitJ6xmf1SSAUeZozD7Gx7h8bNnX3a1ZBzqeivsvVg"]},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8","license":"MIT","urls":["bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621","dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL"]},"src/helpers/SwapHelpers.sol":{"keccak256":"0x715a11c789a36817f616e59cfbf3f39a984e36b7e97b892152756bb0891439a6","license":"MIT","urls":["bzz-raw://2d51594fa6813fed602817f1339210d287199570644dc4c9125dcb4b000bb7f2","dweb:/ipfs/QmaGhEqd3HrgcLMw34jJAAn7c2tCy9uvF7yXU8wg3G2jR9"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Helper contract to update swap data on-chain","methods":{},"version":1},"devdoc":{"kind":"dev","errors":{"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"methods":{},"version":1},"sourceIds":{"src/helpers/SwapHelpers.sol":{"id":6},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"id":2},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"id":1},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":3},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"id":0},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"id":4},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":5}},"additionalInput":null,"stdJsonInput":{"sources":{"src/helpers/SwapHelpers.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport { IERC20, SafeERC20 } from \"openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol\";\n\n/**\n * @notice Helper contract to update swap data on-chain\n */\ncontract SwapHelpers {\n    using SafeERC20 for IERC20;\n\n    uint256 public constant VERSION = 5;\n    IERC20 private constant _ETH = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);\n\n    error IncorrectValue(uint256 expected, uint256 actual);\n    error TransferFailed(address receiver);\n\n    function swapWithLimit(\n        address primary,\n        address operator,\n        IERC20 tokenIn,\n        IERC20 tokenOut,\n        uint256 amountIn,\n        uint256 maxAmountOut,\n        address receiver,\n        address feeReceiver,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        public\n        payable\n        returns (uint256 amountOut)\n    {\n        uint256 balanceBefore = _balance(tokenOut, receiver);\n        _swap(primary, operator, tokenIn, amountIn, data, pointers);\n        amountOut = _balance(tokenOut, address(this));\n        if (maxAmountOut > 0 && amountOut > maxAmountOut) {\n            uint256 fee = amountOut - maxAmountOut;\n            _transfer(tokenOut, feeReceiver, fee);\n            amountOut = maxAmountOut;\n        }\n        _transfer(tokenOut, receiver, amountOut);\n        uint256 balanceAfter = _balance(tokenOut, receiver);\n        amountOut = balanceAfter - balanceBefore;\n    }\n\n    function swap(\n        address primary,\n        address operator,\n        IERC20 tokenIn,\n        IERC20 tokenOut,\n        uint256 amountIn,\n        address receiver,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        public\n        payable\n        returns (uint256 amountOut)\n    {\n        uint256 balanceBefore = _balance(tokenOut, receiver);\n        _swap(primary, operator, tokenIn, amountIn, data, pointers);\n        _transfer(tokenOut, receiver, _balance(tokenOut, address(this)));\n        uint256 balanceAfter = _balance(tokenOut, receiver);\n        amountOut = balanceAfter - balanceBefore;\n    }\n\n    function swap(\n        address primary,\n        IERC20 tokenIn,\n        IERC20 tokenOut,\n        uint256 amountIn,\n        address receiver,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        external\n        payable\n        returns (uint256)\n    {\n        return swap(primary, primary, tokenIn, tokenOut, amountIn, receiver, data, pointers);\n    }\n\n    function insertAmount(\n        bytes memory data,\n        uint256[] memory pointers,\n        uint256 amount\n    )\n        public\n        pure\n        returns (bytes memory)\n    {\n        uint256 length = pointers.length;\n        assembly {\n            for { let i := 0 } lt(i, length) { i := add(i, 1) } {\n                let pointer := mload(add(pointers, mul(32, add(i, 1))))\n                mstore(add(data, add(36, pointer)), amount)\n            }\n        }\n        return data;\n    }\n\n    function _swap(\n        address primary,\n        address operator,\n        IERC20 tokenIn,\n        uint256 amountIn,\n        bytes memory data,\n        uint256[] memory pointers\n    )\n        public\n        payable\n    {\n        if (pointers.length != 0) insertAmount(data, pointers, amountIn);\n        if (tokenIn == _ETH) {\n            if (msg.value != amountIn) revert IncorrectValue(amountIn, msg.value);\n        } else {\n            if (msg.value != 0) revert IncorrectValue(0, msg.value);\n            tokenIn.safeTransferFrom(msg.sender, address(this), amountIn);\n            tokenIn.forceApprove(operator, amountIn);\n        }\n        (bool success, bytes memory response) = primary.call{ value: msg.value }(data);\n        if (!success) {\n            assembly {\n                revert(add(response, 0x20), mload(response))\n            }\n        }\n    }\n    \n    function _transfer(\n        IERC20 token,\n        address receiver,\n        uint256 amount\n    )\n        internal\n    {\n        if (token == _ETH) {\n            (bool success,) = receiver.call{ value: amount }(\"\");\n            if (!success) revert TransferFailed(receiver);\n        } else {\n            token.safeTransfer(receiver, amount);\n        }\n    }\n\n    function _balance(\n        IERC20 token,\n        address account\n    )\n        internal\n        view\n        returns (uint256 balance)\n    {\n        balance = token == _ETH\n            ? account.balance\n            : token.balanceOf(account);\n    }\n\n    receive() external payable { }\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            // bubble errors\n            if iszero(success) {\n                let ptr := mload(0x40)\n                returndatacopy(ptr, 0, returndatasize())\n                revert(ptr, returndatasize())\n            }\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        bool success;\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/","@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/","@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/","@uniswap/v4-core/=lib/v4-core/","@uniswap/v4-periphery/=lib/v4-periphery/","devtools/=lib/devtools/packages/toolbox-foundry/src/","ds-test/=lib/forge-std/lib/ds-test/src/","enso-weiroll/=lib/enso-weiroll/contracts/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","layerzero-v2/=lib/layerzero-v2/","openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/","safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/","safe-tools/=lib/safe-tools/src/","solady/=lib/solady/src/","solmate/=lib/solady/lib/solmate/src/","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/","hardhat/=lib/v4-core/node_modules/hardhat/","permit2/=lib/v4-periphery/lib/permit2/","v4-core/=lib/v4-core/src/","v4-periphery/=lib/v4-periphery/"]}},"stdJsonOutput":{"sources":{"src/helpers/SwapHelpers.sol":{"id":6},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"id":2},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"id":1},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":3},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"id":0},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"id":4},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":5}},"contracts":{"src/helpers/SwapHelpers.sol":{"SwapHelpers":{"abi":[{"name":"IncorrectValue","type":"error","inputs":[{"name":"expected","type":"uint256","internalType":"uint256"},{"name":"actual","type":"uint256","internalType":"uint256"}]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"TransferFailed","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"_swap","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[],"stateMutability":"payable"},{"name":"insertAmount","type":"function","inputs":[{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"swap","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"tokenOut","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"swap","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"tokenOut","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"swapWithLimit","type":"function","inputs":[{"name":"primary","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"},{"name":"tokenIn","type":"address","internalType":"contract IERC20"},{"name":"tokenOut","type":"address","internalType":"contract IERC20"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"maxAmountOut","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"feeReceiver","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"pointers","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"expected\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actual\",\"type\":\"uint256\"}],\"name\":\"IncorrectValue\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"VERSION\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"primary\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256[]\",\"name\":\"pointers\",\"type\":\"uint256[]\"}],\"name\":\"_swap\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256[]\",\"name\":\"pointers\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"insertAmount\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"primary\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"tokenOut\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256[]\",\"name\":\"pointers\",\"type\":\"uint256[]\"}],\"name\":\"swap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"primary\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"tokenOut\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256[]\",\"name\":\"pointers\",\"type\":\"uint256[]\"}],\"name\":\"swap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"primary\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"tokenOut\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"feeReceiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256[]\",\"name\":\"pointers\",\"type\":\"uint256[]\"}],\"name\":\"swapWithLimit\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Helper contract to update swap data on-chain\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/helpers/SwapHelpers.sol\":\"SwapHelpers\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@ensdomains/=lib/v4-core/node_modules/@ensdomains/\",\":@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/\",\":@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/\",\":@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/\",\":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/\",\":@uniswap/v4-core/=lib/v4-core/\",\":@uniswap/v4-periphery/=lib/v4-periphery/\",\":devtools/=lib/devtools/packages/toolbox-foundry/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":enso-weiroll/=lib/enso-weiroll/contracts/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":hardhat/=lib/v4-core/node_modules/hardhat/\",\":layerzero-v2/=lib/layerzero-v2/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/\",\":permit2/=lib/v4-periphery/lib/permit2/\",\":safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/\",\":safe-tools/=lib/safe-tools/src/\",\":solady/=lib/solady/src/\",\":solmate/=lib/solady/lib/solmate/src/\",\":v4-core/=lib/v4-core/src/\",\":v4-periphery/=lib/v4-periphery/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol\":{\"keccak256\":\"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://da62d6be1f5c6edf577f0cb45666a8aa9c2086a4bac87d95d65f02e2f4c36a4b\",\"dweb:/ipfs/QmNkpvBpoCMvX8JwAFNSc5XxJ2q5BXJpL5L1txb4QkqVFF\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol\":{\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a\",\"dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba\",\"dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0x4ea01544758fd2c7045961904686bfe232d2220a04ecaa2d6b08dac17827febf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://fabe6bef5167ae741dd8c22d7f81d3f9120bd61b290762a2e8f176712567d329\",\"dweb:/ipfs/QmSnEitJ6xmf1SSAUeZozD7Gx7h8bNnX3a1ZBzqeivsvVg\"]},\"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621\",\"dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL\"]},\"src/helpers/SwapHelpers.sol\":{\"keccak256\":\"0x715a11c789a36817f616e59cfbf3f39a984e36b7e97b892152756bb0891439a6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2d51594fa6813fed602817f1339210d287199570644dc4c9125dcb4b000bb7f2\",\"dweb:/ipfs/QmaGhEqd3HrgcLMw34jJAAn7c2tCy9uvF7yXU8wg3G2jR9\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Helper contract to update swap data on-chain","methods":{},"version":1},"devdoc":{"kind":"dev","errors":{"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"methods":{},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"215:4261:6:-:0;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"215:4261:6:-:0;;;;;;;;;-1:-1:-1;215:4261:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;:::i;:::-;;;;;:::i;:::-;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;:::o;:::-;;;;;;;:::i;:::-;:::o;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;:::o;:::-;;:::i;:::-;-1:-1:-1;;;;;215:4261:6;;;;;;-1:-1:-1;;215:4261:6;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;215:4261:6;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;:::i;:::-;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;-1:-1:-1;;215:4261:6;;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;215:4261:6;;;;;;;;-1:-1:-1;;215:4261:6;;;;;;;;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;2375:77;215:4261;;;;;;:::i;:::-;2375:77;;;:::i;215:4261::-;;;-1:-1:-1;;215:4261:6;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;215:4261:6;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;-1:-1:-1;;215:4261:6;;;;;;;309:1;215:4261;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;1453:628;;1996:28;1453:628;;1880:8;1453:628;2046:28;1453:628;;1792:28;;;;:::i;:::-;1880:8;;:::i;:::-;1929:33;;1956:4;1929:33;;:::i;:::-;;;;:::i;:::-;1996:28;:::i;:::-;2046;:::i;:::-;1453:628;:::o;509:938::-;;;1412:28;509:938;1319:9;509:938;1362:28;509:938;;;;1004:8;509:938;916:28;;;;:::i;:::-;1004:8;;:::i;:::-;1035:33;1062:4;1035:33;;:::i;:::-;1082:16;;;;:44;;;509:938;1078:202;;509:938;1319:9;;;;;:::i;1078:202::-;1156:24;;1227:3;1156:24;;;:::i;:::-;1227:3;;;:::i;:::-;1078:202;;;;1082:44;1102:24;;;;1082:44;;2465:488;;215:4261;;2694:232;;;;;;;;2935:11;;;;2465:488;:::o;2694:232::-;;;;;;;;;;;;;;;;;;;347:50;;;;;;;;;;:::i;:::-;215:4261;;;;;;;:::i;:::-;347:50;;;-1:-1:-1;347:50:6;;;;:::o;:::-;215:4261;347:50;:::o;2959:859::-;;;;;;215:4261;;;3188:64;;2959:859;-1:-1:-1;;;;;;;215:4261:6;;354:42;3266:15;354:42;;3301:9;;;;:21;3297:69;;3262:330;3211:1;3262:330;;;;3641:38;;;;;3662:9;;3641:38;;;;;:::i;:::-;3693:8;;3689:123;;2959:859;:::o;3689:123::-;3641:38;3717:85;;;;;3297:69;-1:-1:-1;;;3211:1:6;3331:35;;215:4261;3301:9;347:50;215:4261;347:50;3211:1;3331:35;3262:330;3401:9;;;;;;;3397:55;;3211:1;;;;3572:8;;3518;3511:4;;3491:10;3511:4;3518:8;:::i;:::-;3572;:::i;:::-;3262:330;;3397:55;-1:-1:-1;;;3211:1:6;3424:28;;;;215:4261;3401:9;347:50;215:4261;347:50;3211:1;3331:35;3188:64;3214:38;;;;:::i;:::-;;3188:64;;;;4190:248;-1:-1:-1;;;;;215:4261:6;354:42;4349:13;;354:42;;4377:15;;4190:248;:::o;4349:82::-;215:4261;;-1:-1:-1;;;4407:24:6;;-1:-1:-1;;;;;215:4261:6;;;4407:24;;;215:4261;;;;;4407:24;;215:4261;;4407:24;;;;;;;-1:-1:-1;4407:24:6;;;4349:82;4190:248;:::o;4407:24::-;;;215:4261;4407:24;;215:4261;4407:24;;;;;;215:4261;4407:24;;;:::i;:::-;;;215:4261;;;;;4190:248;:::o;4407:24::-;;;-1:-1:-1;4407:24:6;;;215:4261;;;-1:-1:-1;215:4261:6;;;;;3828:356;;;;-1:-1:-1;;;;;215:4261:6;;354:42;3960:13;354:42;;4007:34;;;;;;;;;;;:::i;:::-;;4059:8;4055:45;;3956:222;3828:356::o;4055:45::-;-1:-1:-1;;;4007:34:6;4076:24;;;-1:-1:-1;;;;;215:4261:6;;;;4076:24;215:4261;;;4076:24;3956:222;215:4261;;-1:-1:-1;;;1328:43:4;;;;-1:-1:-1;;;;;215:4261:6;;;;1328:43:4;;;215:4261:6;;;;;;;;;1328:43:4;;;;;215:4261:6;1328:43:4;215:4261:6;;1328:43:4;:::i;:::-;;:::i;1618:188::-;215:4261:6;;-1:-1:-1;;;1745:53:4;;;;-1:-1:-1;;;;;215:4261:6;;;1745:53:4;;;215:4261:6;;;;;;;;;;;;;;;;;1745:53:4;;;;;;;215:4261:6;1745:53:4;:::i;4400:380::-;215:4261:6;;-1:-1:-1;;;4515:47:4;;;;;;;-1:-1:-1;;;;;215:4261:6;;4515:47:4;;;215:4261:6;;;;;;;;;4515:47:4;;;215:4261:6;;;;-1:-1:-1;;4515:47:4;215:4261:6;;4515:47:4;:::i;:::-;9086:199;;;;;;;-1:-1:-1;9086:199:4;;;;9301:80;;4400:380;-1:-1:-1;4577:45:4;;-1:-1:-1;4577:45:4;4573:201;;4400:380;;;:::o;4573:201::-;215:4261:6;;-1:-1:-1;;;4515:47:4;4665:43;;;-1:-1:-1;;;;;215:4261:6;;;;4515:47:4;4665:43;;215:4261:6;-1:-1:-1;215:4261:6;;;;;;;;4665:43:4;;4750:12;;4665:43;;;215:4261:6;;4665:43:4;:::i;:::-;;;:::i;9301:80::-;9313:15;;;-1:-1:-1;9313:15:4;;-1:-1:-1;4577:45:4;-1:-1:-1;;;;;215:4261:6;;9331:26:4;:30;;9313:67;9301:80;;;9313:67;9379:1;4577:45;9364:16;;9313:67;;7686:720;;-1:-1:-1;7823:421:4;7686:720;7823:421;;;;;;;;;;;;-1:-1:-1;7823:421:4;;8258:15;;-1:-1:-1;;;;;;215:4261:6;;8276:26:4;:31;8258:68;8254:146;;7686:720;:::o;8254:146::-;-1:-1:-1;;;;8349:40:4;;;-1:-1:-1;;;;;215:4261:6;;;;8349:40:4;215:4261:6;;;8349:40:4;8258:68;8325:1;8310:16;;8258:68;","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"insertAmount(bytes,uint256[],uint256)","signatureHash4":"0x7cbb0c4f","signatureHash32":"0x7cbb0c4fb5cd50c508f45375058583f31c764d45bdabbd7f78163c2b295cbfaa"},{"signature":"swap(address,address,address,address,uint256,address,bytes,uint256[])","signatureHash4":"0x01f9f423","signatureHash32":"0x01f9f42350333d36c4566bab187ab6d7c8405cf5d38cd73466c0508d5cdece65"},{"signature":"swap(address,address,address,uint256,address,bytes,uint256[])","signatureHash4":"0x83d1eb84","signatureHash32":"0x83d1eb8436618ca966fb1803bc1f0c776b254607578d3ea43ba581da812bcf34"},{"signature":"_swap(address,address,address,uint256,bytes,uint256[])","signatureHash4":"0x91c9d3f6","signatureHash32":"0x91c9d3f62c55837c6b930276158d60250cb012a8e52fb92c7de2f495197de243"},{"signature":"swapWithLimit(address,address,address,address,uint256,uint256,address,address,bytes,uint256[])","signatureHash4":"0x346387bf","signatureHash32":"0x346387bff4ba677b2a4f58f8167e4c1c09faae7abaad73072f2efbc0ae8eff2c"},{"signature":"VERSION()","signatureHash4":"0xffa1ad74","signatureHash32":"0xffa1ad74ba96b4c159a84d090433911c3991c54f629eb60d0c84aed3be5f067c"}],"event":[],"error":[{"signature":"IncorrectValue(uint256,uint256)","signatureHash4":"0xb25102da","signatureHash32":"0xb25102da78f1716b7f920d4812cb6d9aef3e4fac3d0a53cb253f1dc361011191"},{"signature":"SafeERC20FailedOperation(address)","signatureHash4":"0x5274afe7","signatureHash32":"0x5274afe73c98b4749fc91ffae6b7b574e7842cb2144a159e9377a5f20b32edf9"},{"signature":"TransferFailed(address)","signatureHash4":"0x39f1c8d9","signatureHash32":"0x39f1c8d9a08940175dbc82f15840b953aa855264e371e68f3e5d5cb38c445fa0"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0xbedFAC7488DCcAAFdD66d1D7D56349780Fe0477e"}