@dodoex/widgets 3.0.4-ve33.1 → 3.0.4-ve33.11

package/dist/types/widgets/ve33/Ve33V3PoolOperate/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/ve33/Ve33V3PoolOperate/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/ve33/Ve33V3PoolOperate/hooks/useAddVe33V3Liquidity.d.ts

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

package/dist/types/widgets/ve33/Ve33V3PoolOperate/hooks/usePoolActiveLiquidityChartData.d.ts

@@ -0,0 +1,37 @@
+import JSBI from 'jsbi';
+import { TokenInfo } from '../../../../hooks/Token';
+import { ChartEntry } from '../components/LiquidityChartRangeInput/types';
+import { Price } from '../../../../utils/fractions';
+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: string | 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/ve33/Ve33V3PoolOperate/hooks/usePriceRangeRatioSelect.d.ts

@@ -0,0 +1,28 @@
+import { Price } from '../../../../utils/fractions';
+import { TokenInfo } from '../../../../hooks/Token';
+import { Bound } from '../types';
+export interface PriceRangeRatioSelectProps {
+    totalApr: bigint | undefined;
+    currentPrice?: string;
+    tickSpacing?: number;
+    priceLower: Price | undefined;
+    priceUpper: Price | undefined;
+    token0: TokenInfo | undefined;
+    token1: TokenInfo | undefined;
+    tickSpaceLimits: {
+        [bound in Bound]?: number | undefined;
+    };
+    onLeftRangeInput: (typedValue: string) => void;
+    onRightRangeInput: (typedValue: string) => void;
+    handleSetFullRange: () => void;
+}
+export declare function usePriceRangeRatioSelect({ totalApr, currentPrice, tickSpacing, priceLower, priceUpper, token0, token1, tickSpaceLimits, onLeftRangeInput, onRightRangeInput, handleSetFullRange, }: PriceRangeRatioSelectProps): {
+    options: {
+        type: string;
+        ratio: string;
+        apr: string;
+        borderRadius: string;
+        active: boolean;
+        onClick: () => void;
+    }[];
+};

package/dist/types/widgets/ve33/Ve33V3PoolOperate/hooks/useRemoveVe33V3Liquidity.d.ts

@@ -0,0 +1,14 @@
+import BigNumber from 'bignumber.js';
+export declare function useRemoveVe33V3Liquidity(): 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/ve33/Ve33V3PoolOperate/hooks/useSetRange.d.ts

@@ -0,0 +1,36 @@
+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;
+}): {
+    tickSpaceLimits: {
+        LOWER: number | undefined;
+        UPPER: number | undefined;
+    };
+    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/ve33/Ve33V3PoolOperate/hooks/useVe33V3Amounts.d.ts

@@ -0,0 +1,19 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import JSBI from 'jsbi';
+export declare function useVe33V3Amounts({ 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/ve33/Ve33V3PoolOperate/hooks/useVe33V3Pair.d.ts

@@ -0,0 +1,58 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+export declare function useVe33V3Pair({ address, baseToken, quoteToken, startPriceTypedValue, }: {
+    address: string | undefined;
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    startPriceTypedValue?: string;
+}): {
+    chainId: undefined;
+    isRearTokenA: boolean;
+    token0: undefined;
+    token1: undefined;
+    token0Wrapped: undefined;
+    token1Wrapped: undefined;
+    isBaseTokenNative: boolean;
+    isQuoteTokenNative: boolean;
+    address: string | undefined;
+    fetchTickSpacing: import("@tanstack/react-query").UseQueryResult<bigint, Error>;
+    fetchGlobalState: import("@tanstack/react-query").UseQueryResult<{
+        sqrtPriceX96: bigint;
+        tick: bigint;
+        observationIndex: bigint;
+        observationCardinality: bigint;
+        observationCardinalityNext: 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;
+    address: string | undefined;
+    fetchTickSpacing: import("@tanstack/react-query").UseQueryResult<bigint, Error>;
+    fetchGlobalState: import("@tanstack/react-query").UseQueryResult<{
+        sqrtPriceX96: bigint;
+        tick: bigint;
+        observationIndex: bigint;
+        observationCardinality: bigint;
+        observationCardinalityNext: 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/ve33/Ve33V3PoolOperate/index.d.ts

@@ -0,0 +1,5 @@
+import { PoolOperateProps } from '../Ve33V2PoolOperate';
+export default function Ve33V3PoolOperateDialog({ modal, ...props }: PoolOperateProps & {
+    modal?: boolean;
+}): JSX.Element;
+export declare function Ve33V3PoolOperate({ sx, pool, operate, account, errorRefetch, submittedBack, onClose, }: PoolOperateProps): JSX.Element;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/types.d.ts

@@ -0,0 +1,10 @@
+export declare enum Field {
+    CURRENCY_A = "CURRENCY_A",
+    CURRENCY_B = "CURRENCY_B"
+}
+export declare enum Bound {
+    LOWER = "LOWER",
+    UPPER = "UPPER"
+}
+export type FullRange = true;
+export type OperateType = null | 'stake' | 'unstake' | 'claim';

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/calldata.d.ts

@@ -0,0 +1,7 @@
+import { BigintIsh } from './constants';
+/**
+ * Converts a big int to a hex string
+ * @param bigintIsh
+ * @returns The hex encoded calldata
+ */
+export declare function toHex(bigintIsh: BigintIsh): string;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/computeSurroundingTicks.d.ts

@@ -0,0 +1,4 @@
+import { Ticks } from '@dodoex/api';
+import { TickProcessed } from '../hooks/usePoolTickData';
+import { TokenInfo } from '../../../../hooks/Token';
+export default function computeSurroundingTicks(token0: TokenInfo, token1: TokenInfo, activeTickProcessed: TickProcessed, sortedTickData: Ticks, pivot: number, ascending: boolean): TickProcessed[];

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/constants.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export declare const MaxUint256: JSBI;
+export declare const ZERO: JSBI;
+export declare const ONE: JSBI;
+export declare const Q96: JSBI;
+export declare const Q192: JSBI;
+export type BigintIsh = JSBI | string | number;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/encodeSqrtRatioX96.d.ts

@@ -0,0 +1,9 @@
+import JSBI from 'jsbi';
+import { BigintIsh } from './constants';
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
+ * @param amount1 The numerator amount i.e., the amount of token1
+ * @param amount0 The denominator amount i.e., the amount of token0
+ * @returns The sqrt ratio
+ */
+export declare function encodeSqrtRatioX96(amount1: BigintIsh, amount0: BigintIsh): JSBI;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/formatTickPrice.d.ts

@@ -0,0 +1 @@
+export declare function formatAmountWithAlphabetSymbol(amount: string | undefined, decimals?: number): string;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/fullMath.d.ts

@@ -0,0 +1,8 @@
+import JSBI from 'jsbi';
+export declare abstract class FullMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static mulDivRoundingUp(a: JSBI, b: JSBI, denominator: JSBI): JSBI;
+}

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/getPositionAmount.d.ts

@@ -0,0 +1,39 @@
+import JSBI from 'jsbi';
+import { BigintIsh } from './constants';
+export declare function getPositionAmount0({ tickCurrent, tickLower, tickUpper, liquidity, roundUp, sqrtRatioX96: sqrtRatioX96Props, }: {
+    tickCurrent: number;
+    tickLower: number;
+    tickUpper: number;
+    liquidity: number | bigint | JSBI | string;
+    roundUp?: boolean;
+    sqrtRatioX96?: JSBI | bigint;
+}): JSBI;
+export declare function getPositionAmount1({ tickCurrent, tickLower, tickUpper, liquidity, roundUp, sqrtRatioX96: sqrtRatioX96Props, }: {
+    tickCurrent: number;
+    tickLower: number;
+    tickUpper: number;
+    liquidity: number | bigint | JSBI | string;
+    roundUp?: boolean;
+    sqrtRatioX96?: bigint;
+}): JSBI;
+export declare function getPositionAmountFromAmount0({ sqrtRatioX96, tickCurrent, tickLower, tickUpper, amount0, useFullPrecision, }: {
+    sqrtRatioX96: JSBI;
+    tickCurrent: number;
+    tickLower: number;
+    tickUpper: number;
+    amount0: BigintIsh;
+    useFullPrecision: boolean;
+}): {
+    amount0: JSBI;
+    amount1: JSBI;
+};
+export declare function getPositionAmountFromAmount1({ sqrtRatioX96, tickCurrent, tickLower, tickUpper, amount1, }: {
+    sqrtRatioX96: JSBI;
+    tickCurrent: number;
+    tickLower: number;
+    tickUpper: number;
+    amount1: BigintIsh;
+}): {
+    amount0: JSBI;
+    amount1: JSBI;
+};

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/getPositionAmountWithSlippage.d.ts

@@ -0,0 +1,23 @@
+import JSBI from 'jsbi';
+import { Percent } from '../../../../utils/fractions';
+import { TokenInfo } from '../../../../hooks/Token';
+/**
+ * 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
+ */
+export declare function mintAmountsWithSlippage(tickCurrent: number, slippageTolerance: Percent, tickLower: number, tickUpper: number, baseToken: TokenInfo, quoteToken: TokenInfo, amount0: string, amount1: string): {
+    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
+ */
+export declare function burnAmountsWithSlippage(tickCurrent: number, slippageTolerance: Percent, tickLower: number, tickUpper: number, liquidity: number | bigint | JSBI | string, baseToken: TokenInfo, quoteToken: TokenInfo): Readonly<{
+    amount0: JSBI;
+    amount1: JSBI;
+}>;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/getTickToPrice.d.ts

@@ -0,0 +1,10 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+/**
+ * Returns the first tick for which the given price is greater than or equal to the tick price
+ * @param price for which to return the closest tick that represents a price less than or equal to the input price,
+ * i.e. the price of the returned tick is less than or equal to the input price
+ */
+export declare function priceToClosestTick(price: Price): number;
+export declare function tickToPrice(baseToken: TokenInfo, quoteToken: TokenInfo, tickCurrent: number | bigint): Price;
+export declare function getTickToPrice(baseToken?: TokenInfo, quoteToken?: TokenInfo, tickCurrent?: number | bigint): string | undefined;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/maxLiquidityForAmounts.d.ts

@@ -0,0 +1,22 @@
+import JSBI from 'jsbi';
+import { BigintIsh } from './constants';
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX96 the current price
+ * @param sqrtRatioAX96 price at lower boundary
+ * @param sqrtRatioBX96 price at upper boundary
+ * @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
+ */
+export declare function maxLiquidityForAmounts(sqrtRatioCurrentX96: JSBI, sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, amount0: BigintIsh, amount1: BigintIsh, useFullPrecision: boolean): JSBI;
+export declare function getLiquidityByAmounts({ sqrtRatioX96, tickLower, tickUpper, amount0, amount1, useFullPrecision, }: {
+    sqrtRatioX96: JSBI;
+    tickLower: number;
+    tickUpper: number;
+    amount0: BigintIsh;
+    amount1: BigintIsh;
+    useFullPrecision: boolean;
+}): JSBI;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/mostSignificantBit.d.ts

@@ -0,0 +1,2 @@
+import JSBI from 'jsbi';
+export declare function mostSignificantBit(x: JSBI): number;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/nearestUsableTick.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the closest tick that is nearest a given tick and usable for the given tick spacing
+ * @param tick the target tick
+ * @param tickSpacing the spacing of the pool
+ */
+export declare function nearestUsableTick(tick: number, tickSpacing: number): number;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/slippage.d.ts

@@ -0,0 +1,3 @@
+import { Percent } from '../../../../utils/fractions';
+export declare function toSlippagePercent(slippage: string | number): Percent;
+export declare function toSlippagePercentNumber(slippage: string | number): number;

package/dist/types/widgets/ve33/Ve33V3PoolOperate/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/ve33/Ve33V3PoolOperate/utils/sqrtPriceMath.d.ts

@@ -0,0 +1,13 @@
+import JSBI from 'jsbi';
+export declare abstract class SqrtPriceMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getAmount0Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getAmount1Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getNextSqrtPriceFromInput(sqrtPX96: JSBI, liquidity: JSBI, amountIn: JSBI, zeroForOne: boolean): JSBI;
+    static getNextSqrtPriceFromOutput(sqrtPX96: JSBI, liquidity: JSBI, amountOut: JSBI, zeroForOne: boolean): JSBI;
+    private static getNextSqrtPriceFromAmount0RoundingUp;
+    private static getNextSqrtPriceFromAmount1RoundingDown;
+}

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/tickMath.d.ts

@@ -0,0 +1,34 @@
+import JSBI from 'jsbi';
+export declare abstract class TickMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * The minimum tick that can be used on any pool.
+     */
+    static MIN_TICK: number;
+    /**
+     * The maximum tick that can be used on any pool.
+     */
+    static MAX_TICK: number;
+    /**
+     * The sqrt ratio corresponding to the minimum tick that could be used on any pool.
+     */
+    static MIN_SQRT_RATIO: JSBI;
+    /**
+     * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
+     */
+    static MAX_SQRT_RATIO: JSBI;
+    /**
+     * Returns the sqrt ratio as a Q64.96 for the given tick. The sqrt ratio is computed as sqrt(1.0001)^tick
+     * @param tick the tick for which to compute the sqrt ratio
+     */
+    static getSqrtRatioAtTick(tick: number): JSBI;
+    /**
+     * Returns the tick corresponding to a given sqrt ratio, s.t. #getSqrtRatioAtTick(tick) <= sqrtRatioX96
+     * and #getSqrtRatioAtTick(tick + 1) > sqrtRatioX96
+     * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
+     */
+    static getTickAtSqrtRatio(sqrtRatioX96: JSBI): number;
+}

package/dist/types/widgets/ve33/Ve33V3PoolOperate/utils/tryParseTick.d.ts

@@ -0,0 +1,4 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+export declare function tryParsePrice(baseToken?: TokenInfo, quoteToken?: TokenInfo, value?: string): Price | undefined;
+export declare function tryParseTick(baseToken?: TokenInfo, quoteToken?: TokenInfo, value?: string, tickSpacing?: number): number | undefined;

package/dist/types/widgets/ve33/VotePoolList/CardList.d.ts

@@ -0,0 +1,12 @@
+import { VotePoolInfoI } from '../types';
+export interface CardListProps {
+    poolList: VotePoolInfoI[];
+    onSelectPool: (item: VotePoolInfoI) => void;
+    selectedPoolList: string[];
+}
+export declare const CardList: ({ poolList, ...props }: CardListProps) => JSX.Element;
+export declare function CardItem({ item, onSelectPool, selectedPoolList, }: {
+    item?: VotePoolInfoI;
+    onSelectPool?: (item: VotePoolInfoI) => void;
+    selectedPoolList?: string[];
+}): JSX.Element;

package/dist/types/widgets/ve33/VotePoolList/SetVotePowerDialog.d.ts

@@ -0,0 +1,12 @@
+import { VotePoolInfoI } from '../types';
+import { Lock } from '../Ve33LockList/hooks/useFetchUserLocks';
+export default function SetVotePowerDialog({ chainId, account, open, onClose, data, lock, setLock, refetch, }: {
+    chainId: number | undefined;
+    account: string | undefined;
+    open: boolean;
+    onClose: () => void;
+    data: Array<VotePoolInfoI>;
+    lock: Lock | null;
+    setLock: (lock: Lock | null) => void;
+    refetch?: () => void;
+}): JSX.Element;

package/dist/types/widgets/ve33/VotePoolList/TableList.d.ts

@@ -0,0 +1,12 @@
+import { ChainId } from '@dodoex/api';
+import { VotePoolInfoI } from '../types';
+export interface TableListProps {
+    chainId: ChainId;
+    poolList: VotePoolInfoI[];
+    hasMore?: boolean;
+    loadMore?: () => void;
+    loadMoreLoading?: boolean;
+    onSelectPool: (item: VotePoolInfoI) => void;
+    selectedPoolList: string[];
+}
+export declare const TableList: ({ chainId, poolList, hasMore, loadMore, loadMoreLoading, onSelectPool, selectedPoolList, }: TableListProps) => JSX.Element;

package/dist/types/widgets/ve33/VotePoolList/hooks/useVoteVe33.d.ts

@@ -0,0 +1,7 @@
+export declare function useVoteVe33({ refetch, }: {
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    tokenId: number;
+    poolIds: string[];
+    weights: number[];
+}, unknown>;

package/dist/types/widgets/ve33/VotePoolList/index.d.ts

@@ -0,0 +1 @@
+export declare const VotePoolList: () => JSX.Element;

package/dist/types/widgets/ve33/VotePoolList/widgets.d.ts

@@ -0,0 +1,35 @@
+import { VotePoolInfoI } from '../types';
+import { Lock } from '../Ve33LockList/hooks/useFetchUserLocks';
+export declare function VAPRWidgets({ item }: {
+    item: VotePoolInfoI;
+}): JSX.Element;
+export declare function IncentivesWidgets({ item, showLogo, singleLine, }: {
+    item: VotePoolInfoI;
+    showLogo?: boolean;
+    singleLine?: boolean;
+}): JSX.Element;
+export declare function FeesWidgets({ item, showLogo, }: {
+    item: VotePoolInfoI;
+    showLogo?: boolean;
+}): JSX.Element;
+export declare function TotalVoteWidgets({ item, showLogo, singleLine, }: {
+    item: VotePoolInfoI;
+    showLogo?: boolean;
+    singleLine?: boolean;
+}): JSX.Element;
+export declare function MyVoteWidgets({ label, value, onChange, onBlur, loading, veNFTAmount, veNFTSymbol, }: {
+    label?: string;
+    value: number | undefined;
+    onChange: (v: number | undefined) => void;
+    onBlur?: () => void;
+    loading?: boolean;
+    veNFTAmount: number | string;
+    veNFTSymbol: string;
+}): JSX.Element;
+export declare function SelectLock({ fullWidth, chainId, account, selectedLock, setSelectedLock, }: {
+    fullWidth?: boolean;
+    chainId: number | undefined;
+    account: string | undefined;
+    selectedLock: Lock | null;
+    setSelectedLock: (lock: Lock | null) => void;
+}): JSX.Element;

package/dist/types/widgets/ve33/components/GoBack.d.ts

@@ -0,0 +1,4 @@
+export interface GoBackProps {
+    onClick: () => void;
+}
+export declare const GoBack: ({ onClick }: GoBackProps) => JSX.Element;

package/dist/types/widgets/ve33/components/LockSlider.d.ts

@@ -0,0 +1,5 @@
+import { SliderProps } from '@dodoex/components';
+export default function LockSlider({ currentValue, ...props }: SliderProps & {
+    currentValue?: boolean;
+}): JSX.Element;
+export declare const MAX_LOCK_DURATION = 31536000;

package/dist/types/widgets/ve33/components/PoolHead.d.ts

@@ -0,0 +1,8 @@
+import { ChainId } from '@dodoex/api';
+import { Ve33PoolInfoI } from '../types';
+export interface PoolHeadProps {
+    chainId: ChainId;
+    poolInfo: Ve33PoolInfoI;
+    size?: 'small' | 'medium';
+}
+export declare const PoolHead: ({ chainId, poolInfo, size, }: PoolHeadProps) => JSX.Element;