Overview
ETH Balance
0 ETH
Eth Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60e06040 | 15777388 | 737 days ago | IN | 0 ETH | 0.03573813 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
SwapHandler1Inch
Compiler Version
v0.8.10+commit.fc410830
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import "./SwapHandlerCombinedBase.sol"; /// @notice Swap handler executing trades on 1Inch contract SwapHandler1Inch is SwapHandlerCombinedBase { address immutable public oneInchAggregator; constructor(address oneInchAggregator_, address uniSwapRouterV2, address uniSwapRouterV3) SwapHandlerCombinedBase(uniSwapRouterV2, uniSwapRouterV3) { oneInchAggregator = oneInchAggregator_; } function swapPrimary(SwapParams memory params) override internal returns (uint amountOut) { setMaxAllowance(params.underlyingIn, params.amountIn, oneInchAggregator); (bool success, bytes memory result) = oneInchAggregator.call(params.payload); if (!success) revertBytes(result); // return amount out reported by 1Inch. It might not be exact for fee-on-transfer or rebasing tokens. amountOut = abi.decode(result, (uint)); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import "./SwapHandlerBase.sol"; import "../vendor/ISwapRouterV3.sol"; import "../vendor/ISwapRouterV2.sol"; /// @notice Base contract for swap handlers which execute a secondary swap on Uniswap V2 or V3 for exact output abstract contract SwapHandlerCombinedBase is SwapHandlerBase { address immutable public uniSwapRouterV2; address immutable public uniSwapRouterV3; constructor(address uniSwapRouterV2_, address uniSwapRouterV3_) { uniSwapRouterV2 = uniSwapRouterV2_; uniSwapRouterV3 = uniSwapRouterV3_; } function executeSwap(SwapParams memory params) external override { require(params.mode <= 1, "SwapHandlerCombinedBase: invalid mode"); if (params.mode == 0) { swapPrimary(params); } else { // For exact output expect a payload for the primary swap provider and a path to swap the remainder on Uni2 or Uni3 bytes memory path; (params.payload, path) = abi.decode(params.payload, (bytes, bytes)); uint primaryAmountOut = swapPrimary(params); if (primaryAmountOut < params.amountOut) { // The path param is reused for UniV2 and UniV3 swaps. The protocol to use is determined by the path length. // The length of valid UniV2 paths is given as n * 20, for n > 1, and the shortes path is 40 bytes. // The length of valid UniV3 paths is given as 20 + n * 23 for n > 0, because of an additional 3 bytes for the pool fee. // The max path length must be lower than the first path length which is valid for both protocols (and is therefore ambiguous) // This value is at 20 UniV3 hops, which corresponds to 24 UniV2 hops. require(path.length >= 40 && path.length < 20 + (20 * 23), "SwapHandlerPayloadBase: secondary path format"); uint remainder; unchecked { remainder = params.amountOut - primaryAmountOut; } swapExactOutDirect(params, remainder, path); } } transferBack(params.underlyingIn); } function swapPrimary(SwapParams memory params) internal virtual returns (uint amountOut); function swapExactOutDirect(SwapParams memory params, uint amountOut, bytes memory path) private { (bool isUniV2, address[] memory uniV2Path) = detectAndDecodeUniV2Path(path); if (isUniV2) { setMaxAllowance(params.underlyingIn, params.amountIn, uniSwapRouterV2); ISwapRouterV2(uniSwapRouterV2).swapTokensForExactTokens(amountOut, type(uint).max, uniV2Path, msg.sender, block.timestamp); } else { setMaxAllowance(params.underlyingIn, params.amountIn, uniSwapRouterV3); ISwapRouterV3(uniSwapRouterV3).exactOutput( ISwapRouterV3.ExactOutputParams({ path: path, recipient: msg.sender, amountOut: amountOut, amountInMaximum: type(uint).max, deadline: block.timestamp }) ); } } function detectAndDecodeUniV2Path(bytes memory path) private pure returns (bool, address[] memory) { bool isUniV2 = path.length % 20 == 0; address[] memory addressPath; if (isUniV2) { uint addressPathSize = path.length / 20; addressPath = new address[](addressPathSize); unchecked { for(uint i = 0; i < addressPathSize; ++i) { addressPath[i] = toAddress(path, i * 20); } } } return (isUniV2, addressPath); } function toAddress(bytes memory data, uint start) private pure returns (address result) { // assuming data length is already validated assembly { // borrowed from BytesLib https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol result := div(mload(add(add(data, 0x20), start)), 0x1000000000000000000000000) } } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import "./ISwapHandler.sol"; import "../Interfaces.sol"; import "../Utils.sol"; /// @notice Base contract for swap handlers abstract contract SwapHandlerBase is ISwapHandler { function trySafeApprove(address token, address to, uint value) internal returns (bool, bytes memory) { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value)); return (success && (data.length == 0 || abi.decode(data, (bool))), data); } function safeApproveWithRetry(address token, address to, uint value) internal { (bool success, bytes memory data) = trySafeApprove(token, to, value); // some tokens, like USDT, require the allowance to be set to 0 first if (!success) { (success,) = trySafeApprove(token, to, 0); if (success) { (success,) = trySafeApprove(token, to, value); } } if (!success) revertBytes(data); } function transferBack(address token) internal { uint balance = IERC20(token).balanceOf(address(this)); if (balance > 0) Utils.safeTransfer(token, msg.sender, balance); } function setMaxAllowance(address token, uint minAllowance, address spender) internal { uint allowance = IERC20(token).allowance(address(this), spender); if (allowance < minAllowance) safeApproveWithRetry(token, spender, type(uint).max); } function revertBytes(bytes memory errMsg) internal pure { if (errMsg.length > 0) { assembly { revert(add(32, errMsg), mload(errMsg)) } } revert("SwapHandlerBase: empty error"); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity >=0.7.5; pragma abicoder v2; import './IUniswapV3SwapCallback.sol'; /// @title Router token swapping functionality /// @notice Functions for swapping tokens via Uniswap V3 interface ISwapRouterV3 is IUniswapV3SwapCallback { struct ExactInputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96; } /// @notice Swaps `amountIn` of one token for as much as possible of another token /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata /// @return amountOut The amount of the received token function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut); struct ExactInputParams { bytes path; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; } /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata /// @return amountOut The amount of the received token function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut); struct ExactOutputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96; } /// @notice Swaps as little as possible of one token for `amountOut` of another token /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata /// @return amountIn The amount of the input token function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn); struct ExactOutputParams { bytes path; address recipient; uint256 deadline; uint256 amountOut; uint256 amountInMaximum; } /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed) /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata /// @return amountIn The amount of the input token function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn); }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface ISwapRouterV2 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; interface ISwapHandler { /// @notice Params for swaps using SwapHub contract and swap handlers /// @param underlyingIn sold token address /// @param underlyingOut bought token address /// @param mode type of the swap: 0 for exact input, 1 for exact output /// @param amountIn amount of token to sell. Exact value for exact input, maximum for exact output /// @param amountOut amount of token to buy. Exact value for exact output, minimum for exact input /// @param exactOutTolerance Maximum difference between requested amountOut and received tokens in exact output swap. Ignored for exact input /// @param payload multi-purpose byte param. The usage depends on the swap handler implementation struct SwapParams { address underlyingIn; address underlyingOut; uint mode; // 0=exactIn 1=exactOut uint amountIn; // mode 0: exact, mode 1: maximum uint amountOut; // mode 0: minimum, mode 1: exact uint exactOutTolerance; // mode 0: ignored, mode 1: downward tolerance on amountOut (fee-on-transfer etc.) bytes payload; } /// @notice Execute a trade on the swap handler /// @param params struct defining the requested trade function executeSwap(SwapParams calldata params) external; }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; interface IERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); } interface IERC20Permit { function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external; function permit(address owner, address spender, uint value, uint deadline, bytes calldata signature) external; } interface IERC3156FlashBorrower { function onFlashLoan(address initiator, address token, uint256 amount, uint256 fee, bytes calldata data) external returns (bytes32); } interface IERC3156FlashLender { function maxFlashLoan(address token) external view returns (uint256); function flashFee(address token, uint256 amount) external view returns (uint256); function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data) external returns (bool); }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; import "./Interfaces.sol"; library Utils { function safeTransferFrom(address token, address from, address to, uint value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), string(data)); } function safeTransfer(address token, address to, uint value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), string(data)); } function safeApprove(address token, address to, uint value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), string(data)); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity >=0.5.0; /// @title Callback for IUniswapV3PoolActions#swap /// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface interface IUniswapV3SwapCallback { /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap. /// @dev In the implementation you must pay the pool tokens owed for the swap. /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory. /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped. /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call function uniswapV3SwapCallback( int256 amount0Delta, int256 amount1Delta, bytes calldata data ) external; }
{ "optimizer": { "enabled": true, "runs": 1000000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"oneInchAggregator_","type":"address"},{"internalType":"address","name":"uniSwapRouterV2","type":"address"},{"internalType":"address","name":"uniSwapRouterV3","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"components":[{"internalType":"address","name":"underlyingIn","type":"address"},{"internalType":"address","name":"underlyingOut","type":"address"},{"internalType":"uint256","name":"mode","type":"uint256"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"exactOutTolerance","type":"uint256"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct ISwapHandler.SwapParams","name":"params","type":"tuple"}],"name":"executeSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oneInchAggregator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniSwapRouterV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniSwapRouterV3","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
0x608060405234801561001057600080fd5b506004361061004c5760003560e01c80632181ac751461005157806332be98ac146100a15780639e8e3eaa146100c8578063df5def35146100ef575b600080fd5b6100787f000000000000000000000000e592427a0aece92de3edee1f18e0157c0586156481565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100787f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d81565b6100787f0000000000000000000000001111111254fb6c44bac0bed2854e76f90643097d81565b6101026100fd366004610d05565b610104565b005b60018160400151111561019e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f5377617048616e646c6572436f6d62696e6564426173653a20696e76616c696460448201527f206d6f646500000000000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b60408101516101b6576101b0816102b9565b506102ab565b60608160c001518060200190518101906101d09190610e2d565b60c0840191909152905060006101e5836102b9565b905082608001518110156102a857602882511015801561020757506101e08251105b610293576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602d60248201527f5377617048616e646c65725061796c6f6164426173653a207365636f6e64617260448201527f79207061746820666f726d6174000000000000000000000000000000000000006064820152608401610195565b60808301518190036102a68482856103ab565b505b50505b80516102b69061062d565b50565b60006102ee826000015183606001517f0000000000000000000000001111111254fb6c44bac0bed2854e76f90643097d6106d5565b6000807f0000000000000000000000001111111254fb6c44bac0bed2854e76f90643097d73ffffffffffffffffffffffffffffffffffffffff168460c0015160405161033a9190610e91565b6000604051808303816000865af19150503d8060008114610377576040519150601f19603f3d011682016040523d82523d6000602084013e61037c565b606091505b50915091508161038f5761038f816107aa565b808060200190518101906103a39190610ead565b949350505050565b6000806103b78361081b565b9150915081156104f9576103f4856000015186606001517f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d6106d5565b6040517f8803dbee00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d1690638803dbee9061048e9087907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90869033904290600401610ec6565b6000604051808303816000875af11580156104ad573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682016040526104f39190810190610f51565b50610626565b61052c856000015186606001517f000000000000000000000000e592427a0aece92de3edee1f18e0157c058615646106d5565b6040805160a0810182528481523360208201524281830152606081018690527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff608082015290517ff28c049800000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564169163f28c0498916105e19190600401611041565b6020604051808303816000875af1158015610600573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106249190610ead565b505b5050505050565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015260009073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa15801561069a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106be9190610ead565b905080156106d1576106d1823383610902565b5050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff82811660248301526000919085169063dd62ed3e90604401602060405180830381865afa15801561074b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061076f9190610ead565b9050828110156107a4576107a484837fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff610a3e565b50505050565b8051156107b957805181602001fd5b6040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f5377617048616e646c6572426173653a20656d707479206572726f72000000006044820152606401610195565b6000606060006014845161082f91906110d6565b159050606081156108f85760006014865161084a91906110ea565b90508067ffffffffffffffff81111561086557610865610b99565b60405190808252806020026020018201604052801561088e578160200160208202803683370190505b50915060005b818110156108f557602060148202880101516c0100000000000000000000000090048382815181106108c8576108c86110fe565b73ffffffffffffffffffffffffffffffffffffffff90921660209283029190910190910152600101610894565b50505b9094909350915050565b6040805173ffffffffffffffffffffffffffffffffffffffff8481166024830152604480830185905283518084039091018152606490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb0000000000000000000000000000000000000000000000000000000017905291516000928392908716916109999190610e91565b6000604051808303816000865af19150503d80600081146109d6576040519150601f19603f3d011682016040523d82523d6000602084013e6109db565b606091505b5091509150818015610a05575080511580610a05575080806020019051810190610a05919061112d565b8190610624576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016101959190611156565b600080610a4c858585610a87565b9150915081610a7957610a6185856000610a87565b5091508115610a7957610a75858585610a87565b5091505b8161062657610626816107aa565b6040805173ffffffffffffffffffffffffffffffffffffffff8481166024830152604480830185905283518084039091018152606490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f095ea7b300000000000000000000000000000000000000000000000000000000179052915160009260609284928392891691610b2191610e91565b6000604051808303816000865af19150503d8060008114610b5e576040519150601f19603f3d011682016040523d82523d6000602084013e610b63565b606091505b5091509150818015610b8d575080511580610b8d575080806020019051810190610b8d919061112d565b97909650945050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60405160e0810167ffffffffffffffff81118282101715610beb57610beb610b99565b60405290565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715610c3857610c38610b99565b604052919050565b803573ffffffffffffffffffffffffffffffffffffffff81168114610c6457600080fd5b919050565b600067ffffffffffffffff821115610c8357610c83610b99565b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01660200190565b600082601f830112610cc057600080fd5b8135610cd3610cce82610c69565b610bf1565b818152846020838601011115610ce857600080fd5b816020850160208301376000918101602001919091529392505050565b600060208284031215610d1757600080fd5b813567ffffffffffffffff80821115610d2f57600080fd5b9083019060e08286031215610d4357600080fd5b610d4b610bc8565b610d5483610c40565b8152610d6260208401610c40565b602082015260408301356040820152606083013560608201526080830135608082015260a083013560a082015260c083013582811115610da157600080fd5b610dad87828601610caf565b60c08301525095945050505050565b60005b83811015610dd7578181015183820152602001610dbf565b838111156107a45750506000910152565b600082601f830112610df957600080fd5b8151610e07610cce82610c69565b818152846020838601011115610e1c57600080fd5b6103a3826020830160208701610dbc565b60008060408385031215610e4057600080fd5b825167ffffffffffffffff80821115610e5857600080fd5b610e6486838701610de8565b93506020850151915080821115610e7a57600080fd5b50610e8785828601610de8565b9150509250929050565b60008251610ea3818460208701610dbc565b9190910192915050565b600060208284031215610ebf57600080fd5b5051919050565b600060a082018783526020878185015260a0604085015281875180845260c086019150828901935060005b81811015610f2357845173ffffffffffffffffffffffffffffffffffffffff1683529383019391830191600101610ef1565b505073ffffffffffffffffffffffffffffffffffffffff969096166060850152505050608001529392505050565b60006020808385031215610f6457600080fd5b825167ffffffffffffffff80821115610f7c57600080fd5b818501915085601f830112610f9057600080fd5b815181811115610fa257610fa2610b99565b8060051b9150610fb3848301610bf1565b8181529183018401918481019088841115610fcd57600080fd5b938501935b83851015610feb57845182529385019390850190610fd2565b98975050505050505050565b6000815180845261100f816020860160208601610dbc565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b602081526000825160a0602084015261105d60c0840182610ff7565b905073ffffffffffffffffffffffffffffffffffffffff60208501511660408401526040840151606084015260608401516080840152608084015160a08401528091505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b6000826110e5576110e56110a7565b500690565b6000826110f9576110f96110a7565b500490565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60006020828403121561113f57600080fd5b8151801515811461114f57600080fd5b9392505050565b60208152600061114f6020830184610ff756fea264697066735822122005bdc0ae9d0a972d6dfd79cfebf0af45b039031ae3d667387334b7dd1ecd85e364736f6c634300080a0033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000001111111254fb6c44bac0bed2854e76f90643097d0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564
-----Decoded View---------------
Arg [0] : oneInchAggregator_ (address): 0x1111111254fb6c44bAC0beD2854e76F90643097d
Arg [1] : uniSwapRouterV2 (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [2] : uniSwapRouterV3 (address): 0xE592427A0AEce92De3Edee1F18E0157C05861564
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000001111111254fb6c44bac0bed2854e76f90643097d
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [2] : 000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564
Deployed Bytecode Sourcemap
163:787:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;405:40:5;;;;;;;;190:42:9;178:55;;;160:74;;148:2;133:18;405:40:5;;;;;;;359;;;;;222:42:3;;;;;617:1560:5;;;;;;:::i;:::-;;:::i;:::-;;;715:1;700:6;:11;;;:16;;692:66;;;;;;;3132:2:9;692:66:5;;;3114:21:9;3171:2;3151:18;;;3144:30;3210:34;3190:18;;;3183:62;3281:7;3261:18;;;3254:35;3306:19;;692:66:5;;;;;;;;;773:11;;;;769:1358;;805:19;817:6;805:11;:19::i;:::-;;769:1358;;;983:17;1050:6;:14;;;1039:42;;;;;;;;;;;;:::i;:::-;1015:14;;;1014:67;;;;;-1:-1:-1;1096:21:5;1120:19;1015:6;1120:11;:19::i;:::-;1096:43;;1177:6;:16;;;1158;:35;1154:963;;;1844:2;1829:4;:11;:17;;:49;;;;;1864:14;1850:4;:11;:28;1829:49;1821:107;;;;;;;4797:2:9;1821:107:5;;;4779:21:9;4836:2;4816:18;;;4809:30;4875:34;4855:18;;;4848:62;4946:15;4926:18;;;4919:43;4979:19;;1821:107:5;4595:409:9;1821:107:5;2003:16;;;;:35;;;2059:43;2003:6;:35;2097:4;2059:18;:43::i;:::-;1195:922;1154:963;841:1286;;769:1358;2150:19;;2137:33;;:12;:33::i;:::-;617:1560;:::o;480:468:3:-;554:14;580:72;596:6;:19;;;617:6;:15;;;634:17;580:15;:72::i;:::-;664:12;678:19;701:17;:22;;724:6;:14;;;701:38;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;663:76;;;;754:7;749:33;;763:19;775:6;763:11;:19::i;:::-;926:6;915:26;;;;;;;;;;;;:::i;:::-;903:38;480:468;-1:-1:-1;;;;480:468:3:o;2278:902:5:-;2386:12;2400:26;2430:30;2455:4;2430:24;:30::i;:::-;2385:75;;;;2475:7;2471:703;;;2498:70;2514:6;:19;;;2535:6;:15;;;2552;2498;:70::i;:::-;2583:122;;;;;:55;2597:15;2583:55;;;;:122;;2639:9;;2650:14;;2666:9;;2677:10;;2689:15;;2583:122;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2471:703;;;2736:70;2752:6;:19;;;2773:6;:15;;;2790;2736;:70::i;:::-;2881:268;;;;;;;;;;;2978:10;2881:268;;;;3115:15;2881:268;;;;;;;;;;3069:14;2881:268;;;;2821:342;;;;;:42;2835:15;2821:42;;;;:342;;2881:268;2821:342;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2471:703;2375:805;;2278:902;;;:::o;1047:189:4:-;1118:38;;;;;1150:4;1118:38;;;160:74:9;1103:12:4;;1118:23;;;;;;133:18:9;;1118:38:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1103:53;-1:-1:-1;1170:11:4;;1166:63;;1183:46;1202:5;1209:10;1221:7;1183:18;:46::i;:::-;1093:143;1047:189;:::o;1242:258::-;1354:47;;;;;1386:4;1354:47;;;8679:34:9;1354:23:4;8749:15:9;;;8729:18;;;8722:43;1337:14:4;;1354:23;;;;;;8591:18:9;;1354:47:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1337:64;;1427:12;1415:9;:24;1411:82;;;1441:52;1462:5;1469:7;1478:14;1441:20;:52::i;:::-;1327:173;1242:258;;;:::o;1506:247::-;1576:13;;:17;1572:126;;1666:6;1660:13;1651:6;1647:2;1643:15;1636:38;1572:126;1708:38;;;;;8978:2:9;1708:38:4;;;8960:21:9;9017:2;8997:18;;;8990:30;9056;9036:18;;;9029:58;9104:18;;1708:38:4;8776:352:9;3186:554:5;3261:4;3267:16;3295:12;3324:2;3310:4;:11;:16;;;;:::i;:::-;:21;;-1:-1:-1;3341:28:5;3380:314;;;;3407:20;3444:2;3430:4;:11;:16;;;;:::i;:::-;3407:39;;3488:15;3474:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3474:30:5;;3460:44;;3551:6;3547:123;3567:15;3563:1;:19;3547:123;;;4073:4;3648:2;3644:6;;4059:27;;;4053:34;4089:27;4049:68;;3611:11;3623:1;3611:14;;;;;;;;:::i;:::-;:40;;;;:14;;;;;;;;;;;:40;3584:3;;3547:123;;;;3393:301;3380:314;3712:7;;3721:11;;-1:-1:-1;3186:554:5;-1:-1:-1;;3186:554:5:o;437:284:1:-;564:59;;;553:10;9945:55:9;;;564:59:1;;;9927:74:9;10017:18;;;;10010:34;;;564:59:1;;;;;;;;;;9900:18:9;;;;564:59:1;;;;;;;;;587:24;564:59;;;553:71;;-1:-1:-1;;;;553:10:1;;;;:71;;564:59;553:71;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;517:107;;;;642:7;:57;;;;-1:-1:-1;654:11:1;;:16;;:44;;;685:4;674:24;;;;;;;;;;;;:::i;:::-;708:4;634:80;;;;;;;;;;;;;;:::i;564:477:4:-;653:12;667:17;688:32;703:5;710:2;714:5;688:14;:32::i;:::-;652:68;;;;814:7;809:184;;850:28;865:5;872:2;876:1;850:14;:28::i;:::-;-1:-1:-1;837:41:4;-1:-1:-1;892:91:4;;;;936:32;951:5;958:2;962:5;936:14;:32::i;:::-;-1:-1:-1;923:45:4;-1:-1:-1;892:91:4;1008:7;1003:31;;1017:17;1029:4;1017:11;:17::i;252:306::-;410:58;;;399:10;9945:55:9;;;410:58:4;;;9927:74:9;10017:18;;;;10010:34;;;410:58:4;;;;;;;;;;9900:18:9;;;;410:58:4;;;;;;;;;433:23;410:58;;;399:70;;-1:-1:-1;;339:12:4;;-1:-1:-1;;;;399:10:4;;;:70;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;363:106;;;;487:7;:57;;;;-1:-1:-1;499:11:4;;:16;;:44;;;530:4;519:24;;;;;;;;;;;;:::i;:::-;479:72;546:4;;-1:-1:-1;252:306:4;-1:-1:-1;;;;;252:306:4:o;245:184:9:-;297:77;294:1;287:88;394:4;391:1;384:15;418:4;415:1;408:15;434:253;506:2;500:9;548:4;536:17;;583:18;568:34;;604:22;;;565:62;562:88;;;630:18;;:::i;:::-;666:2;659:22;434:253;:::o;692:334::-;763:2;757:9;819:2;809:13;;824:66;805:86;793:99;;922:18;907:34;;943:22;;;904:62;901:88;;;969:18;;:::i;:::-;1005:2;998:22;692:334;;-1:-1:-1;692:334:9:o;1031:196::-;1099:20;;1159:42;1148:54;;1138:65;;1128:93;;1217:1;1214;1207:12;1128:93;1031:196;;;:::o;1232:245::-;1280:4;1313:18;1305:6;1302:30;1299:56;;;1335:18;;:::i;:::-;-1:-1:-1;1392:2:9;1380:15;1397:66;1376:88;1466:4;1372:99;;1232:245::o;1482:462::-;1524:5;1577:3;1570:4;1562:6;1558:17;1554:27;1544:55;;1595:1;1592;1585:12;1544:55;1631:6;1618:20;1662:48;1678:31;1706:2;1678:31;:::i;:::-;1662:48;:::i;:::-;1735:2;1726:7;1719:19;1781:3;1774:4;1769:2;1761:6;1757:15;1753:26;1750:35;1747:55;;;1798:1;1795;1788:12;1747:55;1863:2;1856:4;1848:6;1844:17;1837:4;1828:7;1824:18;1811:55;1911:1;1886:16;;;1904:4;1882:27;1875:38;;;;1890:7;1482:462;-1:-1:-1;;;1482:462:9:o;1949:976::-;2035:6;2088:2;2076:9;2067:7;2063:23;2059:32;2056:52;;;2104:1;2101;2094:12;2056:52;2144:9;2131:23;2173:18;2214:2;2206:6;2203:14;2200:34;;;2230:1;2227;2220:12;2200:34;2253:22;;;;2309:4;2291:16;;;2287:27;2284:47;;;2327:1;2324;2317:12;2284:47;2353:22;;:::i;:::-;2398;2417:2;2398:22;:::i;:::-;2391:5;2384:37;2453:31;2480:2;2476;2472:11;2453:31;:::i;:::-;2448:2;2441:5;2437:14;2430:55;2538:2;2534;2530:11;2517:25;2512:2;2505:5;2501:14;2494:49;2596:2;2592;2588:11;2575:25;2570:2;2563:5;2559:14;2552:49;2655:3;2651:2;2647:12;2634:26;2628:3;2621:5;2617:15;2610:51;2715:3;2711:2;2707:12;2694:26;2688:3;2681:5;2677:15;2670:51;2767:3;2763:2;2759:12;2746:26;2797:2;2787:8;2784:16;2781:36;;;2813:1;2810;2803:12;2781:36;2850:44;2886:7;2875:8;2871:2;2867:17;2850:44;:::i;:::-;2844:3;2833:15;;2826:69;-1:-1:-1;2837:5:9;1949:976;-1:-1:-1;;;;;1949:976:9:o;3336:258::-;3408:1;3418:113;3432:6;3429:1;3426:13;3418:113;;;3508:11;;;3502:18;3489:11;;;3482:39;3454:2;3447:10;3418:113;;;3549:6;3546:1;3543:13;3540:48;;;-1:-1:-1;;3584:1:9;3566:16;;3559:27;3336:258::o;3599:428::-;3652:5;3705:3;3698:4;3690:6;3686:17;3682:27;3672:55;;3723:1;3720;3713:12;3672:55;3752:6;3746:13;3783:48;3799:31;3827:2;3799:31;:::i;3783:48::-;3856:2;3847:7;3840:19;3902:3;3895:4;3890:2;3882:6;3878:15;3874:26;3871:35;3868:55;;;3919:1;3916;3909:12;3868:55;3932:64;3993:2;3986:4;3977:7;3973:18;3966:4;3958:6;3954:17;3932:64;:::i;4032:558::-;4129:6;4137;4190:2;4178:9;4169:7;4165:23;4161:32;4158:52;;;4206:1;4203;4196:12;4158:52;4239:9;4233:16;4268:18;4309:2;4301:6;4298:14;4295:34;;;4325:1;4322;4315:12;4295:34;4348:60;4400:7;4391:6;4380:9;4376:22;4348:60;:::i;:::-;4338:70;;4454:2;4443:9;4439:18;4433:25;4417:41;;4483:2;4473:8;4470:16;4467:36;;;4499:1;4496;4489:12;4467:36;;4522:62;4576:7;4565:8;4554:9;4550:24;4522:62;:::i;:::-;4512:72;;;4032:558;;;;;:::o;5009:274::-;5138:3;5176:6;5170:13;5192:53;5238:6;5233:3;5226:4;5218:6;5214:17;5192:53;:::i;:::-;5261:16;;;;;5009:274;-1:-1:-1;;5009:274:9:o;5288:184::-;5358:6;5411:2;5399:9;5390:7;5386:23;5382:32;5379:52;;;5427:1;5424;5417:12;5379:52;-1:-1:-1;5450:16:9;;5288:184;-1:-1:-1;5288:184:9:o;5477:1018::-;5731:4;5779:3;5768:9;5764:19;5810:6;5799:9;5792:25;5836:2;5874:6;5869:2;5858:9;5854:18;5847:34;5917:3;5912:2;5901:9;5897:18;5890:31;5941:6;5976;5970:13;6007:6;5999;5992:22;6045:3;6034:9;6030:19;6023:26;;6084:2;6076:6;6072:15;6058:29;;6105:1;6115:218;6129:6;6126:1;6123:13;6115:218;;;6194:13;;6209:42;6190:62;6178:75;;6308:15;;;;6273:12;;;;6151:1;6144:9;6115:218;;;-1:-1:-1;;6401:42:9;6389:55;;;;6384:2;6369:18;;6362:83;-1:-1:-1;;;6476:3:9;6461:19;6454:35;6350:3;5477:1018;-1:-1:-1;;;5477:1018:9:o;6500:936::-;6595:6;6626:2;6669;6657:9;6648:7;6644:23;6640:32;6637:52;;;6685:1;6682;6675:12;6637:52;6718:9;6712:16;6747:18;6788:2;6780:6;6777:14;6774:34;;;6804:1;6801;6794:12;6774:34;6842:6;6831:9;6827:22;6817:32;;6887:7;6880:4;6876:2;6872:13;6868:27;6858:55;;6909:1;6906;6899:12;6858:55;6938:2;6932:9;6960:2;6956;6953:10;6950:36;;;6966:18;;:::i;:::-;7012:2;7009:1;7005:10;6995:20;;7035:28;7059:2;7055;7051:11;7035:28;:::i;:::-;7097:15;;;7167:11;;;7163:20;;;7128:12;;;;7195:19;;;7192:39;;;7227:1;7224;7217:12;7192:39;7251:11;;;;7271:135;7287:6;7282:3;7279:15;7271:135;;;7353:10;;7341:23;;7304:12;;;;7384;;;;7271:135;;;7425:5;6500:936;-1:-1:-1;;;;;;;;6500:936:9:o;7441:316::-;7482:3;7520:5;7514:12;7547:6;7542:3;7535:19;7563:63;7619:6;7612:4;7607:3;7603:14;7596:4;7589:5;7585:16;7563:63;:::i;:::-;7671:2;7659:15;7676:66;7655:88;7646:98;;;;7746:4;7642:109;;7441:316;-1:-1:-1;;7441:316:9:o;7762:677::-;7961:2;7950:9;7943:21;7924:4;7999:6;7993:13;8042:4;8037:2;8026:9;8022:18;8015:32;8070:51;8116:3;8105:9;8101:19;8087:12;8070:51;:::i;:::-;8056:65;;8185:42;8179:2;8171:6;8167:15;8161:22;8157:71;8152:2;8141:9;8137:18;8130:99;8283:2;8275:6;8271:15;8265:22;8260:2;8249:9;8245:18;8238:50;8343:2;8335:6;8331:15;8325:22;8319:3;8308:9;8304:19;8297:51;8404:3;8396:6;8392:16;8386:23;8379:4;8368:9;8364:20;8357:53;8427:6;8419:14;;;7762:677;;;;:::o;9133:184::-;9185:77;9182:1;9175:88;9282:4;9279:1;9272:15;9306:4;9303:1;9296:15;9322:112;9354:1;9380;9370:35;;9385:18;;:::i;:::-;-1:-1:-1;9419:9:9;;9322:112::o;9439:120::-;9479:1;9505;9495:35;;9510:18;;:::i;:::-;-1:-1:-1;9544:9:9;;9439:120::o;9564:184::-;9616:77;9613:1;9606:88;9713:4;9710:1;9703:15;9737:4;9734:1;9727:15;10055:277;10122:6;10175:2;10163:9;10154:7;10150:23;10146:32;10143:52;;;10191:1;10188;10181:12;10143:52;10223:9;10217:16;10276:5;10269:13;10262:21;10255:5;10252:32;10242:60;;10298:1;10295;10288:12;10242:60;10321:5;10055:277;-1:-1:-1;;;10055:277:9:o;10337:219::-;10486:2;10475:9;10468:21;10449:4;10506:44;10546:2;10535:9;10531:18;10523:6;10506:44;:::i
Swarm Source
ipfs://05bdc0ae9d0a972d6dfd79cfebf0af45b039031ae3d667387334b7dd1ecd85e3
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.