@qidao/sdk 5.0.0-canary.117

package/dist/entities/Pair.d.ts

@@ -0,0 +1,41 @@
+import { BigintIsh } from '../types';
+import { CurrencyAmount } from './CurrencyAmount';
+import { Price } from './Price';
+import { Token } from './Token';
+export declare class Pair {
+    readonly liquidityToken: Token;
+    private readonly tokenAmounts;
+    static getAddress(tokenA: Token, tokenB: Token): string;
+    constructor(currencyAmountA: CurrencyAmount<Token>, currencyAmountB: 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>;
+    getOutputAmount(inputAmount: CurrencyAmount<Token>): [CurrencyAmount<Token>, Pair];
+    getInputAmount(outputAmount: CurrencyAmount<Token>): [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>;
+}

package/dist/entities/Percent.d.ts

@@ -0,0 +1,15 @@
+import { BigintIsh } from '../types';
+import { Fraction } from './Fraction';
+import { Rounding } from '../enums';
+export declare class Percent extends Fraction {
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
+    readonly isPercent: true;
+    add(other: Fraction | BigintIsh): Percent;
+    subtract(other: Fraction | BigintIsh): Percent;
+    multiply(other: Fraction | BigintIsh): Percent;
+    divide(other: Fraction | BigintIsh): Percent;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/dist/entities/Price.d.ts

@@ -0,0 +1,39 @@
+import { BigintIsh } from '../types';
+import { Currency } from './Currency';
+import { CurrencyAmount } from './CurrencyAmount';
+import { Fraction } from './Fraction';
+import { Rounding } from '../enums';
+export declare class Price<TBase extends Currency, TQuote extends Currency> extends Fraction {
+    readonly baseCurrency: TBase;
+    readonly quoteCurrency: TQuote;
+    readonly scalar: Fraction;
+    /**
+     * Construct a price, either with the base and quote currency amount, or the
+     * @param args
+     */
+    constructor(...args: [TBase, TQuote, BigintIsh, BigintIsh] | [{
+        baseAmount: CurrencyAmount<TBase>;
+        quoteAmount: CurrencyAmount<TQuote>;
+    }]);
+    /**
+     * Flip the price, switching the base and quote currency
+     */
+    invert(): Price<TQuote, TBase>;
+    /**
+     * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+     * @param other the other price
+     */
+    multiply<TOtherQuote extends Currency>(other: Price<TQuote, TOtherQuote>): Price<TBase, TOtherQuote>;
+    /**
+     * Return the amount of quote currency corresponding to a given amount of the base currency
+     * @param currencyAmount the amount of base currency to quote against the price
+     */
+    quote(currencyAmount: CurrencyAmount<TBase>): CurrencyAmount<TQuote>;
+    /**
+     * Get the value scaled by decimals for formatting
+     * @private
+     */
+    private get adjustedForDecimals();
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

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

@@ -0,0 +1,33 @@
+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 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: Currency): boolean;
+    /**
+     * Returns true if the address of this token sorts before the address of the other token
+     * @param other other token to compare
+     * @throws if the tokens have the same address
+     * @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;

package/dist/entities/Trade.d.ts

@@ -0,0 +1,107 @@
+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<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/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

@@ -0,0 +1,14 @@
+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,31 @@
+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,
+    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/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/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

@@ -0,0 +1,12 @@
+import JSBI from 'jsbi';
+export { JSBI };
+export * 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';

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./sdk.cjs.production.min.js')
+} else {
+  module.exports = require('./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';