Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// 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"
      ]
    }
  }
}

• 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"}]

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

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

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

ipfs://05bdc0ae9d0a972d6dfd79cfebf0af45b039031ae3d667387334b7dd1ecd85e3