@dodoex/widgets 3.0.0-taiko.4 → 3.0.0-taiko.41

package/dist/types/utils/formatter.d.ts

@@ -0,0 +1,50 @@
+import { BigNumber } from 'bignumber.js';
+/**
+ * format to readable number, like: 0.00 -> 0, 1.00 -> 1, 1.235 -> 1.23, 1.230 -> 1.23
+ * @param input
+ */
+export declare function formatReadableNumber({ input, showDecimals, showPrecisionDecimals, exponentialDecimalsAmount, showIntegerOnly, showDecimalsOnly, noGroupSeparator, roundingMode, }: {
+    input: BigNumber | number | string;
+    showDecimals?: number;
+    showIntegerOnly?: boolean;
+    showDecimalsOnly?: boolean;
+    showPrecisionDecimals?: number;
+    exponentialDecimalsAmount?: number;
+    noGroupSeparator?: boolean;
+    roundingMode?: BigNumber.RoundingMode;
+}): string;
+export declare function formatTokenAmountNumber({ input, decimals, showPrecisionDecimals, exponentialDecimalsAmount, noGroupSeparator, }: {
+    input?: BigNumber | number | string | null;
+    decimals?: number;
+    showPrecisionDecimals?: number;
+    exponentialDecimalsAmount?: number;
+    noGroupSeparator?: boolean;
+}): string;
+export declare const fixedString: (raw: string | number | BigNumber, showDecimals?: number) => string;
+export declare const fixedInputStringToFormattedNumber: (inputValue: string, inputTokenShowDecimals: number) => string | null;
+export declare const toWei: (amount: BigNumber | string | number, decimals: number, notDp?: boolean) => BigNumber;
+export declare const byWei: (amount: BigNumber | string | number, decimals: number) => BigNumber;
+export declare const getDecimalLimit: (decimals: number | undefined | null) => number;
+export declare function getIntegerNumber(v: number): number;
+/**
+ * format to short number, like: -0.12 -> 0, 0.0000123->0.000012, 123.234 -> 123.23, 1234.12 -> 1.23K, 1000000.123->1.00M
+ * @param n
+ */
+export declare function formatShortNumber(n?: BigNumber, showDecimals?: number): string;
+export declare function formatExponentialNotation(n?: BigNumber): string;
+/**
+ * format to percentage number
+ * @param param0 input number
+ */
+export declare function formatPercentageNumber({ input, showDecimals, 
+/** The percentage is rounded by default. */
+roundingMode, }: {
+    input?: BigNumber | string | number | null;
+    showDecimals?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}): string;
+export declare const formatApy: (amount: BigNumber, showDecimals?: number) => string;
+export declare function formatUnknownTokenSymbol(token?: {
+    symbol: string;
+    name: string;
+} | null): string;

package/dist/types/utils/time.d.ts

@@ -0,0 +1,12 @@
+/**
+ * time formatter
+ * output => 17mins54s or 17 Minutes
+ */
+export declare function formatReadableTimeDuration({ start, end, showSecondUnit, }: {
+    start?: number;
+    end?: number;
+    showSecondUnit?: boolean;
+}): string | null;
+export declare function getTimeText(time: Date, split?: string, { noYear, }?: {
+    noYear?: boolean;
+}): string;

package/dist/types/utils/token.d.ts

@@ -0,0 +1,30 @@
+import { TokenInfo } from '../hooks/Token';
+import { ChainId } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+export declare const getTokenSymbolDisplay: (baseToken: TokenInfo) => string;
+export declare const getSwapTxValue: ({ tokenAmount, tokenAddress, chainId, }: {
+    tokenAmount: string | number | BigNumber;
+    tokenAddress: string;
+    chainId: ChainId;
+}) => string;
+export declare function getTokenPairCompareText({ fromToken, toToken, fromFiatPrice, toFiatPrice, reverse, showDecimals, }: {
+    fromToken: TokenInfo | undefined;
+    toToken: TokenInfo | undefined;
+    fromFiatPrice: BigNumber | undefined;
+    toFiatPrice: BigNumber | undefined;
+    reverse?: boolean;
+    showDecimals?: number;
+}): {
+    comparePrice: BigNumber | null;
+    comparePriceText: string;
+    loading: boolean;
+};
+export declare function getShowDecimals(decimals: string | number): 4 | 6;
+export declare function convertFetchTokenToTokenInfo(token: {
+    id?: string | null;
+    address?: string | null;
+    symbol?: string | null;
+    name?: string | null;
+    decimals?: number | null;
+    logoImg?: string | null | undefined;
+} | undefined | null, chainId: ChainId | number): TokenInfo | null | undefined;

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

@@ -0,0 +1,6 @@
+export default function LpTokenMiningOperate({ chainId, account, poolAddress, goLpLink, }: {
+    chainId: number;
+    account: string | undefined;
+    poolAddress: string;
+    goLpLink?: () => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/components/PoolCard.d.ts

@@ -0,0 +1,18 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { DexConfigI } from '../../types';
+export default function PoolCard({ id: address, activePlatform, baseToken, quoteToken, baseReserve, quoteReserve, basePrice, quotePrice, creator, createdAtTimestamp, checked, onClick, children, loading, }: {
+    id: string;
+    activePlatform: DexConfigI | null;
+    baseToken: TokenInfo;
+    quoteToken: TokenInfo;
+    baseReserve: string;
+    quoteReserve: string;
+    creator?: string;
+    createdAtTimestamp?: string;
+    basePrice: number;
+    quotePrice: number;
+    checked?: boolean;
+    onClick: () => void;
+    children?: React.ReactNode;
+    loading?: boolean;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/components/PoolPicker.d.ts

@@ -0,0 +1,22 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { DexKey } from '../utils';
+export interface PoolInfo {
+    id: string;
+    baseReserve: string;
+    quoteReserve: string;
+    baseToken: TokenInfo;
+    quoteToken: TokenInfo;
+    basePrice: number;
+    quotePrice: number;
+    creator?: string;
+    createdAtTimestamp?: string;
+}
+interface Props {
+    on: boolean;
+    onClose: () => void;
+    onConfirm: (pool: PoolInfo) => void;
+    platform?: DexKey;
+    handleGotoCreatePool?: () => void;
+}
+export default function PoolPicker({ on, onClose, onConfirm, platform, handleGotoCreatePool, }: Props): JSX.Element;
+export {};

package/dist/types/widgets/MiningWidget/MiningCreate/components/RewardDetailList.d.ts

@@ -0,0 +1,7 @@
+import { Actions, StateProps } from '../hooks/reducers';
+import { SectionStatusT } from '../types';
+export declare function RewardDetailList({ rewards, status, dispatch, }: {
+    rewards: StateProps['rewards'];
+    status: SectionStatusT;
+    dispatch: React.Dispatch<Actions>;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/components/RewardTokenSelect.d.ts

@@ -0,0 +1,9 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { useGetTokenStatus } from '../../../../hooks/Token/useGetTokenStatus';
+import { RewardStatus } from '../types';
+export declare function RewardTokenSelect({ token, onClick, rewardStatus, submitApprove, }: {
+    token: TokenInfo | undefined;
+    onClick: () => void;
+    rewardStatus: RewardStatus | undefined;
+    submitApprove: ReturnType<typeof useGetTokenStatus>['submitApprove'];
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/components/SectionTitle.d.ts

@@ -0,0 +1,6 @@
+import { SectionStatusT } from '../types';
+export declare function SectionTitle({ index, title, status, }: {
+    index: number;
+    title: string;
+    status: SectionStatusT;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/components/StakingRules.d.ts

@@ -0,0 +1,8 @@
+import { StateProps } from '../hooks/reducers';
+import { SectionStatusT } from '../types';
+export declare function StakingRules({ status, tokenType, saveAToken, pool, }: {
+    status: SectionStatusT;
+    tokenType: StateProps['tokenType'];
+    saveAToken: StateProps['saveAToken'];
+    pool: StateProps['pool'];
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/components/StepTitle.d.ts

@@ -0,0 +1,4 @@
+import { StateProps } from '../hooks/reducers';
+export declare function StepTitle({ currentStep, }: {
+    currentStep: StateProps['currentStep'];
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/reducers.d.ts

@@ -0,0 +1,56 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { PoolInfo } from '../components/PoolPicker';
+export declare enum TokenType {
+    SINGLE = 1,
+    LP = 2
+}
+export interface RewardI {
+    token: TokenInfo | undefined;
+    total: string;
+    startTime: number | null;
+    endTime: number | null;
+}
+export interface StateProps {
+    tokenType: TokenType;
+    saveAToken?: TokenInfo;
+    isHadSetDefaultRewardToken?: boolean;
+    pool: PoolInfo | undefined;
+    rewards: RewardI[];
+    isInitCache: boolean;
+    currentStep: 0 | 1 | 2 | 3;
+    confirmModalVisible: boolean;
+}
+export declare function init(): StateProps;
+export declare enum Types {
+    updateTokenType = 1,
+    updateSaveAToken = 2,
+    updatePlatform = 3,
+    updatePool = 4,
+    updateReward = 5,
+    addReward = 6,
+    removeReward = 7,
+    reset = 8,
+    cover = 9,
+    updateInitCache = 10,
+    SetCurrentStep = 11,
+    SetConfirmModalVisible = 12
+}
+interface PayloadRewardI extends Partial<RewardI> {
+    index: number;
+}
+type Payload = {
+    [Types.updateTokenType]: TokenType;
+    [Types.updateSaveAToken]: TokenInfo | undefined;
+    [Types.updatePool]: PoolInfo | undefined;
+    [Types.updateReward]: PayloadRewardI;
+    [Types.addReward]: undefined;
+    [Types.removeReward]: number;
+    [Types.reset]: undefined;
+    [Types.cover]: StateProps;
+    [Types.updateInitCache]: boolean;
+    [Types.SetCurrentStep]: StateProps['currentStep'];
+    [Types.SetConfirmModalVisible]: boolean;
+};
+export type Actions = ActionMap<Payload>[keyof ActionMap<Payload>];
+export declare function reducer(state: StateProps, action: Actions): StateProps;
+export {};

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/useCreateMining.d.ts

@@ -0,0 +1,12 @@
+import BigNumber from 'bignumber.js';
+import { LpTokenPlatformID } from '../../types';
+export declare const useCreateMining: ({ submittedBack, handleGotoMiningList, }?: {
+    submittedBack?: () => void;
+    handleGotoMiningList?: () => void;
+}) => {
+    state: import("./reducers").StateProps;
+    dispatch: import("react").Dispatch<import("./reducers").Actions>;
+    createMutation: import("@tanstack/react-query").UseMutationResult<void, Error, LpTokenPlatformID | undefined, unknown>;
+    blockNumber: BigNumber;
+    blockTime: number;
+};

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/useCreateMiningTypeList.d.ts

@@ -0,0 +1,6 @@
+import { CreateMiningTypeI } from '../types';
+import { TokenType } from './reducers';
+export declare function useCreateMiningTypeList(): {
+    createMiningTypeList: CreateMiningTypeI[];
+    createMiningTypeMap: Record<TokenType, CreateMiningTypeI>;
+};

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/useDefaultStakeToken.d.ts

@@ -0,0 +1,5 @@
+import { TokenInfo } from '../../../../hooks/Token';
+export declare const useDefaultStakeToken: ({ setStakeToken, defaultStakeTokenAddress, }: {
+    setStakeToken: (token: TokenInfo) => void;
+    defaultStakeTokenAddress?: string;
+}) => void;

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/usePoolPairList.d.ts

@@ -0,0 +1,38 @@
+import { ExcludeNone, PoolApi } from '@dodoex/api';
+export type FetchPoolList = ExcludeNone<ReturnType<Exclude<(typeof PoolApi.graphql.fetchPoolPairList)['__apiType'], undefined>>['basePairs']>;
+export declare const usePoolPairList: ({ baseAddress, quoteAddress, poolAddress, isMyPool, skip, }: {
+    baseAddress?: string;
+    quoteAddress?: string;
+    poolAddress?: string;
+    isMyPool?: boolean;
+    skip?: boolean;
+}) => {
+    loading: boolean;
+    datas: {
+        id: string;
+        type: string;
+        creator: any;
+        lpFeeRate: any;
+        i?: any | null;
+        k?: any | null;
+        baseReserve: any;
+        quoteReserve: any;
+        createdAtTimestamp: any;
+        lastTradePrice: any;
+        volumeUSD: any;
+        baseToken: {
+            id: string;
+            symbol: string;
+            name: string;
+            decimals: any;
+            usdPrice: any;
+        };
+        quoteToken: {
+            id: string;
+            symbol: string;
+            name: string;
+            decimals: any;
+            usdPrice: any;
+        };
+    }[];
+};

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/usePoolTokenBalance.d.ts

@@ -0,0 +1,6 @@
+import BigNumber from 'bignumber.js';
+import { TokenInfo } from '../../../../hooks/Token';
+export declare const usePoolTokenBalance: (poolAddress: string, baseToken?: TokenInfo, quoteToken?: TokenInfo) => {
+    loading: boolean;
+    reserves: BigNumber[] | undefined;
+};

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/useRewardsStatus.d.ts

@@ -0,0 +1,9 @@
+import { RewardStatus } from '../types';
+import { StateProps } from './reducers';
+export declare function useRewardsStatus({ rewards, }: {
+    rewards: StateProps['rewards'];
+}): {
+    rewardsStatus: RewardStatus[];
+    submitApprove: (token: import("../../../..").TokenInfo | null, isReset?: boolean, submittedBack?: () => void, canceledCallback?: () => void, successBack?: () => void, failedCallback?: () => void) => Promise<void>;
+    getMaxBalance: (token: import("../../../..").TokenInfo | null, balance: import("bignumber.js").BigNumber | null) => import("bignumber.js").BigNumber;
+};

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/useTokenPair.d.ts

@@ -0,0 +1,17 @@
+import { TokenInfo } from '../../../../hooks/Token/type';
+export declare const useTokenPair: ({ side, defaultBaseToken, defaultQuoteToken, }?: {
+    side?: "base" | "quote";
+    defaultBaseToken?: TokenInfo;
+    defaultQuoteToken?: TokenInfo;
+}) => {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    baseTokenChange: (token: TokenInfo, occupied?: boolean) => void;
+    quoteTokenChange: (token: TokenInfo, occupied?: boolean) => void;
+    baseOccupiedAddrs: string[] | undefined;
+    quoteOccupiedAddrs: string[] | undefined;
+    token: TokenInfo | undefined;
+    onTokenChange: (token: TokenInfo, occupied?: boolean) => void;
+    occupiedAddrs: string[] | undefined;
+    reset: () => void;
+};

package/dist/types/widgets/MiningWidget/MiningCreate/hooks/useTokenPairStatus.d.ts

@@ -0,0 +1,19 @@
+import { TokenInfo } from '../../../../hooks/Token/type';
+export declare const useTokenPairStatus: ({ side, baseToken, quoteToken, onChangeBaseToken, onChangeQuoteToken, }: {
+    side?: "base" | "quote";
+    baseToken?: TokenInfo;
+    quoteToken?: TokenInfo;
+    onChangeBaseToken: (token?: TokenInfo) => void;
+    onChangeQuoteToken?: (token?: TokenInfo) => void;
+}) => {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    baseTokenChange: (token: TokenInfo, occupied?: boolean) => void;
+    quoteTokenChange: (token: TokenInfo, occupied?: boolean) => void;
+    baseOccupiedAddrs: string[] | undefined;
+    quoteOccupiedAddrs: string[] | undefined;
+    token: TokenInfo | undefined;
+    onTokenChange: (token: TokenInfo, occupied?: boolean) => void;
+    occupiedAddrs: string[] | undefined;
+    reset: () => void;
+};

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

@@ -0,0 +1,5 @@
+export declare function MiningCreate({ handleGotoMiningList, handleGotoCreatePool, handleGoBack, }: {
+    handleGotoMiningList?: () => void;
+    handleGotoCreatePool?: () => void;
+    handleGoBack: () => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/operate-widgets/BottomButtonGroup.d.ts

@@ -0,0 +1,13 @@
+import { Dispatch } from 'react';
+import { useGetTokenStatus } from '../../../../hooks/Token/useGetTokenStatus';
+import { Actions, StateProps } from '../hooks/reducers';
+import { RewardStatus } from '../types';
+export declare function BottomButtonGroup({ state, dispatch, rewardsStatus, submitApprove, createLoading, handleCreate, handleGoBack, }: {
+    state: StateProps;
+    dispatch: Dispatch<Actions>;
+    rewardsStatus: RewardStatus[];
+    submitApprove: ReturnType<typeof useGetTokenStatus>['submitApprove'];
+    createLoading: boolean;
+    handleCreate: () => void;
+    handleGoBack: () => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/operate-widgets/CreateMiningTypeSelect.d.ts

@@ -0,0 +1,6 @@
+import { Dispatch } from 'react';
+import { Actions, StateProps } from '../hooks/reducers';
+export default function CreateMiningTypeSelect({ tokenType, dispatch, }: {
+    tokenType: StateProps['tokenType'];
+    dispatch: Dispatch<Actions>;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/operate-widgets/RewardForm.d.ts

@@ -0,0 +1,14 @@
+import BigNumber from 'bignumber.js';
+import { useGetTokenStatus } from '../../../../hooks/Token/useGetTokenStatus';
+import { Actions, StateProps } from '../hooks/reducers';
+import { RewardStatus } from '../types';
+export default function RewardForm({ state, dispatch, dataTestIdPrefix, rewardsStatus, blockTime, blockNumber, submitApprove, getMaxBalance, }: {
+    state: StateProps;
+    dispatch: React.Dispatch<Actions>;
+    dataTestIdPrefix: string;
+    rewardsStatus: RewardStatus[];
+    blockNumber: BigNumber;
+    blockTime: number;
+    submitApprove: ReturnType<typeof useGetTokenStatus>['submitApprove'];
+    getMaxBalance: ReturnType<typeof useGetTokenStatus>['getMaxBalance'];
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/operate-widgets/SingleTokenSelect.d.ts

@@ -0,0 +1,5 @@
+import { Actions, StateProps } from '../hooks/reducers';
+export declare function SingleTokenSelect({ state, dispatch, }: {
+    state: StateProps;
+    dispatch: React.Dispatch<Actions>;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningCreate/operate-widgets/TokenPairSelect.d.ts

@@ -0,0 +1,11 @@
+import { DexConfigI } from '../../types';
+import { Actions, StateProps } from '../hooks/reducers';
+import { DexKey } from '../utils';
+export declare function TokenPairSelect({ state, dispatch, platform, setPlatform, activePlatform, handleGotoCreatePool, }: {
+    state: StateProps;
+    dispatch: React.Dispatch<Actions>;
+    platform: DexKey;
+    setPlatform: React.Dispatch<React.SetStateAction<DexKey>>;
+    activePlatform: DexConfigI | null;
+    handleGotoCreatePool?: () => void;
+}): JSX.Element;

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

@@ -0,0 +1,14 @@
+import BigNumber from 'bignumber.js';
+import { ApprovalState } from '../../../hooks/Token/type';
+import { TokenType } from './hooks/reducers';
+export interface CreateMiningTypeI {
+    type: TokenType;
+    title: string;
+    description: string;
+}
+export interface RewardStatus {
+    pendingReset?: boolean;
+    state?: ApprovalState;
+    balance: BigNumber | null;
+}
+export type SectionStatusT = 'waiting' | 'running' | 'completed';

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

@@ -0,0 +1,45 @@
+import BigNumber from 'bignumber.js';
+import { DexConfigI } from '../types';
+import { RewardI } from './hooks/reducers';
+import { ChainId } from '@dodoex/api';
+export declare const dexListObj: Record<string, DexConfigI>;
+export type DexKey = keyof typeof dexListObj;
+export declare const BSC_SWAPINFO: {
+    name: string;
+    factoryAddress: string;
+    initHash: string;
+    fee: number;
+}[];
+export declare function GetGeneralUniInfo(chainId: number): {
+    name: string;
+    factoryAddress: string;
+    initHash: string;
+    fee?: number;
+}[];
+export declare function getOtherDexPool(chainId: number, dexName: string, token0Address: string, token1Address: string, GetGeneralUniInfo: (chainId: number) => Array<{
+    name: string;
+    factoryAddress: string;
+    initHash: string;
+    fee?: number;
+}>): string;
+export declare const getChainDexList: (chainId: ChainId, filterCreateMiningEnable?: boolean) => {
+    key: DexKey;
+    value: JSX.Element;
+}[];
+export declare function formatDate(time: number | null): string;
+export declare function computeDailyAmount({ startTime, endTime, total, }: {
+    startTime: BigNumber | number | null | undefined;
+    endTime: BigNumber | number | null | undefined;
+    total: string;
+}): string | null;
+export declare function isValidRewardInfo({ reward, now, }: {
+    reward: RewardI;
+    now: number;
+}): {
+    startTimeIsError: boolean;
+    endTimeIsError: boolean;
+    totalIsError: boolean;
+    isInvalid: boolean;
+};
+export declare const getWrappedTokenAddress: (addressOrigin: string, chainId: ChainId) => string;
+export declare const isBrowser: boolean;

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

@@ -0,0 +1,14 @@
+import { MiningStatusE } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+import { Dispatch, SetStateAction } from 'react';
+import { MiningRewardTokenWithAprI, MiningStakeTokenWithAmountI, OperateType, TabMiningI } from '../types';
+export declare function MiningInfo({ status, stakedTokenList, onClose, onClick, setShareModalVisible, totalAprList, miningItem, rewardTokenWithAprListArray, }: {
+    stakedTokenList: Array<MiningStakeTokenWithAmountI>;
+    onClose: () => void;
+    onClick: (type: OperateType) => void;
+    setShareModalVisible: Dispatch<SetStateAction<boolean>>;
+    status: MiningStatusE;
+    totalAprList: (BigNumber | undefined)[];
+    miningItem: TabMiningI;
+    rewardTokenWithAprListArray: MiningRewardTokenWithAprI[][];
+}): JSX.Element;

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

@@ -0,0 +1,10 @@
+import { MiningRewardTokenWithAprI, RewardUpdateHistoryItemI, TabMiningI } from '../types';
+export interface RewardCardProps {
+    index: number;
+    rewardToken: MiningRewardTokenWithAprI;
+    miningContractAddress: string | undefined;
+    chainId: number;
+    version: TabMiningI['version'];
+    rewardUpdateHistoryList: RewardUpdateHistoryItemI[];
+}
+export declare const RewardCard: ({ index, rewardToken, miningContractAddress, chainId, version, rewardUpdateHistoryList, }: RewardCardProps) => JSX.Element;

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

@@ -0,0 +1,23 @@
+import { CompositeMiningContractDataI, TabMiningI } from '../types';
+export interface InnerMiningProps {
+    contractData: CompositeMiningContractDataI | undefined;
+    miningItem: TabMiningI;
+    refetchContractData: () => void;
+    handleGotoMiningList: () => void;
+    handleGotoPoolDetail: ({ pool, chainId, }: {
+        pool: string;
+        chainId: number;
+    }) => void;
+}
+export declare function MiningDetail({ query, handleGotoMiningList, handleGotoPoolDetail, }: {
+    query: {
+        mining?: string;
+        address?: string;
+        chainId: number;
+    };
+    handleGotoMiningList: () => void;
+    handleGotoPoolDetail: ({ pool, chainId, }: {
+        pool: string;
+        chainId: number;
+    }) => void;
+}): JSX.Element;

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

@@ -0,0 +1,23 @@
+import { BoxProps } from '@dodoex/components';
+export declare const CardWrapper: ({ sx, children, }: {
+    sx?: BoxProps["sx"];
+    children?: React.ReactNode;
+}) => JSX.Element;
+export declare function InnerCardWrapper({ children, sx, innerSx, }: {
+    children: React.ReactNode;
+    sx?: BoxProps['sx'];
+    innerSx?: BoxProps['sx'];
+}): JSX.Element;
+export declare const OperateButton: ({ disabled, sx, children, onClick, }: {
+    disabled?: boolean;
+    sx?: BoxProps["sx"];
+    children?: React.ReactNode;
+    onClick?: () => void;
+}) => JSX.Element;
+export declare function Item({ title, children, wrapperSx, sx, }: {
+    title: string;
+    children: React.ReactNode;
+    component?: BoxProps['component'];
+    wrapperSx?: BoxProps['sx'];
+    sx?: BoxProps['sx'];
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/APRSection.d.ts

@@ -0,0 +1,8 @@
+import BigNumber from 'bignumber.js';
+export declare function APRWrapper({ children }: {
+    children: React.ReactNode;
+}): JSX.Element;
+export declare function APRSection({ apr, size, }: {
+    apr?: BigNumber;
+    size: 'small' | 'medium' | 'large';
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/CloseButton.d.ts

@@ -0,0 +1,3 @@
+export declare function CloseButton({ onClick }: {
+    onClick?: () => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/GoBack.d.ts

@@ -0,0 +1,5 @@
+import { BoxProps } from '@dodoex/components';
+export default function GoBack({ sx, onClick, }: {
+    sx?: BoxProps['sx'];
+    onClick?: () => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/ManageButtonList.d.ts

@@ -0,0 +1,7 @@
+export declare function ManageButtonList({ chainId, operating, stakeTokenAddress, miningContractAddress, onClick, }: {
+    chainId: number;
+    operating: boolean;
+    stakeTokenAddress: string | undefined;
+    miningContractAddress: string | undefined;
+    onClick: () => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/MiningCardLayout.d.ts

@@ -0,0 +1,8 @@
+export declare function MiningCardLayout({ headerLeft, headerRight, children, center, footer, onClick, }: {
+    headerLeft: React.ReactNode;
+    headerRight: React.ReactNode;
+    children: React.ReactNode;
+    center?: React.ReactNode;
+    footer: React.ReactNode;
+    onClick?: () => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/MiningListEmpty.d.ts

@@ -0,0 +1,4 @@
+export declare function MiningListEmpty({ notFoundText, hasSearch, }: {
+    notFoundText: string;
+    hasSearch?: boolean;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/MiningListLoading.d.ts

@@ -0,0 +1 @@
+export declare function MiningListLoading(): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/MiningStatusTabSelect.d.ts

@@ -0,0 +1,5 @@
+import { MiningTabType } from '../../types';
+export declare function MiningStatusTabSelect({ value, onChange, }: {
+    value: MiningTabType;
+    onChange: (value: MiningTabType) => void;
+}): JSX.Element;

package/dist/types/widgets/MiningWidget/MiningList/components/MiningTags.d.ts

@@ -0,0 +1,6 @@
+import { MiningStatusE } from '@dodoex/api';
+import { BoxProps } from '@dodoex/components';
+export declare function MiningTags({ type, sx, }: {
+    type: MiningStatusE;
+    sx?: BoxProps['sx'];
+}): JSX.Element | null;