@dodoex/widgets 3.0.2-bartio.1 → 3.0.2-bartio.2

package/dist/types/widgets/PoolWidget/Algebra/hooks/useFetchPositionFromTokenId.d.ts

@@ -0,0 +1,295 @@
+export declare function useFetchPositionFromTokenId({ chainId, tokenId, }: {
+    chainId: number | undefined;
+    tokenId: string | undefined;
+}): {
+    position: {
+        tokenId: string | undefined;
+        pool: string;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        liquidity: bigint;
+        nonce: bigint;
+        operator: string;
+        tickLower: number;
+        tickUpper: number;
+        token0: string;
+        token1: string;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    } | undefined;
+    data: {
+        nonce: bigint;
+        operator: string;
+        token0: string;
+        token1: string;
+        deployer: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidity: bigint;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        nonce: bigint;
+        operator: string;
+        token0: string;
+        token1: string;
+        deployer: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidity: bigint;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    position: {
+        tokenId: string | undefined;
+        pool: string;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        liquidity: bigint;
+        nonce: bigint;
+        operator: string;
+        tickLower: number;
+        tickUpper: number;
+        token0: string;
+        token1: string;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    } | undefined;
+    data: {
+        nonce: bigint;
+        operator: string;
+        token0: string;
+        token1: string;
+        deployer: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidity: bigint;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        nonce: bigint;
+        operator: string;
+        token0: string;
+        token1: string;
+        deployer: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidity: bigint;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    position: {
+        tokenId: string | undefined;
+        pool: string;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        liquidity: bigint;
+        nonce: bigint;
+        operator: string;
+        tickLower: number;
+        tickUpper: number;
+        token0: string;
+        token1: string;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    } | undefined;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        nonce: bigint;
+        operator: string;
+        token0: string;
+        token1: string;
+        deployer: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidity: bigint;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    position: {
+        tokenId: string | undefined;
+        pool: string;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        liquidity: bigint;
+        nonce: bigint;
+        operator: string;
+        tickLower: number;
+        tickUpper: number;
+        token0: string;
+        token1: string;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    } | undefined;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        nonce: bigint;
+        operator: string;
+        token0: string;
+        token1: string;
+        deployer: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidity: bigint;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    position: {
+        tokenId: string | undefined;
+        pool: string;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        liquidity: bigint;
+        nonce: bigint;
+        operator: string;
+        tickLower: number;
+        tickUpper: number;
+        token0: string;
+        token1: string;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    } | undefined;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        nonce: bigint;
+        operator: string;
+        token0: string;
+        token1: string;
+        deployer: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidity: bigint;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};

package/dist/types/widgets/PoolWidget/Algebra/hooks/useFetchPositions.d.ts

@@ -0,0 +1,23 @@
+export declare function useFetchPositions({ account, chainId, }: {
+    account?: string;
+    chainId?: number;
+}): {
+    isError: boolean;
+    isLoading: boolean;
+    refetchError: () => void;
+    positions: {
+        tokenId: number;
+        pool: string;
+        feeGrowthInside0LastX128: bigint;
+        feeGrowthInside1LastX128: bigint;
+        liquidity: bigint;
+        nonce: bigint;
+        operator: string;
+        tickLower: bigint;
+        tickUpper: bigint;
+        token0: string;
+        token1: string;
+        tokensOwed0: bigint;
+        tokensOwed1: bigint;
+    }[];
+};

package/dist/types/widgets/PoolWidget/Algebra/hooks/usePoolTickData.d.ts

@@ -0,0 +1,20 @@
+import { ChainId } from '@dodoex/api';
+import JSBI from 'jsbi';
+import { Currency, Price, Token } from '../sdks/sdk-core';
+import { FeeAmount } from '../sdks/v3-sdk';
+export interface TickProcessed {
+    tick: number;
+    liquidityActive: JSBI;
+    liquidityNet: JSBI;
+    price0: string;
+    sdkPrice: Price<Token, Token>;
+}
+export declare function usePoolActiveLiquidity(currencyA: Currency | undefined, currencyB: Currency | undefined, feeAmount: FeeAmount | undefined, chainId?: ChainId): {
+    isLoading: boolean;
+    error: any;
+    currentTick?: number;
+    activeTick?: number;
+    liquidity?: JSBI;
+    sqrtPriceX96?: JSBI;
+    data?: TickProcessed[];
+};

package/dist/types/widgets/PoolWidget/Algebra/hooks/usePools.d.ts

@@ -0,0 +1,22 @@
+import { ChainId } from '@dodoex/api';
+import { BigintIsh, Currency, Token } from '../sdks/sdk-core';
+import { FeeAmount, Pool } from '../sdks/v3-sdk';
+export declare class PoolCache {
+    private static MAX_ENTRIES;
+    private static pools;
+    private static addresses;
+    static getPoolAddress(factoryAddress: string, tokenA: Token, tokenB: Token, fee: FeeAmount, chainId: ChainId): string;
+    static getPool(tokenA: Token, tokenB: Token, fee: FeeAmount, sqrtPriceX96: BigintIsh, liquidity: BigintIsh, tick: number): Pool;
+}
+export declare enum PoolState {
+    LOADING = 0,
+    NOT_EXISTS = 1,
+    EXISTS = 2,
+    INVALID = 3
+}
+export declare function usePools(poolKeys: [
+    Currency | undefined,
+    Currency | undefined,
+    FeeAmount | undefined
+][]): [PoolState, Pool | null][];
+export declare function usePool(currencyA: Currency | undefined, currencyB: Currency | undefined, feeAmount: FeeAmount | undefined): [PoolState, Pool | null];

package/dist/types/widgets/PoolWidget/Algebra/hooks/useRemoveAlgebraLiquidity.d.ts

@@ -0,0 +1,14 @@
+import BigNumber from 'bignumber.js';
+export declare function useRemoveAlgebraLiquidity(): import("@tanstack/react-query").UseMutationResult<import("../../../../hooks/Submission/types").ExecutionResult | undefined, Error, {
+    chainId?: number;
+    tokenId?: number | string;
+    amount0Min: string;
+    amount1Min: string;
+    newLiquidity: string;
+    collectOptions: {
+        expectedCurrencyOwed0: BigNumber;
+        expectedCurrencyOwed1: BigNumber;
+        recipient: string;
+    };
+    successBack?: () => void;
+}, unknown>;

package/dist/types/widgets/PoolWidget/Algebra/hooks/useSetRange.d.ts

@@ -0,0 +1,32 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import React from 'react';
+import { Price } from '../../../../utils/fractions';
+export declare function useSetRange({ tickCurrent, token0, token1, sorted, tickSpacing, price, }: {
+    tickCurrent: number | undefined;
+    token0: TokenInfo | undefined;
+    token1: TokenInfo | undefined;
+    sorted: boolean;
+    tickSpacing: number;
+    price?: Price;
+}): {
+    ticksAtLimit: {
+        LOWER: boolean;
+        UPPER: boolean;
+    };
+    tickLower: number;
+    tickUpper: number;
+    priceLower: Price | undefined;
+    priceUpper: Price | undefined;
+    leftRangeTypedValue: string | boolean;
+    rightRangeTypedValue: string | boolean;
+    invalidRange: boolean;
+    outOfRange: boolean;
+    getDecrementLower: () => string;
+    getIncrementLower: () => string;
+    getDecrementUpper: () => string;
+    getIncrementUpper: () => string;
+    handleSetFullRange: () => void;
+    handleRateToggle: () => void;
+    onLeftRangeInput: React.Dispatch<React.SetStateAction<string | boolean>>;
+    onRightRangeInput: React.Dispatch<React.SetStateAction<string | boolean>>;
+};

package/dist/types/widgets/PoolWidget/Algebra/hooks/useSwapTaxes.d.ts

@@ -0,0 +1,5 @@
+import { ChainId } from '@dodoex/api';
+export declare function useSwapTaxes(inputTokenAddress?: string, outputTokenAddress?: string, tokenChainId?: ChainId): {
+    inputTax: import("../../../../utils/fractions").Percent;
+    outputTax: import("../../../../utils/fractions").Percent;
+};

package/dist/types/widgets/PoolWidget/Algebra/hooks/useV3MintActionHandlers.d.ts

@@ -0,0 +1,11 @@
+import { Actions } from '../reducer';
+export declare function useV3MintActionHandlers({ noLiquidity, dispatch, }: {
+    noLiquidity: boolean | undefined;
+    dispatch: React.Dispatch<Actions>;
+}): {
+    onFieldAInput: (typedValue: string) => void;
+    onFieldBInput: (typedValue: string) => void;
+    onLeftRangeInput: (typedValue: string) => void;
+    onRightRangeInput: (typedValue: string) => void;
+    onStartPriceInput: (typedValue: string) => void;
+};

package/dist/types/widgets/PoolWidget/Algebra/hooks/useV3PositionFees.d.ts

@@ -0,0 +1,8 @@
+import { ChainId, Currency, CurrencyAmount } from '../sdks/sdk-core';
+import { Pool } from '../sdks/v3-sdk';
+export declare function useV3PositionFees({ chainId, pool, tokenId, asWETH, }: {
+    chainId: ChainId;
+    pool?: Pool;
+    tokenId: string;
+    asWETH: boolean;
+}): [CurrencyAmount<Currency>, CurrencyAmount<Currency>] | [undefined, undefined];

package/dist/types/widgets/PoolWidget/Algebra/hooks/useV3Positions.d.ts

@@ -0,0 +1,13 @@
+import { ChainId } from '@dodoex/api';
+import { PositionDetails } from '../types/position';
+interface UseV3PositionsResults {
+    loading: boolean;
+    positions?: PositionDetails[];
+}
+interface UseV3PositionResults {
+    loading: boolean;
+    position?: PositionDetails;
+}
+export declare function useV3PositionFromTokenId(tokenId: string | undefined, chainId: ChainId): UseV3PositionResults;
+export declare function useV3Positions(account: string | null | undefined, chainId: ChainId): UseV3PositionsResults;
+export {};

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/addresses.d.ts

@@ -0,0 +1,12 @@
+import { SupportedChainsType } from './chains';
+type AddressMap = {
+    [chainId: number]: string;
+};
+type ChainAddresses = {
+    v3CoreFactoryAddress: string;
+    nonfungiblePositionManagerAddress?: string;
+};
+export declare const CHAIN_TO_ADDRESSES_MAP: Record<SupportedChainsType, ChainAddresses>;
+export declare const V3_CORE_FACTORY_ADDRESSES: AddressMap;
+export declare const NONFUNGIBLE_POSITION_MANAGER_ADDRESSES: AddressMap;
+export {};

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/chains.d.ts

@@ -0,0 +1,4 @@
+import { ChainId } from '@dodoex/api';
+export { ChainId } from '@dodoex/api';
+export declare const SUPPORTED_CHAINS: readonly [ChainId.MAINNET, ChainId.ARBITRUM_ONE, ChainId.SEPOLIA, ChainId.TAIKO];
+export type SupportedChainsType = (typeof SUPPORTED_CHAINS)[number];

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/constants.d.ts

@@ -0,0 +1,12 @@
+import JSBI from 'jsbi';
+export type BigintIsh = JSBI | string | number;
+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 MaxUint256: JSBI;

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/entities/baseCurrency.d.ts

@@ -0,0 +1,49 @@
+import { Currency } from './currency';
+import { Token } from './token';
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+export declare abstract class BaseCurrency {
+    /**
+     * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+     */
+    abstract readonly isNative: boolean;
+    /**
+     * Returns whether the currency is a token that is usable in Uniswap without wrapping
+     */
+    abstract readonly isToken: boolean;
+    /**
+     * The chain ID on which this currency resides
+     */
+    readonly chainId: number;
+    /**
+     * The decimals used in representing currency amounts
+     */
+    readonly decimals: number;
+    /**
+     * The symbol of the currency, i.e. a short textual non-unique identifier
+     */
+    readonly symbol?: string;
+    /**
+     * The name of the currency, i.e. a descriptive textual non-unique identifier
+     */
+    readonly name?: string;
+    /**
+     * Constructs an instance of the base class `BaseCurrency`.
+     * @param chainId the chain ID on which this currency resides
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     */
+    protected constructor(chainId: number, decimals: number, symbol?: string, name?: string);
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    abstract equals(other: Currency): boolean;
+    /**
+     * Return the wrapped version of this currency that can be used with the Uniswap contracts. Currencies must
+     * implement this to be used in Uniswap
+     */
+    abstract get wrapped(): Token;
+}

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/entities/currency.d.ts

@@ -0,0 +1,3 @@
+import { NativeCurrency } from './nativeCurrency';
+import { Token } from './token';
+export type Currency = NativeCurrency | Token;

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/entities/fractions/currencyAmount.d.ts

@@ -0,0 +1,32 @@
+import JSBI from 'jsbi';
+import { Currency } from '../currency';
+import { Token } from '../token';
+import { Fraction } from './fraction';
+import BigNumber from 'bignumber.js';
+import { BigintIsh, Rounding } from '../../constants';
+export declare class CurrencyAmount<T extends Currency> extends Fraction {
+    readonly currency: T;
+    readonly decimalScale: JSBI;
+    /**
+     * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+     * @param currency the currency in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount<T extends Currency>(currency: T, rawAmount: BigintIsh): CurrencyAmount<T>;
+    /**
+     * Construct a currency amount with a denominator that is not equal to 1
+     * @param currency the currency
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount<T extends Currency>(currency: T, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount<T>;
+    protected constructor(currency: T, numerator: BigintIsh, denominator?: BigintIsh);
+    add(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    subtract(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    multiply(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    divide(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(): BigNumber;
+    get wrapped(): CurrencyAmount<Token>;
+}

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/entities/fractions/fraction.d.ts

@@ -0,0 +1,24 @@
+import JSBI from 'jsbi';
+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;
+    add(other: Fraction | BigintIsh): Fraction;
+    subtract(other: Fraction | BigintIsh): Fraction;
+    lessThan(other: Fraction | BigintIsh): boolean;
+    equalTo(other: Fraction | BigintIsh): boolean;
+    greaterThan(other: Fraction | BigintIsh): boolean;
+    multiply(other: Fraction | BigintIsh): 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/types/widgets/PoolWidget/Algebra/sdks/sdk-core/entities/fractions/index.d.ts

@@ -0,0 +1,4 @@
+export { CurrencyAmount } from './currencyAmount';
+export { Fraction } from './fraction';
+export { Percent } from './percent';
+export { Price } from './price';

package/dist/types/widgets/PoolWidget/Algebra/sdks/sdk-core/entities/fractions/percent.d.ts

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

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