novaswap-v2-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Uniswap Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @uniswap/v2-sdk - Now at `Uniswap/sdks`
+
+All versions after 4.3.0 of this SDK can be found in the [SDK monorepo](https://github.com/Uniswap/sdks/tree/main/sdks/v2-sdk)! Please file all future issues, PR’s, and discussions there.
+
+### Old Issues and PR’s
+
+If you have an issue or open PR that is still active on this SDK in this repository, please recreate it in the new repository. Some existing issues and PR’s may be automatically migrated by the Uniswap Labs team.

package/dist/constants.d.ts

@@ -0,0 +1,19 @@
+import { Percent } from '@uniswap/sdk-core';
+import JSBI from 'jsbi';
+/**
+ * @deprecated use FACTORY_ADDRESS_MAP instead
+ */
+export declare const FACTORY_ADDRESS = "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f";
+export declare const FACTORY_ADDRESS_MAP: {
+    [chainId: number]: string;
+};
+export declare const INIT_CODE_HASH = "0x0ef7ca4700ff7e705236379af2cdac62d4fa0bbd010fb163697b63379941118e";
+export declare const MINIMUM_LIQUIDITY: JSBI;
+export declare const ZERO: JSBI;
+export declare const ONE: JSBI;
+export declare const FIVE: JSBI;
+export declare const _997: JSBI;
+export declare const _1000: JSBI;
+export declare const BASIS_POINTS: JSBI;
+export declare const ZERO_PERCENT: Percent;
+export declare const ONE_HUNDRED_PERCENT: Percent;

package/dist/entities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pair';
+export * from './route';
+export * from './trade';

package/dist/entities/pair.d.ts

@@ -0,0 +1,147 @@
+import { BigintIsh, CurrencyAmount, Price, Token } from '@uniswap/sdk-core';
+export declare const computePairAddress: ({ factoryAddress, tokenA, tokenB }: {
+    factoryAddress: string;
+    tokenA: Token;
+    tokenB: Token;
+}) => string;
+export declare class Pair {
+    readonly liquidityToken: Token;
+    private readonly tokenAmounts;
+    static getAddress(tokenA: Token, tokenB: Token): string;
+    constructor(currencyAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>);
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token to check
+     */
+    involvesToken(token: Token): boolean;
+    /**
+     * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0
+     */
+    get token0Price(): Price<Token, Token>;
+    /**
+     * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
+     */
+    get token1Price(): Price<Token, Token>;
+    /**
+     * Return the price of the given token in terms of the other token in the pair.
+     * @param token token to return price of
+     */
+    priceOf(token: Token): Price<Token, Token>;
+    /**
+     * Returns the chain ID of the tokens in the pair.
+     */
+    get chainId(): number;
+    get token0(): Token;
+    get token1(): Token;
+    get reserve0(): CurrencyAmount<Token>;
+    get reserve1(): CurrencyAmount<Token>;
+    reserveOf(token: Token): CurrencyAmount<Token>;
+    /**
+     * getAmountOut is the linear algebra of reserve ratio against amountIn:amountOut.
+     * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000
+     * has the math deduction for the reserve calculation without fee-on-transfer fees.
+     *
+     * With fee-on-transfer tax, intuitively it's just:
+     * inputAmountWithFeeAndTax = 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
+     *                          = (1 - amountIn.sellFeesBips / 10000) * amountInWithFee
+     * where amountInWithFee is the amountIn after taking out the LP fees
+     * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)
+     *
+     * But we are illustrating the math deduction below to ensure that's the case.
+     *
+     * before swap A * B = K where A = reserveIn B = reserveOut
+     *
+     * after swap A' * B' = K where only k is a constant value
+     *
+     * getAmountOut
+     *
+     * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted
+     * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)
+     * amountOut = (B - B') / (1 - amountOut.buyFeesBips / 10000) # where A' * B' still is k
+     *           = (B - K/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
+     *             /
+     *             (1 - amountOut.buyFeesBips / 10000)
+     *           = (B - AB/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
+     *             /
+     *             (1 - amountOut.buyFeesBips / 10000)
+     *           = ((BA + B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn - AB)/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
+     *             /
+     *             (1 - amountOut.buyFeesBips / 10000)
+     *           = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn / (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
+     *             /
+     *             (1 - amountOut.buyFeesBips / 10000)
+     * amountOut * (1 - amountOut.buyFeesBips / 10000) = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
+     *                                                    /
+     *                                                    (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
+     *
+     * outputAmountWithTax = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
+     *                       /
+     *                       (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
+     *                       = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn * 1000
+     *                       /
+     *                       ((A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn) * 1000)
+     *                     = (B * (1 - amountIn.sellFeesBips / 10000) 997 * * amountIn
+     *                       /
+     *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * 997 * amountIn)
+     *                     = (B * (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)
+     *                       /
+     *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)
+     *                     = (B * inputAmountWithFeeAndTax)
+     *                       /
+     *                       (1000 * A + inputAmountWithFeeAndTax)
+     *
+     * inputAmountWithFeeAndTax = (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee
+     * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)
+     *
+     * @param inputAmount
+     * @param calculateFotFees
+     */
+    getOutputAmount(inputAmount: CurrencyAmount<Token>, calculateFotFees?: boolean): [CurrencyAmount<Token>, Pair];
+    /**
+     * getAmountIn is the linear algebra of reserve ratio against amountIn:amountOut.
+     * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000
+     * has the math deduction for the reserve calculation without fee-on-transfer fees.
+     *
+     * With fee-on-transfer fees, intuitively it's just:
+     * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)
+     * inputAmountWithTax = amountIn / (1 - amountIn.sellFeesBips / 10000) / 0.997
+     *
+     * But we are illustrating the math deduction below to ensure that's the case.
+     *
+     * before swap A * B = K where A = reserveIn B = reserveOut
+     *
+     * after swap A' * B' = K where only k is a constant value
+     *
+     * getAmountIn
+     *
+     * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)
+     * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted
+     * amountIn = (A' - A) / (0.997 * (1 - amountIn.sellFeesBips / 10000))
+     *          = (K / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)
+     *            /
+     *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+     *          = (AB / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)
+     *            /
+     *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+     *          = ((AB - AB + A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
+     *            /
+     *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+     *          = ((A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
+     *            /
+     *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+     *          = ((A * 1000 * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
+     *            /
+     *            (997 * (1 - amountIn.sellFeesBips / 10000))
+     *
+     * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)
+     * inputAmountWithTax = amountIn / (997 * (1 - amountIn.sellFeesBips / 10000))
+     *                    = (A * outputAmountWithTax * 1000) / ((B - outputAmountWithTax) * 997)
+     *
+     * @param outputAmount
+     */
+    getInputAmount(outputAmount: CurrencyAmount<Token>, calculateFotFees?: boolean): [CurrencyAmount<Token>, Pair];
+    getLiquidityMinted(totalSupply: CurrencyAmount<Token>, tokenAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>): CurrencyAmount<Token>;
+    getLiquidityValue(token: Token, totalSupply: CurrencyAmount<Token>, liquidity: CurrencyAmount<Token>, feeOn?: boolean, kLast?: BigintIsh): CurrencyAmount<Token>;
+    private derivePercentAfterSellFees;
+    private derivePercentAfterBuyFees;
+}

package/dist/entities/route.d.ts

@@ -0,0 +1,12 @@
+import { Currency, Price, Token } from '@uniswap/sdk-core';
+import { Pair } from './pair';
+export declare class Route<TInput extends Currency, TOutput extends Currency> {
+    readonly pairs: Pair[];
+    readonly path: Token[];
+    readonly input: TInput;
+    readonly output: TOutput;
+    constructor(pairs: Pair[], input: TInput, output: TOutput);
+    private _midPrice;
+    get midPrice(): Price<TInput, TOutput>;
+    get chainId(): number;
+}

package/dist/entities/trade.d.ts

@@ -0,0 +1,103 @@
+import { Currency, CurrencyAmount, Percent, Price, TradeType } from '@uniswap/sdk-core';
+import { Pair } from './pair';
+import { Route } from './route';
+interface InputOutput<TInput extends Currency, TOutput extends Currency> {
+    readonly inputAmount: CurrencyAmount<TInput>;
+    readonly outputAmount: CurrencyAmount<TOutput>;
+}
+export declare function inputOutputComparator<TInput extends Currency, TOutput extends Currency>(a: InputOutput<TInput, TOutput>, b: InputOutput<TInput, TOutput>): number;
+export declare function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(a: Trade<TInput, TOutput, TTradeType>, b: Trade<TInput, TOutput, TTradeType>): number;
+export interface BestTradeOptions {
+    maxNumResults?: number;
+    maxHops?: number;
+}
+/**
+ * Represents a trade executed against a list of pairs.
+ * Does not account for slippage, i.e. trades that front run this trade and move the price.
+ */
+export declare class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    /**
+     * The route of the trade, i.e. which pairs the trade goes through and the input/output currencies.
+     */
+    readonly route: Route<TInput, TOutput>;
+    /**
+     * The type of the trade, either exact in or exact out.
+     */
+    readonly tradeType: TTradeType;
+    /**
+     * The input amount for the trade assuming no slippage.
+     */
+    readonly inputAmount: CurrencyAmount<TInput>;
+    /**
+     * The output amount for the trade assuming no slippage.
+     */
+    readonly outputAmount: CurrencyAmount<TOutput>;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    readonly executionPrice: Price<TInput, TOutput>;
+    /**
+     * The percent difference between the mid price before the trade and the trade execution price.
+     */
+    readonly priceImpact: Percent;
+    /**
+     * Constructs an exact in trade with the given amount in and route
+     * @param route route of the exact in trade
+     * @param amountIn the amount being passed in
+     */
+    static exactIn<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountIn: CurrencyAmount<TInput>): Trade<TInput, TOutput, TradeType.EXACT_INPUT>;
+    /**
+     * Constructs an exact out trade with the given amount out and route
+     * @param route route of the exact out trade
+     * @param amountOut the amount returned by the trade
+     */
+    static exactOut<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountOut: CurrencyAmount<TOutput>): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>;
+    constructor(route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType);
+    /**
+     * Get the minimum amount that must be received from this trade for the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
+     */
+    minimumAmountOut(slippageTolerance: Percent): CurrencyAmount<TOutput>;
+    /**
+     * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
+     */
+    maximumAmountIn(slippageTolerance: Percent): CurrencyAmount<TInput>;
+    /**
+     * Given a list of pairs, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
+     * amount to an output token, making at most `maxHops` hops.
+     * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
+     * the amount in among multiple routes.
+     * @param pairs the pairs to consider in finding the best trade
+     * @param nextAmountIn exact amount of input currency to spend
+     * @param currencyOut the desired currency out
+     * @param maxNumResults maximum number of results to return
+     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
+     * @param currentPairs used in recursion; the current list of pairs
+     * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
+     * @param bestTrades used in recursion; the current list of best trades
+     */
+    static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(pairs: Pair[], currencyAmountIn: CurrencyAmount<TInput>, currencyOut: TOutput, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], nextAmountIn?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[];
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @param slippageTolerance the allowed tolerated slippage
+     */
+    worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
+    /**
+     * similar to the above method but instead targets a fixed output amount
+     * given a list of pairs, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
+     * to an output token amount, making at most `maxHops` hops
+     * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
+     * the amount in among multiple routes.
+     * @param pairs the pairs to consider in finding the best trade
+     * @param currencyIn the currency to spend
+     * @param nextAmountOut the exact amount of currency out
+     * @param maxNumResults maximum number of results to return
+     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
+     * @param currentPairs used in recursion; the current list of pairs
+     * @param currencyAmountOut used in recursion; the original value of the currencyAmountOut parameter
+     * @param bestTrades used in recursion; the current list of best trades
+     */
+    static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(pairs: Pair[], currencyIn: TInput, currencyAmountOut: CurrencyAmount<TOutput>, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], nextAmountOut?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[];
+}
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
+ */
+export declare class InsufficientReservesError extends Error {
+    readonly isInsufficientReservesError: true;
+    constructor();
+}
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
+ */
+export declare class InsufficientInputAmountError extends Error {
+    readonly isInsufficientInputAmountError: true;
+    constructor();
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { FACTORY_ADDRESS_MAP, INIT_CODE_HASH, MINIMUM_LIQUIDITY } from './constants';
+export * from './errors';
+export * from './entities';
+export * from './router';

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./novaswap-v2-sdk.cjs.production.min.js')
+} else {
+  module.exports = require('./novaswap-v2-sdk.cjs.development.js')
+}