@dodoex/widgets 3.2.2 → 3.2.4-beta.1

package/dist/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/entities/fractions/price.d.ts

@@ -0,0 +1,38 @@
+import { BigintIsh, Rounding } from '../../constants';
+import { Currency } from '../currency';
+import { Fraction } from './fraction';
+import { CurrencyAmount } from './currencyAmount';
+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/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/entities/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fractions';
+export * from './currency';
+export * from './nativeCurrencyClass';
+export * from './token';

package/dist/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/entities/nativeCurrency.d.ts

@@ -0,0 +1,16 @@
+import { ChainId } from '@dodoex/api';
+import { Currency, NativeCurrencyClass, Token } from '..';
+export declare class NativeCurrency implements NativeCurrencyClass {
+    constructor(chainId: number);
+    chainId: ChainId;
+    decimals: number;
+    name: string;
+    symbol: string;
+    isNative: true;
+    isToken: false;
+    address: string;
+    equals(currency: Currency): boolean;
+    get wrapped(): Token;
+    private static _cachedNativeCurrency;
+    static onChain(chainId: number): NativeCurrency;
+}

package/dist/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/entities/nativeCurrencyClass.d.ts

@@ -0,0 +1,8 @@
+import { BaseCurrency } from './baseCurrency';
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+export declare abstract class NativeCurrencyClass extends BaseCurrency {
+    readonly isNative: true;
+    readonly isToken: false;
+}

package/dist/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/entities/token.d.ts

@@ -0,0 +1,48 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { BaseCurrency } from './baseCurrency';
+import { Currency } from './currency';
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+export declare class Token extends BaseCurrency {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * Relevant for fee-on-transfer (FOT) token taxes,
+     * Not every ERC20 token is FOT token, so this field is optional
+     */
+    readonly buyFeeBps?: BigNumber;
+    readonly sellFeeBps?: BigNumber;
+    /**
+     *
+     * @param chainId {@link BaseCurrency#chainId}
+     * @param address The contract address on the chain on which this token lives
+     * @param decimals {@link BaseCurrency#decimals}
+     * @param symbol {@link BaseCurrency#symbol}
+     * @param name {@link BaseCurrency#name}
+     * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+     * @param buyFeeBps Buy fee tax for FOT tokens, in basis points
+     * @param sellFeeBps Sell fee tax for FOT tokens, in basis points
+     */
+    constructor(chainId: number, address: string, decimals: number, symbol?: string, name?: string, bypassChecksum?: boolean, buyFeeBps?: BigNumber, sellFeeBps?: BigNumber);
+    /**
+     * 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;
+}

package/dist/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/index.d.ts

@@ -0,0 +1,5 @@
+export * from './addresses';
+export * from './chains';
+export * from './constants';
+export * from './entities';
+export * from './utils';

package/dist/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/utils/computePriceImpact.d.ts

@@ -0,0 +1,8 @@
+import { Currency, CurrencyAmount, Percent, Price } from '../entities';
+/**
+ * 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/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { computePriceImpact } from './computePriceImpact';
+export { sortedInsert } from './sortedInsert';
+export { sqrt } from './sqrt';
+export { validateAndParseAddress } from './validateAndParseAddress';

package/dist/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/utils/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/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/utils/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/types/widgets/PoolWidget/AMMV3/sdks/sdk-core/utils/validateAndParseAddress.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validates an address and returns the parsed (checksummed) version of that address
+ * @param address the unchecksummed hex address
+ */
+export declare function validateAndParseAddress(address: string): string;
+/**
+ * Checks if an address is valid by checking 0x prefix, length === 42 and hex encoding.
+ * @param address the unchecksummed hex address
+ */
+export declare function checkValidAddress(address: string): string;

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/constants.d.ts

@@ -0,0 +1,32 @@
+import { ChainId } from '../sdk-core';
+/**
+ * Taiko UniswapV3Factory
+ * @see https://taikoscan.io/address/0x78172691DD3B8ADa7aEbd9bFfB487FB11D735DB2?tab=contract#code
+ */
+export declare const FACTORY_ADDRESS = "0x78172691DD3B8ADa7aEbd9bFfB487FB11D735DB2";
+export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+export declare const POOL_INIT_CODE_HASH = "0x5ccd5621c1bb9e44ce98cef8b90d31eb2423dec3793b6239232cefae976936ea";
+/**
+ * Taiko  POOL_INIT_CODE_HASH
+ * @see PoolAddress.sol
+ * @see https://taikoscan.io/address/0x202bEE65B164aEcBb6A2318438bf46bEF14E1072?tab=contract#code#F12#L6
+ */
+export declare function poolInitCodeHash(chainId?: ChainId): string;
+/**
+ * The default factory enabled fee amounts, denominated in hundredths of bips.
+ */
+export declare enum FeeAmount {
+    LOWEST = 100,
+    LOW_200 = 200,
+    LOW_300 = 300,
+    LOW_400 = 400,
+    LOW = 500,
+    MEDIUM = 3000,
+    HIGH = 10000
+}
+/**
+ * The default factory tick spacings by fee amount.
+ */
+export declare const TICK_SPACINGS: {
+    [amount in FeeAmount]: number;
+};

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/entities/index.d.ts

@@ -0,0 +1,7 @@
+export * from './pool';
+export * from './position';
+export * from './route';
+export * from './tick';
+export * from './trade';
+export * from './tickDataProvider';
+export * from './tickListDataProvider';

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/entities/pool.d.ts

@@ -0,0 +1,81 @@
+import JSBI from 'jsbi';
+import { BigintIsh, CurrencyAmount, Price, Token } from '../../sdk-core';
+import { FeeAmount } from '../constants';
+import { Tick, TickConstructorArgs } from './tick';
+import { TickDataProvider } from './tickDataProvider';
+/**
+ * Represents a V3 pool
+ */
+export declare class Pool {
+    readonly token0: Token;
+    readonly token1: Token;
+    readonly fee: FeeAmount;
+    readonly sqrtRatioX96: JSBI;
+    readonly liquidity: JSBI;
+    readonly tickCurrent: number;
+    readonly tickDataProvider: TickDataProvider;
+    private _token0Price?;
+    private _token1Price?;
+    static getAddress(tokenA: Token, tokenB: Token, fee: FeeAmount, initCodeHashManualOverride?: string, factoryAddressOverride?: string): string;
+    /**
+     * Construct a pool
+     * @param tokenA One of the tokens in the pool
+     * @param tokenB The other token in the pool
+     * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+     * @param sqrtRatioX96 The sqrt of the current ratio of amounts of token1 to token0
+     * @param liquidity The current value of in range liquidity
+     * @param tickCurrent The current tick of the pool
+     * @param ticks The current state of the pool ticks or a data provider that can return tick data
+     */
+    constructor(tokenA: Token, tokenB: Token, fee: FeeAmount, sqrtRatioX96: BigintIsh, liquidity: BigintIsh, tickCurrent: number, ticks?: TickDataProvider | (Tick | TickConstructorArgs)[]);
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token The token to check
+     * @returns True if token is either token0 or token
+     */
+    involvesToken(token: Token): boolean;
+    /**
+     * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+     */
+    get token0Price(): Price<Token, Token>;
+    /**
+     * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+     */
+    get token1Price(): Price<Token, Token>;
+    /**
+     * Return the price of the given token in terms of the other token in the pool.
+     * @param token The token to return price of
+     * @returns The price of the given token, in terms of the other.
+     */
+    priceOf(token: Token): Price<Token, Token>;
+    /**
+     * Returns the chain ID of the tokens in the pool.
+     */
+    get chainId(): number;
+    /**
+     * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+     * @param inputAmount The input amount for which to quote the output amount
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit
+     * @returns The output amount and the pool with updated state
+     */
+    getOutputAmount(inputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+     * @param outputAmount the output amount for which to quote the input amount
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns The input amount and the pool with updated state
+     */
+    getInputAmount(outputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * Executes a swap
+     * @param zeroForOne Whether the amount in is token0 or token1
+     * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns amountCalculated
+     * @returns sqrtRatioX96
+     * @returns liquidity
+     * @returns tickCurrent
+     */
+    private swap;
+    get tickSpacing(): number;
+}

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/entities/position.d.ts

@@ -0,0 +1,131 @@
+import JSBI from 'jsbi';
+import { BigintIsh, CurrencyAmount, Percent, Price, Token } from '../../sdk-core';
+import { Pool } from './pool';
+interface PositionConstructorArgs {
+    pool: Pool;
+    tickLower: number;
+    tickUpper: number;
+    liquidity: BigintIsh;
+}
+/**
+ * Represents a position on a Uniswap V3 Pool
+ */
+export declare class Position {
+    readonly pool: Pool;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly liquidity: JSBI;
+    private _token0Amount;
+    private _token1Amount;
+    private _mintAmounts;
+    /**
+     * Constructs a position for a given pool with the given liquidity
+     * @param pool For which pool the liquidity is assigned
+     * @param liquidity The amount of liquidity that is in the position
+     * @param tickLower The lower tick of the position
+     * @param tickUpper The upper tick of the position
+     */
+    constructor({ pool, liquidity, tickLower, tickUpper, }: PositionConstructorArgs);
+    /**
+     * Returns the price of token0 at the lower tick
+     */
+    get token0PriceLower(): Price<Token, Token>;
+    /**
+     * Returns the price of token0 at the upper tick
+     */
+    get token0PriceUpper(): Price<Token, Token>;
+    /**
+     * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+     */
+    get amount0(): CurrencyAmount<Token>;
+    /**
+     * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+     */
+    get amount1(): CurrencyAmount<Token>;
+    /**
+     * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+     * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+     * @returns The sqrt ratios after slippage
+     */
+    private ratiosAfterSlippage;
+    /**
+     * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
+     * with the given slippage tolerance
+     * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    mintAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+     * position with the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    burnAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+     * the current price for the pool
+     */
+    get mintAmounts(): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+     * and the prices at the tick boundaries.
+     * @param pool The pool for which the position should be created
+     * @param tickLower The lower tick of the position
+     * @param tickUpper The upper tick of the position
+     * @param amount0 token0 amount
+     * @param amount1 token1 amount
+     * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The amount of liquidity for the position
+     */
+    static fromAmounts({ pool, tickLower, tickUpper, amount0, amount1, useFullPrecision, }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount0: BigintIsh;
+        amount1: BigintIsh;
+        useFullPrecision: boolean;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of token0, assuming an unlimited amount of token1
+     * @param pool The pool for which the position is created
+     * @param tickLower The lower tick
+     * @param tickUpper The upper tick
+     * @param amount0 The desired amount of token0
+     * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The position
+     */
+    static fromAmount0({ pool, tickLower, tickUpper, amount0, useFullPrecision, }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount0: BigintIsh;
+        useFullPrecision: boolean;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
+     * @param pool The pool for which the position is created
+     * @param tickLower The lower tick
+     * @param tickUpper The upper tick
+     * @param amount1 The desired amount of token1
+     * @returns The position
+     */
+    static fromAmount1({ pool, tickLower, tickUpper, amount1, }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount1: BigintIsh;
+    }): Position;
+}
+export {};

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/entities/route.d.ts

@@ -0,0 +1,26 @@
+import { Currency, Price, Token } from '../../sdk-core';
+import { Pool } from './pool';
+/**
+ * Represents a list of pools through which a swap can occur
+ * @template TInput The input token
+ * @template TOutput The output token
+ */
+export declare class Route<TInput extends Currency, TOutput extends Currency> {
+    readonly pools: Pool[];
+    readonly tokenPath: Token[];
+    readonly input: TInput;
+    readonly output: TOutput;
+    private _midPrice;
+    /**
+     * Creates an instance of route.
+     * @param pools An array of `Pool` objects, ordered by the route the swap will take
+     * @param input The input token
+     * @param output The output token
+     */
+    constructor(pools: Pool[], input: TInput, output: TOutput);
+    get chainId(): number;
+    /**
+     * Returns the mid price of the route
+     */
+    get midPrice(): Price<TInput, TOutput>;
+}

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/entities/tick.d.ts

@@ -0,0 +1,13 @@
+import JSBI from 'jsbi';
+import { BigintIsh } from '../../sdk-core';
+export interface TickConstructorArgs {
+    index: number;
+    liquidityGross: BigintIsh;
+    liquidityNet: BigintIsh;
+}
+export declare class Tick {
+    readonly index: number;
+    readonly liquidityGross: JSBI;
+    readonly liquidityNet: JSBI;
+    constructor({ index, liquidityGross, liquidityNet }: TickConstructorArgs);
+}

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/entities/tickDataProvider.d.ts

@@ -0,0 +1,31 @@
+import { BigintIsh } from '../../sdk-core';
+/**
+ * Provides information about ticks
+ */
+export interface TickDataProvider {
+    /**
+     * Return information corresponding to a specific tick
+     * @param tick the tick to load
+     */
+    getTick(tick: number): Promise<{
+        liquidityNet: BigintIsh;
+    }>;
+    /**
+     * Return the next tick that is initialized within a single word
+     * @param tick The current tick
+     * @param lte Whether the next tick should be lte the current tick
+     * @param tickSpacing The tick spacing of the pool
+     */
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+}
+/**
+ * This tick data provider does not know how to fetch any tick data. It throws whenever it is required. Useful if you
+ * do not need to load tick data for your use case.
+ */
+export declare class NoTickDataProvider implements TickDataProvider {
+    private static ERROR_MESSAGE;
+    getTick(_tick: number): Promise<{
+        liquidityNet: BigintIsh;
+    }>;
+    nextInitializedTickWithinOneWord(_tick: number, _lte: boolean, _tickSpacing: number): Promise<[number, boolean]>;
+}

package/dist/types/widgets/PoolWidget/AMMV3/sdks/v3-sdk/entities/tickListDataProvider.d.ts

@@ -0,0 +1,15 @@
+import { BigintIsh } from '../../sdk-core';
+import { Tick, TickConstructorArgs } from './tick';
+import { TickDataProvider } from './tickDataProvider';
+/**
+ * A data provider for ticks that is backed by an in-memory array of ticks.
+ */
+export declare class TickListDataProvider implements TickDataProvider {
+    private ticks;
+    constructor(ticks: (Tick | TickConstructorArgs)[], tickSpacing: number);
+    getTick(tick: number): Promise<{
+        liquidityNet: BigintIsh;
+        liquidityGross: BigintIsh;
+    }>;
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+}