Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.27;


import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Errors as OnchainCLOBErrors} from "@onchainclob/contracts/Errors.sol";
import {IOnchainCLOB} from "@onchainclob/contracts/IOnchainCLOB.sol";


import {IRouter, Hop} from "./IRouter.sol";
import {IOGRouter} from "./IOGRouter.sol";
import {IV2Router} from "./IV2Router.sol";
import {IV3Router} from "./IV3Router.sol";
import {IWETH} from "./IWETH.sol";
import {Errors} from "./Errors.sol";


contract Router is IRouter, ReentrancyGuard {
  using SafeERC20 for IERC20;

  uint8 constant UNWRAP_AND_WRAP_ID = 0;
  uint8 constant ONCHAINCLOB_ID = 1;
  uint8 constant ORGANIC_GROWTH_ROUTER_ID = 2;
  uint8 constant V2_ROUTER_ID = 3;
  uint8 constant V3_ROUTER_ID = 4;

  struct SwapParams {
    uint256 amountIn;
    address routerAddress;
    address fromToken;
    address toToken;
    bool isFromNative;
    bool isToNative;
    uint24 poolV3fee;
    uint256 deadline;
  }

  receive() external payable {
  }

  function swapEthForTokens(
    uint256 amountOutMin,
    Hop[] calldata hops,
    address to,
    uint256 deadline
  ) external payable nonReentrant() returns (uint256[] memory amounts) {
    require(msg.value > 0, OnchainCLOBErrors.ZeroTokenTransferNotAllowed());
    require(hops.length > 0, Errors.WrongHopsCount());

    uint256[] memory amountRests;

    (amounts, amountRests) = _swap(
      msg.value,
      hops,
      deadline
    );

    // check final balances
    IERC20 toToken = IERC20(hops[hops.length - 1].toToken);

    uint256 finalAmountOut = toToken.balanceOf(address(this));
    require(finalAmountOut >= amountOutMin, Errors.InsufficientAmountOut());

    // withdraw tokens
    toToken.safeTransfer(to, finalAmountOut);

    // refund rests
    _refundRests(hops, amountRests);
  }

  function swapTokensForEth(
    uint256 amountIn,
    uint256 amountOutMin,
    Hop[] calldata hops,
    address to,
    uint256 deadline
  ) external nonReentrant() returns (uint256[] memory amounts) {
    require(amountIn > 0, OnchainCLOBErrors.ZeroTokenTransferNotAllowed());
    require(hops.length > 0, Errors.WrongHopsCount());

    IERC20 fromToken = IERC20(hops[0].fromToken);

    // deposit tokens
    _safeTansferFromWithBalanceCheck(
      fromToken,
      msg.sender,
      address(this),
      amountIn
    );

    uint256[] memory amountRests;

    (amounts, amountRests) = _swap(
      amountIn,
      hops,
      deadline
    );

    uint256 finalAmountOut = address(this).balance;
    require(finalAmountOut >= amountOutMin, Errors.InsufficientAmountOut());

    // withdraw result
    _sendETH(to, finalAmountOut);

    // refund rests
    _refundRests(hops, amountRests);
  }

  function swapTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    Hop[] calldata hops,
    address to,
    uint256 deadline
  ) external nonReentrant() returns (uint256[] memory amounts) {
    require(amountIn > 0, OnchainCLOBErrors.ZeroTokenTransferNotAllowed());
    require(hops.length > 0, Errors.WrongHopsCount());

    IERC20 fromToken = IERC20(hops[0].fromToken);

    // deposit tokens
    _safeTansferFromWithBalanceCheck(
      fromToken,
      msg.sender,
      address(this),
      amountIn
    );

    uint256[] memory amountRests;

    (amounts, amountRests) = _swap(
      amountIn,
      hops,
      deadline
    );

    // check final balances
    IERC20 toToken = IERC20(hops[hops.length - 1].toToken);

    uint256 finalAmountOut = toToken.balanceOf(address(this));
    require(finalAmountOut >= amountOutMin, Errors.InsufficientAmountOut());

    // withdraw tokens
    toToken.safeTransfer(to, finalAmountOut);

    // refund rests
    _refundRests(hops, amountRests);
  }

  function _swap(
    uint256 amountIn,
    Hop[] calldata hops,
    uint256 deadline
  ) internal returns (uint256[] memory hopsAmountOut, uint256[] memory hopsAmountOutRest) {
    hopsAmountOut = new uint256[](hops.length + 1);
    hopsAmountOut[0] = amountIn;

    hopsAmountOutRest = new uint256[](hops.length + 1);
    hopsAmountOutRest[0] = amountIn;

    // execute hops
    for (uint i = 0; i < hops.length; ++i) {
      uint hopId = i + 1;

      uint8 dexId;
      bool useForRest;
      SwapParams memory swapParams;

      (
        dexId,
        useForRest,
        swapParams.isFromNative,
        swapParams.isToNative,
        swapParams.poolV3fee
      ) = _unpackParams(hops[i].params);

      swapParams.routerAddress = hops[i].routerAddress;
      swapParams.fromToken = hops[i].fromToken;
      swapParams.toToken = hops[i].toToken;
      swapParams.amountIn = _calculateHopAmountIn(hops[i], hopsAmountOut, hopsAmountOutRest, useForRest);
      swapParams.deadline = deadline;

      uint256 hopFromTokenBalanceOld = _getBalance(swapParams.fromToken, swapParams.isFromNative);
      uint256 hopToTokenBalanceOld = _getBalance(swapParams.toToken, swapParams.isToNative);

      if (dexId == UNWRAP_AND_WRAP_ID) {
        _unwrapAndWrap(swapParams);
      } else if (dexId == ONCHAINCLOB_ID) {
        _swapUsingOnchainCLOB(swapParams);
      } else if (dexId == ORGANIC_GROWTH_ROUTER_ID) {
        _swapUsingOrganicGrowthRouter(swapParams);
      } else if (dexId == V2_ROUTER_ID) {
        _swapUsingV2Router(swapParams);
      } else if (dexId == V3_ROUTER_ID) {
        _swapUsingV3Router(swapParams);
      } else {
        revert Errors.UnsupportedDex();
      }

      uint256 hopFromTokenBalanceNew = _getBalance(swapParams.fromToken, swapParams.isFromNative);
      uint256 hopToTokenBalanceNew = _getBalance(swapParams.toToken, swapParams.isToNative);

      hopsAmountOut[hopId] = hopToTokenBalanceNew - hopToTokenBalanceOld;
      hopsAmountOutRest[hopId] = hopsAmountOut[hopId];

      uint256 executedAmountIn = hopFromTokenBalanceOld - hopFromTokenBalanceNew;
      uint256 restAmountIn = swapParams.amountIn - executedAmountIn;

      if (restAmountIn > 0) {
        _returnRestAmountIn(hops[i], hopsAmountOutRest, restAmountIn);
      }
    }
  }

  function _calculateHopAmountIn(
    Hop calldata hop,
    uint256[] memory hopsAmountOut,
    uint256[] memory hopsAmountOutRest,
    bool useForRest
  ) internal pure returns (uint256 amountIn) {
    for (uint i = 0; i < hop.inputHopParams.length; ++i) {
      (uint8 inputHopId, uint16 inputAmountPercent) = _unpackInputHopParams(hop.inputHopParams[i]);

      uint256 inputAmount = hopsAmountOut[inputHopId] * inputAmountPercent / 10000;
      amountIn += inputAmount;
      hopsAmountOutRest[inputHopId] -= inputAmount;

      // if hop used to swap amount rests or rest < 1/10000
      if (useForRest || hopsAmountOutRest[inputHopId] < hopsAmountOut[inputHopId] / 10000)  {
        amountIn += hopsAmountOutRest[inputHopId];
        hopsAmountOutRest[inputHopId] = 0;
      }
    }
  }

  function _returnRestAmountIn(
    Hop calldata hop,
    uint256[] memory hopsAmountOutRest,
    uint256 restAmountIn
  ) internal pure {
    for (uint i = hop.inputHopParams.length; i > 0; i--) {
      (uint8 inputHopId, uint16 inputAmountPercent) = _unpackInputHopParams(hop.inputHopParams[i - 1]);

      // if input used by more than one hop (<100%), try to return rest amount here
      if (inputAmountPercent < 10000) {
        hopsAmountOutRest[inputHopId] += restAmountIn;
        return;
      }
    }

    // no chance, throw the rest amount into any input
    (uint8 restHopId,) = _unpackInputHopParams(hop.inputHopParams[hop.inputHopParams.length - 1]);
    hopsAmountOutRest[restHopId] += restAmountIn;
  }

  function _refundRests(
    Hop[] calldata hops,
    uint256[] memory amountRests
  ) internal {
    // amountRests has length = hops.length + 1 and the following structure:
    // [amountIn rest, hops[0] output rest, hops[1] output rest, ..., hops[hops.length - 1] output = amountOut]
    //
    // with corresponding tokens:
    // [hops[-1].toToken = hops[0].fromToken, hops[0].toToken, hops[1].toToken, ..., hops[hops.length - 1].toToken]

    // try to refund all outputs except the last one
    for (uint i = 0; i < amountRests.length - 1; ++i) {
      if (amountRests[i] == 0) {
        continue;
      }

      uint hopIndex = i == 0 ? 0 : i - 1;

      (,, bool isFromNative, bool isToNative,) = _unpackParams(hops[hopIndex].params);

      (address token, bool isNative) = i == 0
        ? (hops[hopIndex].fromToken, isFromNative)
        : (hops[hopIndex].toToken, isToNative);

      if (isNative) {
        _sendETH(msg.sender, amountRests[i]);
      } else {
        IERC20(token).safeTransfer(msg.sender, amountRests[i]);
      }
    }
  }

  function _getBalance(address tokenAddress, bool isNative) internal view returns (uint256) {
    if (isNative) { // || tokenAddress == address(0)
      return address(this).balance;
    } else {
      return IERC20(tokenAddress).balanceOf(address(this));
    }
  }

  function _unwrapAndWrap(
    SwapParams memory params
  ) internal {
    if (params.fromToken != address(0) && !params.isFromNative) {
      IWETH fromTokenWeth = IWETH(params.fromToken);
      fromTokenWeth.withdraw(params.amountIn);
    }

    if (params.toToken != address(0) && !params.isToNative) {
      IWETH toTokenWeth = IWETH(params.toToken);
      toTokenWeth.deposit{value: params.amountIn}();
    }
  }

  function _swapUsingOnchainCLOB(
    SwapParams memory params
  ) internal {
    uint256 nativeAmountIn = 0;

    if (params.isFromNative) {
      nativeAmountIn = params.amountIn;
    } else {
      IERC20(params.fromToken).approve(params.routerAddress, params.amountIn);
    }

    IOnchainCLOB lob = IOnchainCLOB(payable(params.routerAddress));

    (
        uint256 scalingFactorTokenX,
        uint256 scalingFactorTokenY,
        address tokenX,
        ,
        ,
        ,
        ,
        ,
        ,
        ,
        ,
        ,
    ) = lob.getConfig();

    if (params.fromToken == tokenX) {
      // x -> y
      lob.placeOrder{value: nativeAmountIn}(
        true,
        uint128(params.amountIn / scalingFactorTokenX),
        1,
        type(uint128).max,
        true,
        false,
        true,
        params.deadline
      );
    } else {
      // y -> x
      lob.placeMarketOrderWithTargetValue{value: nativeAmountIn}(
        false,
        uint128(params.amountIn / scalingFactorTokenY),
        999999000000000000000,
        type(uint128).max,
        true,
        params.deadline
      );
    }
  }

  function _swapUsingV2Router(
    SwapParams memory params
  ) internal {
    uint256 nativeAmountIn = 0;

    if (params.isFromNative) {
      nativeAmountIn = params.amountIn;
    } else {
      IERC20(params.fromToken).approve(params.routerAddress, params.amountIn);
    }

    IV2Router router = IV2Router(params.routerAddress);

    address[] memory path = new address[](2);
    path[0] = params.fromToken;
    path[1] = params.toToken;

    if (params.isFromNative) {
      router.swapExactETHForTokens{value: nativeAmountIn}(
        0,
        path,
        address(this),
        params.deadline
      );
    } else if (params.isToNative) {
      router.swapExactTokensForETH(
        params.amountIn,
        0,
        path,
        address(this),
        params.deadline
      );
    } else {
      router.swapExactTokensForTokens(
        params.amountIn,
        0,
        path,
        address(this),
        params.deadline
      );
    }
  }

  function _swapUsingV3Router(
    SwapParams memory params
  ) internal {
    IERC20(params.fromToken).approve(params.routerAddress, params.amountIn);

    IV3Router router = IV3Router(params.routerAddress);

    IV3Router.ExactInputSingleParams memory v3params = IV3Router.ExactInputSingleParams({
      tokenIn: params.fromToken,
      tokenOut: params.toToken,
      fee: params.poolV3fee,
      recipient: address(this),
      deadline: params.deadline,
      amountIn: params.amountIn,
      amountOutMinimum: 0,
      sqrtPriceLimitX96: 0
    });

    router.exactInputSingle(v3params);
  }

  function _swapUsingOrganicGrowthRouter(
    SwapParams memory params
  ) internal {
    uint256 nativeAmountIn = 0;

    if (params.isFromNative) {
      nativeAmountIn = params.amountIn;
    } else {
      IERC20(params.fromToken).approve(params.routerAddress, params.amountIn);
    }

    IOGRouter router = IOGRouter(params.routerAddress);

    if (params.isFromNative) {
      router.swapExactETHForTokens{value: nativeAmountIn}(
        0,
        params.toToken,
        address(this),
        params.deadline
      );
    } else if (params.isToNative) {
      router.swapExactTokensForETH(
        params.amountIn,
        0,
        params.fromToken,
        address(this),
        params.deadline
      );
    } else {
      address[] memory path = new address[](2);
      path[0] = params.fromToken;
      path[1] = params.toToken;

      router.swapExactTokensForTokens(
        params.amountIn,
        0,
        path,
        address(this),
        params.deadline
      );
    }
  }

  function _safeTansferFromWithBalanceCheck(
    IERC20 token,
    address from,
    address to,
    uint256 value
  ) internal {
    uint256 balanceBefore = token.balanceOf(address(this));
    token.safeTransferFrom(from, to, value);
    uint256 balanceAfter = token.balanceOf(address(this));
    require(balanceAfter - balanceBefore == value, OnchainCLOBErrors.InvalidTransfer());
  }

  function _sendETH(address to, uint256 value) internal {
    (bool success, ) = to.call{value: value}("");
    require(success, OnchainCLOBErrors.TransferFailed());
  }

  function _unpackInputHopParams(
    uint32 packedInputParams
  ) internal pure returns (uint8 hopId, uint16 amountPercent) {
    hopId = uint8(packedInputParams & 0xFF);
    amountPercent = uint16((packedInputParams >> 8) & 0xFFFF);
  }

  function _unpackParams(
    uint64 packedParams
  ) internal pure returns (
    uint8 dexId,
    bool useForRest,
    bool isFromNative,
    bool isToNative,
    uint24 poolV3fee
  ) {
    dexId = uint8(packedParams & 0xFF);
    useForRest = ((packedParams >> 8) & 0x1) > 0;
    isFromNative = ((packedParams >> 9) & 0x1) > 0;
    isToNative = ((packedParams >> 10) & 0x1) > 0;
    poolV3fee = uint24((packedParams >> 11) & 0xFFFFFF);
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;


contract Errors {
    error AddressIsZero();
    error ArrayLengthMismatch();
    error ChainIsUnstableForTrades();
    error ClaimNotAllowed();
    error CommissionParamTooHigh();
    error Disabled();
    error EmptyOrderError();
    error ExcessiveSignificantFigures();
    error Expired();
    error Forbidden();
    error FractionalNumbersNotAllowed();
    error InsufficientTokenXBalance();
    error InsufficientTokenYBalance();
    error InvalidCommissionRate();
    error InvalidFloatingPointRepresentation();
    error InvalidMarketMaker();
    error InvalidPriceRange();
    error InvalidTransfer();
    error MarketOnlyAndPostOnlyFlagsConflict();
    error MaxCommissionFailure();
    error NativeETHDisabled();
    error NonceExhaustedFailure();
    error NotImplementedYet();
    error OnlyOwnerCanCancelOrders();
    error PointerAlreadyFreed();
    error PriceExceedsMaximumAllowedValue();
    error TransferFailed();
    error UnknownOrderId();
    error UnknownTrader();
    error WrongOwner();
    error ZeroMaxDelayNotAllowed();
    error ZeroRecoveryTimeNotAllowed();
    error ZeroTokenTransferNotAllowed();
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;


interface IOnchainCLOB {
    function getConfig() external view returns (
        uint256 _scaling_factor_token_x,
        uint256 _scaling_factor_token_y,
        address _token_x,
        address _token_y,
        bool _supports_native_eth,
        bool _is_token_x_weth,
        address _ask_trie,
        address _bid_trie,
        uint64 _admin_commission_rate,
        uint64 _total_aggressive_commission_rate,
        uint64 _total_passive_commission_rate,
        uint64 _passive_order_payout_rate,
        bool _should_invoke_on_trade
    );

    receive() external payable;

    function getTraderBalance(address address_) external view returns (uint128, uint128, bool);

    function changeMarketMaker(
        address _marketmaker,
        bool _should_invoke_on_trade,
        uint64 _admin_commission_rate
    ) external;

    function setClaimableStatus(bool status) external;

    function placeOrder(
        bool isAsk,
        uint128 quantity,
        uint72 price,
        uint128 max_commission,
        bool market_only,
        bool post_only,
        bool transfer_executed_tokens,
        uint256 expires
    ) external payable returns (
        uint64 order_id,
        uint128 executed_shares,
        uint128 executed_value,
        uint128 aggressive_fee
    );

    function placeOrder(
        bool isAsk,
        uint128 quantity,
        uint72 price,
        uint128 max_commission,
        uint128 amount_to_approve,
        bool market_only,
        bool post_only,
        bool transfer_executed_tokens,
        uint256 expires,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external payable returns (
        uint64 order_id,
        uint128 executed_shares,
        uint128 executed_value,
        uint128 aggressive_fee
    );

    function placeMarketOrderWithTargetValue(
        bool isAsk,
        uint128 target_token_y_value,
        uint72 price,
        uint128 max_commission,
        uint128 amount_to_approve,
        bool transfer_executed_tokens,
        uint256 expires,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external payable returns (
        uint128 executed_shares,
        uint128 executed_value,
        uint128 aggressive_fee
    );

    function placeMarketOrderWithTargetValue(
        bool isAsk,
        uint128 target_token_y_value,
        uint72 price,
        uint128 max_commission,
        bool transfer_executed_tokens,
        uint256 expires
    ) external payable returns (
        uint128 executed_shares,
        uint128 executed_value,
        uint128 aggressive_fee
    );

    function claimOrder(
        uint64 order_id,
        bool only_claim,
        bool transfer_tokens,
        uint256 expires
    ) external;

    function batchClaim(
        address[] memory addresses,
        uint64[] memory order_ids,
        bool only_claim,
        uint256 expires
    ) external;

    function changeOrder(
        uint64 old_order_id, 
        uint128 new_quantity, 
        uint72 new_price,
        uint128 max_commission,
        bool post_only,
        bool transfer_tokens,
        uint256 expires
    ) external returns (uint64);

    function batchChangeOrder(
        uint64[] memory order_ids, 
        uint128[] memory quantities, 
        uint72[] memory prices,
        uint128 max_commission_per_order,
        bool post_only,
        bool transfer_tokens,
        uint256 expires
    ) external returns (uint64[] memory new_order_ids);

    function depositTokens(uint128 token_x_amount, uint128 token_y_amount) external;

    function depositTokens(
        uint128 token_x_amount,
        uint128 token_y_amount,
        uint8 v_x,
        bytes32 r_x,
        bytes32 s_x,
        uint8 v_y,
        bytes32 r_y,
        bytes32 s_y,
        uint256 expires
    ) external;

    function withdrawTokens(bool withdraw_all, uint128 token_x_amount, uint128 token_y_amount) external;

    function getAccumulatedFees() external returns (uint256);

    function transferFees() external;
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.27;


struct Hop {
  uint64 params;
  uint32[] inputHopParams;
  address routerAddress;
  address fromToken;
  address toToken;
}


interface IRouter {
  function swapEthForTokens(
    uint256 amountOutMin,
    Hop[] calldata hops,
    address to,
    uint256 deadline
  ) external payable returns (uint256[] memory amounts);

  function swapTokensForEth(
    uint256 amountIn,
    uint256 amountOutMin,
    Hop[] calldata hops,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  function swapTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    Hop[] calldata hops,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.27;


interface IOGRouter {
  function swapExactTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  function swapExactETHForTokens(
    uint256 amountOutMin,
    address token,
    address to,
    uint256 deadline
  ) external payable returns (uint256 amountTokenOut);

  function swapExactTokensForETH(
    uint256 amountIn,
    uint256 amountOutMin,
    address token,
    address to,
    uint256 deadline
  ) external returns (uint256 amountWethOut);
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.27;


interface IV2Router {
  function swapExactTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  function swapExactETHForTokens(
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external payable returns (uint256[] memory amounts);

  function swapExactTokensForETH(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.27;


interface IV3Router {
  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);
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.27;


interface IWETH {
    function deposit() external payable;
    function withdraw(uint wad) external;
}

// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.27;


contract Errors {
    error InsufficientAmountOut();
    error UnsupportedDex();
    error WrongHopsCount();
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Address.sol)

pragma solidity ^0.8.20;

import {Errors} from "./Errors.sol";

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert Errors.FailedCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {Errors.FailedCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
     * of an unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {Errors.FailedCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../token/ERC20/IERC20.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../utils/introspection/IERC165.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 *
 * _Available since v5.1._
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();

    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();

    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "forge-std/=lib/forge-std/src/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@organicgrowth/contracts/=lib/organic-growth-contracts/contracts/",
    "@onchainclob/contracts/=lib/hanji-contracts/src/",
    "@openzeppelin/contracts-upgradeable/=lib/hanji-contracts/lib/openzeppelin-contracts-upgradeable/contracts/",
    "@solmate/src/=lib/hanji-contracts/lib/solmate/src/",
    "ds-test/=lib/organic-growth-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "eth-gas-reporter/=lib/organic-growth-contracts/node_modules/eth-gas-reporter/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    "hanji-contracts/=lib/hanji-contracts/src/",
    "hardhat/=lib/organic-growth-contracts/node_modules/hardhat/",
    "openzeppelin-contracts-upgradeable/=lib/hanji-contracts/lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/organic-growth-contracts/lib/openzeppelin-contracts/contracts/",
    "organic-growth-contracts/=lib/organic-growth-contracts/contracts/",
    "solmate/=lib/hanji-contracts/lib/solmate/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"InsufficientAmountOut","type":"error"},{"inputs":[],"name":"InvalidTransfer","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"UnsupportedDex","type":"error"},{"inputs":[],"name":"WrongHopsCount","type":"error"},{"inputs":[],"name":"ZeroTokenTransferNotAllowed","type":"error"},{"inputs":[{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"components":[{"internalType":"uint64","name":"params","type":"uint64"},{"internalType":"uint32[]","name":"inputHopParams","type":"uint32[]"},{"internalType":"address","name":"routerAddress","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"}],"internalType":"struct Hop[]","name":"hops","type":"tuple[]"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapEthForTokens","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"components":[{"internalType":"uint64","name":"params","type":"uint64"},{"internalType":"uint32[]","name":"inputHopParams","type":"uint32[]"},{"internalType":"address","name":"routerAddress","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"}],"internalType":"struct Hop[]","name":"hops","type":"tuple[]"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapTokensForEth","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"components":[{"internalType":"uint64","name":"params","type":"uint64"},{"internalType":"uint32[]","name":"inputHopParams","type":"uint32[]"},{"internalType":"address","name":"routerAddress","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"}],"internalType":"struct Hop[]","name":"hops","type":"tuple[]"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapTokensForTokens","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

773:13718:17:-:0;;;;;;;;;-1:-1:-1;773:13718:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2466:103:9;;;;;;;;:::i;:::-;2314:12:17;;773:13718;;2390:15;;773:13718;;2688:55;;773:13718;;;;2607:8;773:13718;-1:-1:-1;;;;;2464:17:17;773:13718;2464:7;773:13718;;2464:7;:::i;:::-;:17;;:::i;:::-;773:13718;2594:4;2568:10;;2607:8;;:::i;:::-;2688:55;:::i;:::-;2775:21;;;;2810:30;;;773:13718;;2916:14;2977:11;2916:14;773:13718;2916:14;;:::i;:::-;2977:11;:::i;:::-;1857:1:9;773:13718:17;1899:1:9;773:13718:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;773:13718:17;;;;;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;773:13718:17;;;;;;2466:103:9;;:::i;:::-;1492:9:17;:13;773:13718;;1569:15;;773:13718;;1677:56;773:13718;;1492:9;;;1677:56;:::i;:::-;773:13718;;-1:-1:-1;;773:13718:17;;;;;;;-1:-1:-1;;;;;773:13718:17;1792:29;;773:13718;;1792:21;;;;;:::i;:29::-;773:13718;;-1:-1:-1;;;1854:32:17;;1880:4;773:13718;1854:32;;773:13718;;;;;;;;;1854:32;;;;;;;773:13718;1854:32;;;773:13718;;;;1900:30;;773:13718;;;2018:14;2079:11;2018:14;;;;:::i;1854:32::-;;;;773:13718;1854:32;;773:13718;1854:32;;;;;;773:13718;1854:32;;;:::i;:::-;;;773:13718;;;;;1854:32;;;;;;;-1:-1:-1;1854:32:17;;;773:13718;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2466:103:9;;;;;;;:::i;:::-;3215:12:17;;773:13718;;3291:15;;773:13718;;3589:55;;773:13718;;;;3508:8;773:13718;-1:-1:-1;;;;;3365:17:17;773:13718;3365:7;773:13718;;3365:7;:::i;3589:55::-;773:13718;;;;;;;;;;;;-1:-1:-1;;;;;773:13718:17;3703:29;;;;:21;;;;;:::i;:29::-;773:13718;;;;;;;3765:32;;3495:4;773:13718;3765:32;;773:13718;;3765:32;;;;;;;;;;;773:13718;3765:32;;;773:13718;3811:30;;;773:13718;;;3929:14;3990:11;3929:14;;;;:::i;3765:32::-;;;;773:13718;3765:32;;773:13718;3765:32;;;;;;773:13718;3765:32;;;:::i;:::-;;;773:13718;;;;;3765:32;;;;;;;-1:-1:-1;3765:32:17;;773:13718;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;;773:13718:17;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;773:13718:17;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;;;;;773:13718:17;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;773:13718:17;;;;;-1:-1:-1;773:13718:17;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;2575:307:9:-;1899:1;2702:7;773:13718:17;2702:18:9;2698:86;;1899:1;2702:7;1899:1;2575:307::o;2698:86::-;2743:30;;;2702:7;2743:30;;2702:7;2743:30;13252:384:17;773:13718;;-1:-1:-1;;;13408:30:17;;13432:4;13408:30;;;773:13718;13252:384;;-1:-1:-1;;;;;773:13718:17;;;13252:384;773:13718;;13408:30;773:13718;;13408:30;;;;;;;-1:-1:-1;13408:30:17;;;13252:384;773:13718;13408:30;773:13718;;;;1797:53:6;773:13718:17;;;;;;;1797:53:6;;;;773:13718:17;;;;;;1797:53:6;;;773:13718:17;;;;;;;;;;;;;;;;;1797:53:6;;;;;;:::i;:::-;;:::i;:::-;773:13718:17;;-1:-1:-1;;;13512:30:17;;13432:4;13408:30;13512;;773:13718;;;;;;13512:30;;;;;;-1:-1:-1;13512:30:17;;;13252:384;13556:28;;;;:::i;:::-;:37;773:13718;;13252:384::o;773:13718::-;;;;-1:-1:-1;773:13718:17;13408:30;-1:-1:-1;773:13718:17;13512:30;;773:13718;13512:30;;773:13718;13512:30;;;;;;773:13718;13512:30;;;:::i;:::-;;;773:13718;;;;13556:28;773:13718;;13512:30;;;;;-1:-1:-1;13512:30:17;;13408;;;;773:13718;13408:30;;;;;773:13718;13408:30;;;;;;773:13718;13408:30;;;:::i;:::-;;;773:13718;;;;;;13408:30;;773:13718;13408:30;;;;;;-1:-1:-1;13408:30:17;;773:13718;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;:::o;:::-;;;;;;;;;:::o;:::-;;;4235:1;773:13718;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;4011:2281::-;;;;;;;4235:1;773:13718;;;;;;;;4297:30;4207;;;:::i;:::-;4243:27;;;;;:::i;:::-;773:13718;4297:30;:::i;:::-;4333:31;;;;:::i;:::-;773:13718;-1:-1:-1;4391:1897:17;4408:15;;;;;;4011:2281;;;:::o;4425:3::-;4235:1;773:13718;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;773:13718:17;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;773:13718:17;;;;4684:29;4698:14;:7;;;;;:::i;:::-;:14;:::i;:::-;773:13718;14254:19;;773:13718;14316:3;773:13718;14311:1;773:13718;14294:25;14293:31;;773:13718;14316:3;773:13718;14363:1;773:13718;14346:25;14345:31;;773:13718;;14316:3;773:13718;14413:2;773:13718;14396:26;14395:32;;773:13718;14469:2;773:13718;14452:31;14051:438;;4684:29;773:13718;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4749:21:17;-1:-1:-1;4749:7:17;;773:13718;4749:7;;:::i;:21::-;773:13718;;;;;-1:-1:-1;;;;;4801:17:17;773:13718;4801:7;;;;;:::i;:17::-;773:13718;;;;;-1:-1:-1;;;;;4847:15:17;773:13718;4847:7;;;;;:::i;:15::-;773:13718;;;;;4914:7;;;;;:::i;:::-;4892:76;-1:-1:-1;6502:10:17;-1:-1:-1;6545:3:17;6518:18;773:13718;6518:18;;;;:::i;:::-;6514:29;;;;;;;6518:18;6628;773:13718;6518:18;;;6628;:::i;:::-;:21;;;;:::i;:::-;;;;:::i;:::-;773:13718;13954:24;;;;14030:1;773:13718;;14008:33;6681:25;13954:24;6681:25;;:::i;:::-;1042:1;;;773:13718;;;;;;;;;;;;;;;;;;;;;6743:23;773:13718;6730:5;773:13718;;;6743:23;;:::i;:::-;773:13718;6774:44;6730:5;773:13718;;;6774:44;773:13718;;;6774:44;;:::i;:::-;1042:1;6774:44;:::i;:::-;;773:13718;;;6774:44;;:::i;:::-;773:13718;6891:79;;;;;6545:3;6887:189;;6545:3;;4235:1;773:13718;6502:10;;6887:189;773:13718;;-1:-1:-1;7034:33:17;773:13718;;4235:1;773:13718;6995:29;773:13718;;6983:41;773:13718;;6995:29;;:::i;:::-;1042:1;6983:41;;:::i;:::-;773:13718;;7034:33;;:::i;:::-;773:13718;6887:189;;;6891:79;773:13718;6905:29;773:13718;;;6905:29;;:::i;:::-;1042:1;6730:5;6937:25;773:13718;;;;6937:25;:::i;:::-;1042:1;773:13718;-1:-1:-1;6891:79:17;;6514:29;;;;;;;;;;;;;773:13718;;;;;;;;5048:58;773:13718;;;;;;;;;;;;;;;;5048:58;;:::i;:::-;773:13718;;5145:54;773:13718;;;;;;;;;;;;;;;;5145:54;;:::i;:::-;773:13718;;5212:27;;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;;;;;773:13718:17;9213:30;;;;:54;;5208:489;9209:167;;5208:489;-1:-1:-1;773:13718:17;;;;-1:-1:-1;;;;;773:13718:17;9386:28;;;;:50;;5208:489;9382:165;;5208:489;;;6055:47;6133:38;5208:489;4235:1;5208:489;;5921:43;5738:58;773:13718;;;;;;;;;;;;;;;;5738:58;;:::i;:::-;773:13718;5835:54;773:13718;;;;;;;;;;;;;;;;5835:54;;:::i;:::-;5921:43;:::i;:::-;5898:66;773:13718;;;;5898:66;:::i;:::-;773:13718;5999:20;773:13718;;;5999:20;;:::i;:::-;1042:1;5972:47;773:13718;;;5972:47;;:::i;:::-;773:13718;6055:47;:::i;:::-;1042:1;;6133:38;:::i;:::-;6184:16;6180:102;;5208:489;4425:3;773:13718;4396:10;;;6180:102;6260:12;6232:7;;;;;;;:::i;:::-;6260:12;:::i;:::-;6180:102;;;9382:165;1042:1;;;;9495:45;;;;;;-1:-1:-1;773:13718:17;9495:45;773:13718;;;;;;;;;9495:45;;;;;;;;;4235:1;9495:45;6133:38;9495:45;6055:47;9495:45;;;9382:165;;;;;;;;;9495:45;-1:-1:-1;9495:45:17;;;:::i;:::-;;;;9386:50;773:13718;;;;;;9386:50;;9209:167;1042:1;;9330:39;;;;;-1:-1:-1;773:13718:17;9330:39;773:13718;;;;;;;;;;;;9330:39;;;;;773:13718;9330:39;;;;;;;9209:167;9330:39;-1:-1:-1;9330:39:17;;;:::i;:::-;;9209:167;;9213:54;773:13718;;;;;;9213:54;;5208:489;5296:23;;;4235:1;5296:23;;4235:1;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;;773:13718:17;;;1042:1;;;9668:164;773:13718;;;;;;-1:-1:-1;;;10105:15:17;;-1:-1:-1;;;;;773:13718:17;;;;10105:15;773:13718;10105:15;773:13718;;10105:15;;;;;;;-1:-1:-1;;;;;10105:15:17;;;9668:164;-1:-1:-1;773:13718:17;;;;-1:-1:-1;;;;;773:13718:17;;;;;10131:26;773:13718;;1042:1;10183:221;-1:-1:-1;;;;;10252:37:17;773:13718;1042:1;;;10252:37;:::i;:::-;773:13718;;;;1042:1;773:13718;;;;;;;;;;;10183:221;;4235:1;10105:15;10183:221;;773:13718;;;;;4235:1;773:13718;;;;-1:-1:-1;;;;;773:13718:17;;;;4235:1;773:13718;;;;-1:-1:-1;773:13718:17;;;;4235:1;773:13718;;;;;;;;10183:221;;;;;;;;10127:555;;;6055:47;4235:1;10127:555;6133:38;10127:555;5208:489;;10183:221;773:13718;10183:221;;;;;;;;;;;;773:13718;10183:221;;;:::i;:::-;;;773:13718;;;;4235:1;773:13718;6133:38;773:13718;;;;;6055:47;773:13718;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::i;:::-;;10183:221;;;;;;;;;;-1:-1:-1;10183:221:17;;10127:555;773:13718;1042:1;;-1:-1:-1;;;;;10532:37:17;10441:234;1042:1;;;10532:37;:::i;:::-;773:13718;;;;1042:1;773:13718;;;;;;;;;;;10441:234;;-1:-1:-1;10105:15:17;10441:234;;773:13718;;;;;10580:21;773:13718;;;;-1:-1:-1;;;;;773:13718:17;;;;4235:1;773:13718;;;;;;;;10441:234;;;;;;;;10127:555;;6055:47;4235:1;10127:555;6133:38;10127:555;5208:489;;10441:234;773:13718;10441:234;;;;;;;;;;;;773:13718;10441:234;;;:::i;:::-;;;773:13718;;;;4235:1;773:13718;6133:38;773:13718;;;;;6055:47;773:13718;;:::i;:::-;;;;;;;:::i;10441:234::-;;;-1:-1:-1;10441:234:17;;10105:15;;;;;;;;;;;;;;;;;;;:::i;:::-;;;773:13718;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::i;:::-;;10105:15;;;;;;;;-1:-1:-1;10105:15:17;;9668:164;773:13718;;;;;;;;;;1042:1;;773:13718;;-1:-1:-1;;;9754:71:17;;-1:-1:-1;;;;;773:13718:17;;;9754:71;;;773:13718;;;;;;;;;;;;;;;;-1:-1:-1;;773:13718:17;9754:71;;;;;;;;9668:164;;;;9754:71;773:13718;9754:71;;;;;;;;;773:13718;9754:71;;;:::i;:::-;;;773:13718;;;;;;;:::i;:::-;;9754:71;;;;;;-1:-1:-1;9754:71:17;;5292:405;5383:33;;;;972:1;5383:33;;972:1;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;;773:13718:17;;;1042:1;;;12372:164;;773:13718;;;;;;;;-1:-1:-1;;;;;773:13718:17;;;;;;;;;;;;;;;1042:1;773:13718;;-1:-1:-1;;;12632:142:17;;-1:-1:-1;12632:142:17;;;773:13718;-1:-1:-1;;;;;773:13718:17;;;;;;;12736:4;773:13718;;;;;;;;;;;;;12632:142;;773:13718;;12632:142;;;;;;;4235:1;12632:142;6133:38;12632:142;6055:47;12632:142;;;12599:645;;5208:489;;12632:142;;;773:13718;12632:142;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;12599:645;-1:-1:-1;773:13718:17;;;;;;;;1042:1;;12818:146;773:13718;;;;;;;;;;;-1:-1:-1;773:13718:17;;;1042:1;773:13718;;;;;;;;;;;12818:146;;;;;773:13718;;;;;;;;;;12926:4;773:13718;;;;;;;;12818:146;;;;;;;4235:1;12818:146;6133:38;12818:146;6055:47;12818:146;;;12787:457;5208:489;;12787:457;-1:-1:-1;13100:137:17;773:13718;;;;;;;;;;:::i;:::-;972:1;773:13718;;-1:-1:-1;;773:13718:17;;;;;;;;;;-1:-1:-1;;;;;773:13718:17;13033:26;;;:::i;:::-;773:13718;;;;;-1:-1:-1;;;;;773:13718:17;13067:24;;;:::i;:::-;773:13718;1042:1;;773:13718;;;;1042:1;773:13718;;;;;;;;;;;;;13100:137;;13199:4;13100:137;;;;;:::i;:::-;;;;;;;;;;4235:1;13100:137;6133:38;13100:137;6055:47;13100:137;;;12787:457;5208:489;;13100:137;;;;;-1:-1:-1;13100:137:17;;;;;;:::i;:::-;;;;;:::i;12372:164::-;773:13718;;;;;;;;;;1042:1;;773:13718;;-1:-1:-1;;;12458:71:17;;-1:-1:-1;;;;;773:13718:17;;;12458:71;;;773:13718;;;;;;;;;;;;;;;;;;;-1:-1:-1;;773:13718:17;12458:71;;;;;;;;12372:164;;;;12458:71;773:13718;12458:71;;;;;;;;;773:13718;12458:71;;;:::i;:::-;;;773:13718;;;;;;;:::i;:::-;;12458:71;;;;;;-1:-1:-1;12458:71:17;;5379:318;1007:1;5488:21;;1007:1;;-1:-1:-1;773:13718:17;;;;-1:-1:-1;;773:13718:17;;;1042:1;;;10800:164;;773:13718;;;;;;-1:-1:-1;;;;;773:13718:17;;;;;;;;;:::i;:::-;972:1;773:13718;;-1:-1:-1;;773:13718:17;;;;;;;;;;-1:-1:-1;;;;;773:13718:17;11073:26;;;:::i;:::-;773:13718;;;;;-1:-1:-1;;;;;773:13718:17;11105:24;;;:::i;:::-;773:13718;;;;;;;;-1:-1:-1;773:13718:17;;;;;;1042:1;773:13718;;;;;;;;;;;;11169:132;;;;;;773:13718;;;;;;;;;;;:::i;:::-;11263:4;;773:13718;;;;;;;;11169:132;;;;;;;;;4235:1;11169:132;6133:38;11169:132;6055:47;11169:132;;;11136:508;5208:489;;11136:508;773:13718;;;;;;-1:-1:-1;773:13718:17;;;11345:134;1042:1;-1:-1:-1;1042:1:17;;;773:13718;;;;1042:1;773:13718;;;;;;;;;;;;;11345:134;;11441:4;11345:134;;;;;:::i;11314:330::-;11500:137;1042:1;-1:-1:-1;1042:1:17;;;773:13718;;;;1042:1;773:13718;;;;;;;;;;;;;11500:137;;11599:4;11500:137;;;;;:::i;10800:164::-;773:13718;;;;;;;;;;1042:1;;773:13718;;-1:-1:-1;;;10886:71:17;;-1:-1:-1;;;;;773:13718:17;;;10886:71;;;773:13718;;;;;;;;;;;;;;;;;;;-1:-1:-1;;773:13718:17;10886:71;;;;;;;;10800:164;;;;10886:71;773:13718;10886:71;;;;;;;;;773:13718;10886:71;;;:::i;:::-;;;773:13718;;;;;;;:::i;:::-;;10886:71;;;;;;-1:-1:-1;10886:71:17;;5484:213;1042:1;5570:21;1042:1;;773:13718;;;;;;;;;;1042:1;;773:13718;;-1:-1:-1;;;11729:71:17;;-1:-1:-1;;;;;773:13718:17;;;1042:1;11729:71;;773:13718;;;;;;;;;;;;;;;;-1:-1:-1;;773:13718:17;11729:71;;;;;;;;5566:131;773:13718;;;;;;;;;;;;;;;;;;;;;;;12209:33;773:13718;;;;;;;;;;;-1:-1:-1;773:13718:17;;;;;;;;;;1042:1;;;773:13718;;;;;;;:::i;:::-;;;11915:287;;;773:13718;;;;11915:287;;;773:13718;;;12069:4;773:13718;11915:287;;773:13718;;;;11915:287;;773:13718;;;;11915:287;;773:13718;;;;11915:287;;773:13718;;;;11915:287;;773:13718;;;;;-1:-1:-1;;;12209:33:17;;773:13718;;-1:-1:-1;;;;;773:13718:17;;;1042:1;12209:33;;773:13718;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12209:33;;;;;;;4235:1;12209:33;6133:38;12209:33;6055:47;12209:33;;;5566:131;5208:489;;11729:71;773:13718;11729:71;;;;;;;;;773:13718;11729:71;;;:::i;:::-;;;773:13718;;;;;;;:::i;:::-;11729:71;;;;;-1:-1:-1;11729:71:17;;5566:131;5665:23;;;-1:-1:-1;5665:23:17;1042:1;-1:-1:-1;5665:23:17;1271:160:6;773:13718:17;;-1:-1:-1;;;1380:43:6;;;;-1:-1:-1;;;;;773:13718:17;;;;1380:43:6;;;773:13718:17;;;;;;;;;1380:43:6;;;;;;773:13718:17;;1380:43:6;:::i;:::-;1271:160::o;7812:1053:17:-;;;;;8326:1;8357:3;773:13718;;-1:-1:-1;;773:13718:17;;;;;;;8329:26;;;;;8374:14;;;;:::i;:::-;1042:1;8374:19;8370:52;;8446:6;;;:18;;;;8354:1;8446:18;8326:1;8446:18;8516:36;8530:21;:14;;;;;:::i;8516:36::-;8594:104;;;;;;;;;;8612:14;:24;:14;:24;:14;;;;:::i;:24::-;8594:104;;8707:148;;;8752:14;;;;;;:::i;:::-;1042:1;8740:10;8752:14;:::i;:::-;773:13718;8317:10;;8707:148;8831:14;;;;;;:::i;:::-;1042:1;8819:10;;773:13718;;;;;;;8831:14;:::i;:::-;8707:148;;8594:104;8663:14;;:22;:14;:22;:14;;;;:::i;:22::-;8594:104;;;8446:18;-1:-1:-1;;773:13718:17;;;;;;;;8354:1;8446:18;;;8370:52;8354:1;8405:8;;;8329:26;;;;;;7812:1053::o;13640:167::-;13719:25;13640:167;;;;;13719:25;;773:13718;;;;;;;;;;;;;;;;;-1:-1:-1;;773:13718:17;;;;;:::i;:::-;;;13719:25;773:13718;;;;;;;;;13640:167::o;773:13718::-;;;;13719:25;773:13718;;13719:25;773:13718;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;8869:263;;8965:163;;;9027:21;;9020:28;:::o;8965:163::-;773:13718;;-1:-1:-1;;;9076:45:17;;9115:4;9076:45;;;773:13718;;;;;;9076:45;;773:13718;;-1:-1:-1;;;;;773:13718:17;9076:45;;;;;;;773:13718;9076:45;;;9069:52;;:::o;9076:45::-;;;773:13718;9076:45;;773:13718;9076:45;;;;;;773:13718;9076:45;;;:::i;:::-;;;773:13718;;;;;9069:52;:::o;9076:45::-;;;-1:-1:-1;9076:45:17;;773:13718;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;773:13718:17;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;773:13718:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;4257:1;773:13718;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;773:13718:17;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;773:13718:17;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;773:13718:17;;;;;;:::o;7090:718::-;;;7245:18;;;;;;;;:::i;:::-;7236:34;;7231:368;7272:5;;;7703:18;7722;7703;;;;:::i;:::-;7722;;;;:::i;:::-;-1:-1:-1;;773:13718:17;;;-1:-1:-1;773:13718:17;;;;7703:49;;773:13718;7703:49;7759:44;7703:49;7759:44;7703:49;;:::i;:::-;;:::i;:::-;13954:24;;7759:44;13954:24;7759:44;;:::i;:::-;1042:1;7759:44;:::i;:::-;;;:::i;:::-;773:13718;7090:718::o;7279:3::-;7362:18;;;;:::i;:::-;773:13718;-1:-1:-1;;773:13718:17;;;;;;;7362:25;;;;;:::i;:::-;7506:5;773:13718;13954:24;773:13718;13954:24;;773:13718;14030:1;773:13718;14008:33;773:13718;7485:26;7481:112;;7279:3;773:13718;;;;-1:-1:-1;;773:13718:17;;7236:34;;7481:112;7523:45;773:13718;;7523:45;773:13718;;;;;;7523:45;;;;;:::i;7738:720:6:-;;-1:-1:-1;7875:421:6;7738:720;7875:421;;;;;;;;;;;;-1:-1:-1;7875:421:6;;8310:15;;-1:-1:-1;;;;;;773:13718:17;;8328:26:6;:31;8310:68;8306:146;;7738:720;:::o;8306:146::-;-1:-1:-1;;;;8401:40:6;;;-1:-1:-1;;;;;773:13718:17;;;;8401:40:6;773:13718:17;;;8401:40:6;8310:68;8377:1;8362:16;;8310:68;

ipfs://c000976eed56636aa54ef9265fd68f91bf2716547bb95dc4c992242b001782dd