@qidao/sdk 5.0.0-canary.117 → 5.0.3

package/dist/constants.d.ts

@@ -0,0 +1,77 @@
+import JSBI from 'jsbi';
+export declare type BigintIsh = JSBI | bigint | string;
+export declare enum ChainId {
+    MAINNET = 1,
+    ROPSTEN = 3,
+    RINKEBY = 4,
+    GÖRLI = 5,
+    KOVAN = 42,
+    MATIC = 137,
+    MATIC_TESTNET = 80001,
+    FANTOM = 250,
+    FANTOM_TESTNET = 4002,
+    XDAI = 100,
+    BSC = 56,
+    BSC_TESTNET = 97,
+    ARBITRUM = 42161,
+    MOONBASE = 1287,
+    MOONBEAM = 1284,
+    AVALANCHE = 43114,
+    FUJI = 43113,
+    HECO = 128,
+    HECO_TESTNET = 256,
+    HARMONY = 1666600000,
+    HARMONY_TESTNET = 1666700000,
+    MOONRIVER = 1285,
+    CRONOS = 25,
+    OPTIMISM = 10
+}
+export declare enum TradeType {
+    EXACT_INPUT = 0,
+    EXACT_OUTPUT = 1
+}
+export declare enum Rounding {
+    ROUND_DOWN = 0,
+    ROUND_HALF_UP = 1,
+    ROUND_UP = 2
+}
+export declare const INIT_CODE_HASH: string;
+export declare const FACTORY_ADDRESS: {
+    [chainId in ChainId]: string;
+};
+export declare const ROUTER_ADDRESS: {
+    [chainId in ChainId]: string;
+};
+export declare const SUSHI_ADDRESS: {
+    [chainId in ChainId]: string;
+};
+export declare const MASTERCHEF_ADDRESS: {
+    [chainId in ChainId]: string;
+};
+export declare const BAR_ADDRESS: {
+    [chainId in ChainId]: string;
+};
+export declare const MAKER_ADDRESS: {
+    [chainId in ChainId]: string;
+};
+export declare const TIMELOCK_ADDRESS: {
+    [chainId in ChainId]: string;
+};
+export declare const MINIMUM_LIQUIDITY: JSBI;
+export declare const ZERO: JSBI;
+export declare const ONE: JSBI;
+export declare const TWO: JSBI;
+export declare const THREE: JSBI;
+export declare const FIVE: JSBI;
+export declare const TEN: JSBI;
+export declare const _100: JSBI;
+export declare const _997: JSBI;
+export declare const _1000: JSBI;
+export declare enum SolidityType {
+    uint8 = "uint8",
+    uint256 = "uint256"
+}
+export declare const SOLIDITY_TYPE_MAXIMA: {
+    uint8: JSBI;
+    uint256: JSBI;
+};

package/dist/entities/currency.d.ts

@@ -0,0 +1,61 @@
+import { ChainId } from '../constants';
+/**
+ * A currency is any fungible financial instrument on Ethereum, including Ether and all ERC20 tokens.
+ *
+ * The only instance of the base class `Currency` is Ether.
+ */
+export declare class Currency {
+    readonly decimals: number;
+    readonly symbol?: string;
+    readonly name?: string;
+    static readonly ETHER: Currency;
+    static readonly BNB: Currency;
+    static readonly FTM: Currency;
+    static readonly MATIC: Currency;
+    static readonly XDAI: Currency;
+    static readonly GLMR: Currency;
+    static readonly AVAX: Currency;
+    static readonly HT: Currency;
+    static readonly ONE: Currency;
+    static readonly MOVR: Currency;
+    static readonly CRO: Currency;
+    static readonly NATIVE: {
+        1: Currency;
+        3: Currency;
+        4: Currency;
+        5: Currency;
+        42: Currency;
+        250: Currency;
+        4002: Currency;
+        137: Currency;
+        80001: Currency;
+        100: Currency;
+        56: Currency;
+        97: Currency;
+        42161: Currency;
+        1287: Currency;
+        43114: Currency;
+        43113: Currency;
+        128: Currency;
+        256: Currency;
+        1666600000: Currency;
+        1666700000: Currency;
+        25: Currency;
+        1285: Currency;
+        10: Currency;
+    };
+    /**
+     * Constructs an instance of the base class `Currency`. The only instance of the base class `Currency` is `Currency.ETHER`.
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     */
+    protected constructor(decimals: number, symbol?: string, name?: string);
+    static getNativeCurrency(chainId?: ChainId): Currency;
+    static getNativeCurrencySymbol(chainId?: ChainId): string | undefined;
+    static getNativeCurrencyName(chainId?: ChainId): string | undefined;
+    getSymbol(chainId?: ChainId): string | undefined;
+    getName(chainId?: ChainId): string | undefined;
+}
+declare const ETHER: Currency;
+export { ETHER };

package/dist/entities/fractions/currencyAmount.d.ts

@@ -0,0 +1,19 @@
+import { Currency } from '../currency';
+import JSBI from 'jsbi';
+import { BigintIsh, Rounding } from '../../constants';
+import { Fraction } from './fraction';
+export declare class CurrencyAmount extends Fraction {
+    readonly currency: Currency;
+    /**
+     * Helper that calls the constructor with the ETHER currency
+     * @param amount ether amount in wei
+     */
+    static ether(amount: BigintIsh): CurrencyAmount;
+    protected constructor(currency: Currency, amount: BigintIsh);
+    get raw(): JSBI;
+    add(other: CurrencyAmount): CurrencyAmount;
+    subtract(other: CurrencyAmount): CurrencyAmount;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+}

package/dist/entities/{Fraction.d.ts → fractions/fraction.d.ts}

@@ -1,11 +1,9 @@
-import { BigintIsh } from '../types';
 import JSBI from 'jsbi';
-import { Rounding } from '../enums';
+import { BigintIsh, Rounding } from '../../constants';
 export declare class Fraction {
     readonly numerator: JSBI;
     readonly denominator: JSBI;
     constructor(numerator: BigintIsh, denominator?: BigintIsh);
-    private static tryParseFraction;
     get quotient(): JSBI;
     get remainder(): Fraction;
     invert(): Fraction;
@@ -18,8 +16,4 @@ export declare class Fraction {
     divide(other: Fraction | BigintIsh): Fraction;
     toSignificant(significantDigits: number, format?: object, rounding?: Rounding): string;
     toFixed(decimalPlaces: number, format?: object, rounding?: Rounding): string;
-    /**
-     * Helper method for converting any super class back to a fraction
-     */
-    get asFraction(): Fraction;
 }

package/dist/entities/fractions/index.d.ts

@@ -0,0 +1,5 @@
+export * from './fraction';
+export * from './percent';
+export * from './tokenAmount';
+export * from './currencyAmount';
+export * from './price';

package/dist/entities/fractions/percent.d.ts

@@ -0,0 +1,6 @@
+import { Rounding } from '../../constants';
+import { Fraction } from './fraction';
+export declare class Percent extends Fraction {
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/dist/entities/fractions/price.d.ts

@@ -0,0 +1,19 @@
+import { BigintIsh, Rounding } from '../../constants';
+import { Currency } from '../currency';
+import { Route } from '../route';
+import { Fraction } from './fraction';
+import { CurrencyAmount } from './currencyAmount';
+export declare class Price extends Fraction {
+    readonly baseCurrency: Currency;
+    readonly quoteCurrency: Currency;
+    readonly scalar: Fraction;
+    static fromRoute(route: Route): Price;
+    constructor(baseCurrency: Currency, quoteCurrency: Currency, denominator: BigintIsh, numerator: BigintIsh);
+    get raw(): Fraction;
+    get adjusted(): Fraction;
+    invert(): Price;
+    multiply(other: Price): Price;
+    quote(currencyAmount: CurrencyAmount): CurrencyAmount;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/dist/entities/fractions/tokenAmount.d.ts

@@ -0,0 +1,9 @@
+import { CurrencyAmount } from './currencyAmount';
+import { Token } from '../token';
+import { BigintIsh } from '../../constants';
+export declare class TokenAmount extends CurrencyAmount {
+    readonly token: Token;
+    constructor(token: Token, amount: BigintIsh);
+    add(other: TokenAmount): TokenAmount;
+    subtract(other: TokenAmount): TokenAmount;
+}

package/dist/entities/index.d.ts

@@ -1,14 +1,6 @@
-export * from './AbstractCurrency';
-export * from './Currency';
-export * from './CurrencyAmount';
-export * from './ConstantProductPool';
-export * from './Fraction';
-export * from './NativeCurrency';
-export * from './Pair';
-export * from './Percent';
-export * from './Price';
-export * from './Route';
-export * from './Token';
-export * from './Trade';
-export * from './Native';
-export * from './eip712';
+export * from './token';
+export * from './pair';
+export * from './route';
+export * from './trade';
+export * from './currency';
+export * from './fractions';

package/dist/entities/pair.d.ts

@@ -0,0 +1,41 @@
+import { Price } from './fractions/price';
+import { TokenAmount } from './fractions/tokenAmount';
+import { BigintIsh, ChainId } from '../constants';
+import { Token } from './token';
+export declare class Pair {
+    readonly liquidityToken: Token;
+    private readonly tokenAmounts;
+    static getAddress(tokenA: Token, tokenB: Token): string;
+    constructor(tokenAmountA: TokenAmount, tokenAmountB: TokenAmount);
+    /**
+     * 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;
+    /**
+     * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
+     */
+    get token1Price(): Price;
+    /**
+     * 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;
+    /**
+     * Returns the chain ID of the tokens in the pair.
+     */
+    get chainId(): ChainId;
+    get token0(): Token;
+    get token1(): Token;
+    get reserve0(): TokenAmount;
+    get reserve1(): TokenAmount;
+    reserveOf(token: Token): TokenAmount;
+    getOutputAmount(inputAmount: TokenAmount): [TokenAmount, Pair];
+    getInputAmount(outputAmount: TokenAmount): [TokenAmount, Pair];
+    getLiquidityMinted(totalSupply: TokenAmount, tokenAmountA: TokenAmount, tokenAmountB: TokenAmount): TokenAmount;
+    getLiquidityValue(token: Token, totalSupply: TokenAmount, liquidity: TokenAmount, feeOn?: boolean, kLast?: BigintIsh): TokenAmount;
+}

package/dist/entities/route.d.ts

@@ -0,0 +1,14 @@
+import { ChainId } from '../constants';
+import { Currency } from './currency';
+import { Token } from './token';
+import { Pair } from './pair';
+import { Price } from './fractions/price';
+export declare class Route {
+    readonly pairs: Pair[];
+    readonly path: Token[];
+    readonly input: Currency;
+    readonly output: Currency;
+    readonly midPrice: Price;
+    constructor(pairs: Pair[], input: Currency, output?: Currency);
+    get chainId(): ChainId;
+}

package/dist/entities/{Token.d.ts → token.d.ts}

@@ -1,20 +1,17 @@
-import { AbstractCurrency } from './AbstractCurrency';
-import { ChainId } from '../enums';
-import { Currency } from './Currency';
+import { ChainId } from '../constants';
+import { Currency } from './currency';
 /**
  * Represents an ERC20 token with a unique address and some metadata.
  */
-export declare class Token extends AbstractCurrency {
+export declare class Token extends Currency {
     readonly chainId: ChainId;
     readonly address: string;
-    readonly isNative: false;
-    readonly isToken: true;
     constructor(chainId: ChainId, address: string, decimals: number, symbol?: string, name?: string);
     /**
      * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
      * @param other other token to compare
      */
-    equals(other: Currency): boolean;
+    equals(other: Token): boolean;
     /**
      * Returns true if the address of this token sorts before the address of the other token
      * @param other other token to compare
@@ -22,12 +19,33 @@ export declare class Token extends AbstractCurrency {
      * @throws if the tokens are on different chains
      */
     sortsBefore(other: Token): boolean;
-    /**
-     * Return this token, which does not need to be wrapped
-     */
-    get wrapped(): Token;
 }
 /**
  * Compares two currencies for equality
  */
 export declare function currencyEquals(currencyA: Currency, currencyB: Currency): boolean;
+export declare const WETH: {
+    1: Token;
+    3: Token;
+    4: Token;
+    5: Token;
+    42: Token;
+    250: Token;
+    4002: Token;
+    137: Token;
+    80001: Token;
+    100: Token;
+    56: Token;
+    97: Token;
+    42161: Token;
+    1287: Token;
+    43114: Token;
+    43113: Token;
+    128: Token;
+    256: Token;
+    1666600000: Token;
+    1666700000: Token;
+    25: Token;
+    10: Token;
+    1285: Token;
+};

package/dist/entities/{Trade.d.ts → trade.d.ts}

@@ -1,16 +1,16 @@
-import { Currency } from './Currency';
-import { CurrencyAmount } from './CurrencyAmount';
-import { Pair } from './Pair';
-import { Percent } from './Percent';
-import { Price } from './Price';
-import { Route } from './Route';
-import { TradeType } from '../enums';
-interface InputOutput<TInput extends Currency, TOutput extends Currency> {
-    readonly inputAmount: CurrencyAmount<TInput>;
-    readonly outputAmount: CurrencyAmount<TOutput>;
+import { TradeType } from '../constants';
+import { Currency } from './currency';
+import { CurrencyAmount } from './fractions/currencyAmount';
+import { Percent } from './fractions/percent';
+import { Price } from './fractions/price';
+import { Pair } from './pair';
+import { Route } from './route';
+interface InputOutput {
+    readonly inputAmount: CurrencyAmount;
+    readonly outputAmount: CurrencyAmount;
 }
-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 declare function inputOutputComparator(a: InputOutput, b: InputOutput): number;
+export declare function tradeComparator(a: Trade, b: Trade): number;
 export interface BestTradeOptions {
     maxNumResults?: number;
     maxHops?: number;
@@ -19,27 +19,31 @@ export interface BestTradeOptions {
  * 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> {
+export declare class Trade {
     /**
-     * The route of the trade, i.e. which pairs the trade goes through and the input/output currencies.
+     * The route of the trade, i.e. which pairs the trade goes through.
      */
-    readonly route: Route<TInput, TOutput>;
+    readonly route: Route;
     /**
      * The type of the trade, either exact in or exact out.
      */
-    readonly tradeType: TTradeType;
+    readonly tradeType: TradeType;
     /**
      * The input amount for the trade assuming no slippage.
      */
-    readonly inputAmount: CurrencyAmount<TInput>;
+    readonly inputAmount: CurrencyAmount;
     /**
      * The output amount for the trade assuming no slippage.
      */
-    readonly outputAmount: CurrencyAmount<TOutput>;
+    readonly outputAmount: CurrencyAmount;
     /**
      * The price expressed in terms of output amount/input amount.
      */
-    readonly executionPrice: Price<TInput, TOutput>;
+    readonly executionPrice: Price;
+    /**
+     * The mid price after the trade executes assuming no slippage.
+     */
+    readonly nextMidPrice: Price;
     /**
      * The percent difference between the mid price before the trade and the trade execution price.
      */
@@ -49,44 +53,39 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @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>;
+    static exactIn(route: Route, amountIn: CurrencyAmount): Trade;
     /**
      * 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);
+    static exactOut(route: Route, amountOut: CurrencyAmount): Trade;
+    constructor(route: Route, amount: CurrencyAmount, tradeType: TradeType);
     /**
      * 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>;
+    minimumAmountOut(slippageTolerance: Percent): CurrencyAmount;
     /**
      * 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>;
+    maximumAmountIn(slippageTolerance: Percent): CurrencyAmount;
     /**
      * 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 currencyAmountIn 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 originalAmountIn 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>;
+    static bestTradeExactIn(pairs: Pair[], currencyAmountIn: CurrencyAmount, currencyOut: Currency, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], originalAmountIn?: CurrencyAmount, bestTrades?: Trade[]): Trade[];
     /**
      * 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
@@ -95,13 +94,13 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * 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 currencyAmountOut 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 originalAmountOut 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>[];
+    static bestTradeExactOut(pairs: Pair[], currencyIn: Currency, currencyAmountOut: CurrencyAmount, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], originalAmountOut?: CurrencyAmount, bestTrades?: Trade[]): Trade[];
 }
 export {};

package/dist/fetcher.d.ts

@@ -0,0 +1,28 @@
+import { Pair } from './entities/pair';
+import { ChainId } from './constants';
+import { Token } from './entities/token';
+/**
+ * Contains methods for constructing instances of pairs and tokens from on-chain data.
+ */
+export declare abstract class Fetcher {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * Fetch information for a given token on the given chain, using the given ethers provider.
+     * @param chainId chain of the token
+     * @param address address of the token on the chain
+     * @param provider provider used to fetch the token
+     * @param symbol optional symbol of the token
+     * @param name optional name of the token
+     */
+    static fetchTokenData(chainId: ChainId, address: string, provider?: import("@ethersproject/providers").BaseProvider, symbol?: string, name?: string): Promise<Token>;
+    /**
+     * Fetches information about a pair and constructs a pair from the given two tokens.
+     * @param tokenA first token
+     * @param tokenB second token
+     * @param provider the provider to use to fetch the data
+     */
+    static fetchPairData(tokenA: Token, tokenB: Token, provider?: import("@ethersproject/providers").BaseProvider): Promise<Pair>;
+}

package/dist/index.d.ts

@@ -1,12 +1,7 @@
 import JSBI from 'jsbi';
 export { JSBI };
-export * from './constants';
+export { BigintIsh, ChainId, TradeType, Rounding, FACTORY_ADDRESS, INIT_CODE_HASH, ROUTER_ADDRESS, SUSHI_ADDRESS, MASTERCHEF_ADDRESS, BAR_ADDRESS, MAKER_ADDRESS, TIMELOCK_ADDRESS, MINIMUM_LIQUIDITY } from './constants';
 export * from './errors';
 export * from './entities';
-export * from './functions';
 export * from './router';
-export * from './enums';
-export * from './router';
-export * from './types';
-export * from './utils/MultiRouterMath';
-export * from './limitorder';
+export * from './fetcher';

package/dist/router.d.ts

@@ -1,8 +1,4 @@
-import { Currency } from './entities/Currency';
-import { CurrencyAmount } from './entities/CurrencyAmount';
-import { Percent } from './entities/Percent';
-import { Trade } from './entities/Trade';
-import { TradeType } from './enums/TradeType';
+import { Percent, Trade } from './entities';
 /**
  * Options for producing the arguments to send call to the router.
  */
@@ -50,7 +46,6 @@ export interface SwapParameters {
      */
     value: string;
 }
-export declare function toHex(currencyAmount: CurrencyAmount<Currency>): string;
 /**
  * Represents the Uniswap V2 Router, and has static methods for helping execute trades.
  */
@@ -64,5 +59,5 @@ export declare abstract class Router {
      * @param trade to produce call parameters for
      * @param options options for the call parameters
      */
-    static swapCallParameters(trade: Trade<Currency, Currency, TradeType>, options: TradeOptions | TradeOptionsDeadline): SwapParameters;
+    static swapCallParameters(trade: Trade, options: TradeOptions | TradeOptionsDeadline): SwapParameters;
 }