novaswap-v2-sdk 1.0.0

package/dist/novaswap-v2-sdk.cjs.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"novaswap-v2-sdk.cjs.development.js","sources":["../src/constants.ts","../src/errors.ts","../src/entities/pair.ts","../src/entities/route.ts","../src/entities/trade.ts","../src/router.ts"],"sourcesContent":["import { Percent} from '@uniswap/sdk-core'\nimport {V2_FACTORY_ADDRESSES } from 'novaswap-core-sdk'\nimport JSBI from 'jsbi'\n\n/**\n * @deprecated use FACTORY_ADDRESS_MAP instead\n */\nexport const FACTORY_ADDRESS = '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f'\n\nexport const FACTORY_ADDRESS_MAP: { [chainId: number]: string } = V2_FACTORY_ADDRESSES\n\nexport const INIT_CODE_HASH = '0x0ef7ca4700ff7e705236379af2cdac62d4fa0bbd010fb163697b63379941118e'\n\nexport const MINIMUM_LIQUIDITY = JSBI.BigInt(1000)\n\n// exports for internal consumption\nexport const ZERO = JSBI.BigInt(0)\nexport const ONE = JSBI.BigInt(1)\nexport const FIVE = JSBI.BigInt(5)\nexport const _997 = JSBI.BigInt(997)\nexport const _1000 = JSBI.BigInt(1000)\nexport const BASIS_POINTS = JSBI.BigInt(10000)\n\nexport const ZERO_PERCENT = new Percent(ZERO)\nexport const ONE_HUNDRED_PERCENT = new Percent(ONE)\n","// see https://stackoverflow.com/a/41102306\nconst CAN_SET_PROTOTYPE = 'setPrototypeOf' in Object\n\n/**\n * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be\n * obtained by sending any amount of input.\n */\nexport class InsufficientReservesError extends Error {\n  public readonly isInsufficientReservesError: true = true\n\n  public constructor() {\n    super()\n    this.name = this.constructor.name\n    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)\n  }\n}\n\n/**\n * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less\n * than the price of a single unit of output after fees.\n */\nexport class InsufficientInputAmountError extends Error {\n  public readonly isInsufficientInputAmountError: true = true\n\n  public constructor() {\n    super()\n    this.name = this.constructor.name\n    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)\n  }\n}\n","import { getCreate2Address } from '@ethersproject/address'\nimport { BigNumber } from '@ethersproject/bignumber'\nimport { keccak256, pack } from '@ethersproject/solidity'\nimport { BigintIsh, CurrencyAmount, Percent, Price, sqrt, Token } from '@uniswap/sdk-core'\nimport JSBI from 'jsbi'\nimport invariant from 'tiny-invariant'\n\nimport {\n  _1000,\n  _997,\n  BASIS_POINTS,\n  FACTORY_ADDRESS,\n  FACTORY_ADDRESS_MAP,\n  FIVE,\n  INIT_CODE_HASH,\n  MINIMUM_LIQUIDITY,\n  ONE,\n  ONE_HUNDRED_PERCENT,\n  ZERO,\n  ZERO_PERCENT\n} from '../constants'\nimport { InsufficientInputAmountError, InsufficientReservesError } from '../errors'\n\nexport const computePairAddress = ({\n  factoryAddress,\n  tokenA,\n  tokenB\n}: {\n  factoryAddress: string\n  tokenA: Token\n  tokenB: Token\n}): string => {\n  const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA] // does safety checks\n  return getCreate2Address(\n    factoryAddress,\n    keccak256(['bytes'], [pack(['address', 'address'], [token0.address, token1.address])]),\n    INIT_CODE_HASH\n  )\n}\nexport class Pair {\n  public readonly liquidityToken: Token\n  private readonly tokenAmounts: [CurrencyAmount<Token>, CurrencyAmount<Token>]\n\n  public static getAddress(tokenA: Token, tokenB: Token): string {\n    const factoryAddress = FACTORY_ADDRESS_MAP[tokenA.chainId] ?? FACTORY_ADDRESS\n    return computePairAddress({ factoryAddress, tokenA, tokenB })\n  }\n\n  public constructor(currencyAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>) {\n    const tokenAmounts = currencyAmountA.currency.sortsBefore(tokenAmountB.currency) // does safety checks\n      ? [currencyAmountA, tokenAmountB]\n      : [tokenAmountB, currencyAmountA]\n    this.liquidityToken = new Token(\n      tokenAmounts[0].currency.chainId,\n      Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency),\n      18,\n      'UNI-V2',\n      'Uniswap V2'\n    )\n    this.tokenAmounts = tokenAmounts as [CurrencyAmount<Token>, CurrencyAmount<Token>]\n  }\n\n  /**\n   * Returns true if the token is either token0 or token1\n   * @param token to check\n   */\n  public involvesToken(token: Token): boolean {\n    return token.equals(this.token0) || token.equals(this.token1)\n  }\n\n  /**\n   * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0\n   */\n  public get token0Price(): Price<Token, Token> {\n    const result = this.tokenAmounts[1].divide(this.tokenAmounts[0])\n    return new Price(this.token0, this.token1, result.denominator, result.numerator)\n  }\n\n  /**\n   * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1\n   */\n  public get token1Price(): Price<Token, Token> {\n    const result = this.tokenAmounts[0].divide(this.tokenAmounts[1])\n    return new Price(this.token1, this.token0, result.denominator, result.numerator)\n  }\n\n  /**\n   * Return the price of the given token in terms of the other token in the pair.\n   * @param token token to return price of\n   */\n  public priceOf(token: Token): Price<Token, Token> {\n    invariant(this.involvesToken(token), 'TOKEN')\n    return token.equals(this.token0) ? this.token0Price : this.token1Price\n  }\n\n  /**\n   * Returns the chain ID of the tokens in the pair.\n   */\n  public get chainId(): number {\n    return this.token0.chainId\n  }\n\n  public get token0(): Token {\n    return this.tokenAmounts[0].currency\n  }\n\n  public get token1(): Token {\n    return this.tokenAmounts[1].currency\n  }\n\n  public get reserve0(): CurrencyAmount<Token> {\n    return this.tokenAmounts[0]\n  }\n\n  public get reserve1(): CurrencyAmount<Token> {\n    return this.tokenAmounts[1]\n  }\n\n  public reserveOf(token: Token): CurrencyAmount<Token> {\n    invariant(this.involvesToken(token), 'TOKEN')\n    return token.equals(this.token0) ? this.reserve0 : this.reserve1\n  }\n\n  /**\n   * getAmountOut is the linear algebra of reserve ratio against amountIn:amountOut.\n   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000\n   * has the math deduction for the reserve calculation without fee-on-transfer fees.\n   *\n   * With fee-on-transfer tax, intuitively it's just:\n   * inputAmountWithFeeAndTax = 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn\n   *                          = (1 - amountIn.sellFeesBips / 10000) * amountInWithFee\n   * where amountInWithFee is the amountIn after taking out the LP fees\n   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)\n   *\n   * But we are illustrating the math deduction below to ensure that's the case.\n   *\n   * before swap A * B = K where A = reserveIn B = reserveOut\n   *\n   * after swap A' * B' = K where only k is a constant value\n   *\n   * getAmountOut\n   *\n   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted\n   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)\n   * amountOut = (B - B') / (1 - amountOut.buyFeesBips / 10000) # where A' * B' still is k\n   *           = (B - K/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   *           = (B - AB/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   *           = ((BA + B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn - AB)/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   *           = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn / (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   * amountOut * (1 - amountOut.buyFeesBips / 10000) = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn\n   *                                                    /\n   *                                                    (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)\n   *\n   * outputAmountWithTax = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn\n   *                       /\n   *                       (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)\n   *                       = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn * 1000\n   *                       /\n   *                       ((A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn) * 1000)\n   *                     = (B * (1 - amountIn.sellFeesBips / 10000) 997 * * amountIn\n   *                       /\n   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * 997 * amountIn)\n   *                     = (B * (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)\n   *                       /\n   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)\n   *                     = (B * inputAmountWithFeeAndTax)\n   *                       /\n   *                       (1000 * A + inputAmountWithFeeAndTax)\n   *\n   * inputAmountWithFeeAndTax = (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee\n   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)\n   *\n   * @param inputAmount\n   * @param calculateFotFees\n   */\n  public getOutputAmount(\n    inputAmount: CurrencyAmount<Token>,\n    calculateFotFees: boolean = true\n  ): [CurrencyAmount<Token>, Pair] {\n    invariant(this.involvesToken(inputAmount.currency), 'TOKEN')\n    if (JSBI.equal(this.reserve0.quotient, ZERO) || JSBI.equal(this.reserve1.quotient, ZERO)) {\n      throw new InsufficientReservesError()\n    }\n    const inputReserve = this.reserveOf(inputAmount.currency)\n    const outputReserve = this.reserveOf(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0)\n\n    const percentAfterSellFees = calculateFotFees ? this.derivePercentAfterSellFees(inputAmount) : ZERO_PERCENT\n    const inputAmountAfterTax = percentAfterSellFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          inputAmount.currency,\n          percentAfterSellFees.multiply(inputAmount).quotient // fraction.quotient will round down by itself, which is desired\n        )\n      : inputAmount\n\n    const inputAmountWithFeeAndAfterTax = JSBI.multiply(inputAmountAfterTax.quotient, _997)\n    const numerator = JSBI.multiply(inputAmountWithFeeAndAfterTax, outputReserve.quotient)\n    const denominator = JSBI.add(JSBI.multiply(inputReserve.quotient, _1000), inputAmountWithFeeAndAfterTax)\n    const outputAmount = CurrencyAmount.fromRawAmount(\n      inputAmount.currency.equals(this.token0) ? this.token1 : this.token0,\n      JSBI.divide(numerator, denominator) // JSBI.divide will round down by itself, which is desired\n    )\n\n    if (JSBI.equal(outputAmount.quotient, ZERO)) {\n      throw new InsufficientInputAmountError()\n    }\n\n    const percentAfterBuyFees = calculateFotFees ? this.derivePercentAfterBuyFees(outputAmount) : ZERO_PERCENT\n    const outputAmountAfterTax = percentAfterBuyFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          outputAmount.currency,\n          outputAmount.multiply(percentAfterBuyFees).quotient // fraction.quotient will round down by itself, which is desired\n        )\n      : outputAmount\n    if (JSBI.equal(outputAmountAfterTax.quotient, ZERO)) {\n      throw new InsufficientInputAmountError()\n    }\n\n    return [\n      outputAmountAfterTax,\n      new Pair(inputReserve.add(inputAmountAfterTax), outputReserve.subtract(outputAmountAfterTax))\n    ]\n  }\n\n  /**\n   * getAmountIn is the linear algebra of reserve ratio against amountIn:amountOut.\n   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000\n   * has the math deduction for the reserve calculation without fee-on-transfer fees.\n   *\n   * With fee-on-transfer fees, intuitively it's just:\n   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)\n   * inputAmountWithTax = amountIn / (1 - amountIn.sellFeesBips / 10000) / 0.997\n   *\n   * But we are illustrating the math deduction below to ensure that's the case.\n   *\n   * before swap A * B = K where A = reserveIn B = reserveOut\n   *\n   * after swap A' * B' = K where only k is a constant value\n   *\n   * getAmountIn\n   *\n   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)\n   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted\n   * amountIn = (A' - A) / (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = (K / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = (AB / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = ((AB - AB + A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = ((A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = ((A * 1000 * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))\n   *            /\n   *            (997 * (1 - amountIn.sellFeesBips / 10000))\n   *\n   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)\n   * inputAmountWithTax = amountIn / (997 * (1 - amountIn.sellFeesBips / 10000))\n   *                    = (A * outputAmountWithTax * 1000) / ((B - outputAmountWithTax) * 997)\n   *\n   * @param outputAmount\n   */\n  public getInputAmount(\n    outputAmount: CurrencyAmount<Token>,\n    calculateFotFees: boolean = true\n  ): [CurrencyAmount<Token>, Pair] {\n    invariant(this.involvesToken(outputAmount.currency), 'TOKEN')\n    const percentAfterBuyFees = calculateFotFees ? this.derivePercentAfterBuyFees(outputAmount) : ZERO_PERCENT\n    const outputAmountBeforeTax = percentAfterBuyFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          outputAmount.currency,\n          JSBI.add(outputAmount.divide(percentAfterBuyFees).quotient, ONE) // add 1 for rounding up\n        )\n      : outputAmount\n\n    if (\n      JSBI.equal(this.reserve0.quotient, ZERO) ||\n      JSBI.equal(this.reserve1.quotient, ZERO) ||\n      JSBI.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient) ||\n      JSBI.greaterThanOrEqual(outputAmountBeforeTax.quotient, this.reserveOf(outputAmount.currency).quotient)\n    ) {\n      throw new InsufficientReservesError()\n    }\n\n    const outputReserve = this.reserveOf(outputAmount.currency)\n    const inputReserve = this.reserveOf(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0)\n\n    const numerator = JSBI.multiply(JSBI.multiply(inputReserve.quotient, outputAmountBeforeTax.quotient), _1000)\n    const denominator = JSBI.multiply(JSBI.subtract(outputReserve.quotient, outputAmountBeforeTax.quotient), _997)\n    const inputAmount = CurrencyAmount.fromRawAmount(\n      outputAmount.currency.equals(this.token0) ? this.token1 : this.token0,\n      JSBI.add(JSBI.divide(numerator, denominator), ONE) // add 1 here is part of the formula, no rounding needed here, since there will not be decimal at this point\n    )\n\n    const percentAfterSellFees = calculateFotFees ? this.derivePercentAfterSellFees(inputAmount) : ZERO_PERCENT\n    const inputAmountBeforeTax = percentAfterSellFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          inputAmount.currency,\n          JSBI.add(inputAmount.divide(percentAfterSellFees).quotient, ONE) // add 1 for rounding up\n        )\n      : inputAmount\n    return [inputAmountBeforeTax, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))]\n  }\n\n  public getLiquidityMinted(\n    totalSupply: CurrencyAmount<Token>,\n    tokenAmountA: CurrencyAmount<Token>,\n    tokenAmountB: CurrencyAmount<Token>\n  ): CurrencyAmount<Token> {\n    invariant(totalSupply.currency.equals(this.liquidityToken), 'LIQUIDITY')\n    const tokenAmounts = tokenAmountA.currency.sortsBefore(tokenAmountB.currency) // does safety checks\n      ? [tokenAmountA, tokenAmountB]\n      : [tokenAmountB, tokenAmountA]\n    invariant(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), 'TOKEN')\n\n    let liquidity: JSBI\n    if (JSBI.equal(totalSupply.quotient, ZERO)) {\n      liquidity = JSBI.subtract(\n        sqrt(JSBI.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)),\n        MINIMUM_LIQUIDITY\n      )\n    } else {\n      const amount0 = JSBI.divide(JSBI.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient)\n      const amount1 = JSBI.divide(JSBI.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient)\n      liquidity = JSBI.lessThanOrEqual(amount0, amount1) ? amount0 : amount1\n    }\n    if (!JSBI.greaterThan(liquidity, ZERO)) {\n      throw new InsufficientInputAmountError()\n    }\n    return CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity)\n  }\n\n  public getLiquidityValue(\n    token: Token,\n    totalSupply: CurrencyAmount<Token>,\n    liquidity: CurrencyAmount<Token>,\n    feeOn: boolean = false,\n    kLast?: BigintIsh\n  ): CurrencyAmount<Token> {\n    invariant(this.involvesToken(token), 'TOKEN')\n    invariant(totalSupply.currency.equals(this.liquidityToken), 'TOTAL_SUPPLY')\n    invariant(liquidity.currency.equals(this.liquidityToken), 'LIQUIDITY')\n    invariant(JSBI.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), 'LIQUIDITY')\n\n    let totalSupplyAdjusted: CurrencyAmount<Token>\n    if (!feeOn) {\n      totalSupplyAdjusted = totalSupply\n    } else {\n      invariant(!!kLast, 'K_LAST')\n      const kLastParsed = JSBI.BigInt(kLast)\n      if (!JSBI.equal(kLastParsed, ZERO)) {\n        const rootK = sqrt(JSBI.multiply(this.reserve0.quotient, this.reserve1.quotient))\n        const rootKLast = sqrt(kLastParsed)\n        if (JSBI.greaterThan(rootK, rootKLast)) {\n          const numerator = JSBI.multiply(totalSupply.quotient, JSBI.subtract(rootK, rootKLast))\n          const denominator = JSBI.add(JSBI.multiply(rootK, FIVE), rootKLast)\n          const feeLiquidity = JSBI.divide(numerator, denominator)\n          totalSupplyAdjusted = totalSupply.add(CurrencyAmount.fromRawAmount(this.liquidityToken, feeLiquidity))\n        } else {\n          totalSupplyAdjusted = totalSupply\n        }\n      } else {\n        totalSupplyAdjusted = totalSupply\n      }\n    }\n\n    return CurrencyAmount.fromRawAmount(\n      token,\n      JSBI.divide(JSBI.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)\n    )\n  }\n\n  private derivePercentAfterSellFees(inputAmount: CurrencyAmount<Token>): Percent {\n    const sellFeeBips = this.token0.wrapped.equals(inputAmount.wrapped.currency)\n      ? this.token0.wrapped.sellFeeBps\n      : this.token1.wrapped.sellFeeBps\n    if (sellFeeBips?.gt(BigNumber.from(0))) {\n      return ONE_HUNDRED_PERCENT.subtract(new Percent(JSBI.BigInt(sellFeeBips)).divide(BASIS_POINTS))\n    } else {\n      return ZERO_PERCENT\n    }\n  }\n\n  private derivePercentAfterBuyFees(outputAmount: CurrencyAmount<Token>): Percent {\n    const buyFeeBps = this.token0.wrapped.equals(outputAmount.wrapped.currency)\n      ? this.token0.wrapped.buyFeeBps\n      : this.token1.wrapped.buyFeeBps\n    if (buyFeeBps?.gt(BigNumber.from(0))) {\n      return ONE_HUNDRED_PERCENT.subtract(new Percent(JSBI.BigInt(buyFeeBps)).divide(BASIS_POINTS))\n    } else {\n      return ZERO_PERCENT\n    }\n  }\n}\n","import invariant from 'tiny-invariant'\nimport { Currency, Price, Token } from '@uniswap/sdk-core'\n\nimport { Pair } from './pair'\n\nexport class Route<TInput extends Currency, TOutput extends Currency> {\n  public readonly pairs: Pair[]\n  public readonly path: Token[]\n  public readonly input: TInput\n  public readonly output: TOutput\n\n  public constructor(pairs: Pair[], input: TInput, output: TOutput) {\n    invariant(pairs.length > 0, 'PAIRS')\n    const chainId: number = pairs[0].chainId\n    invariant(\n      pairs.every(pair => pair.chainId === chainId),\n      'CHAIN_IDS'\n    )\n\n    const wrappedInput = input.wrapped\n    invariant(pairs[0].involvesToken(wrappedInput), 'INPUT')\n    invariant(typeof output === 'undefined' || pairs[pairs.length - 1].involvesToken(output.wrapped), 'OUTPUT')\n\n    const path: Token[] = [wrappedInput]\n    for (const [i, pair] of pairs.entries()) {\n      const currentInput = path[i]\n      invariant(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), 'PATH')\n      const output = currentInput.equals(pair.token0) ? pair.token1 : pair.token0\n      path.push(output)\n    }\n\n    this.pairs = pairs\n    this.path = path\n    this.input = input\n    this.output = output\n  }\n\n  private _midPrice: Price<TInput, TOutput> | null = null\n\n  public get midPrice(): Price<TInput, TOutput> {\n    if (this._midPrice !== null) return this._midPrice\n    const prices: Price<Currency, Currency>[] = []\n    for (const [i, pair] of this.pairs.entries()) {\n      prices.push(\n        this.path[i].equals(pair.token0)\n          ? new Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient)\n          : new Price(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient)\n      )\n    }\n    const reduced = prices.slice(1).reduce((accumulator, currentValue) => accumulator.multiply(currentValue), prices[0])\n    return (this._midPrice = new Price(this.input, this.output, reduced.denominator, reduced.numerator))\n  }\n\n  public get chainId(): number {\n    return this.pairs[0].chainId\n  }\n}\n","import {\n  computePriceImpact,\n  Token,\n  Currency,\n  CurrencyAmount,\n  Fraction,\n  Percent,\n  Price,\n  sortedInsert,\n  TradeType\n} from '@uniswap/sdk-core'\nimport { ONE, ZERO } from '../constants'\nimport invariant from 'tiny-invariant'\n\nimport { Pair } from './pair'\nimport { Route } from './route'\n\n// minimal interface so the input output comparator may be shared across types\ninterface InputOutput<TInput extends Currency, TOutput extends Currency> {\n  readonly inputAmount: CurrencyAmount<TInput>\n  readonly outputAmount: CurrencyAmount<TOutput>\n}\n\n// comparator function that allows sorting trades by their output amounts, in decreasing order, and then input amounts\n// in increasing order. i.e. the best trades have the most outputs for the least inputs and are sorted first\nexport function inputOutputComparator<TInput extends Currency, TOutput extends Currency>(\n  a: InputOutput<TInput, TOutput>,\n  b: InputOutput<TInput, TOutput>\n): number {\n  // must have same input and output token for comparison\n  invariant(a.inputAmount.currency.equals(b.inputAmount.currency), 'INPUT_CURRENCY')\n  invariant(a.outputAmount.currency.equals(b.outputAmount.currency), 'OUTPUT_CURRENCY')\n  if (a.outputAmount.equalTo(b.outputAmount)) {\n    if (a.inputAmount.equalTo(b.inputAmount)) {\n      return 0\n    }\n    // trade A requires less input than trade B, so A should come first\n    if (a.inputAmount.lessThan(b.inputAmount)) {\n      return -1\n    } else {\n      return 1\n    }\n  } else {\n    // tradeA has less output than trade B, so should come second\n    if (a.outputAmount.lessThan(b.outputAmount)) {\n      return 1\n    } else {\n      return -1\n    }\n  }\n}\n\n// extension of the input output comparator that also considers other dimensions of the trade in ranking them\nexport function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(\n  a: Trade<TInput, TOutput, TTradeType>,\n  b: Trade<TInput, TOutput, TTradeType>\n) {\n  const ioComp = inputOutputComparator(a, b)\n  if (ioComp !== 0) {\n    return ioComp\n  }\n\n  // consider lowest slippage next, since these are less likely to fail\n  if (a.priceImpact.lessThan(b.priceImpact)) {\n    return -1\n  } else if (a.priceImpact.greaterThan(b.priceImpact)) {\n    return 1\n  }\n\n  // finally consider the number of hops since each hop costs gas\n  return a.route.path.length - b.route.path.length\n}\n\nexport interface BestTradeOptions {\n  // how many results to return\n  maxNumResults?: number\n  // the maximum number of hops a trade should contain\n  maxHops?: number\n}\n\n/**\n * Represents a trade executed against a list of pairs.\n * Does not account for slippage, i.e. trades that front run this trade and move the price.\n */\nexport class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {\n  /**\n   * The route of the trade, i.e. which pairs the trade goes through and the input/output currencies.\n   */\n  public readonly route: Route<TInput, TOutput>\n  /**\n   * The type of the trade, either exact in or exact out.\n   */\n  public readonly tradeType: TTradeType\n  /**\n   * The input amount for the trade assuming no slippage.\n   */\n  public readonly inputAmount: CurrencyAmount<TInput>\n  /**\n   * The output amount for the trade assuming no slippage.\n   */\n  public readonly outputAmount: CurrencyAmount<TOutput>\n  /**\n   * The price expressed in terms of output amount/input amount.\n   */\n  public readonly executionPrice: Price<TInput, TOutput>\n  /**\n   * The percent difference between the mid price before the trade and the trade execution price.\n   */\n  public readonly priceImpact: Percent\n\n  /**\n   * Constructs an exact in trade with the given amount in and route\n   * @param route route of the exact in trade\n   * @param amountIn the amount being passed in\n   */\n  public static exactIn<TInput extends Currency, TOutput extends Currency>(\n    route: Route<TInput, TOutput>,\n    amountIn: CurrencyAmount<TInput>\n  ): Trade<TInput, TOutput, TradeType.EXACT_INPUT> {\n    return new Trade(route, amountIn, TradeType.EXACT_INPUT)\n  }\n\n  /**\n   * Constructs an exact out trade with the given amount out and route\n   * @param route route of the exact out trade\n   * @param amountOut the amount returned by the trade\n   */\n  public static exactOut<TInput extends Currency, TOutput extends Currency>(\n    route: Route<TInput, TOutput>,\n    amountOut: CurrencyAmount<TOutput>\n  ): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT> {\n    return new Trade(route, amountOut, TradeType.EXACT_OUTPUT)\n  }\n\n  public constructor(\n    route: Route<TInput, TOutput>,\n    amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>,\n    tradeType: TTradeType\n  ) {\n    this.route = route\n    this.tradeType = tradeType\n\n    const tokenAmounts: CurrencyAmount<Token>[] = new Array(route.path.length)\n    if (tradeType === TradeType.EXACT_INPUT) {\n      invariant(amount.currency.equals(route.input), 'INPUT')\n      tokenAmounts[0] = amount.wrapped\n      for (let i = 0; i < route.path.length - 1; i++) {\n        const pair = route.pairs[i]\n        const [outputAmount] = pair.getOutputAmount(tokenAmounts[i])\n        tokenAmounts[i + 1] = outputAmount\n      }\n      this.inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator)\n      this.outputAmount = CurrencyAmount.fromFractionalAmount(\n        route.output,\n        tokenAmounts[tokenAmounts.length - 1].numerator,\n        tokenAmounts[tokenAmounts.length - 1].denominator\n      )\n    } else {\n      invariant(amount.currency.equals(route.output), 'OUTPUT')\n      tokenAmounts[tokenAmounts.length - 1] = amount.wrapped\n      for (let i = route.path.length - 1; i > 0; i--) {\n        const pair = route.pairs[i - 1]\n        const [inputAmount] = pair.getInputAmount(tokenAmounts[i])\n        tokenAmounts[i - 1] = inputAmount\n      }\n      this.inputAmount = CurrencyAmount.fromFractionalAmount(\n        route.input,\n        tokenAmounts[0].numerator,\n        tokenAmounts[0].denominator\n      )\n      this.outputAmount = CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator)\n    }\n    this.executionPrice = new Price(\n      this.inputAmount.currency,\n      this.outputAmount.currency,\n      this.inputAmount.quotient,\n      this.outputAmount.quotient\n    )\n    this.priceImpact = computePriceImpact(route.midPrice, this.inputAmount, this.outputAmount)\n  }\n\n  /**\n   * Get the minimum amount that must be received from this trade for the given slippage tolerance\n   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade\n   */\n  public minimumAmountOut(slippageTolerance: Percent): CurrencyAmount<TOutput> {\n    invariant(!slippageTolerance.lessThan(ZERO), 'SLIPPAGE_TOLERANCE')\n    if (this.tradeType === TradeType.EXACT_OUTPUT) {\n      return this.outputAmount\n    } else {\n      const slippageAdjustedAmountOut = new Fraction(ONE)\n        .add(slippageTolerance)\n        .invert()\n        .multiply(this.outputAmount.quotient).quotient\n      return CurrencyAmount.fromRawAmount(this.outputAmount.currency, slippageAdjustedAmountOut)\n    }\n  }\n\n  /**\n   * Get the maximum amount in that can be spent via this trade for the given slippage tolerance\n   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade\n   */\n  public maximumAmountIn(slippageTolerance: Percent): CurrencyAmount<TInput> {\n    invariant(!slippageTolerance.lessThan(ZERO), 'SLIPPAGE_TOLERANCE')\n    if (this.tradeType === TradeType.EXACT_INPUT) {\n      return this.inputAmount\n    } else {\n      const slippageAdjustedAmountIn = new Fraction(ONE).add(slippageTolerance).multiply(this.inputAmount.quotient)\n        .quotient\n      return CurrencyAmount.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn)\n    }\n  }\n\n  /**\n   * Given a list of pairs, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token\n   * amount to an output token, making at most `maxHops` hops.\n   * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting\n   * the amount in among multiple routes.\n   * @param pairs the pairs to consider in finding the best trade\n   * @param nextAmountIn exact amount of input currency to spend\n   * @param currencyOut the desired currency out\n   * @param maxNumResults maximum number of results to return\n   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair\n   * @param currentPairs used in recursion; the current list of pairs\n   * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter\n   * @param bestTrades used in recursion; the current list of best trades\n   */\n  public static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(\n    pairs: Pair[],\n    currencyAmountIn: CurrencyAmount<TInput>,\n    currencyOut: TOutput,\n    { maxNumResults = 3, maxHops = 3 }: BestTradeOptions = {},\n    // used in recursion.\n    currentPairs: Pair[] = [],\n    nextAmountIn: CurrencyAmount<Currency> = currencyAmountIn,\n    bestTrades: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[] = []\n  ): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[] {\n    invariant(pairs.length > 0, 'PAIRS')\n    invariant(maxHops > 0, 'MAX_HOPS')\n    invariant(currencyAmountIn === nextAmountIn || currentPairs.length > 0, 'INVALID_RECURSION')\n\n    const amountIn = nextAmountIn.wrapped\n    const tokenOut = currencyOut.wrapped\n    for (let i = 0; i < pairs.length; i++) {\n      const pair = pairs[i]\n      // pair irrelevant\n      if (!pair.token0.equals(amountIn.currency) && !pair.token1.equals(amountIn.currency)) continue\n      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO)) continue\n\n      let amountOut: CurrencyAmount<Token>\n      try {\n        ;[amountOut] = pair.getOutputAmount(amountIn)\n      } catch (error) {\n        // input too low\n        if (error.isInsufficientInputAmountError) {\n          continue\n        }\n        throw error\n      }\n      // we have arrived at the output token, so this is the final trade of one of the paths\n      if (amountOut.currency.equals(tokenOut)) {\n        sortedInsert(\n          bestTrades,\n          new Trade(\n            new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut),\n            currencyAmountIn,\n            TradeType.EXACT_INPUT\n          ),\n          maxNumResults,\n          tradeComparator\n        )\n      } else if (maxHops > 1 && pairs.length > 1) {\n        const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length))\n\n        // otherwise, consider all the other paths that lead from this token as long as we have not exceeded maxHops\n        Trade.bestTradeExactIn(\n          pairsExcludingThisPair,\n          currencyAmountIn,\n          currencyOut,\n          {\n            maxNumResults,\n            maxHops: maxHops - 1\n          },\n          [...currentPairs, pair],\n          amountOut,\n          bestTrades\n        )\n      }\n    }\n\n    return bestTrades\n  }\n\n  /**\n   * Return the execution price after accounting for slippage tolerance\n   * @param slippageTolerance the allowed tolerated slippage\n   */\n  public worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput> {\n    return new Price(\n      this.inputAmount.currency,\n      this.outputAmount.currency,\n      this.maximumAmountIn(slippageTolerance).quotient,\n      this.minimumAmountOut(slippageTolerance).quotient\n    )\n  }\n\n  /**\n   * similar to the above method but instead targets a fixed output amount\n   * given a list of pairs, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token\n   * to an output token amount, making at most `maxHops` hops\n   * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting\n   * the amount in among multiple routes.\n   * @param pairs the pairs to consider in finding the best trade\n   * @param currencyIn the currency to spend\n   * @param nextAmountOut the exact amount of currency out\n   * @param maxNumResults maximum number of results to return\n   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair\n   * @param currentPairs used in recursion; the current list of pairs\n   * @param currencyAmountOut used in recursion; the original value of the currencyAmountOut parameter\n   * @param bestTrades used in recursion; the current list of best trades\n   */\n  public static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(\n    pairs: Pair[],\n    currencyIn: TInput,\n    currencyAmountOut: CurrencyAmount<TOutput>,\n    { maxNumResults = 3, maxHops = 3 }: BestTradeOptions = {},\n    // used in recursion.\n    currentPairs: Pair[] = [],\n    nextAmountOut: CurrencyAmount<Currency> = currencyAmountOut,\n    bestTrades: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[] = []\n  ): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[] {\n    invariant(pairs.length > 0, 'PAIRS')\n    invariant(maxHops > 0, 'MAX_HOPS')\n    invariant(currencyAmountOut === nextAmountOut || currentPairs.length > 0, 'INVALID_RECURSION')\n\n    const amountOut = nextAmountOut.wrapped\n    const tokenIn = currencyIn.wrapped\n    for (let i = 0; i < pairs.length; i++) {\n      const pair = pairs[i]\n      // pair irrelevant\n      if (!pair.token0.equals(amountOut.currency) && !pair.token1.equals(amountOut.currency)) continue\n      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO)) continue\n\n      let amountIn: CurrencyAmount<Token>\n      try {\n        ;[amountIn] = pair.getInputAmount(amountOut)\n      } catch (error) {\n        // not enough liquidity in this pair\n        if (error.isInsufficientReservesError) {\n          continue\n        }\n        throw error\n      }\n      // we have arrived at the input token, so this is the first trade of one of the paths\n      if (amountIn.currency.equals(tokenIn)) {\n        sortedInsert(\n          bestTrades,\n          new Trade(\n            new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency),\n            currencyAmountOut,\n            TradeType.EXACT_OUTPUT\n          ),\n          maxNumResults,\n          tradeComparator\n        )\n      } else if (maxHops > 1 && pairs.length > 1) {\n        const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length))\n\n        // otherwise, consider all the other paths that arrive at this token as long as we have not exceeded maxHops\n        Trade.bestTradeExactOut(\n          pairsExcludingThisPair,\n          currencyIn,\n          currencyAmountOut,\n          {\n            maxNumResults,\n            maxHops: maxHops - 1\n          },\n          [pair, ...currentPairs],\n          amountIn,\n          bestTrades\n        )\n      }\n    }\n\n    return bestTrades\n  }\n}\n","import { Token, Currency, CurrencyAmount, Percent, TradeType, validateAndParseAddress } from '@uniswap/sdk-core'\nimport { Trade } from './entities'\nimport invariant from 'tiny-invariant'\n\n/**\n * Options for producing the arguments to send call to the router.\n */\nexport interface TradeOptions {\n  /**\n   * How much the execution price is allowed to move unfavorably from the trade execution price.\n   */\n  allowedSlippage: Percent\n  /**\n   * How long the swap is valid until it expires, in seconds.\n   * This will be used to produce a `deadline` parameter which is computed from when the swap call parameters\n   * are generated.\n   */\n  ttl: number\n  /**\n   * The account that should receive the output of the swap.\n   */\n  recipient: string\n\n  /**\n   * Whether any of the tokens in the path are fee on transfer tokens, which should be handled with special methods\n   */\n  feeOnTransfer?: boolean\n}\n\nexport interface TradeOptionsDeadline extends Omit<TradeOptions, 'ttl'> {\n  /**\n   * When the transaction expires.\n   * This is an atlernate to specifying the ttl, for when you do not want to use local time.\n   */\n  deadline: number\n}\n\n/**\n * The parameters to use in the call to the Uniswap V2 Router to execute a trade.\n */\nexport interface SwapParameters {\n  /**\n   * The method to call on the Uniswap V2 Router.\n   */\n  methodName: string\n  /**\n   * The arguments to pass to the method, all hex encoded.\n   */\n  args: (string | string[])[]\n  /**\n   * The amount of wei to send in hex.\n   */\n  value: string\n}\n\nfunction toHex(currencyAmount: CurrencyAmount<Currency>) {\n  return `0x${currencyAmount.quotient.toString(16)}`\n}\n\nconst ZERO_HEX = '0x0'\n\n/**\n * Represents the Uniswap V2 Router, and has static methods for helping execute trades.\n */\nexport abstract class Router {\n  /**\n   * Cannot be constructed.\n   */\n  private constructor() {}\n  /**\n   * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.\n   * @param trade to produce call parameters for\n   * @param options options for the call parameters\n   */\n  public static swapCallParameters(\n    trade: Trade<Currency, Currency, TradeType>,\n    options: TradeOptions | TradeOptionsDeadline\n  ): SwapParameters {\n    const etherIn = trade.inputAmount.currency.isNative\n    const etherOut = trade.outputAmount.currency.isNative\n    // the router does not support both ether in and out\n    invariant(!(etherIn && etherOut), 'ETHER_IN_OUT')\n    invariant(!('ttl' in options) || options.ttl > 0, 'TTL')\n\n    const to: string = validateAndParseAddress(options.recipient)\n    const amountIn: string = toHex(trade.maximumAmountIn(options.allowedSlippage))\n    const amountOut: string = toHex(trade.minimumAmountOut(options.allowedSlippage))\n    const path: string[] = trade.route.path.map((token: Token) => token.address)\n    const deadline =\n      'ttl' in options\n        ? `0x${(Math.floor(new Date().getTime() / 1000) + options.ttl).toString(16)}`\n        : `0x${options.deadline.toString(16)}`\n\n    const useFeeOnTransfer = Boolean(options.feeOnTransfer)\n\n    let methodName: string\n    let args: (string | string[])[]\n    let value: string\n    switch (trade.tradeType) {\n      case TradeType.EXACT_INPUT:\n        if (etherIn) {\n          methodName = useFeeOnTransfer ? 'swapExactETHForTokensSupportingFeeOnTransferTokens' : 'swapExactETHForTokens'\n          // (uint amountOutMin, address[] calldata path, address to, uint deadline)\n          args = [amountOut, path, to, deadline]\n          value = amountIn\n        } else if (etherOut) {\n          methodName = useFeeOnTransfer ? 'swapExactTokensForETHSupportingFeeOnTransferTokens' : 'swapExactTokensForETH'\n          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n          args = [amountIn, amountOut, path, to, deadline]\n          value = ZERO_HEX\n        } else {\n          methodName = useFeeOnTransfer\n            ? 'swapExactTokensForTokensSupportingFeeOnTransferTokens'\n            : 'swapExactTokensForTokens'\n          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n          args = [amountIn, amountOut, path, to, deadline]\n          value = ZERO_HEX\n        }\n        break\n      case TradeType.EXACT_OUTPUT:\n        invariant(!useFeeOnTransfer, 'EXACT_OUT_FOT')\n        if (etherIn) {\n          methodName = 'swapETHForExactTokens'\n          // (uint amountOut, address[] calldata path, address to, uint deadline)\n          args = [amountOut, path, to, deadline]\n          value = amountIn\n        } else if (etherOut) {\n          methodName = 'swapTokensForExactETH'\n          // (uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n          args = [amountOut, amountIn, path, to, deadline]\n          value = ZERO_HEX\n        } else {\n          methodName = 'swapTokensForExactTokens'\n          // (uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n          args = [amountOut, amountIn, path, to, deadline]\n          value = ZERO_HEX\n        }\n        break\n    }\n    return {\n      methodName,\n      args,\n      value\n    }\n  }\n}\n"],"names":["FACTORY_ADDRESS","FACTORY_ADDRESS_MAP","V2_FACTORY_ADDRESSES","INIT_CODE_HASH","MINIMUM_LIQUIDITY","JSBI","BigInt","ZERO","ONE","FIVE","_997","_1000","BASIS_POINTS","ZERO_PERCENT","Percent","ONE_HUNDRED_PERCENT","CAN_SET_PROTOTYPE","Object","InsufficientReservesError","name","constructor","setPrototypeOf","prototype","Error","InsufficientInputAmountError","computePairAddress","factoryAddress","tokenA","tokenB","sortsBefore","token0","token1","getCreate2Address","keccak256","pack","address","Pair","currencyAmountA","tokenAmountB","tokenAmounts","currency","liquidityToken","Token","chainId","getAddress","involvesToken","token","equals","priceOf","invariant","token0Price","token1Price","reserveOf","reserve0","reserve1","getOutputAmount","inputAmount","calculateFotFees","equal","quotient","inputReserve","outputReserve","percentAfterSellFees","derivePercentAfterSellFees","inputAmountAfterTax","greaterThan","CurrencyAmount","fromRawAmount","multiply","inputAmountWithFeeAndAfterTax","numerator","denominator","add","outputAmount","divide","percentAfterBuyFees","derivePercentAfterBuyFees","outputAmountAfterTax","subtract","getInputAmount","outputAmountBeforeTax","greaterThanOrEqual","inputAmountBeforeTax","getLiquidityMinted","totalSupply","tokenAmountA","liquidity","sqrt","amount0","amount1","lessThanOrEqual","getLiquidityValue","feeOn","kLast","totalSupplyAdjusted","kLastParsed","rootK","rootKLast","feeLiquidity","sellFeeBips","wrapped","sellFeeBps","gt","BigNumber","from","buyFeeBps","result","Price","Route","pairs","input","output","length","every","pair","wrappedInput","path","entries","i","currentInput","push","_midPrice","prices","reduced","slice","reduce","accumulator","currentValue","inputOutputComparator","a","b","equalTo","lessThan","tradeComparator","ioComp","priceImpact","route","Trade","amount","tradeType","Array","TradeType","EXACT_INPUT","fromFractionalAmount","executionPrice","computePriceImpact","midPrice","exactIn","amountIn","exactOut","amountOut","EXACT_OUTPUT","minimumAmountOut","slippageTolerance","slippageAdjustedAmountOut","Fraction","invert","maximumAmountIn","slippageAdjustedAmountIn","bestTradeExactIn","currencyAmountIn","currencyOut","currentPairs","nextAmountIn","bestTrades","maxNumResults","maxHops","tokenOut","error","isInsufficientInputAmountError","sortedInsert","pairsExcludingThisPair","concat","worstExecutionPrice","bestTradeExactOut","currencyIn","currencyAmountOut","nextAmountOut","tokenIn","isInsufficientReservesError","toHex","currencyAmount","toString","ZERO_HEX","Router","swapCallParameters","trade","options","etherIn","isNative","etherOut","ttl","to","validateAndParseAddress","recipient","allowedSlippage","map","deadline","Math","floor","Date","getTime","useFeeOnTransfer","Boolean","feeOnTransfer","methodName","args","value"],"mappings":"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"}

package/dist/novaswap-v2-sdk.cjs.production.min.js

@@ -0,0 +1,2 @@
+"use strict";function t(t){return t&&"object"==typeof t&&"default"in t?t.default:t}Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@uniswap/sdk-core"),r=require("novaswap-core-sdk"),n=t(require("jsbi")),u=require("@ethersproject/address"),o=require("@ethersproject/bignumber"),i=require("@ethersproject/solidity"),s=t(require("tiny-invariant")),a=r.V2_FACTORY_ADDRESSES,c="0x0ef7ca4700ff7e705236379af2cdac62d4fa0bbd010fb163697b63379941118e",p=n.BigInt(1e3),l=n.BigInt(0),m=n.BigInt(1),f=n.BigInt(5),h=n.BigInt(997),d=n.BigInt(1e3),y=n.BigInt(1e4),v=new e.Percent(l),A=new e.Percent(m);function T(t,e){for(var r=0;r<e.length;r++){var n=e[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,n.key,n)}}function q(t,e,r){return e&&T(t.prototype,e),r&&T(t,r),t}function k(t,e){t.prototype=Object.create(e.prototype),t.prototype.constructor=t,t.__proto__=e}function w(t){return(w=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}function g(t,e){return(g=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function b(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],(function(){}))),!0}catch(t){return!1}}function I(t,e,r){return(I=b()?Reflect.construct:function(t,e,r){var n=[null];n.push.apply(n,e);var u=new(Function.bind.apply(t,n));return r&&g(u,r.prototype),u}).apply(null,arguments)}function O(t){var e="function"==typeof Map?new Map:void 0;return(O=function(t){if(null===t||-1===Function.toString.call(t).indexOf("[native code]"))return t;if("function"!=typeof t)throw new TypeError("Super expression must either be null or a function");if(void 0!==e){if(e.has(t))return e.get(t);e.set(t,r)}function r(){return I(t,arguments,w(this).constructor)}return r.prototype=Object.create(t.prototype,{constructor:{value:r,enumerable:!1,writable:!0,configurable:!0}}),g(r,t)})(t)}function x(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}function P(t,e){(null==e||e>t.length)&&(e=t.length);for(var r=0,n=new Array(e);r<e;r++)n[r]=t[r];return n}function E(t,e){var r;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(r=function(t,e){if(t){if("string"==typeof t)return P(t,void 0);var r=Object.prototype.toString.call(t).slice(8,-1);return"Object"===r&&t.constructor&&(r=t.constructor.name),"Map"===r||"Set"===r?Array.from(t):"Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?P(t,void 0):void 0}}(t))||e&&t&&"number"==typeof t.length){r&&(t=r);var n=0;return function(){return n>=t.length?{done:!0}:{done:!1,value:t[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}return(r=t[Symbol.iterator]()).next.bind(r)}var C="setPrototypeOf"in Object,_=function(t){function e(){var r;return(r=t.call(this)||this).isInsufficientReservesError=!0,r.name=r.constructor.name,C&&Object.setPrototypeOf(x(r),(this instanceof e?this.constructor:void 0).prototype),r}return k(e,t),e}(O(Error)),F=function(t){function e(){var r;return(r=t.call(this)||this).isInsufficientInputAmountError=!0,r.name=r.constructor.name,C&&Object.setPrototypeOf(x(r),(this instanceof e?this.constructor:void 0).prototype),r}return k(e,t),e}(O(Error)),R=function(t){var e=t.factoryAddress,r=t.tokenA,n=t.tokenB,o=r.sortsBefore(n)?[r,n]:[n,r];return u.getCreate2Address(e,i.keccak256(["bytes"],[i.pack(["address","address"],[o[0].address,o[1].address])]),c)},B=function(){function t(r,n){var u=r.currency.sortsBefore(n.currency)?[r,n]:[n,r];this.liquidityToken=new e.Token(u[0].currency.chainId,t.getAddress(u[0].currency,u[1].currency),18,"UNI-V2","Uniswap V2"),this.tokenAmounts=u}t.getAddress=function(t,e){var r,n=null!=(r=a[t.chainId])?r:"0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f";return R({factoryAddress:n,tokenA:t,tokenB:e})};var r=t.prototype;return r.involvesToken=function(t){return t.equals(this.token0)||t.equals(this.token1)},r.priceOf=function(t){return this.involvesToken(t)||s(!1),t.equals(this.token0)?this.token0Price:this.token1Price},r.reserveOf=function(t){return this.involvesToken(t)||s(!1),t.equals(this.token0)?this.reserve0:this.reserve1},r.getOutputAmount=function(r,u){if(void 0===u&&(u=!0),this.involvesToken(r.currency)||s(!1),n.equal(this.reserve0.quotient,l)||n.equal(this.reserve1.quotient,l))throw new _;var o=this.reserveOf(r.currency),i=this.reserveOf(r.currency.equals(this.token0)?this.token1:this.token0),a=u?this.derivePercentAfterSellFees(r):v,c=a.greaterThan(v)?e.CurrencyAmount.fromRawAmount(r.currency,a.multiply(r).quotient):r,p=n.multiply(c.quotient,h),m=n.multiply(p,i.quotient),f=n.add(n.multiply(o.quotient,d),p),y=e.CurrencyAmount.fromRawAmount(r.currency.equals(this.token0)?this.token1:this.token0,n.divide(m,f));if(n.equal(y.quotient,l))throw new F;var A=u?this.derivePercentAfterBuyFees(y):v,T=A.greaterThan(v)?e.CurrencyAmount.fromRawAmount(y.currency,y.multiply(A).quotient):y;if(n.equal(T.quotient,l))throw new F;return[T,new t(o.add(c),i.subtract(T))]},r.getInputAmount=function(r,u){void 0===u&&(u=!0),this.involvesToken(r.currency)||s(!1);var o=u?this.derivePercentAfterBuyFees(r):v,i=o.greaterThan(v)?e.CurrencyAmount.fromRawAmount(r.currency,n.add(r.divide(o).quotient,m)):r;if(n.equal(this.reserve0.quotient,l)||n.equal(this.reserve1.quotient,l)||n.greaterThanOrEqual(r.quotient,this.reserveOf(r.currency).quotient)||n.greaterThanOrEqual(i.quotient,this.reserveOf(r.currency).quotient))throw new _;var a=this.reserveOf(r.currency),c=this.reserveOf(r.currency.equals(this.token0)?this.token1:this.token0),p=n.multiply(n.multiply(c.quotient,i.quotient),d),f=n.multiply(n.subtract(a.quotient,i.quotient),h),y=e.CurrencyAmount.fromRawAmount(r.currency.equals(this.token0)?this.token1:this.token0,n.add(n.divide(p,f),m)),A=u?this.derivePercentAfterSellFees(y):v;return[A.greaterThan(v)?e.CurrencyAmount.fromRawAmount(y.currency,n.add(y.divide(A).quotient,m)):y,new t(c.add(y),a.subtract(r))]},r.getLiquidityMinted=function(t,r,u){t.currency.equals(this.liquidityToken)||s(!1);var o,i=r.currency.sortsBefore(u.currency)?[r,u]:[u,r];if(i[0].currency.equals(this.token0)&&i[1].currency.equals(this.token1)||s(!1),n.equal(t.quotient,l))o=n.subtract(e.sqrt(n.multiply(i[0].quotient,i[1].quotient)),p);else{var a=n.divide(n.multiply(i[0].quotient,t.quotient),this.reserve0.quotient),c=n.divide(n.multiply(i[1].quotient,t.quotient),this.reserve1.quotient);o=n.lessThanOrEqual(a,c)?a:c}if(!n.greaterThan(o,l))throw new F;return e.CurrencyAmount.fromRawAmount(this.liquidityToken,o)},r.getLiquidityValue=function(t,r,u,o,i){var a;if(void 0===o&&(o=!1),this.involvesToken(t)||s(!1),r.currency.equals(this.liquidityToken)||s(!1),u.currency.equals(this.liquidityToken)||s(!1),n.lessThanOrEqual(u.quotient,r.quotient)||s(!1),o){i||s(!1);var c=n.BigInt(i);if(n.equal(c,l))a=r;else{var p=e.sqrt(n.multiply(this.reserve0.quotient,this.reserve1.quotient)),m=e.sqrt(c);if(n.greaterThan(p,m)){var h=n.multiply(r.quotient,n.subtract(p,m)),d=n.add(n.multiply(p,f),m),y=n.divide(h,d);a=r.add(e.CurrencyAmount.fromRawAmount(this.liquidityToken,y))}else a=r}}else a=r;return e.CurrencyAmount.fromRawAmount(t,n.divide(n.multiply(u.quotient,this.reserveOf(t).quotient),a.quotient))},r.derivePercentAfterSellFees=function(t){var r=this.token0.wrapped.equals(t.wrapped.currency)?this.token0.wrapped.sellFeeBps:this.token1.wrapped.sellFeeBps;return null!=r&&r.gt(o.BigNumber.from(0))?A.subtract(new e.Percent(n.BigInt(r)).divide(y)):v},r.derivePercentAfterBuyFees=function(t){var r=this.token0.wrapped.equals(t.wrapped.currency)?this.token0.wrapped.buyFeeBps:this.token1.wrapped.buyFeeBps;return null!=r&&r.gt(o.BigNumber.from(0))?A.subtract(new e.Percent(n.BigInt(r)).divide(y)):v},q(t,[{key:"token0Price",get:function(){var t=this.tokenAmounts[1].divide(this.tokenAmounts[0]);return new e.Price(this.token0,this.token1,t.denominator,t.numerator)}},{key:"token1Price",get:function(){var t=this.tokenAmounts[0].divide(this.tokenAmounts[1]);return new e.Price(this.token1,this.token0,t.denominator,t.numerator)}},{key:"chainId",get:function(){return this.token0.chainId}},{key:"token0",get:function(){return this.tokenAmounts[0].currency}},{key:"token1",get:function(){return this.tokenAmounts[1].currency}},{key:"reserve0",get:function(){return this.tokenAmounts[0]}},{key:"reserve1",get:function(){return this.tokenAmounts[1]}}]),t}(),S=function(){function t(t,e,r){this._midPrice=null,t.length>0||s(!1);var n=t[0].chainId;t.every((function(t){return t.chainId===n}))||s(!1);var u=e.wrapped;t[0].involvesToken(u)||s(!1),void 0===r||t[t.length-1].involvesToken(r.wrapped)||s(!1);for(var o,i=[u],a=E(t.entries());!(o=a()).done;){var c=o.value,p=c[1],l=i[c[0]];l.equals(p.token0)||l.equals(p.token1)||s(!1);var m=l.equals(p.token0)?p.token1:p.token0;i.push(m)}this.pairs=t,this.path=i,this.input=e,this.output=r}return q(t,[{key:"midPrice",get:function(){if(null!==this._midPrice)return this._midPrice;for(var t,r=[],n=E(this.pairs.entries());!(t=n()).done;){var u=t.value,o=u[1];r.push(this.path[u[0]].equals(o.token0)?new e.Price(o.reserve0.currency,o.reserve1.currency,o.reserve0.quotient,o.reserve1.quotient):new e.Price(o.reserve1.currency,o.reserve0.currency,o.reserve1.quotient,o.reserve0.quotient))}var i=r.slice(1).reduce((function(t,e){return t.multiply(e)}),r[0]);return this._midPrice=new e.Price(this.input,this.output,i.denominator,i.numerator)}},{key:"chainId",get:function(){return this.pairs[0].chainId}}]),t}();function j(t,e){return t.inputAmount.currency.equals(e.inputAmount.currency)||s(!1),t.outputAmount.currency.equals(e.outputAmount.currency)||s(!1),t.outputAmount.equalTo(e.outputAmount)?t.inputAmount.equalTo(e.inputAmount)?0:t.inputAmount.lessThan(e.inputAmount)?-1:1:t.outputAmount.lessThan(e.outputAmount)?1:-1}function U(t,e){var r=j(t,e);return 0!==r?r:t.priceImpact.lessThan(e.priceImpact)?-1:t.priceImpact.greaterThan(e.priceImpact)?1:t.route.path.length-e.route.path.length}var N=function(){function t(t,r,n){this.route=t,this.tradeType=n;var u=new Array(t.path.length);if(n===e.TradeType.EXACT_INPUT){r.currency.equals(t.input)||s(!1),u[0]=r.wrapped;for(var o=0;o<t.path.length-1;o++){var i=t.pairs[o].getOutputAmount(u[o]);u[o+1]=i[0]}this.inputAmount=e.CurrencyAmount.fromFractionalAmount(t.input,r.numerator,r.denominator),this.outputAmount=e.CurrencyAmount.fromFractionalAmount(t.output,u[u.length-1].numerator,u[u.length-1].denominator)}else{r.currency.equals(t.output)||s(!1),u[u.length-1]=r.wrapped;for(var a=t.path.length-1;a>0;a--){var c=t.pairs[a-1].getInputAmount(u[a]);u[a-1]=c[0]}this.inputAmount=e.CurrencyAmount.fromFractionalAmount(t.input,u[0].numerator,u[0].denominator),this.outputAmount=e.CurrencyAmount.fromFractionalAmount(t.output,r.numerator,r.denominator)}this.executionPrice=new e.Price(this.inputAmount.currency,this.outputAmount.currency,this.inputAmount.quotient,this.outputAmount.quotient),this.priceImpact=e.computePriceImpact(t.midPrice,this.inputAmount,this.outputAmount)}t.exactIn=function(r,n){return new t(r,n,e.TradeType.EXACT_INPUT)},t.exactOut=function(r,n){return new t(r,n,e.TradeType.EXACT_OUTPUT)};var r=t.prototype;return r.minimumAmountOut=function(t){if(t.lessThan(l)&&s(!1),this.tradeType===e.TradeType.EXACT_OUTPUT)return this.outputAmount;var r=new e.Fraction(m).add(t).invert().multiply(this.outputAmount.quotient).quotient;return e.CurrencyAmount.fromRawAmount(this.outputAmount.currency,r)},r.maximumAmountIn=function(t){if(t.lessThan(l)&&s(!1),this.tradeType===e.TradeType.EXACT_INPUT)return this.inputAmount;var r=new e.Fraction(m).add(t).multiply(this.inputAmount.quotient).quotient;return e.CurrencyAmount.fromRawAmount(this.inputAmount.currency,r)},t.bestTradeExactIn=function(r,n,u,o,i,a,c){var p=void 0===o?{}:o,m=p.maxNumResults,f=void 0===m?3:m,h=p.maxHops,d=void 0===h?3:h;void 0===i&&(i=[]),void 0===a&&(a=n),void 0===c&&(c=[]),r.length>0||s(!1),d>0||s(!1),n===a||i.length>0||s(!1);for(var y=a.wrapped,v=u.wrapped,A=0;A<r.length;A++){var T=r[A];if((T.token0.equals(y.currency)||T.token1.equals(y.currency))&&!T.reserve0.equalTo(l)&&!T.reserve1.equalTo(l)){var q=void 0;try{q=T.getOutputAmount(y)[0]}catch(t){if(t.isInsufficientInputAmountError)continue;throw t}if(q.currency.equals(v))e.sortedInsert(c,new t(new S([].concat(i,[T]),n.currency,u),n,e.TradeType.EXACT_INPUT),f,U);else if(d>1&&r.length>1){var k=r.slice(0,A).concat(r.slice(A+1,r.length));t.bestTradeExactIn(k,n,u,{maxNumResults:f,maxHops:d-1},[].concat(i,[T]),q,c)}}}return c},r.worstExecutionPrice=function(t){return new e.Price(this.inputAmount.currency,this.outputAmount.currency,this.maximumAmountIn(t).quotient,this.minimumAmountOut(t).quotient)},t.bestTradeExactOut=function(r,n,u,o,i,a,c){var p=void 0===o?{}:o,m=p.maxNumResults,f=void 0===m?3:m,h=p.maxHops,d=void 0===h?3:h;void 0===i&&(i=[]),void 0===a&&(a=u),void 0===c&&(c=[]),r.length>0||s(!1),d>0||s(!1),u===a||i.length>0||s(!1);for(var y=a.wrapped,v=n.wrapped,A=0;A<r.length;A++){var T=r[A];if((T.token0.equals(y.currency)||T.token1.equals(y.currency))&&!T.reserve0.equalTo(l)&&!T.reserve1.equalTo(l)){var q=void 0;try{q=T.getInputAmount(y)[0]}catch(t){if(t.isInsufficientReservesError)continue;throw t}if(q.currency.equals(v))e.sortedInsert(c,new t(new S([T].concat(i),n,u.currency),u,e.TradeType.EXACT_OUTPUT),f,U);else if(d>1&&r.length>1){var k=r.slice(0,A).concat(r.slice(A+1,r.length));t.bestTradeExactOut(k,n,u,{maxNumResults:f,maxHops:d-1},[T].concat(i),q,c)}}}return c},t}();function H(t){return"0x"+t.quotient.toString(16)}var D=function(){function t(){}return t.swapCallParameters=function(t,r){var n=t.inputAmount.currency.isNative,u=t.outputAmount.currency.isNative;n&&u&&s(!1),!("ttl"in r)||r.ttl>0||s(!1);var o,i,a,c=e.validateAndParseAddress(r.recipient),p=H(t.maximumAmountIn(r.allowedSlippage)),l=H(t.minimumAmountOut(r.allowedSlippage)),m=t.route.path.map((function(t){return t.address})),f="ttl"in r?"0x"+(Math.floor((new Date).getTime()/1e3)+r.ttl).toString(16):"0x"+r.deadline.toString(16),h=Boolean(r.feeOnTransfer);switch(t.tradeType){case e.TradeType.EXACT_INPUT:n?(o=h?"swapExactETHForTokensSupportingFeeOnTransferTokens":"swapExactETHForTokens",i=[l,m,c,f],a=p):u?(o=h?"swapExactTokensForETHSupportingFeeOnTransferTokens":"swapExactTokensForETH",i=[p,l,m,c,f],a="0x0"):(o=h?"swapExactTokensForTokensSupportingFeeOnTransferTokens":"swapExactTokensForTokens",i=[p,l,m,c,f],a="0x0");break;case e.TradeType.EXACT_OUTPUT:h&&s(!1),n?(o="swapETHForExactTokens",i=[l,m,c,f],a=p):u?(o="swapTokensForExactETH",i=[l,p,m,c,f],a="0x0"):(o="swapTokensForExactTokens",i=[l,p,m,c,f],a="0x0")}return{methodName:o,args:i,value:a}},t}();exports.FACTORY_ADDRESS_MAP=a,exports.INIT_CODE_HASH=c,exports.InsufficientInputAmountError=F,exports.InsufficientReservesError=_,exports.MINIMUM_LIQUIDITY=p,exports.Pair=B,exports.Route=S,exports.Router=D,exports.Trade=N,exports.computePairAddress=R,exports.inputOutputComparator=j,exports.tradeComparator=U;
+//# sourceMappingURL=novaswap-v2-sdk.cjs.production.min.js.map

package/dist/novaswap-v2-sdk.cjs.production.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"novaswap-v2-sdk.cjs.production.min.js","sources":["../src/constants.ts","../src/errors.ts","../src/entities/pair.ts","../src/entities/route.ts","../src/entities/trade.ts","../src/router.ts"],"sourcesContent":["import { Percent} from '@uniswap/sdk-core'\nimport {V2_FACTORY_ADDRESSES } from 'novaswap-core-sdk'\nimport JSBI from 'jsbi'\n\n/**\n * @deprecated use FACTORY_ADDRESS_MAP instead\n */\nexport const FACTORY_ADDRESS = '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f'\n\nexport const FACTORY_ADDRESS_MAP: { [chainId: number]: string } = V2_FACTORY_ADDRESSES\n\nexport const INIT_CODE_HASH = '0x0ef7ca4700ff7e705236379af2cdac62d4fa0bbd010fb163697b63379941118e'\n\nexport const MINIMUM_LIQUIDITY = JSBI.BigInt(1000)\n\n// exports for internal consumption\nexport const ZERO = JSBI.BigInt(0)\nexport const ONE = JSBI.BigInt(1)\nexport const FIVE = JSBI.BigInt(5)\nexport const _997 = JSBI.BigInt(997)\nexport const _1000 = JSBI.BigInt(1000)\nexport const BASIS_POINTS = JSBI.BigInt(10000)\n\nexport const ZERO_PERCENT = new Percent(ZERO)\nexport const ONE_HUNDRED_PERCENT = new Percent(ONE)\n","// see https://stackoverflow.com/a/41102306\nconst CAN_SET_PROTOTYPE = 'setPrototypeOf' in Object\n\n/**\n * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be\n * obtained by sending any amount of input.\n */\nexport class InsufficientReservesError extends Error {\n  public readonly isInsufficientReservesError: true = true\n\n  public constructor() {\n    super()\n    this.name = this.constructor.name\n    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)\n  }\n}\n\n/**\n * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less\n * than the price of a single unit of output after fees.\n */\nexport class InsufficientInputAmountError extends Error {\n  public readonly isInsufficientInputAmountError: true = true\n\n  public constructor() {\n    super()\n    this.name = this.constructor.name\n    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype)\n  }\n}\n","import { getCreate2Address } from '@ethersproject/address'\nimport { BigNumber } from '@ethersproject/bignumber'\nimport { keccak256, pack } from '@ethersproject/solidity'\nimport { BigintIsh, CurrencyAmount, Percent, Price, sqrt, Token } from '@uniswap/sdk-core'\nimport JSBI from 'jsbi'\nimport invariant from 'tiny-invariant'\n\nimport {\n  _1000,\n  _997,\n  BASIS_POINTS,\n  FACTORY_ADDRESS,\n  FACTORY_ADDRESS_MAP,\n  FIVE,\n  INIT_CODE_HASH,\n  MINIMUM_LIQUIDITY,\n  ONE,\n  ONE_HUNDRED_PERCENT,\n  ZERO,\n  ZERO_PERCENT\n} from '../constants'\nimport { InsufficientInputAmountError, InsufficientReservesError } from '../errors'\n\nexport const computePairAddress = ({\n  factoryAddress,\n  tokenA,\n  tokenB\n}: {\n  factoryAddress: string\n  tokenA: Token\n  tokenB: Token\n}): string => {\n  const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA] // does safety checks\n  return getCreate2Address(\n    factoryAddress,\n    keccak256(['bytes'], [pack(['address', 'address'], [token0.address, token1.address])]),\n    INIT_CODE_HASH\n  )\n}\nexport class Pair {\n  public readonly liquidityToken: Token\n  private readonly tokenAmounts: [CurrencyAmount<Token>, CurrencyAmount<Token>]\n\n  public static getAddress(tokenA: Token, tokenB: Token): string {\n    const factoryAddress = FACTORY_ADDRESS_MAP[tokenA.chainId] ?? FACTORY_ADDRESS\n    return computePairAddress({ factoryAddress, tokenA, tokenB })\n  }\n\n  public constructor(currencyAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>) {\n    const tokenAmounts = currencyAmountA.currency.sortsBefore(tokenAmountB.currency) // does safety checks\n      ? [currencyAmountA, tokenAmountB]\n      : [tokenAmountB, currencyAmountA]\n    this.liquidityToken = new Token(\n      tokenAmounts[0].currency.chainId,\n      Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency),\n      18,\n      'UNI-V2',\n      'Uniswap V2'\n    )\n    this.tokenAmounts = tokenAmounts as [CurrencyAmount<Token>, CurrencyAmount<Token>]\n  }\n\n  /**\n   * Returns true if the token is either token0 or token1\n   * @param token to check\n   */\n  public involvesToken(token: Token): boolean {\n    return token.equals(this.token0) || token.equals(this.token1)\n  }\n\n  /**\n   * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0\n   */\n  public get token0Price(): Price<Token, Token> {\n    const result = this.tokenAmounts[1].divide(this.tokenAmounts[0])\n    return new Price(this.token0, this.token1, result.denominator, result.numerator)\n  }\n\n  /**\n   * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1\n   */\n  public get token1Price(): Price<Token, Token> {\n    const result = this.tokenAmounts[0].divide(this.tokenAmounts[1])\n    return new Price(this.token1, this.token0, result.denominator, result.numerator)\n  }\n\n  /**\n   * Return the price of the given token in terms of the other token in the pair.\n   * @param token token to return price of\n   */\n  public priceOf(token: Token): Price<Token, Token> {\n    invariant(this.involvesToken(token), 'TOKEN')\n    return token.equals(this.token0) ? this.token0Price : this.token1Price\n  }\n\n  /**\n   * Returns the chain ID of the tokens in the pair.\n   */\n  public get chainId(): number {\n    return this.token0.chainId\n  }\n\n  public get token0(): Token {\n    return this.tokenAmounts[0].currency\n  }\n\n  public get token1(): Token {\n    return this.tokenAmounts[1].currency\n  }\n\n  public get reserve0(): CurrencyAmount<Token> {\n    return this.tokenAmounts[0]\n  }\n\n  public get reserve1(): CurrencyAmount<Token> {\n    return this.tokenAmounts[1]\n  }\n\n  public reserveOf(token: Token): CurrencyAmount<Token> {\n    invariant(this.involvesToken(token), 'TOKEN')\n    return token.equals(this.token0) ? this.reserve0 : this.reserve1\n  }\n\n  /**\n   * getAmountOut is the linear algebra of reserve ratio against amountIn:amountOut.\n   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000\n   * has the math deduction for the reserve calculation without fee-on-transfer fees.\n   *\n   * With fee-on-transfer tax, intuitively it's just:\n   * inputAmountWithFeeAndTax = 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn\n   *                          = (1 - amountIn.sellFeesBips / 10000) * amountInWithFee\n   * where amountInWithFee is the amountIn after taking out the LP fees\n   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)\n   *\n   * But we are illustrating the math deduction below to ensure that's the case.\n   *\n   * before swap A * B = K where A = reserveIn B = reserveOut\n   *\n   * after swap A' * B' = K where only k is a constant value\n   *\n   * getAmountOut\n   *\n   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted\n   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)\n   * amountOut = (B - B') / (1 - amountOut.buyFeesBips / 10000) # where A' * B' still is k\n   *           = (B - K/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   *           = (B - AB/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   *           = ((BA + B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn - AB)/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   *           = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn / (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)\n   *             /\n   *             (1 - amountOut.buyFeesBips / 10000)\n   * amountOut * (1 - amountOut.buyFeesBips / 10000) = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn\n   *                                                    /\n   *                                                    (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)\n   *\n   * outputAmountWithTax = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn\n   *                       /\n   *                       (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)\n   *                       = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn * 1000\n   *                       /\n   *                       ((A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn) * 1000)\n   *                     = (B * (1 - amountIn.sellFeesBips / 10000) 997 * * amountIn\n   *                       /\n   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * 997 * amountIn)\n   *                     = (B * (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)\n   *                       /\n   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)\n   *                     = (B * inputAmountWithFeeAndTax)\n   *                       /\n   *                       (1000 * A + inputAmountWithFeeAndTax)\n   *\n   * inputAmountWithFeeAndTax = (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee\n   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)\n   *\n   * @param inputAmount\n   * @param calculateFotFees\n   */\n  public getOutputAmount(\n    inputAmount: CurrencyAmount<Token>,\n    calculateFotFees: boolean = true\n  ): [CurrencyAmount<Token>, Pair] {\n    invariant(this.involvesToken(inputAmount.currency), 'TOKEN')\n    if (JSBI.equal(this.reserve0.quotient, ZERO) || JSBI.equal(this.reserve1.quotient, ZERO)) {\n      throw new InsufficientReservesError()\n    }\n    const inputReserve = this.reserveOf(inputAmount.currency)\n    const outputReserve = this.reserveOf(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0)\n\n    const percentAfterSellFees = calculateFotFees ? this.derivePercentAfterSellFees(inputAmount) : ZERO_PERCENT\n    const inputAmountAfterTax = percentAfterSellFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          inputAmount.currency,\n          percentAfterSellFees.multiply(inputAmount).quotient // fraction.quotient will round down by itself, which is desired\n        )\n      : inputAmount\n\n    const inputAmountWithFeeAndAfterTax = JSBI.multiply(inputAmountAfterTax.quotient, _997)\n    const numerator = JSBI.multiply(inputAmountWithFeeAndAfterTax, outputReserve.quotient)\n    const denominator = JSBI.add(JSBI.multiply(inputReserve.quotient, _1000), inputAmountWithFeeAndAfterTax)\n    const outputAmount = CurrencyAmount.fromRawAmount(\n      inputAmount.currency.equals(this.token0) ? this.token1 : this.token0,\n      JSBI.divide(numerator, denominator) // JSBI.divide will round down by itself, which is desired\n    )\n\n    if (JSBI.equal(outputAmount.quotient, ZERO)) {\n      throw new InsufficientInputAmountError()\n    }\n\n    const percentAfterBuyFees = calculateFotFees ? this.derivePercentAfterBuyFees(outputAmount) : ZERO_PERCENT\n    const outputAmountAfterTax = percentAfterBuyFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          outputAmount.currency,\n          outputAmount.multiply(percentAfterBuyFees).quotient // fraction.quotient will round down by itself, which is desired\n        )\n      : outputAmount\n    if (JSBI.equal(outputAmountAfterTax.quotient, ZERO)) {\n      throw new InsufficientInputAmountError()\n    }\n\n    return [\n      outputAmountAfterTax,\n      new Pair(inputReserve.add(inputAmountAfterTax), outputReserve.subtract(outputAmountAfterTax))\n    ]\n  }\n\n  /**\n   * getAmountIn is the linear algebra of reserve ratio against amountIn:amountOut.\n   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000\n   * has the math deduction for the reserve calculation without fee-on-transfer fees.\n   *\n   * With fee-on-transfer fees, intuitively it's just:\n   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)\n   * inputAmountWithTax = amountIn / (1 - amountIn.sellFeesBips / 10000) / 0.997\n   *\n   * But we are illustrating the math deduction below to ensure that's the case.\n   *\n   * before swap A * B = K where A = reserveIn B = reserveOut\n   *\n   * after swap A' * B' = K where only k is a constant value\n   *\n   * getAmountIn\n   *\n   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)\n   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted\n   * amountIn = (A' - A) / (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = (K / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = (AB / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = ((AB - AB + A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = ((A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))\n   *            /\n   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))\n   *          = ((A * 1000 * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))\n   *            /\n   *            (997 * (1 - amountIn.sellFeesBips / 10000))\n   *\n   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)\n   * inputAmountWithTax = amountIn / (997 * (1 - amountIn.sellFeesBips / 10000))\n   *                    = (A * outputAmountWithTax * 1000) / ((B - outputAmountWithTax) * 997)\n   *\n   * @param outputAmount\n   */\n  public getInputAmount(\n    outputAmount: CurrencyAmount<Token>,\n    calculateFotFees: boolean = true\n  ): [CurrencyAmount<Token>, Pair] {\n    invariant(this.involvesToken(outputAmount.currency), 'TOKEN')\n    const percentAfterBuyFees = calculateFotFees ? this.derivePercentAfterBuyFees(outputAmount) : ZERO_PERCENT\n    const outputAmountBeforeTax = percentAfterBuyFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          outputAmount.currency,\n          JSBI.add(outputAmount.divide(percentAfterBuyFees).quotient, ONE) // add 1 for rounding up\n        )\n      : outputAmount\n\n    if (\n      JSBI.equal(this.reserve0.quotient, ZERO) ||\n      JSBI.equal(this.reserve1.quotient, ZERO) ||\n      JSBI.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient) ||\n      JSBI.greaterThanOrEqual(outputAmountBeforeTax.quotient, this.reserveOf(outputAmount.currency).quotient)\n    ) {\n      throw new InsufficientReservesError()\n    }\n\n    const outputReserve = this.reserveOf(outputAmount.currency)\n    const inputReserve = this.reserveOf(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0)\n\n    const numerator = JSBI.multiply(JSBI.multiply(inputReserve.quotient, outputAmountBeforeTax.quotient), _1000)\n    const denominator = JSBI.multiply(JSBI.subtract(outputReserve.quotient, outputAmountBeforeTax.quotient), _997)\n    const inputAmount = CurrencyAmount.fromRawAmount(\n      outputAmount.currency.equals(this.token0) ? this.token1 : this.token0,\n      JSBI.add(JSBI.divide(numerator, denominator), ONE) // add 1 here is part of the formula, no rounding needed here, since there will not be decimal at this point\n    )\n\n    const percentAfterSellFees = calculateFotFees ? this.derivePercentAfterSellFees(inputAmount) : ZERO_PERCENT\n    const inputAmountBeforeTax = percentAfterSellFees.greaterThan(ZERO_PERCENT)\n      ? CurrencyAmount.fromRawAmount(\n          inputAmount.currency,\n          JSBI.add(inputAmount.divide(percentAfterSellFees).quotient, ONE) // add 1 for rounding up\n        )\n      : inputAmount\n    return [inputAmountBeforeTax, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))]\n  }\n\n  public getLiquidityMinted(\n    totalSupply: CurrencyAmount<Token>,\n    tokenAmountA: CurrencyAmount<Token>,\n    tokenAmountB: CurrencyAmount<Token>\n  ): CurrencyAmount<Token> {\n    invariant(totalSupply.currency.equals(this.liquidityToken), 'LIQUIDITY')\n    const tokenAmounts = tokenAmountA.currency.sortsBefore(tokenAmountB.currency) // does safety checks\n      ? [tokenAmountA, tokenAmountB]\n      : [tokenAmountB, tokenAmountA]\n    invariant(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), 'TOKEN')\n\n    let liquidity: JSBI\n    if (JSBI.equal(totalSupply.quotient, ZERO)) {\n      liquidity = JSBI.subtract(\n        sqrt(JSBI.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)),\n        MINIMUM_LIQUIDITY\n      )\n    } else {\n      const amount0 = JSBI.divide(JSBI.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient)\n      const amount1 = JSBI.divide(JSBI.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient)\n      liquidity = JSBI.lessThanOrEqual(amount0, amount1) ? amount0 : amount1\n    }\n    if (!JSBI.greaterThan(liquidity, ZERO)) {\n      throw new InsufficientInputAmountError()\n    }\n    return CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity)\n  }\n\n  public getLiquidityValue(\n    token: Token,\n    totalSupply: CurrencyAmount<Token>,\n    liquidity: CurrencyAmount<Token>,\n    feeOn: boolean = false,\n    kLast?: BigintIsh\n  ): CurrencyAmount<Token> {\n    invariant(this.involvesToken(token), 'TOKEN')\n    invariant(totalSupply.currency.equals(this.liquidityToken), 'TOTAL_SUPPLY')\n    invariant(liquidity.currency.equals(this.liquidityToken), 'LIQUIDITY')\n    invariant(JSBI.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), 'LIQUIDITY')\n\n    let totalSupplyAdjusted: CurrencyAmount<Token>\n    if (!feeOn) {\n      totalSupplyAdjusted = totalSupply\n    } else {\n      invariant(!!kLast, 'K_LAST')\n      const kLastParsed = JSBI.BigInt(kLast)\n      if (!JSBI.equal(kLastParsed, ZERO)) {\n        const rootK = sqrt(JSBI.multiply(this.reserve0.quotient, this.reserve1.quotient))\n        const rootKLast = sqrt(kLastParsed)\n        if (JSBI.greaterThan(rootK, rootKLast)) {\n          const numerator = JSBI.multiply(totalSupply.quotient, JSBI.subtract(rootK, rootKLast))\n          const denominator = JSBI.add(JSBI.multiply(rootK, FIVE), rootKLast)\n          const feeLiquidity = JSBI.divide(numerator, denominator)\n          totalSupplyAdjusted = totalSupply.add(CurrencyAmount.fromRawAmount(this.liquidityToken, feeLiquidity))\n        } else {\n          totalSupplyAdjusted = totalSupply\n        }\n      } else {\n        totalSupplyAdjusted = totalSupply\n      }\n    }\n\n    return CurrencyAmount.fromRawAmount(\n      token,\n      JSBI.divide(JSBI.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)\n    )\n  }\n\n  private derivePercentAfterSellFees(inputAmount: CurrencyAmount<Token>): Percent {\n    const sellFeeBips = this.token0.wrapped.equals(inputAmount.wrapped.currency)\n      ? this.token0.wrapped.sellFeeBps\n      : this.token1.wrapped.sellFeeBps\n    if (sellFeeBips?.gt(BigNumber.from(0))) {\n      return ONE_HUNDRED_PERCENT.subtract(new Percent(JSBI.BigInt(sellFeeBips)).divide(BASIS_POINTS))\n    } else {\n      return ZERO_PERCENT\n    }\n  }\n\n  private derivePercentAfterBuyFees(outputAmount: CurrencyAmount<Token>): Percent {\n    const buyFeeBps = this.token0.wrapped.equals(outputAmount.wrapped.currency)\n      ? this.token0.wrapped.buyFeeBps\n      : this.token1.wrapped.buyFeeBps\n    if (buyFeeBps?.gt(BigNumber.from(0))) {\n      return ONE_HUNDRED_PERCENT.subtract(new Percent(JSBI.BigInt(buyFeeBps)).divide(BASIS_POINTS))\n    } else {\n      return ZERO_PERCENT\n    }\n  }\n}\n","import invariant from 'tiny-invariant'\nimport { Currency, Price, Token } from '@uniswap/sdk-core'\n\nimport { Pair } from './pair'\n\nexport class Route<TInput extends Currency, TOutput extends Currency> {\n  public readonly pairs: Pair[]\n  public readonly path: Token[]\n  public readonly input: TInput\n  public readonly output: TOutput\n\n  public constructor(pairs: Pair[], input: TInput, output: TOutput) {\n    invariant(pairs.length > 0, 'PAIRS')\n    const chainId: number = pairs[0].chainId\n    invariant(\n      pairs.every(pair => pair.chainId === chainId),\n      'CHAIN_IDS'\n    )\n\n    const wrappedInput = input.wrapped\n    invariant(pairs[0].involvesToken(wrappedInput), 'INPUT')\n    invariant(typeof output === 'undefined' || pairs[pairs.length - 1].involvesToken(output.wrapped), 'OUTPUT')\n\n    const path: Token[] = [wrappedInput]\n    for (const [i, pair] of pairs.entries()) {\n      const currentInput = path[i]\n      invariant(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), 'PATH')\n      const output = currentInput.equals(pair.token0) ? pair.token1 : pair.token0\n      path.push(output)\n    }\n\n    this.pairs = pairs\n    this.path = path\n    this.input = input\n    this.output = output\n  }\n\n  private _midPrice: Price<TInput, TOutput> | null = null\n\n  public get midPrice(): Price<TInput, TOutput> {\n    if (this._midPrice !== null) return this._midPrice\n    const prices: Price<Currency, Currency>[] = []\n    for (const [i, pair] of this.pairs.entries()) {\n      prices.push(\n        this.path[i].equals(pair.token0)\n          ? new Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient)\n          : new Price(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient)\n      )\n    }\n    const reduced = prices.slice(1).reduce((accumulator, currentValue) => accumulator.multiply(currentValue), prices[0])\n    return (this._midPrice = new Price(this.input, this.output, reduced.denominator, reduced.numerator))\n  }\n\n  public get chainId(): number {\n    return this.pairs[0].chainId\n  }\n}\n","import {\n  computePriceImpact,\n  Token,\n  Currency,\n  CurrencyAmount,\n  Fraction,\n  Percent,\n  Price,\n  sortedInsert,\n  TradeType\n} from '@uniswap/sdk-core'\nimport { ONE, ZERO } from '../constants'\nimport invariant from 'tiny-invariant'\n\nimport { Pair } from './pair'\nimport { Route } from './route'\n\n// minimal interface so the input output comparator may be shared across types\ninterface InputOutput<TInput extends Currency, TOutput extends Currency> {\n  readonly inputAmount: CurrencyAmount<TInput>\n  readonly outputAmount: CurrencyAmount<TOutput>\n}\n\n// comparator function that allows sorting trades by their output amounts, in decreasing order, and then input amounts\n// in increasing order. i.e. the best trades have the most outputs for the least inputs and are sorted first\nexport function inputOutputComparator<TInput extends Currency, TOutput extends Currency>(\n  a: InputOutput<TInput, TOutput>,\n  b: InputOutput<TInput, TOutput>\n): number {\n  // must have same input and output token for comparison\n  invariant(a.inputAmount.currency.equals(b.inputAmount.currency), 'INPUT_CURRENCY')\n  invariant(a.outputAmount.currency.equals(b.outputAmount.currency), 'OUTPUT_CURRENCY')\n  if (a.outputAmount.equalTo(b.outputAmount)) {\n    if (a.inputAmount.equalTo(b.inputAmount)) {\n      return 0\n    }\n    // trade A requires less input than trade B, so A should come first\n    if (a.inputAmount.lessThan(b.inputAmount)) {\n      return -1\n    } else {\n      return 1\n    }\n  } else {\n    // tradeA has less output than trade B, so should come second\n    if (a.outputAmount.lessThan(b.outputAmount)) {\n      return 1\n    } else {\n      return -1\n    }\n  }\n}\n\n// extension of the input output comparator that also considers other dimensions of the trade in ranking them\nexport function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(\n  a: Trade<TInput, TOutput, TTradeType>,\n  b: Trade<TInput, TOutput, TTradeType>\n) {\n  const ioComp = inputOutputComparator(a, b)\n  if (ioComp !== 0) {\n    return ioComp\n  }\n\n  // consider lowest slippage next, since these are less likely to fail\n  if (a.priceImpact.lessThan(b.priceImpact)) {\n    return -1\n  } else if (a.priceImpact.greaterThan(b.priceImpact)) {\n    return 1\n  }\n\n  // finally consider the number of hops since each hop costs gas\n  return a.route.path.length - b.route.path.length\n}\n\nexport interface BestTradeOptions {\n  // how many results to return\n  maxNumResults?: number\n  // the maximum number of hops a trade should contain\n  maxHops?: number\n}\n\n/**\n * Represents a trade executed against a list of pairs.\n * Does not account for slippage, i.e. trades that front run this trade and move the price.\n */\nexport class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {\n  /**\n   * The route of the trade, i.e. which pairs the trade goes through and the input/output currencies.\n   */\n  public readonly route: Route<TInput, TOutput>\n  /**\n   * The type of the trade, either exact in or exact out.\n   */\n  public readonly tradeType: TTradeType\n  /**\n   * The input amount for the trade assuming no slippage.\n   */\n  public readonly inputAmount: CurrencyAmount<TInput>\n  /**\n   * The output amount for the trade assuming no slippage.\n   */\n  public readonly outputAmount: CurrencyAmount<TOutput>\n  /**\n   * The price expressed in terms of output amount/input amount.\n   */\n  public readonly executionPrice: Price<TInput, TOutput>\n  /**\n   * The percent difference between the mid price before the trade and the trade execution price.\n   */\n  public readonly priceImpact: Percent\n\n  /**\n   * Constructs an exact in trade with the given amount in and route\n   * @param route route of the exact in trade\n   * @param amountIn the amount being passed in\n   */\n  public static exactIn<TInput extends Currency, TOutput extends Currency>(\n    route: Route<TInput, TOutput>,\n    amountIn: CurrencyAmount<TInput>\n  ): Trade<TInput, TOutput, TradeType.EXACT_INPUT> {\n    return new Trade(route, amountIn, TradeType.EXACT_INPUT)\n  }\n\n  /**\n   * Constructs an exact out trade with the given amount out and route\n   * @param route route of the exact out trade\n   * @param amountOut the amount returned by the trade\n   */\n  public static exactOut<TInput extends Currency, TOutput extends Currency>(\n    route: Route<TInput, TOutput>,\n    amountOut: CurrencyAmount<TOutput>\n  ): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT> {\n    return new Trade(route, amountOut, TradeType.EXACT_OUTPUT)\n  }\n\n  public constructor(\n    route: Route<TInput, TOutput>,\n    amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>,\n    tradeType: TTradeType\n  ) {\n    this.route = route\n    this.tradeType = tradeType\n\n    const tokenAmounts: CurrencyAmount<Token>[] = new Array(route.path.length)\n    if (tradeType === TradeType.EXACT_INPUT) {\n      invariant(amount.currency.equals(route.input), 'INPUT')\n      tokenAmounts[0] = amount.wrapped\n      for (let i = 0; i < route.path.length - 1; i++) {\n        const pair = route.pairs[i]\n        const [outputAmount] = pair.getOutputAmount(tokenAmounts[i])\n        tokenAmounts[i + 1] = outputAmount\n      }\n      this.inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator)\n      this.outputAmount = CurrencyAmount.fromFractionalAmount(\n        route.output,\n        tokenAmounts[tokenAmounts.length - 1].numerator,\n        tokenAmounts[tokenAmounts.length - 1].denominator\n      )\n    } else {\n      invariant(amount.currency.equals(route.output), 'OUTPUT')\n      tokenAmounts[tokenAmounts.length - 1] = amount.wrapped\n      for (let i = route.path.length - 1; i > 0; i--) {\n        const pair = route.pairs[i - 1]\n        const [inputAmount] = pair.getInputAmount(tokenAmounts[i])\n        tokenAmounts[i - 1] = inputAmount\n      }\n      this.inputAmount = CurrencyAmount.fromFractionalAmount(\n        route.input,\n        tokenAmounts[0].numerator,\n        tokenAmounts[0].denominator\n      )\n      this.outputAmount = CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator)\n    }\n    this.executionPrice = new Price(\n      this.inputAmount.currency,\n      this.outputAmount.currency,\n      this.inputAmount.quotient,\n      this.outputAmount.quotient\n    )\n    this.priceImpact = computePriceImpact(route.midPrice, this.inputAmount, this.outputAmount)\n  }\n\n  /**\n   * Get the minimum amount that must be received from this trade for the given slippage tolerance\n   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade\n   */\n  public minimumAmountOut(slippageTolerance: Percent): CurrencyAmount<TOutput> {\n    invariant(!slippageTolerance.lessThan(ZERO), 'SLIPPAGE_TOLERANCE')\n    if (this.tradeType === TradeType.EXACT_OUTPUT) {\n      return this.outputAmount\n    } else {\n      const slippageAdjustedAmountOut = new Fraction(ONE)\n        .add(slippageTolerance)\n        .invert()\n        .multiply(this.outputAmount.quotient).quotient\n      return CurrencyAmount.fromRawAmount(this.outputAmount.currency, slippageAdjustedAmountOut)\n    }\n  }\n\n  /**\n   * Get the maximum amount in that can be spent via this trade for the given slippage tolerance\n   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade\n   */\n  public maximumAmountIn(slippageTolerance: Percent): CurrencyAmount<TInput> {\n    invariant(!slippageTolerance.lessThan(ZERO), 'SLIPPAGE_TOLERANCE')\n    if (this.tradeType === TradeType.EXACT_INPUT) {\n      return this.inputAmount\n    } else {\n      const slippageAdjustedAmountIn = new Fraction(ONE).add(slippageTolerance).multiply(this.inputAmount.quotient)\n        .quotient\n      return CurrencyAmount.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn)\n    }\n  }\n\n  /**\n   * Given a list of pairs, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token\n   * amount to an output token, making at most `maxHops` hops.\n   * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting\n   * the amount in among multiple routes.\n   * @param pairs the pairs to consider in finding the best trade\n   * @param nextAmountIn exact amount of input currency to spend\n   * @param currencyOut the desired currency out\n   * @param maxNumResults maximum number of results to return\n   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair\n   * @param currentPairs used in recursion; the current list of pairs\n   * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter\n   * @param bestTrades used in recursion; the current list of best trades\n   */\n  public static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(\n    pairs: Pair[],\n    currencyAmountIn: CurrencyAmount<TInput>,\n    currencyOut: TOutput,\n    { maxNumResults = 3, maxHops = 3 }: BestTradeOptions = {},\n    // used in recursion.\n    currentPairs: Pair[] = [],\n    nextAmountIn: CurrencyAmount<Currency> = currencyAmountIn,\n    bestTrades: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[] = []\n  ): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[] {\n    invariant(pairs.length > 0, 'PAIRS')\n    invariant(maxHops > 0, 'MAX_HOPS')\n    invariant(currencyAmountIn === nextAmountIn || currentPairs.length > 0, 'INVALID_RECURSION')\n\n    const amountIn = nextAmountIn.wrapped\n    const tokenOut = currencyOut.wrapped\n    for (let i = 0; i < pairs.length; i++) {\n      const pair = pairs[i]\n      // pair irrelevant\n      if (!pair.token0.equals(amountIn.currency) && !pair.token1.equals(amountIn.currency)) continue\n      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO)) continue\n\n      let amountOut: CurrencyAmount<Token>\n      try {\n        ;[amountOut] = pair.getOutputAmount(amountIn)\n      } catch (error) {\n        // input too low\n        if (error.isInsufficientInputAmountError) {\n          continue\n        }\n        throw error\n      }\n      // we have arrived at the output token, so this is the final trade of one of the paths\n      if (amountOut.currency.equals(tokenOut)) {\n        sortedInsert(\n          bestTrades,\n          new Trade(\n            new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut),\n            currencyAmountIn,\n            TradeType.EXACT_INPUT\n          ),\n          maxNumResults,\n          tradeComparator\n        )\n      } else if (maxHops > 1 && pairs.length > 1) {\n        const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length))\n\n        // otherwise, consider all the other paths that lead from this token as long as we have not exceeded maxHops\n        Trade.bestTradeExactIn(\n          pairsExcludingThisPair,\n          currencyAmountIn,\n          currencyOut,\n          {\n            maxNumResults,\n            maxHops: maxHops - 1\n          },\n          [...currentPairs, pair],\n          amountOut,\n          bestTrades\n        )\n      }\n    }\n\n    return bestTrades\n  }\n\n  /**\n   * Return the execution price after accounting for slippage tolerance\n   * @param slippageTolerance the allowed tolerated slippage\n   */\n  public worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput> {\n    return new Price(\n      this.inputAmount.currency,\n      this.outputAmount.currency,\n      this.maximumAmountIn(slippageTolerance).quotient,\n      this.minimumAmountOut(slippageTolerance).quotient\n    )\n  }\n\n  /**\n   * similar to the above method but instead targets a fixed output amount\n   * given a list of pairs, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token\n   * to an output token amount, making at most `maxHops` hops\n   * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting\n   * the amount in among multiple routes.\n   * @param pairs the pairs to consider in finding the best trade\n   * @param currencyIn the currency to spend\n   * @param nextAmountOut the exact amount of currency out\n   * @param maxNumResults maximum number of results to return\n   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair\n   * @param currentPairs used in recursion; the current list of pairs\n   * @param currencyAmountOut used in recursion; the original value of the currencyAmountOut parameter\n   * @param bestTrades used in recursion; the current list of best trades\n   */\n  public static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(\n    pairs: Pair[],\n    currencyIn: TInput,\n    currencyAmountOut: CurrencyAmount<TOutput>,\n    { maxNumResults = 3, maxHops = 3 }: BestTradeOptions = {},\n    // used in recursion.\n    currentPairs: Pair[] = [],\n    nextAmountOut: CurrencyAmount<Currency> = currencyAmountOut,\n    bestTrades: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[] = []\n  ): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[] {\n    invariant(pairs.length > 0, 'PAIRS')\n    invariant(maxHops > 0, 'MAX_HOPS')\n    invariant(currencyAmountOut === nextAmountOut || currentPairs.length > 0, 'INVALID_RECURSION')\n\n    const amountOut = nextAmountOut.wrapped\n    const tokenIn = currencyIn.wrapped\n    for (let i = 0; i < pairs.length; i++) {\n      const pair = pairs[i]\n      // pair irrelevant\n      if (!pair.token0.equals(amountOut.currency) && !pair.token1.equals(amountOut.currency)) continue\n      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO)) continue\n\n      let amountIn: CurrencyAmount<Token>\n      try {\n        ;[amountIn] = pair.getInputAmount(amountOut)\n      } catch (error) {\n        // not enough liquidity in this pair\n        if (error.isInsufficientReservesError) {\n          continue\n        }\n        throw error\n      }\n      // we have arrived at the input token, so this is the first trade of one of the paths\n      if (amountIn.currency.equals(tokenIn)) {\n        sortedInsert(\n          bestTrades,\n          new Trade(\n            new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency),\n            currencyAmountOut,\n            TradeType.EXACT_OUTPUT\n          ),\n          maxNumResults,\n          tradeComparator\n        )\n      } else if (maxHops > 1 && pairs.length > 1) {\n        const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length))\n\n        // otherwise, consider all the other paths that arrive at this token as long as we have not exceeded maxHops\n        Trade.bestTradeExactOut(\n          pairsExcludingThisPair,\n          currencyIn,\n          currencyAmountOut,\n          {\n            maxNumResults,\n            maxHops: maxHops - 1\n          },\n          [pair, ...currentPairs],\n          amountIn,\n          bestTrades\n        )\n      }\n    }\n\n    return bestTrades\n  }\n}\n","import { Token, Currency, CurrencyAmount, Percent, TradeType, validateAndParseAddress } from '@uniswap/sdk-core'\nimport { Trade } from './entities'\nimport invariant from 'tiny-invariant'\n\n/**\n * Options for producing the arguments to send call to the router.\n */\nexport interface TradeOptions {\n  /**\n   * How much the execution price is allowed to move unfavorably from the trade execution price.\n   */\n  allowedSlippage: Percent\n  /**\n   * How long the swap is valid until it expires, in seconds.\n   * This will be used to produce a `deadline` parameter which is computed from when the swap call parameters\n   * are generated.\n   */\n  ttl: number\n  /**\n   * The account that should receive the output of the swap.\n   */\n  recipient: string\n\n  /**\n   * Whether any of the tokens in the path are fee on transfer tokens, which should be handled with special methods\n   */\n  feeOnTransfer?: boolean\n}\n\nexport interface TradeOptionsDeadline extends Omit<TradeOptions, 'ttl'> {\n  /**\n   * When the transaction expires.\n   * This is an atlernate to specifying the ttl, for when you do not want to use local time.\n   */\n  deadline: number\n}\n\n/**\n * The parameters to use in the call to the Uniswap V2 Router to execute a trade.\n */\nexport interface SwapParameters {\n  /**\n   * The method to call on the Uniswap V2 Router.\n   */\n  methodName: string\n  /**\n   * The arguments to pass to the method, all hex encoded.\n   */\n  args: (string | string[])[]\n  /**\n   * The amount of wei to send in hex.\n   */\n  value: string\n}\n\nfunction toHex(currencyAmount: CurrencyAmount<Currency>) {\n  return `0x${currencyAmount.quotient.toString(16)}`\n}\n\nconst ZERO_HEX = '0x0'\n\n/**\n * Represents the Uniswap V2 Router, and has static methods for helping execute trades.\n */\nexport abstract class Router {\n  /**\n   * Cannot be constructed.\n   */\n  private constructor() {}\n  /**\n   * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.\n   * @param trade to produce call parameters for\n   * @param options options for the call parameters\n   */\n  public static swapCallParameters(\n    trade: Trade<Currency, Currency, TradeType>,\n    options: TradeOptions | TradeOptionsDeadline\n  ): SwapParameters {\n    const etherIn = trade.inputAmount.currency.isNative\n    const etherOut = trade.outputAmount.currency.isNative\n    // the router does not support both ether in and out\n    invariant(!(etherIn && etherOut), 'ETHER_IN_OUT')\n    invariant(!('ttl' in options) || options.ttl > 0, 'TTL')\n\n    const to: string = validateAndParseAddress(options.recipient)\n    const amountIn: string = toHex(trade.maximumAmountIn(options.allowedSlippage))\n    const amountOut: string = toHex(trade.minimumAmountOut(options.allowedSlippage))\n    const path: string[] = trade.route.path.map((token: Token) => token.address)\n    const deadline =\n      'ttl' in options\n        ? `0x${(Math.floor(new Date().getTime() / 1000) + options.ttl).toString(16)}`\n        : `0x${options.deadline.toString(16)}`\n\n    const useFeeOnTransfer = Boolean(options.feeOnTransfer)\n\n    let methodName: string\n    let args: (string | string[])[]\n    let value: string\n    switch (trade.tradeType) {\n      case TradeType.EXACT_INPUT:\n        if (etherIn) {\n          methodName = useFeeOnTransfer ? 'swapExactETHForTokensSupportingFeeOnTransferTokens' : 'swapExactETHForTokens'\n          // (uint amountOutMin, address[] calldata path, address to, uint deadline)\n          args = [amountOut, path, to, deadline]\n          value = amountIn\n        } else if (etherOut) {\n          methodName = useFeeOnTransfer ? 'swapExactTokensForETHSupportingFeeOnTransferTokens' : 'swapExactTokensForETH'\n          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n          args = [amountIn, amountOut, path, to, deadline]\n          value = ZERO_HEX\n        } else {\n          methodName = useFeeOnTransfer\n            ? 'swapExactTokensForTokensSupportingFeeOnTransferTokens'\n            : 'swapExactTokensForTokens'\n          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n          args = [amountIn, amountOut, path, to, deadline]\n          value = ZERO_HEX\n        }\n        break\n      case TradeType.EXACT_OUTPUT:\n        invariant(!useFeeOnTransfer, 'EXACT_OUT_FOT')\n        if (etherIn) {\n          methodName = 'swapETHForExactTokens'\n          // (uint amountOut, address[] calldata path, address to, uint deadline)\n          args = [amountOut, path, to, deadline]\n          value = amountIn\n        } else if (etherOut) {\n          methodName = 'swapTokensForExactETH'\n          // (uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n          args = [amountOut, amountIn, path, to, deadline]\n          value = ZERO_HEX\n        } else {\n          methodName = 'swapTokensForExactTokens'\n          // (uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n          args = [amountOut, amountIn, path, to, deadline]\n          value = ZERO_HEX\n        }\n        break\n    }\n    return {\n      methodName,\n      args,\n      value\n    }\n  }\n}\n"],"names":["FACTORY_ADDRESS_MAP","V2_FACTORY_ADDRESSES","INIT_CODE_HASH","MINIMUM_LIQUIDITY","JSBI","BigInt","ZERO","ONE","FIVE","_997","_1000","BASIS_POINTS","ZERO_PERCENT","Percent","ONE_HUNDRED_PERCENT","CAN_SET_PROTOTYPE","Object","InsufficientReservesError","name","_this","constructor","setPrototypeOf","prototype","Error","InsufficientInputAmountError","_this2","computePairAddress","factoryAddress","tokenA","tokenB","sortsBefore","getCreate2Address","keccak256","pack","address","Pair","currencyAmountA","tokenAmountB","tokenAmounts","currency","liquidityToken","Token","chainId","getAddress","involvesToken","token","equals","this","token0","token1","priceOf","invariant","token0Price","token1Price","reserveOf","reserve0","reserve1","getOutputAmount","inputAmount","calculateFotFees","equal","quotient","inputReserve","outputReserve","percentAfterSellFees","derivePercentAfterSellFees","inputAmountAfterTax","greaterThan","CurrencyAmount","fromRawAmount","multiply","inputAmountWithFeeAndAfterTax","numerator","denominator","add","outputAmount","divide","percentAfterBuyFees","derivePercentAfterBuyFees","outputAmountAfterTax","subtract","getInputAmount","outputAmountBeforeTax","greaterThanOrEqual","getLiquidityMinted","totalSupply","tokenAmountA","liquidity","sqrt","amount0","amount1","lessThanOrEqual","getLiquidityValue","feeOn","kLast","totalSupplyAdjusted","kLastParsed","rootK","rootKLast","feeLiquidity","sellFeeBips","wrapped","sellFeeBps","gt","BigNumber","from","buyFeeBps","result","Price","Route","pairs","input","output","length","every","pair","wrappedInput","path","entries","currentInput","push","_midPrice","prices","reduced","slice","reduce","accumulator","currentValue","inputOutputComparator","a","b","equalTo","lessThan","tradeComparator","ioComp","priceImpact","route","Trade","amount","tradeType","Array","TradeType","EXACT_INPUT","i","fromFractionalAmount","executionPrice","computePriceImpact","midPrice","exactIn","amountIn","exactOut","amountOut","EXACT_OUTPUT","minimumAmountOut","slippageTolerance","slippageAdjustedAmountOut","Fraction","invert","maximumAmountIn","slippageAdjustedAmountIn","bestTradeExactIn","currencyAmountIn","currencyOut","currentPairs","nextAmountIn","bestTrades","maxNumResults","maxHops","tokenOut","error","isInsufficientInputAmountError","sortedInsert","pairsExcludingThisPair","concat","worstExecutionPrice","bestTradeExactOut","currencyIn","currencyAmountOut","nextAmountOut","tokenIn","isInsufficientReservesError","toHex","currencyAmount","toString","Router","swapCallParameters","trade","options","etherIn","isNative","etherOut","ttl","methodName","args","value","to","validateAndParseAddress","recipient","allowedSlippage","map","deadline","Math","floor","Date","getTime","useFeeOnTransfer","Boolean","feeOnTransfer"],"mappings":"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"}