@dodoex/widgets 3.2.0-beta.7 → 3.2.0-beta.8

package/dist/types/widgets/PoolWidget/Algebra/components/widgets.d.ts

@@ -0,0 +1,56 @@
+import { BoxProps } from '@dodoex/components';
+declare const gapValues: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
+export type Gap = keyof typeof gapValues;
+export interface YellowCardProps {
+    children?: React.ReactNode;
+}
+export declare const Card: ({ children, sx, }: {
+    sx?: BoxProps["sx"];
+    children?: React.ReactNode;
+}) => JSX.Element;
+export declare const LightCard: ({ children, border, sx, }: {
+    sx?: BoxProps["sx"];
+    border?: boolean;
+    children?: React.ReactNode;
+}) => JSX.Element;
+export declare const YellowCard: ({ children }: YellowCardProps) => JSX.Element;
+export declare function ColumnCenter({ gap, flex, children, style, }: {
+    gap?: Gap | string;
+    flex?: string;
+    children: React.ReactNode;
+    style?: BoxProps['sx'];
+}): JSX.Element;
+export declare function AutoColumn({ gap, justify, grow, children, style, }: {
+    gap?: Gap | string;
+    justify?: 'stretch' | 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'space-between';
+    grow?: true;
+    children: React.ReactNode;
+    style?: BoxProps['sx'];
+}): JSX.Element;
+export declare function Row({ gap, children, sx, }: {
+    gap?: Gap | string;
+    children: React.ReactNode;
+    sx?: BoxProps['sx'];
+}): JSX.Element;
+export declare function RowBetween({ children, style, }: {
+    children: React.ReactNode;
+    style?: BoxProps['sx'];
+}): JSX.Element;
+export declare function RowFixed({ gap, justify, children, sx, }: {
+    gap?: string;
+    justify?: string;
+    children: React.ReactNode;
+    sx?: BoxProps['sx'];
+}): JSX.Element;
+export declare function DynamicSection({ children, disabled, sx, }: {
+    children: React.ReactNode;
+    disabled?: boolean;
+    sx?: BoxProps['sx'];
+}): JSX.Element;
+export {};

package/dist/types/widgets/PoolWidget/Algebra/constants/misc.d.ts

@@ -0,0 +1,17 @@
+import JSBI from 'jsbi';
+import { Percent } from '../../../../utils/fractions';
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const DEFAULT_DEADLINE_FROM_NOW: number;
+export declare const L2_DEADLINE_FROM_NOW: number;
+export declare const DEFAULT_TXN_DISMISS_MS = 10000;
+export declare const L2_TXN_DISMISS_MS = 5000;
+export declare const BIG_INT_ZERO: JSBI;
+export declare const BIPS_BASE = 10000;
+export declare const ONE_BIPS: Percent;
+export declare const ALLOWED_PRICE_IMPACT_LOW: Percent;
+export declare const ALLOWED_PRICE_IMPACT_MEDIUM: Percent;
+export declare const ALLOWED_PRICE_IMPACT_HIGH: Percent;
+export declare const PRICE_IMPACT_WITHOUT_FEE_CONFIRM_MIN: Percent;
+export declare const BLOCKED_PRICE_IMPACT_NON_EXPERT: Percent;
+export declare const ZERO_PERCENT: Percent;
+export declare const ONE_HUNDRED_PERCENT: Percent;

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

@@ -0,0 +1,15 @@
+import { useAlgebraPair } from './useAlgebraPair';
+export declare function useAddAlgebraLiquidity(): import("@tanstack/react-query").UseMutationResult<import("../../../../hooks/Submission/types").ExecutionResult | undefined, Error, {
+    createPool?: boolean;
+    recipient?: string;
+    deployer?: string;
+    pool?: ReturnType<typeof useAlgebraPair>;
+    tokenId?: number | string;
+    amount0: string;
+    amount1: string;
+    tickLower: number;
+    tickUpper: number;
+    amount0Min: string;
+    amount1Min: string;
+    successBack?: () => void;
+}, unknown>;

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

@@ -0,0 +1,19 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import JSBI from 'jsbi';
+export declare function useAlgebraAmounts({ baseToken, quoteToken, sqrtRatioX96, tickCurrent, tickLower, tickUpper, }: {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    sqrtRatioX96: JSBI | undefined;
+    tickCurrent: number | undefined;
+    tickLower: number | undefined;
+    tickUpper: number | undefined;
+}): {
+    readonly: boolean;
+    baseAmount: string;
+    quoteAmount: string;
+    handleChangeBaseAmount: (value: string) => void;
+    handleChangeQuoteAmount: (value: string) => void;
+    handleBlurBaseAmount: (value: string) => void;
+    handleBlurQuoteAmount: (value: string) => void;
+    reset: () => void;
+};

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

@@ -0,0 +1,59 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+export declare function useAlgebraPair({ baseToken, quoteToken, startPriceTypedValue, }: {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    startPriceTypedValue?: string;
+}): {
+    chainId: undefined;
+    isRearTokenA: boolean;
+    token0: undefined;
+    token1: undefined;
+    token0Wrapped: undefined;
+    token1Wrapped: undefined;
+    isBaseTokenNative: boolean;
+    isQuoteTokenNative: boolean;
+    isExists: boolean;
+    address: string | undefined;
+    fetchTickSpacing: import("@tanstack/react-query").UseQueryResult<bigint, Error>;
+    fetchGlobalState: import("@tanstack/react-query").UseQueryResult<{
+        price: bigint;
+        tick: bigint;
+        lastFee: bigint;
+        pluginConfig: bigint;
+        communityFee: bigint;
+        unlocked: boolean;
+    }, Error>;
+    fetchLiquidity: import("@tanstack/react-query").UseQueryResult<bigint, Error>;
+    currentTick: number | undefined;
+    currentSqrt: string | undefined;
+    price: Price | undefined;
+    reversePrice: string | undefined;
+    tickSpacing: number;
+} | {
+    chainId: import("@dodoex/api").ChainId;
+    isRearTokenA: boolean;
+    token0: TokenInfo;
+    token1: TokenInfo;
+    token0Wrapped: TokenInfo;
+    token1Wrapped: TokenInfo;
+    isBaseTokenNative: boolean;
+    isQuoteTokenNative: boolean;
+    isExists: boolean;
+    address: string | undefined;
+    fetchTickSpacing: import("@tanstack/react-query").UseQueryResult<bigint, Error>;
+    fetchGlobalState: import("@tanstack/react-query").UseQueryResult<{
+        price: bigint;
+        tick: bigint;
+        lastFee: bigint;
+        pluginConfig: bigint;
+        communityFee: bigint;
+        unlocked: boolean;
+    }, Error>;
+    fetchLiquidity: import("@tanstack/react-query").UseQueryResult<bigint, Error>;
+    currentTick: number | undefined;
+    currentSqrt: string | undefined;
+    price: Price | undefined;
+    reversePrice: string | undefined;
+    tickSpacing: number;
+};

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

@@ -0,0 +1,13 @@
+import { ChainId } from '@dodoex/api';
+export declare function useAlgebraPositionFees({ chainId, tokenId, }: {
+    chainId: ChainId;
+    tokenId: string;
+}): {
+    data: {
+        amount0: bigint;
+        amount1: bigint;
+    } | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    errorRefetch: () => void;
+};

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

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

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

@@ -0,0 +1,2 @@
+import { ChainId } from '@dodoex/api';
+export declare function useV3NFTPositionManagerContract(chainId: ChainId | undefined): string | undefined;

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/usePoolActiveLiquidityChartData.d.ts

@@ -0,0 +1,37 @@
+import JSBI from 'jsbi';
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+import { ChartEntry } from '../components/LiquidityChartRangeInput/types';
+export interface TickProcessed {
+    tick: number;
+    liquidityActive: JSBI;
+    liquidityNet: JSBI;
+    price0: string;
+    sdkPrice: Price;
+}
+export interface FetchTicks {
+    ticks: Array<{
+        id: string;
+        liquidityNet: string;
+        poolAddress?: string;
+        price0: string;
+        price1: string;
+        tickIdx: string;
+    }> | undefined | null;
+    isLoading: boolean;
+    isError: boolean;
+    refetch: () => void;
+}
+export declare function usePoolActiveLiquidityChartData({ tickCurrent, liquidity, fetchTicks, token0, token1, }: {
+    tickCurrent: number | undefined;
+    liquidity: number | undefined;
+    fetchTicks?: FetchTicks;
+    token0: TokenInfo | undefined;
+    token1: TokenInfo | undefined;
+}): {
+    hidden: boolean;
+    isLoading: boolean;
+    error: boolean;
+    data: TickProcessed[] | undefined;
+    formattedData: ChartEntry[] | undefined;
+};

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 {};