@dodoex/widgets 3.2.2 → 3.2.3

package/dist/types/widgets/PoolWidget/PoolOperate/components/TokenList.d.ts

@@ -0,0 +1,11 @@
+import { usePoolBalanceInfo } from '../../hooks/usePoolBalanceInfo';
+import { CheckTokenType } from '../hooks/useCheckToken';
+import { OperatePool } from '../types';
+export default function TokenList({ pool, checkTokenType, setCheckToken, balanceInfo, baseTokenBalanceUpdateLoading, quoteBalanceUpdateLoading, }: {
+    pool?: OperatePool;
+    checkTokenType: CheckTokenType;
+    setCheckToken: (checkTokenType: CheckTokenType) => void;
+    balanceInfo?: ReturnType<typeof usePoolBalanceInfo>;
+    baseTokenBalanceUpdateLoading: boolean;
+    quoteBalanceUpdateLoading: boolean;
+}): JSX.Element | null;

package/dist/types/widgets/PoolWidget/PoolOperate/hooks/useCheckToken.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { TokenInfo } from '../../../../hooks/Token';
+import { OperatePool } from '../types';
+export declare enum CheckTokenType {
+    base = 1,
+    quote = 2
+}
+export declare const useCheckToken: (pool?: OperatePool) => {
+    isBase: boolean | undefined;
+    checkToken: TokenInfo | undefined;
+    checkTokenType: CheckTokenType;
+    setCheckToken: React.Dispatch<React.SetStateAction<CheckTokenType>>;
+};

package/dist/types/widgets/PoolWidget/PoolOperate/hooks/useComparePrice.d.ts

@@ -0,0 +1,19 @@
+import BigNumber from 'bignumber.js';
+import { TokenInfo } from '../../../../hooks/Token';
+export declare function useDODOPrice({ baseToken, quoteToken, }: {
+    baseToken?: TokenInfo;
+    quoteToken?: TokenInfo;
+}): {
+    comparePrice: BigNumber | null;
+    comparePriceText: string;
+    loading: boolean;
+};
+export declare const lqAndDodoCompareSmallNum = 0.01;
+export declare const lqAndDodoCompareWarningNum = 0.03;
+export declare const useComparePrice: (baseToken?: TokenInfo, quoteToken?: TokenInfo, midPrice?: BigNumber) => {
+    lqAndDodoCompare: number;
+    lqAndDodoCompareText: string;
+    midPrice: BigNumber | undefined;
+    isShowCompare: boolean;
+    isWarnCompare: boolean;
+};

package/dist/types/widgets/PoolWidget/PoolOperate/hooks/useLiquidityOperateAmount.d.ts

@@ -0,0 +1,53 @@
+import BigNumber from 'bignumber.js';
+import { OperatePool } from '../types';
+import { usePoolBalanceInfo } from '../../hooks/usePoolBalanceInfo';
+export declare function useLiquidityOperateAmount({ pool, maxBaseAmount, maxQuoteAmount, isRemove, }: {
+    pool: OperatePool;
+    maxBaseAmount?: BigNumber | null;
+    maxQuoteAmount?: BigNumber | null;
+    isRemove?: boolean;
+    balanceInfo?: ReturnType<typeof usePoolBalanceInfo>;
+}): {
+    baseAmount: string;
+    quoteAmount: string;
+    handleChangeBaseAmount: () => void;
+    handleChangeQuoteAmount: () => void;
+    reset: () => void;
+    addPortion?: undefined;
+    amountLoading?: undefined;
+    amountError?: undefined;
+    amountRefetch?: undefined;
+    amountCheckedDisabled?: undefined;
+    midPrice?: undefined;
+    uniV2Pair?: undefined;
+} | {
+    baseAmount: string;
+    quoteAmount: string;
+    handleChangeBaseAmount: (newValue: string) => void;
+    handleChangeQuoteAmount: (newValue: string) => void;
+    reset: () => void;
+    addPortion: BigNumber;
+    amountLoading: boolean;
+    amountError: boolean;
+    amountRefetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        baseReserve: BigNumber;
+        quoteReserve: BigNumber;
+    } | null, Error>>;
+    amountCheckedDisabled: boolean;
+    midPrice: BigNumber | undefined;
+    uniV2Pair: {
+        isRearTokenA: boolean;
+        pair: import("@uniswap/v2-sdk").Pair | null;
+        price: BigNumber | undefined;
+        invertedPrice: BigNumber | undefined;
+        reserveQuery: import("@tanstack/react-query").UseQueryResult<{
+            baseReserve: BigNumber;
+            quoteReserve: BigNumber;
+        } | null, Error>;
+        totalBaseLpQuery: import("@tanstack/react-query").UseQueryResult<BigNumber | null, Error>;
+        liquidityMinted: BigNumber | undefined;
+        poolTokenPercentage: BigNumber | undefined;
+        shareOfPool: string;
+        isExists: boolean;
+    };
+};

package/dist/types/widgets/PoolWidget/PoolOperate/hooks/usePercentageRemove.d.ts

@@ -0,0 +1,26 @@
+import BigNumber from 'bignumber.js';
+import { OperatePool } from '../types';
+export declare const initSliderPercentage = 50;
+export declare enum RemoveMode {
+    quantity = 1,
+    percentage = 2
+}
+export declare function usePercentageRemove({ isBase, pool, baseOverride, quoteOverride, resetAmount, handleChangeBaseAmount, handleChangeQuoteAmount, }: {
+    isBase: boolean | undefined;
+    pool: OperatePool | undefined;
+    baseOverride: BigNumber | undefined | null;
+    quoteOverride: BigNumber | undefined | null;
+    resetAmount: () => void;
+    handleChangeBaseAmount: (val: string) => void;
+    handleChangeQuoteAmount: (val: string) => void;
+}): {
+    mode: RemoveMode;
+    modeOptions: {
+        key: RemoveMode;
+        value: string;
+    }[];
+    handleChangeMode: (mode: RemoveMode) => void;
+    sliderPercentage: number;
+    handleChangeSliderPercentage: (val: number) => void;
+    resetPercentage: () => void;
+};

package/dist/types/widgets/PoolWidget/PoolOperate/hooks/usePoolOperateTabs.d.ts

@@ -0,0 +1,12 @@
+export declare enum OperateTab {
+    Add = 1,
+    Remove = 2
+}
+export declare function usePoolOperateTabs(defaultValue?: OperateTab): {
+    operateTab: OperateTab;
+    operateTabs: {
+        key: OperateTab;
+        value: string;
+    }[];
+    handleChangeTab: (poolTab: OperateTab) => void;
+};

package/dist/types/widgets/PoolWidget/PoolOperate/hooks/usePoolOrMiningTabs.d.ts

@@ -0,0 +1,14 @@
+export declare enum PoolOrMiningTab {
+    Liquidity = 1,
+    Mining = 2
+}
+export declare function usePoolOrMiningTabs({ hasMining }: {
+    hasMining?: boolean;
+}): {
+    poolOrMiningTab: PoolOrMiningTab;
+    poolOrMiningTabs: {
+        key: PoolOrMiningTab;
+        value: string;
+    }[];
+    handleChangeTab: (poolTab: PoolOrMiningTab) => void;
+};

package/dist/types/widgets/PoolWidget/PoolOperate/hooks/useRemoveLiquidityTokenStatus.d.ts

@@ -0,0 +1,35 @@
+import { usePoolBalanceInfo } from '../../hooks/usePoolBalanceInfo';
+import { OperatePool } from '../types';
+export declare function useRemoveLiquidityTokenStatus({ pool, baseAmount, quoteAmount, balanceInfo, }: {
+    pool: OperatePool | undefined;
+    baseAmount: string;
+    quoteAmount: string;
+    balanceInfo: ReturnType<typeof usePoolBalanceInfo>;
+}): {
+    baseTokenStatus: {
+        token: import("../../../..").TokenInfo | null | undefined;
+        isApproving: boolean;
+        isGetApproveLoading: boolean;
+        needApprove: boolean;
+        needReset: boolean | undefined;
+        needShowTokenStatusButton: boolean;
+        insufficientBalance: boolean;
+        loading: boolean;
+        approveTitle: string;
+        submitApprove: () => Promise<void>;
+        getMaxBalance: () => string;
+    };
+    quoteTokenStatus: {
+        token: import("../../../..").TokenInfo | null | undefined;
+        isApproving: boolean;
+        isGetApproveLoading: boolean;
+        needApprove: boolean;
+        needReset: boolean | undefined;
+        needShowTokenStatusButton: boolean;
+        insufficientBalance: boolean;
+        loading: boolean;
+        approveTitle: string;
+        submitApprove: () => Promise<void>;
+        getMaxBalance: () => string;
+    };
+};

package/dist/types/widgets/PoolWidget/PoolOperate/index.d.ts

@@ -0,0 +1,20 @@
+import { BoxProps } from '@dodoex/components';
+import { PoolOperateInnerProps } from './PoolOperateInner';
+import { GetMigrationPairAndMining, ShowMigrationPairAndMining } from './types';
+export interface PoolOperateProps {
+    onClose?: () => void;
+    account: string | undefined;
+    pool?: PoolOperateInnerProps['pool'];
+    address?: string;
+    operate?: PoolOperateInnerProps['operate'];
+    chainId?: number;
+    hasMining?: boolean;
+    hidePoolInfo?: boolean;
+    sx?: BoxProps['sx'];
+    getMigrationPairAndMining?: GetMigrationPairAndMining;
+    showMigrationPairAndMining?: ShowMigrationPairAndMining;
+}
+export declare function PoolOperate({ onClose, pool: poolProps, address, operate, chainId, hasMining, hidePoolInfo, sx, getMigrationPairAndMining, showMigrationPairAndMining, }: PoolOperateProps): JSX.Element;
+export default function PoolOperateDialog({ modal, ...props }: PoolOperateProps & {
+    modal?: boolean;
+}): JSX.Element;

package/dist/types/widgets/PoolWidget/PoolOperate/types.d.ts

@@ -0,0 +1,34 @@
+import { ExcludeNone, PoolType } from '@dodoex/api';
+import { TokenInfo } from '../../../hooks/Token';
+import { FetchMyLiquidityListLqList } from '../utils';
+export type OperatePool = {
+    address: string;
+    chainId: number;
+    baseToken: TokenInfo;
+    quoteToken: TokenInfo;
+    baseLpToken?: {
+        id: string;
+        decimals: number;
+    };
+    quoteLpToken?: {
+        id: string;
+        decimals: number;
+    };
+    type: PoolType;
+    owner?: string;
+    creator: string;
+    lpFeeRate?: string;
+    liquidityPositions?: ExcludeNone<ExcludeNone<FetchMyLiquidityListLqList>[0]>['liquidityPositions'];
+} | undefined;
+export interface LiquidityMigrationInfo {
+    chainId: number;
+    miningContractAddress: string;
+    stakeTokenAddress: string;
+    newMiningContractAddress: string;
+    newStakeTokenAddress: string;
+}
+export type GetMigrationPairAndMining = (p: {
+    address: string;
+    chainId: number;
+}) => LiquidityMigrationInfo | undefined;
+export type ShowMigrationPairAndMining = (p: LiquidityMigrationInfo) => void;

package/dist/types/widgets/PoolWidget/hooks/contract/getModifyDPPPoolParams.d.ts

@@ -0,0 +1,87 @@
+import BigNumber from 'bignumber.js';
+import { TokenInfo } from '../../../../hooks/Token';
+interface ModifyPool {
+    address: string;
+    baseReserve: string | BigNumber;
+    quoteReserve: string | BigNumber;
+    feeRate: string;
+    i: number;
+    k: number;
+}
+export declare function useDiffer({ srcPool, newPool, }: {
+    srcPool?: ModifyPool;
+    newPool: {
+        baseToken: TokenInfo;
+        quoteToken: TokenInfo;
+        baseAmount: string;
+        quoteAmount: string;
+        feeRate: string;
+        initPrice: string;
+        slippageCoefficient: string;
+    };
+}): {
+    baseAmount: {
+        now: BigNumber;
+        target: BigNumber;
+        isChange: boolean;
+        change: BigNumber;
+        changeText: string;
+        isAdd: boolean;
+        isRemove: boolean;
+    };
+    quoteAmount: {
+        now: BigNumber;
+        target: BigNumber;
+        isChange: boolean;
+        change: BigNumber;
+        changeText: string;
+        isAdd: boolean;
+        isRemove: boolean;
+    };
+    feeRate: {
+        now: BigNumber;
+        target: BigNumber;
+        isChange: boolean;
+        change: BigNumber;
+        changeText: string;
+        isAdd: boolean;
+        isRemove: boolean;
+    };
+    initPrice: {
+        now: BigNumber;
+        target: BigNumber;
+        isChange: boolean;
+        change: BigNumber;
+        changeText: string;
+        isAdd: boolean;
+        isRemove: boolean;
+    };
+    slippageCoefficient: {
+        now: BigNumber;
+        target: BigNumber;
+        isChange: boolean;
+        change: BigNumber;
+        changeText: string;
+        isAdd: boolean;
+        isRemove: boolean;
+    };
+} | null;
+export declare const getModifyDPPPoolParams: ({ chainId, account, srcPool, baseToken, quoteToken, baseAmount, quoteAmount, feeRate, initPrice, slippageCoefficient, ddl, SLIPPAGE_PROTECTION, }: {
+    chainId?: number;
+    account?: string;
+    srcPool?: ModifyPool;
+    baseToken: TokenInfo;
+    quoteToken: TokenInfo;
+    baseAmount: string;
+    quoteAmount: string;
+    feeRate: string;
+    initPrice: string;
+    slippageCoefficient: string;
+    ddl: number | undefined;
+    SLIPPAGE_PROTECTION: number;
+}) => Promise<{
+    data: string;
+    to: string;
+    value?: number | string;
+} | null>;
+export {};

package/dist/types/widgets/PoolWidget/hooks/contract/useModifyDppPool.d.ts

@@ -0,0 +1,22 @@
+import { PoolType } from '@dodoex/api';
+import { TokenInfo } from '../../../../hooks/Token';
+export declare function useModifyDppPool({ pool, }: {
+    pool?: {
+        chainId: number;
+        address: string;
+        type: PoolType;
+        baseToken: TokenInfo;
+        quoteToken: TokenInfo;
+    };
+}): {
+    modifyDPPMutation: import("@tanstack/react-query").UseMutationResult<import("../../../../hooks/Submission/types").ExecutionResult | undefined, Error, {
+        baseAmount: string;
+        quoteAmount: string;
+        isRemove?: boolean;
+        feeRate?: string;
+        initPrice?: string;
+        slippageCoefficient?: string;
+        txTitle: string;
+        submittedBack?: () => void;
+    }, unknown>;
+};

package/dist/types/widgets/PoolWidget/hooks/contract/useOperateLiquidity.d.ts

@@ -0,0 +1,36 @@
+import { PoolType } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+import { TokenInfo } from '../../../../hooks/Token';
+import { usePoolBalanceInfo } from '../usePoolBalanceInfo';
+export interface SubmitLiquidityParams {
+    balanceInfo?: ReturnType<typeof usePoolBalanceInfo>;
+    baseAmount: string;
+    quoteAmount: string;
+    slippageProtection: number;
+    SLIPPAGE_PROTECTION: number;
+    txTitle: string;
+    isRemove?: boolean;
+    submittedBack?: () => void;
+    successBack?: () => void;
+    withdrawInfo?: {
+        withdrawFee: string;
+        receiveBaseAmount: string;
+        receiveQuoteAmount: string;
+        receiveAmountBg: BigNumber | undefined;
+    };
+}
+export declare const useOperateLiquidity: (pool?: {
+    chainId: number;
+    address: string;
+    type: PoolType;
+    baseToken: TokenInfo;
+    quoteToken: TokenInfo;
+    baseLpToken?: {
+        id: string;
+    };
+    quoteLpToken?: {
+        id: string;
+    };
+}) => {
+    operateLiquidityMutation: import("@tanstack/react-query").UseMutationResult<void, Error, SubmitLiquidityParams, unknown>;
+};

package/dist/types/widgets/PoolWidget/hooks/contract/useWithdrawInfo.d.ts

@@ -0,0 +1,33 @@
+import { PoolType } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+export declare const useWithdrawInfo: ({ pool, isBase, baseAmount, quoteAmount, }: {
+    pool?: {
+        chainId: number;
+        address: string;
+        type: PoolType;
+        baseToken: {
+            symbol: string;
+            decimals: number;
+        };
+        quoteToken: {
+            symbol: string;
+            decimals: number;
+        };
+    };
+    isBase?: boolean;
+    baseAmount: string;
+    quoteAmount: string;
+}) => {
+    withdrawFee: string;
+    baseWithdrawFee: string;
+    quoteWithdrawFee: string;
+    receiveBaseAmount: string;
+    receiveQuoteAmount: string;
+    receiveAmountBg: BigNumber | undefined;
+    receiveList: {
+        amount: string;
+        symbol: string;
+    }[];
+    loading: boolean;
+    error: Error | null;
+};

package/dist/types/widgets/PoolWidget/hooks/useAMMV2AddLiquidity.d.ts

@@ -0,0 +1,12 @@
+import { TokenInfo } from '../../../hooks/Token';
+export declare function useAMMV2AddLiquidity({ baseToken, quoteToken, baseAmount, quoteAmount, slippage, fee, isExists, successBack, submittedBack, }: {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    baseAmount: string;
+    quoteAmount: string;
+    slippage: number;
+    fee: number | undefined;
+    isExists?: boolean;
+    successBack?: () => void;
+    submittedBack?: () => void;
+}): import("@tanstack/react-query").UseMutationResult<import("../../../hooks/Submission/types").ExecutionResult | undefined, Error, void, unknown>;

package/dist/types/widgets/PoolWidget/hooks/useAMMV2Balance.d.ts

@@ -0,0 +1,13 @@
+import { Pair } from '@uniswap/v2-sdk';
+import BigNumber from 'bignumber.js';
+export declare function useAMMV2Balance({ pairAddress, pair, }: {
+    pairAddress?: string;
+    pair?: Pair | null;
+}): {
+    isBalanceLoading: boolean;
+    isDepositedLoading: boolean;
+    balance: BigNumber | undefined;
+    poolTokenPercentage: BigNumber | undefined;
+    token0Deposited: BigNumber | undefined;
+    token1Deposited: BigNumber | undefined;
+};

package/dist/types/widgets/PoolWidget/hooks/useAMMV2RemoveLiquidity.d.ts

@@ -0,0 +1,11 @@
+import { TokenInfo } from '../../../hooks/Token';
+export declare function useAMMV2RemoveLiquidity({ baseToken, quoteToken, baseAmount, quoteAmount, liquidityAmount, slippage, fee, submittedBack, }: {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    baseAmount: string;
+    quoteAmount: string;
+    liquidityAmount: string;
+    slippage: number;
+    fee: number | undefined;
+    submittedBack?: () => void;
+}): import("@tanstack/react-query").UseMutationResult<import("../../../hooks/Submission/types").ExecutionResult | undefined, Error, void, unknown>;

package/dist/types/widgets/PoolWidget/hooks/usePoolBalanceInfo.d.ts

@@ -0,0 +1,49 @@
+import { PoolType } from '@dodoex/api';
+import { BigNumber } from 'bignumber.js';
+type Balance = BigNumber | null | undefined;
+export declare function getLpToTokenBalance(userLpBalance: Balance, totalLpBalance: Balance, reserve: Balance, target: Balance, address: string | undefined, type: PoolType | undefined, decimals: number | undefined): undefined[] | BigNumber[];
+export declare function usePoolBalanceInfo({ account, pool, }: {
+    account?: string;
+    pool?: {
+        address: string;
+        chainId: number;
+        baseTokenDecimals: number;
+        quoteTokenDecimals: number;
+        baseLpTokenDecimals: number;
+        quoteLpTokenDecimals: number;
+        type: PoolType;
+    };
+}): {
+    /** existing base lp balance */
+    totalBaseLpBalance: BigNumber | null | undefined;
+    /** existing quote lp balance */
+    totalQuoteLpBalance: BigNumber | null | undefined;
+    /** the total deposited base lp balance */
+    baseReserve: BigNumber | undefined;
+    /** the total deposited quote lp balance */
+    quoteReserve: BigNumber | undefined;
+    /** classical base equilibrium target */
+    classicalBaseTarget: BigNumber | undefined;
+    /** classical quote equilibrium target */
+    classicalQuoteTarget: BigNumber | undefined;
+    /** the user's existing base lp balance */
+    userBaseLpBalance: Balance;
+    /** the user's existing quote lp balance */
+    userQuoteLpBalance: Balance;
+    /** The number of base that can be obtained when a user withdraws from the pool */
+    userBaseLpToTokenBalance: BigNumber | undefined;
+    /** The number of quote that can be obtained when a user withdraws from the pool */
+    userQuoteLpToTokenBalance: BigNumber | null | undefined;
+    baseLpToTokenProportion: BigNumber | undefined;
+    quoteLpToTokenProportion: BigNumber | undefined;
+    isSinglePool: boolean;
+    userLpBalanceLoading: boolean;
+    userLpToTokenBalanceLoading: boolean;
+    userLpBalanceError: boolean;
+    userLpToTokenBalanceError: boolean;
+    userLpToTokenBalanceRefetch: () => void;
+    error: boolean;
+    loading: boolean;
+    refetch: () => void;
+};
+export {};