@qidao/sdk 5.0.8 → 5.0.9

package/dist/entities/Route.d.ts

@@ -0,0 +1,14 @@
+import { Currency } from './Currency';
+import { Pair } from './Pair';
+import { Price } from './Price';
+import { Token } from './Token';
+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/{token.d.ts → Token.d.ts}

@@ -1,17 +1,20 @@
-import { ChainId } from '../constants';
-import { Currency } from './currency';
+import { AbstractCurrency } from './AbstractCurrency';
+import { ChainId } from '../enums';
+import { Currency } from './Currency';
 /**
  * Represents an ERC20 token with a unique address and some metadata.
  */
-export declare class Token extends Currency {
+export declare class Token extends AbstractCurrency {
     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: Token): boolean;
+    equals(other: Currency): boolean;
     /**
      * Returns true if the address of this token sorts before the address of the other token
      * @param other other token to compare
@@ -19,44 +22,12 @@ export declare class Token extends Currency {
      * @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;
-    1285: Token;
-    25: Token;
-    10: Token;
-    57: Token;
-    1088: Token;
-    1284: Token;
-    2001: Token;
-    2222: Token;
-    4689: Token;
-    8217: Token;
-    42220: Token;
-    1313161554: Token;
-    288: Token;
-    1818: Token;
-};

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

@@ -1,16 +1,16 @@
-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;
+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>;
 }
-export declare function inputOutputComparator(a: InputOutput, b: InputOutput): number;
-export declare function tradeComparator(a: Trade, b: Trade): number;
+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;
@@ -19,31 +19,27 @@ 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 {
+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.
+     * The route of the trade, i.e. which pairs the trade goes through and the input/output currencies.
      */
-    readonly route: Route;
+    readonly route: Route<TInput, TOutput>;
     /**
      * The type of the trade, either exact in or exact out.
      */
-    readonly tradeType: TradeType;
+    readonly tradeType: TTradeType;
     /**
      * The input amount for the trade assuming no slippage.
      */
-    readonly inputAmount: CurrencyAmount;
+    readonly inputAmount: CurrencyAmount<TInput>;
     /**
      * The output amount for the trade assuming no slippage.
      */
-    readonly outputAmount: CurrencyAmount;
+    readonly outputAmount: CurrencyAmount<TOutput>;
     /**
      * The price expressed in terms of output amount/input amount.
      */
-    readonly executionPrice: Price;
-    /**
-     * The mid price after the trade executes assuming no slippage.
-     */
-    readonly nextMidPrice: Price;
+    readonly executionPrice: Price<TInput, TOutput>;
     /**
      * The percent difference between the mid price before the trade and the trade execution price.
      */
@@ -53,39 +49,44 @@ export declare class Trade {
      * @param route route of the exact in trade
      * @param amountIn the amount being passed in
      */
-    static exactIn(route: Route, amountIn: CurrencyAmount): Trade;
+    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(route: Route, amountOut: CurrencyAmount): Trade;
-    constructor(route: Route, amount: CurrencyAmount, tradeType: TradeType);
+    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;
+    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;
+    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 currencyAmountIn exact amount of input currency to spend
+     * @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 originalAmountIn used in recursion; the original value of the currencyAmountIn parameter
+     * @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(pairs: Pair[], currencyAmountIn: CurrencyAmount, currencyOut: Currency, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], originalAmountIn?: CurrencyAmount, bestTrades?: Trade[]): Trade[];
+    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
@@ -94,13 +95,13 @@ export declare class Trade {
      * the amount in among multiple routes.
      * @param pairs the pairs to consider in finding the best trade
      * @param currencyIn the currency to spend
-     * @param currencyAmountOut the exact amount of currency out
+     * @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 originalAmountOut used in recursion; the original value of the currencyAmountOut parameter
+     * @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(pairs: Pair[], currencyIn: Currency, currencyAmountOut: CurrencyAmount, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], originalAmountOut?: CurrencyAmount, bestTrades?: Trade[]): Trade[];
+    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/entities/eip712.d.ts

@@ -0,0 +1,78 @@
+import { ChainId } from '../enums';
+import { Web3Provider } from '@ethersproject/providers';
+export interface Domain {
+    name: string;
+    chainId: ChainId;
+    verifyingContract: string;
+}
+export interface Message {
+    maker: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    amountOut: string;
+    recipient: string;
+    startTime: string;
+    endTime: string;
+    stopPrice: string;
+    oracleAddress: string;
+    oracleData: string;
+}
+export interface BentoApprovalMessage {
+    warning: string;
+    user: string;
+    masterContract: string;
+    approved: boolean;
+    nonce: number;
+}
+export declare const getSignature: (message: Message, chainId: ChainId, privateKey: string) => {
+    v: number;
+    r: string;
+    s: string;
+};
+export declare const getTypedData: (message: Message, chainId: ChainId) => {
+    types: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        LimitOrder: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: string;
+    domain: Domain;
+    message: Message;
+};
+export declare const getTypedDataBento: (message: BentoApprovalMessage, chainId: ChainId) => {
+    types: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        SetMasterContractApproval: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: string;
+    domain: Domain;
+    message: BentoApprovalMessage;
+};
+export declare const getTypeHash: (typedData: any) => string;
+export declare const getSignatureWithProvider: (message: Message, chainId: ChainId, provider: Web3Provider) => Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+export declare const getSignatureWithProviderBentobox: (message: BentoApprovalMessage, chainId: ChainId, provider: Web3Provider) => Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+export declare const getSignatureBento: (bentoApproval: BentoApprovalMessage, chainId: ChainId, privateKey: string) => Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;

package/dist/entities/index.d.ts

@@ -1,6 +1,14 @@
-export * from './token';
-export * from './pair';
-export * from './route';
-export * from './trade';
-export * from './currency';
-export * from './fractions';
+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';

package/dist/enums/ChainId.d.ts

@@ -0,0 +1,32 @@
+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,
+    ARBITRUM_TESTNET = 79377087078960,
+    MOONBEAM_TESTNET = 1287,
+    MOONBEAM = 1284,
+    AVALANCHE = 43114,
+    AVALANCHE_TESTNET = 43113,
+    HECO = 128,
+    HECO_TESTNET = 256,
+    HARMONY = 1666600000,
+    HARMONY_TESTNET = 1666700000,
+    OKEX = 66,
+    OKEX_TESTNET = 65,
+    CELO = 42220,
+    PALM = 11297108109,
+    PALM_TESTNET = 11297108099,
+    MOONRIVER = 1285,
+    FUSE = 122,
+    TELOS = 40
+}

package/dist/enums/Fee.d.ts

@@ -0,0 +1,3 @@
+export declare enum Fee {
+    DEFAULT = 30
+}

package/dist/enums/KashiAction.d.ts

@@ -0,0 +1,18 @@
+export declare enum KashiAction {
+    ADD_ASSET = 1,
+    REPAY = 2,
+    REMOVE_ASSET = 3,
+    REMOVE_COLLATERAL = 4,
+    BORROW = 5,
+    GET_REPAY_SHARE = 6,
+    GET_REPAY_PART = 7,
+    ACCRUE = 8,
+    ADD_COLLATERAL = 10,
+    UPDATE_EXCHANGE_RATE = 11,
+    BENTO_DEPOSIT = 20,
+    BENTO_WITHDRAW = 21,
+    BENTO_TRANSFER = 22,
+    BENTO_TRANSFER_MULTIPLE = 23,
+    BENTO_SETAPPROVAL = 24,
+    CALL = 30
+}

package/dist/enums/OrderStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum OrderStatus {
+    FILLED = "FILLED",
+    CANCELLED = "CANCELLED",
+    EXPIRED = "EXPIRED",
+    PENDING = "PENDING"
+}

package/dist/enums/Rounding.d.ts

@@ -0,0 +1,5 @@
+export declare enum Rounding {
+    ROUND_DOWN = 0,
+    ROUND_HALF_UP = 1,
+    ROUND_UP = 2
+}

package/dist/enums/TradeType.d.ts

@@ -0,0 +1,4 @@
+export declare enum TradeType {
+    EXACT_INPUT = 0,
+    EXACT_OUTPUT = 1
+}

package/dist/enums/index.d.ts

@@ -0,0 +1,6 @@
+export { ChainId } from './ChainId';
+export { Rounding } from './Rounding';
+export { TradeType } from './TradeType';
+export { KashiAction } from './KashiAction';
+export { Fee } from './Fee';
+export { OrderStatus } from './OrderStatus';

package/dist/functions/bentobox.d.ts

@@ -0,0 +1,3 @@
+import { BigNumber } from '@ethersproject/bignumber';
+export declare function toAmount(token: any, shares: BigNumber): BigNumber;
+export declare function toShare(token: any, amount: BigNumber): BigNumber;

package/dist/functions/computeConstantProductPoolAddress.d.ts

@@ -0,0 +1,9 @@
+import { Fee } from '../enums';
+import { Token } from '../entities';
+export declare const computeConstantProductPoolAddress: ({ factoryAddress, tokenA, tokenB, fee, twap }: {
+    factoryAddress: string;
+    tokenA: Token;
+    tokenB: Token;
+    fee: Fee;
+    twap: boolean;
+}) => string;

package/dist/functions/computePairAddress.d.ts

@@ -0,0 +1,6 @@
+import { Token } from '../entities';
+export declare const computePairAddress: ({ factoryAddress, tokenA, tokenB }: {
+    factoryAddress: string;
+    tokenA: Token;
+    tokenB: Token;
+}) => string;

package/dist/functions/computePoolInitCodeHash.d.ts

@@ -0,0 +1,5 @@
+export declare const computePoolInitCodeHash: ({ creationCode, deployData, masterDeployerAddress }: {
+    creationCode: string;
+    deployData: string;
+    masterDeployerAddress: string;
+}) => string;

package/dist/functions/computePriceImpact.d.ts

@@ -0,0 +1,11 @@
+import { Currency } from '../entities/Currency';
+import { CurrencyAmount } from '../entities/CurrencyAmount';
+import { Percent } from '../entities/Percent';
+import { Price } from '../entities/Price';
+/**
+ * Returns the percent difference between the mid price and the execution price, i.e. price impact.
+ * @param midPrice mid price before the trade
+ * @param inputAmount the input amount of the trade
+ * @param outputAmount the output amount of the trade
+ */
+export declare function computePriceImpact<TBase extends Currency, TQuote extends Currency>(midPrice: Price<TBase, TQuote>, inputAmount: CurrencyAmount<TBase>, outputAmount: CurrencyAmount<TQuote>): Percent;

package/dist/functions/index.d.ts

@@ -0,0 +1,8 @@
+export { computePairAddress } from './computePairAddress';
+export { computePriceImpact } from './computePriceImpact';
+export { computeConstantProductPoolAddress } from './computeConstantProductPoolAddress';
+export { computePoolInitCodeHash } from './computePoolInitCodeHash';
+export { sortedInsert } from './sortedInsert';
+export { sqrt } from './sqrt';
+export { validateAndParseAddress } from './validateAndParseAddress';
+export { validateSolidityTypeInstance } from './validateSolidityTypeInstance';

package/dist/functions/kashi.d.ts

@@ -0,0 +1,9 @@
+import { BigNumber } from '@ethersproject/bignumber';
+export declare function accrue(pair: any, amount: BigNumber, includePrincipal?: boolean): BigNumber;
+export declare function accrueTotalAssetWithFee(pair: any): {
+    elastic: BigNumber;
+    base: BigNumber;
+};
+export declare function interestAccrue(pair: any, interest: BigNumber): BigNumber;
+export declare function takeFee(amount: BigNumber): BigNumber;
+export declare function addBorrowFee(amount: BigNumber): BigNumber;

package/dist/functions/rebase.d.ts

@@ -0,0 +1,4 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Rebase } from '../interfaces';
+export declare function rebase(value: BigNumber, from: BigNumber, to: BigNumber): BigNumber;
+export declare function toElastic(total: Rebase, base: BigNumber, roundUp: boolean): BigNumber;

package/dist/functions/sortedInsert.d.ts

@@ -0,0 +1 @@
+export declare function sortedInsert<T>(items: T[], add: T, maxSize: number, comparator: (a: T, b: T) => number): T | null;

package/dist/functions/sqrt.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export declare const MAX_SAFE_INTEGER: JSBI;
+/**
+ * Computes floor(sqrt(value))
+ * @param value the value for which to compute the square root, rounded down
+ */
+export declare function sqrt(value: JSBI): JSBI;

package/dist/functions/validateAndParseAddress.d.ts

@@ -0,0 +1 @@
+export declare function validateAndParseAddress(address: string): string;

package/dist/functions/validateSolidityTypeInstance.d.ts

@@ -0,0 +1,3 @@
+import { SolidityType } from '../constants';
+import JSBI from 'jsbi';
+export declare function validateSolidityTypeInstance(value: JSBI, solidityType: SolidityType): void;

package/dist/index.d.ts

@@ -1,7 +1,12 @@
 import JSBI from 'jsbi';
 export { JSBI };
-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 './constants';
 export * from './errors';
 export * from './entities';
+export * from './functions';
 export * from './router';
-export * from './fetcher';
+export * from './enums';
+export * from './router';
+export * from './types';
+export * from './utils/MultiRouterMath';
+export * from './limitorder';

package/dist/index.js

@@ -2,7 +2,7 @@
 'use strict'
 
 if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./sdk.cjs.production.min.js')
+  module.exports = require('./qidao-sdk.cjs.production.min.js')
 } else {
-  module.exports = require('./sdk.cjs.development.js')
+  module.exports = require('./qidao-sdk.cjs.development.js')
 }

package/dist/interfaces/AccrueInfo.d.ts

@@ -0,0 +1,6 @@
+import { BigNumber } from '@ethersproject/bignumber';
+export interface AccrueInfo {
+    interestPerSecond: BigNumber;
+    lastAccrued: BigNumber;
+    feesEarnedFraction: BigNumber;
+}

package/dist/interfaces/Rebase.d.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from '@ethersproject/bignumber';
+export interface Rebase {
+    base: BigNumber;
+    elastic: BigNumber;
+}

package/dist/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export { AccrueInfo } from './AccrueInfo';
+export { Rebase } from './Rebase';