@dodoex/widgets 3.0.0-taiko.3 → 3.0.0-taiko.30

package/dist/types/widgets/MiningWidget/MiningList/operate-area/StakeButton.d.ts

@@ -0,0 +1,25 @@
+import { MiningStatusE } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+import { useTokenStatus } from '../../../../hooks/Token/useTokenStatus';
+import { MiningLpTokenI, MiningMiningI, TabMiningI } from '../../types';
+import { useDepositOrWithdrawOrClaim } from '../hooks/useDepositOrWithdrawOrClaim';
+export declare function StakeButton({ depositOrWithdrawOrClaimMutation, id, firstStartTime, source, version, miningContractAddress, lpTokenStatus, currentTokenAmount, lpTokenAccountBalance, submitApprove, goLpLink, optToken, approveTokenStatus, isApproving, isGetApproveLoading, chainId, currentChainId, lpTokenBalanceLoading, }: {
+    depositOrWithdrawOrClaimMutation: ReturnType<typeof useDepositOrWithdrawOrClaim>['depositOrWithdrawOrClaimMutation'];
+    id: TabMiningI['id'];
+    firstStartTime: BigNumber | undefined;
+    source: TabMiningI['source'];
+    version: TabMiningI['version'];
+    miningContractAddress: MiningMiningI['miningContractAddress'];
+    lpTokenStatus: MiningStatusE;
+    currentTokenAmount: string;
+    lpTokenAccountBalance: BigNumber | undefined;
+    submitApprove: () => Promise<void>;
+    goLpLink: () => Promise<void>;
+    optToken: MiningLpTokenI;
+    approveTokenStatus: ReturnType<typeof useTokenStatus>;
+    isApproving: boolean;
+    isGetApproveLoading: boolean;
+    chainId: number;
+    currentChainId: number | undefined;
+    lpTokenBalanceLoading: boolean;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/operate-area/StakeTokenSelect.d.ts

@@ -0,0 +1,10 @@
+import { Dispatch, SetStateAction } from 'react';
+import { OperateDataProps, TabMiningI } from '../../types';
+export declare function StakeTokenSelect({ type, operateType, stakedTokenWithAmountList, selectedStakeTokenIndex, setSelectedStakeTokenIndex, goLpLink, miningMinings, customChainId, }: {
+    type: TabMiningI['type'];
+    selectedStakeTokenIndex: 0 | 1;
+    setSelectedStakeTokenIndex: Dispatch<SetStateAction<0 | 1>>;
+    goLpLink: (() => Promise<void>) | undefined;
+    miningMinings: TabMiningI['miningMinings'];
+    customChainId?: number;
+} & Pick<OperateDataProps, 'operateType' | 'stakedTokenWithAmountList'>): JSX.Element | null;

package/dist/types/widgets/MiningWidget/MiningList/operate-area/UnstakeButton.d.ts

@@ -0,0 +1,15 @@
+import { MiningStatusE } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+import { TabMiningI } from '../../types';
+import { useDepositOrWithdrawOrClaim } from '../hooks/useDepositOrWithdrawOrClaim';
+export declare function UnstakeButton({ depositOrWithdrawOrClaimMutation, id, version, lpTokenStatus, lpTokenAccountStakedBalance, currentTokenAmount, chainId, currentChainId, lpTokenBalanceLoading, }: {
+    depositOrWithdrawOrClaimMutation: ReturnType<typeof useDepositOrWithdrawOrClaim>['depositOrWithdrawOrClaimMutation'];
+    id: TabMiningI['id'];
+    version: TabMiningI['version'];
+    lpTokenStatus: MiningStatusE;
+    lpTokenAccountStakedBalance: BigNumber | undefined;
+    currentTokenAmount: string;
+    chainId: number;
+    currentChainId: number | undefined;
+    lpTokenBalanceLoading: boolean;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/operate-area/index.d.ts

@@ -0,0 +1,2 @@
+import { OperateDataProps } from '../../types';
+export declare function OperateArea(props: OperateDataProps): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/operate-area/utils.d.ts

@@ -0,0 +1,24 @@
+import { MiningLpTokenI, MiningStakeTokenWithAmountI, MiningTokenI, TabMiningI } from '../../types';
+export declare function getOptTokenSymbol({ stakedTokenList, type, selectedStakeTokenIndex, }: {
+    stakedTokenList: Array<MiningTokenI>;
+    type: TabMiningI['type'];
+    selectedStakeTokenIndex: 0 | 1;
+}): string;
+export declare function getOptToken({ stakedTokenList, type, lpToken, selectedStakeTokenIndex, }: {
+    stakedTokenList: Array<MiningTokenI>;
+    type: TabMiningI['type'];
+    lpToken: MiningLpTokenI;
+    selectedStakeTokenIndex: 0 | 1;
+}): {
+    symbol: string;
+    address: string | undefined;
+    decimals: number | undefined;
+};
+export declare function getOptTokenPairs({ stakedTokenList, type, selectedStakeTokenIndex, }: {
+    stakedTokenList: Array<MiningStakeTokenWithAmountI>;
+    type: TabMiningI['type'];
+    selectedStakeTokenIndex: 0 | 1;
+}): Array<{
+    address?: string;
+    logoUrl?: string;
+}>;

package/dist/types/widgets/MiningWidget/MiningList/utils.d.ts

@@ -0,0 +1,41 @@
+import BigNumber from 'bignumber.js';
+import { useSubmission } from '../../../hooks/Submission';
+import { CompositeMiningContractDataI, MiningWithContractDataI, TabMiningI } from '../types';
+export declare const EARN_MINING_DETAIL_ID = "earn-mining-detail";
+export declare const EARN_MINING_CREATE_AREA = "earn-mining-create-area";
+export declare const EARN_MINING_OPERATE_AREA = "earn-mining-operate-area";
+export declare const MINING_OPERATE_EXPIRED_TIME = 180;
+export declare function isUnexpiredTx(submitTime: number): boolean;
+export declare function isJoinedMining({ contractData, miningMinings, }: {
+    miningMinings: TabMiningI['miningMinings'];
+    contractData: CompositeMiningContractDataI | undefined;
+}): boolean;
+export declare function isMyStakedLoading({ id, miningMinings, requests, balanceDataMap, }: {
+    id: TabMiningI['id'];
+    miningMinings: TabMiningI['miningMinings'];
+    requests: ReturnType<typeof useSubmission>['requests'];
+    balanceDataMap: Map<string, MiningWithContractDataI>;
+}): boolean;
+export declare function isJoinedOrStakedProcessing({ miningItem, contractDataMap, othersChainContractDataMap, requests, }: {
+    miningItem: TabMiningI;
+    contractDataMap: Map<string, CompositeMiningContractDataI>;
+    othersChainContractDataMap: Map<string, CompositeMiningContractDataI>;
+    requests: ReturnType<typeof useSubmission>['requests'];
+}): boolean;
+export declare function formatApr(apr?: BigNumber): string;
+export declare function formatDate(time: number | null): string;
+export declare function getOperateAreaWrapperEle(): HTMLElement;
+export declare function getDetailWrapperEle(): HTMLElement;
+export declare function hideExistedNode(ele: HTMLElement): void;
+export declare function showExistedNode(ele: HTMLElement): void;
+export declare function generateMiningDetailUrl({ chainId, miningContractAddress, stakeTokenAddress, }: {
+    chainId?: number;
+    miningContractAddress: string | undefined;
+    stakeTokenAddress: string | undefined;
+}): string;
+export declare function computeEndTimestampByEndBlock({ endTime, endBlock, targetEndBlock, blockTime, }: {
+    endTime: BigNumber;
+    endBlock: BigNumber;
+    targetEndBlock: BigNumber;
+    blockTime: number;
+}): number;

package/dist/types/widgets/MiningWidget/OperateArea/AssociateMine.d.ts

@@ -0,0 +1,20 @@
+import BigNumber from 'bignumber.js';
+import type { TokenInfo } from '../../../hooks/Token';
+import { FetchMiningListItem } from '../types';
+type Tokens = Array<TokenInfo & {
+    symbolEle?: string;
+    amount?: string;
+}>;
+export declare function AssociatedMine({ chainId, loading, miningItem, miningContractAddress, stakedTokenUSD, stakedTokenUSDLoading, miningTitle, associatedMineSectionShort, stakedTokenList, isEnded, }: {
+    chainId: number;
+    loading?: boolean;
+    miningItem: FetchMiningListItem;
+    miningContractAddress: string;
+    miningTitle: string | undefined;
+    associatedMineSectionShort?: boolean;
+    stakedTokenUSD: BigNumber | undefined;
+    stakedTokenUSDLoading?: boolean;
+    stakedTokenList: Tokens;
+    isEnded?: boolean;
+}): JSX.Element;
+export {};

package/dist/types/widgets/MiningWidget/OperateArea/ClaimButton.d.ts

@@ -0,0 +1,4 @@
+import { FetchMiningListItem } from '../types';
+export default function ClaimButton({ miningItem, }: {
+    miningItem: FetchMiningListItem;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/OperateArea/GetLpLink.d.ts

@@ -0,0 +1,4 @@
+export default function GetLpLink({ tokenSymbol, goLpLink, }: {
+    tokenSymbol: string | undefined;
+    goLpLink: () => Promise<void> | void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/OperateArea/RewardListCard.d.ts

@@ -0,0 +1,7 @@
+import { BoxProps } from '@dodoex/components';
+import { FetchMiningListItem } from '../types';
+export declare function RewardListCard({ miningItem, loading, sx, }: {
+    miningItem: FetchMiningListItem;
+    loading?: boolean;
+    sx?: BoxProps['sx'];
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/OperateArea/StakeButton.d.ts

@@ -0,0 +1,12 @@
+import { FetchMiningListItem } from '../types';
+import { usePoolBalanceInfo } from '../../PoolWidget/hooks/usePoolBalanceInfo';
+import { BalanceData } from '../../../hooks/Submission/useBalanceUpdateLoading';
+export declare function StakeButton({ goLpLink, amount, miningItem, balanceInfo, submittedBack, successBack, logBalance, }: {
+    amount: string;
+    miningItem: FetchMiningListItem;
+    balanceInfo: ReturnType<typeof usePoolBalanceInfo>;
+    goLpLink?: () => Promise<void> | void;
+    submittedBack?: () => void;
+    successBack?: () => void;
+    logBalance?: BalanceData;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/OperateArea/UnstakeButton.d.ts

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+import { FetchMiningListItem } from '../types';
+import { BalanceData } from '../../../hooks/Submission/useBalanceUpdateLoading';
+export default function UnstakeButton({ amount, miningItem, overrideBalance, submittedBack, successBack, logBalance, }: {
+    amount: string;
+    miningItem: FetchMiningListItem;
+    overrideBalance: BigNumber | undefined | null;
+    submittedBack?: () => void;
+    successBack?: () => void;
+    logBalance?: BalanceData;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/OperateArea/Widgets.d.ts

@@ -0,0 +1,2 @@
+import { BoxProps } from '@dodoex/components';
+export declare function OperateButtonWrapper({ sx, ...props }: BoxProps): JSX.Element;

package/dist/types/widgets/MiningWidget/hooks/helper.d.ts

@@ -0,0 +1,69 @@
+import { MiningApi } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+import { BaseMiningI, MyCreatedMiningI, ReviewedMiningRewardTokenI, TabMiningI } from '../types';
+export type RewardTokenInfosParameters = {
+    endBlock: string;
+    rewardPerBlock: string;
+    rewardToken: string;
+    startBlock: string;
+};
+type MiningListQueryListItem = ElementType<NonNullable<NonNullable<ReturnType<Exclude<(typeof MiningApi.graphql.fetchMiningListV1)['__apiType'], undefined>>['mining_list']>['list']>>;
+export declare const manualStopMiningList: Record<string, [
+    blockNumber: string,
+    timestamp: string
+]>;
+export declare function transformRawMiningToBaseMining(obj: MiningListQueryListItem): BaseMiningI | null;
+export declare function transformRawMiningToTabMining(obj: MiningListQueryListItem): TabMiningI | null;
+export declare function transformStrToBN(raw: any, decimals: number | undefined): BigNumber | undefined;
+export declare function transformRawMiningToMyCreatedMining(obj: ElementType<NonNullable<NonNullable<ReturnType<Exclude<(typeof MiningApi.graphql.fetchMyCreatedMiningList)['__apiType'], undefined>>['mining_list']>['list']>>): MyCreatedMiningI | null;
+export declare function getStakeTokenAPR({ chainId, rewardPerBlock, rewardTokenUSDPrice, totalStakedTokenUSD, }: {
+    chainId: number;
+    rewardPerBlock: BigNumber | undefined;
+    rewardTokenUSDPrice: BigNumber | undefined;
+    totalStakedTokenUSD: BigNumber | undefined;
+}): BigNumber | undefined;
+export declare function getReserveForMining({ balance, totalSupply, reserve, }: {
+    balance: BigNumber | undefined;
+    totalSupply: BigNumber | undefined;
+    reserve: BigNumber | undefined;
+}): BigNumber | undefined;
+export declare function getVaultReserveForMining({ baseStakeTokenBalance, quoteStakeTokenBalance, baseStakeTokenTotalSupply, quoteStakeTokenTotalSupply, baseTokenReserve, quoteTokenReserve, midPrice, baseTokenUSD, quoteTokenUSD, }: {
+    baseStakeTokenBalance?: BigNumber;
+    quoteStakeTokenBalance?: BigNumber;
+    baseStakeTokenTotalSupply?: BigNumber;
+    quoteStakeTokenTotalSupply?: BigNumber;
+    baseTokenReserve?: BigNumber;
+    quoteTokenReserve?: BigNumber;
+    midPrice?: BigNumber;
+    baseTokenUSD?: BigNumber;
+    quoteTokenUSD?: BigNumber;
+}): {
+    baseReserveForMining: BigNumber | undefined;
+    quoteReserveForMining: BigNumber | undefined;
+    baseReserveForMiningUSD: BigNumber | undefined;
+    quoteReserveForMiningUSD: BigNumber | undefined;
+    totalStakedTokenUSD: BigNumber | undefined;
+    totalStakedTokenWithoutMidPriceUSD: BigNumber | undefined;
+};
+export declare function computeUnreleasedRewardByBlock({ blockNumber, lastFlagBlock, endBlock, decimals, rewardPerBlock, }: {
+    blockNumber: BigNumber;
+    lastFlagBlock: BigNumber;
+    endBlock: BigNumber;
+    decimals: number;
+    rewardPerBlock: BigNumber;
+}): BigNumber;
+export declare function getV3MiningSingleRewardAmount(t: ReviewedMiningRewardTokenI, blockNumber: BigNumber, blockTime: number, decimals: number | undefined): {
+    totalReward: BigNumber | null;
+    dailyReward: BigNumber | null;
+    releasedReward: BigNumber | null;
+    unreleasedReward: BigNumber | null;
+    workThroughReward: BigNumber | undefined;
+    lastFlagBlock: BigNumber | undefined;
+    rewardVault: string | undefined;
+    rewardPerBlock: BigNumber | undefined;
+    startBlock: BigNumber | undefined;
+    endBlock: BigNumber | undefined;
+    startTime: BigNumber | undefined;
+    endTime: BigNumber | undefined;
+};
+export {};

package/dist/types/widgets/MiningWidget/hooks/useClaimMiningSubmit.d.ts

@@ -0,0 +1,5 @@
+import { FetchMiningListItem } from '../types';
+export declare const useClaimMiningSubmit: ({ miningItem, successBack, }: {
+    miningItem: FetchMiningListItem;
+    successBack?: () => void;
+}) => import("@tanstack/react-query").UseMutationResult<import("../../../hooks/Submission/types").ExecutionResult | undefined, Error, void, unknown>;

package/dist/types/widgets/MiningWidget/hooks/useMiningBlockNumber.d.ts

@@ -0,0 +1,6 @@
+import { ChainId } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+export declare function useMiningBlockNumber(chainId: ChainId, otherChainBlockNumber: BigNumber | undefined): {
+    blockNumber: BigNumber;
+    blockTime: number;
+};

package/dist/types/widgets/MiningWidget/hooks/useMiningItem.d.ts

@@ -0,0 +1,11 @@
+export declare function useMiningItem({ miningContractAddress, poolAddress, account, chainId, }: {
+    miningContractAddress?: string;
+    poolAddress?: string;
+    account: string | undefined;
+    chainId: number;
+}): {
+    miningItem: import("../types").TabMiningI | undefined;
+    error: Error | null;
+    loading: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").MiningListQuery, Error>>;
+};

package/dist/types/widgets/MiningWidget/hooks/useMiningList.d.ts

@@ -0,0 +1,12 @@
+import { TabMiningI } from '../types';
+export declare function useMiningList({ isEnded, searchText, account, chainIds, }: {
+    isEnded: boolean | undefined;
+    searchText: string | undefined;
+    account: string | undefined;
+    chainIds: Array<number> | null;
+}): {
+    error: Error | null;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").MiningListQuery, Error>>;
+    loading: boolean;
+    miningList: TabMiningI[];
+};

package/dist/types/widgets/MiningWidget/hooks/useMiningListContractDataMap.d.ts

@@ -0,0 +1,12 @@
+import { CompositeMiningContractDataI, TabMiningI } from '../types';
+export declare function useMiningListContractDataMap({ miningList, account, currentChainId, }: {
+    miningList: TabMiningI[];
+    account?: string;
+    currentChainId: number | undefined;
+}): {
+    contractDataMap: Map<string, CompositeMiningContractDataI>;
+    othersChainContractDataMap: Map<string, CompositeMiningContractDataI>;
+    loading: boolean;
+    otherChinsLoading: boolean;
+    refetch: () => void;
+};

package/dist/types/widgets/MiningWidget/hooks/useMyCreatedMiningList.d.ts

@@ -0,0 +1,11 @@
+import { MyCreatedMiningI } from '../types';
+export declare function useMyCreatedMiningList({ searchText, account, chainIds, }: {
+    searchText: string | undefined;
+    account: string | undefined;
+    chainIds: Array<number> | null;
+}): {
+    error: Error | null;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").MyCreatedMiningListQuery, Error>>;
+    loading: boolean;
+    miningList: MyCreatedMiningI[];
+};

package/dist/types/widgets/MiningWidget/hooks/usePrevious.d.ts

@@ -0,0 +1 @@
+export declare function usePrevious<Value>(value: Value): Value | undefined;

package/dist/types/widgets/MiningWidget/hooks/useRefetch.d.ts

@@ -0,0 +1,5 @@
+export declare function useRefetch(callback?: () => void): {
+    refetch: () => void;
+    refetchTimes: number;
+    isRefetch: boolean;
+};

package/dist/types/widgets/MiningWidget/hooks/useReviewRewardToken.d.ts

@@ -0,0 +1,28 @@
+import BigNumber from 'bignumber.js';
+import { MiningRewardTokenI, ReviewedMiningRewardTokenI } from '../types';
+export declare function useReviewRewardToken({ chainId, index, miningContractAddress, rewardToken, skip, }: {
+    chainId: number;
+    index: number;
+    miningContractAddress: string | undefined;
+    rewardToken: MiningRewardTokenI;
+    skip?: Boolean;
+}): {
+    inCurrentChain: boolean;
+    blockNumber: BigNumber;
+    blockTime: number;
+    reviewedRewardToken: ReviewedMiningRewardTokenI;
+    rewardAmount: {
+        totalReward: BigNumber | null;
+        dailyReward: BigNumber | null;
+        releasedReward: BigNumber | null;
+        unreleasedReward: BigNumber | null;
+        workThroughReward: BigNumber | undefined;
+        lastFlagBlock: BigNumber | undefined;
+        rewardVault: string | undefined;
+        rewardPerBlock: BigNumber | undefined;
+        startBlock: BigNumber | undefined;
+        endBlock: BigNumber | undefined;
+        startTime: BigNumber | undefined;
+        endTime: BigNumber | undefined;
+    };
+};

package/dist/types/widgets/MiningWidget/hooks/useStakeMiningSubmit.d.ts

@@ -0,0 +1,9 @@
+import { BalanceData } from '../../../hooks/Submission/useBalanceUpdateLoading';
+import { FetchMiningListItem } from '../types';
+export declare const useStakeMiningSubmit: ({ miningItem, amount, submittedBack, successBack, logBalance, }: {
+    miningItem: FetchMiningListItem;
+    amount: string;
+    submittedBack?: () => void;
+    successBack?: () => void;
+    logBalance?: BalanceData;
+}) => import("@tanstack/react-query").UseMutationResult<import("../../../hooks/Submission/types").ExecutionResult | undefined, Error, void, unknown>;

package/dist/types/widgets/MiningWidget/hooks/useStatusAndStartBlockNumber.d.ts

@@ -0,0 +1,13 @@
+import { MiningStatusE } from '@dodoex/api';
+import { FetchMiningListItem } from '../types';
+export declare function useStatusAndStartBlockNumber({ miningItem, }: {
+    miningItem: FetchMiningListItem;
+}): {
+    status: MiningStatusE;
+    miningStatusList: {
+        status: import("@dodoex/api/dist/types/services/mining/utils").MiningStatusE;
+        firstStartTime: import("bignumber.js").BigNumber | undefined;
+        lastEndTime: import("bignumber.js").BigNumber | undefined;
+        currentTime: import("bignumber.js").BigNumber;
+    }[];
+};

package/dist/types/widgets/MiningWidget/hooks/useUnstakeMiningSubmit.d.ts

@@ -0,0 +1,9 @@
+import { BalanceData } from '../../../hooks/Submission/useBalanceUpdateLoading';
+import { FetchMiningListItem } from '../types';
+export declare const useUnstakeMiningSubmit: ({ miningItem, amount, submittedBack, successBack, logBalance, }: {
+    miningItem: FetchMiningListItem;
+    amount: string;
+    submittedBack?: () => void;
+    successBack?: () => void;
+    logBalance?: BalanceData;
+}) => import("@tanstack/react-query").UseMutationResult<import("../../../hooks/Submission/types").ExecutionResult | undefined, Error, void, unknown>;

package/dist/types/widgets/MiningWidget/hooks/utils.d.ts

@@ -0,0 +1,30 @@
+import { ChainId, MiningStatusE } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+import dayjs from 'dayjs';
+import { BaseMiningI, MiningRewardTokenI } from '../types';
+export declare const MINING_POOL_REFETCH_INTERVAL = 60000;
+export declare const VALID_MINING_TYPE: Array<BaseMiningI['type']>;
+export declare const VALID_MINING_VERSION: Array<BaseMiningI['version']>;
+export declare function getMiningRewardStatus({ startTime, endTime, }: {
+    startTime: BigNumber | undefined;
+    endTime: BigNumber | undefined;
+}): {
+    status: MiningStatusE;
+    currentTime: BigNumber;
+};
+export declare function getMiningStatusByTimestamp({ rewardTokenInfoList, }: {
+    rewardTokenInfoList: Pick<MiningRewardTokenI, 'startTime' | 'endTime'>[];
+}): {
+    status: MiningStatusE;
+    firstStartTime: BigNumber | undefined;
+    lastEndTime: BigNumber | undefined;
+    currentTime: BigNumber;
+};
+export declare function computeDailyRewardByPerBlock(blockTime: number, rewardPerBlock: BigNumber | undefined): BigNumber | null;
+export declare const getPreBlock: (blockTime: number, blockNumber: BigNumber, time: number | Date) => BigNumber;
+export declare const getTimeByPreBlock: (blockTime: number, blockNumber: BigNumber, preBlockNumber: string | number | BigNumber) => dayjs.Dayjs;
+/**
+ * 一天预估产生多少区块
+ */
+export declare function getBlocksCountPerDay(chainId: ChainId): number;
+export declare function getBlocksCountPerYear(chainId: number): number;

package/dist/types/widgets/MiningWidget/types.d.ts

@@ -0,0 +1,210 @@
+import { ExcludeNone, MiningApi, MiningStatusE } from '@dodoex/api';
+import { BoxProps } from '@dodoex/components';
+import BigNumber from 'bignumber.js';
+import React, { Dispatch, SetStateAction } from 'react';
+import { TokenInfo } from '../../hooks/Token';
+export type FetchMiningList = ExcludeNone<ReturnType<Exclude<(typeof MiningApi.graphql.fetchMiningList)['__apiType'], undefined>>['mining_list']>['list'];
+export type FetchMiningListItem = ExcludeNone<FetchMiningList>[0] | undefined;
+export type MiningTopTabType = null | 'all' | 'staked' | 'created';
+export type MiningTabType = 'active' | 'ended';
+export type OperateType = null | 'stake' | 'unstake' | 'claim';
+export interface MiningTokenI {
+    address: string | undefined;
+    decimals: number | undefined;
+    symbol: string | undefined;
+}
+/** The original token corresponding to lptoken has a price */
+export interface MiningERC20TokenI extends MiningTokenI {
+    usdPrice: BigNumber | undefined;
+    logoImg: string | undefined;
+}
+/** lptoken, a token obtained by pledging the original token, has no price */
+export interface MiningLpTokenI extends MiningTokenI {
+}
+/** Reward tokens */
+export interface MiningRewardTokenI extends MiningERC20TokenI {
+    /**
+     * Block height when rewards start to be released: If not configured, it defaults to undefined and is considered to have ended.
+     */
+    startBlock: BigNumber | undefined;
+    /**
+     * The timestamp corresponding to the block height when rewards start to be released; unit: seconds
+     */
+    startTime: BigNumber | undefined;
+    /**
+     * Block height released after reward ends: If not configured, it defaults to undefined and is considered to have ended.
+     */
+    endBlock: BigNumber | undefined;
+    /**
+     * The timestamp corresponding to the block height released after the reward ends; unit: seconds
+     */
+    endTime: BigNumber | undefined;
+    /** The number of rewards released per block */
+    rewardPerBlock: BigNumber | undefined;
+    /** The apy returned by the interface is inaccurate and not timely. It is only used for initial rendering and subsequent front-end calculations */
+    initialApr: BigNumber | undefined;
+    blockNumber: BigNumber | undefined;
+}
+export interface ReviewedMiningRewardTokenI extends Pick<MiningRewardTokenI, 'rewardPerBlock' | 'startBlock' | 'endBlock' | 'startTime' | 'endTime'> {
+    workThroughReward: BigNumber | undefined;
+    lastFlagBlock: BigNumber | undefined;
+    rewardVault: string | undefined;
+}
+/**
+ * One mining project may correspond to multiple mining contracts. For example, classic mining bilateral pledge can obtain respective lpToken and then pledge them into different mining contracts. This mining project is equivalent to two mining projects, 1 to 2 , but the front end needs to be displayed on a card
+ *
+ * Avoid using identifiers such as base or quote in the data structure, and use array records to record this kind of 1-to-2 mining.
+ */
+export interface MiningMiningI {
+    /** lpToken.address-miningContractAddress */
+    id: string;
+    sourceToken: Array<MiningERC20TokenI>;
+    lpToken: MiningLpTokenI;
+    /** Mining contract: one mining contract corresponds to one lptoken */
+    miningContractAddress: string | undefined;
+    /**
+     * The v2 version has only one reward token; v3 may have multiple;
+     */
+    rewardTokenList: MiningRewardTokenI[];
+}
+export interface BaseMiningI {
+    chainId: number;
+    type: 'dvm' | 'single' | 'classical' | 'vdodo' | 'lptoken';
+    version: '2' | '3';
+    stakeTokenAddress: string;
+    miningContractAddress: string;
+    quoteLpTokenMiningContractAddress?: string;
+}
+export declare enum LpTokenPlatformID {
+    dodo = 0,
+    pancakeV2 = 1
+}
+export interface DexConfigI {
+    name: string;
+    Icon: React.FunctionComponent<React.SVGProps<SVGSVGElement> & {
+        title?: string;
+    }>;
+    createMiningEnable?: boolean;
+    platformID?: LpTokenPlatformID;
+}
+export interface CommonMiningI extends Pick<BaseMiningI, 'chainId' | 'version' | 'stakeTokenAddress'> {
+    /** `${chainId}-${BaseMiningI.stakeTokenAddress}-${BaseMiningI.miningContractAddress}`.toLowerCase() */
+    id: string;
+    name: string | undefined;
+    source: 'official' | 'unofficial';
+    lpTokenPlatformID: LpTokenPlatformID;
+    miningMinings: [MiningMiningI] | [MiningMiningI, MiningMiningI];
+    miningTotalDollar?: string | number | null;
+    isGSP: boolean;
+    isNewERCMineV3: boolean;
+}
+interface SingleMiningI extends CommonMiningI {
+    type: 'single' | 'vdodo';
+}
+interface PairMiningI extends CommonMiningI {
+    type: 'dvm' | 'classical' | 'lptoken';
+    baseToken: MiningERC20TokenI;
+    quoteToken: MiningERC20TokenI;
+}
+export type TabMiningI = SingleMiningI | PairMiningI;
+export interface MiningWithBalanceI {
+    lpTokenAccountBalance: BigNumber | undefined;
+    lpTokenAccountStakedBalance: BigNumber | undefined;
+    rewardTokenWithBalanceMap: Map<string, BigNumber | undefined>;
+}
+export interface MiningPoolContractDataI {
+    midPrice: BigNumber | undefined;
+    baseTokenReserve: BigNumber | undefined;
+    quoteTokenReserve: BigNumber | undefined;
+}
+export interface MiningWithContractDataI extends MiningWithBalanceI {
+    lpTokenMiningBalance: BigNumber | undefined;
+    lpTokenTotalSupply: BigNumber | undefined;
+}
+export interface CompositeMiningContractDataI extends MiningPoolContractDataI {
+    balanceDataMap: Map<MiningMiningI['id'], MiningWithContractDataI>;
+    chainId: number;
+}
+export interface MyCreatedMiningRewardTokenI extends MiningRewardTokenI {
+}
+export interface MyCreatedMiningI {
+    id: string;
+    chainId: number;
+    type: 'single' | 'lptoken';
+    miningContractAddress: string;
+    participantsNum: number | undefined;
+    apy: BigNumber | undefined;
+    name: string | undefined;
+    token: MiningERC20TokenI;
+    lpToken: {
+        /** pair address */
+        id: string;
+        baseToken: MiningERC20TokenI;
+        quoteToken: MiningERC20TokenI;
+    };
+    status: MiningStatusE;
+    rewardTokenList: MyCreatedMiningRewardTokenI[];
+    isGSP: boolean;
+    isNewERCMineV3: boolean;
+}
+export interface RewardUpdateHistoryItemI {
+    rewardToken: TokenInfo;
+    updateTime: number;
+    endBlockBN: BigNumber;
+    dailyReward: BigNumber | null;
+    totalReward: BigNumber | null;
+    rewardPerBlockBN: BigNumber;
+}
+export interface LiquidityMigrationInfo {
+    chainId: number;
+    miningContractAddress: string;
+    stakeTokenAddress: string;
+    newMiningContractAddress: string;
+    newStakeTokenAddress: string;
+}
+export interface MiningRewardTokenWithAprI extends MiningRewardTokenI {
+    apr: BigNumber | undefined;
+    pendingReward: BigNumber | undefined;
+}
+export interface MiningRewardTokenWithTagI extends MiningRewardTokenWithAprI {
+    symbolEle: JSX.Element | string | undefined;
+}
+export interface MiningStakeTokenWithAmountI extends MiningERC20TokenI {
+    unstakedSourceTokenAmount: BigNumber | undefined;
+    unstakedSourceTokenAmountUSD: BigNumber | undefined;
+    sourceTokenAmount: BigNumber | undefined;
+    sourceTokenAmountUSD: BigNumber | undefined;
+    valueLockedAmount: BigNumber | undefined;
+}
+export interface OperateDataProps {
+    operateType: OperateType;
+    setOperateType: Dispatch<SetStateAction<OperateType>>;
+    miningItem: TabMiningI;
+    balanceDataMap: CompositeMiningContractDataI['balanceDataMap'] | undefined;
+    totalRewardUSD: BigNumber | undefined;
+    stakedTokenUSD: BigNumber | undefined;
+    rewardTokenList: MiningRewardTokenWithTagI[];
+    stakedTokenWithAmountList: MiningStakeTokenWithAmountI[];
+    onClose?: () => void;
+    setShareModalVisible?: Dispatch<SetStateAction<boolean>>;
+    refetchBalance: () => void;
+    refetchAfterClaim: () => void;
+    titleSectionVisible: boolean;
+    associatedMineSectionVisible: boolean;
+    associatedMineSectionShort?: boolean;
+    sx?: BoxProps['sx'];
+    addLiquidityEnable: boolean;
+    externalAddLiquidityCallback?: () => void;
+    miningStatusList: {
+        status: MiningStatusE;
+        firstStartTime: BigNumber | undefined;
+        lastEndTime: BigNumber | undefined;
+        currentTime: BigNumber;
+    }[];
+    rewardTokenWithAprListArray: MiningRewardTokenWithAprI[][];
+    addLiquiditySuccessfulPair: [boolean, boolean];
+    lpTokenAccountStakedBalanceLoading: [boolean, boolean];
+    lpTokenAccountBalanceLoading: [boolean, boolean];
+    gspPairRiskWarningVisible?: boolean;
+}
+export {};