@dodoex/widgets 2.6.12-beta.8 → 2.6.12

package/dist/types/index.d.ts

@@ -0,0 +1,37 @@
+import { SwapProps } from './components/Swap';
+import { WidgetProps } from './components/Widget';
+export { useRouterStore, PageType } from './router';
+export type { Page } from './router';
+export { WIDGET_CLASS_NAME } from './components/Widget';
+export { MetadataFlag } from './hooks/Submission/types';
+export { rpcServerMap, scanUrlDomainMap } from './constants/chains';
+export { chainListMap } from './constants/chainList';
+export { Widget, UnstyleWidget, Message } from './components/Widget';
+export { WIDGET_MODULE_CLASS_NAME } from './components/WidgetContainer';
+export type { WidgetProps } from './components/Widget';
+export type SwapWidgetProps = WidgetProps & SwapProps;
+export type { TokenInfo } from './hooks/Token/type';
+export { useMessageState } from './hooks/useMessageState';
+export { Swap } from './components/Swap';
+export { default as SwapOrderHistory } from './components/Swap/SwapOrderHistory';
+export { useTradeSwapOrderList } from './hooks/Swap/useTradeSwapOrderList';
+export { Pool } from './widgets/PoolWidget';
+export { default as PoolList } from './widgets/PoolWidget/PoolList';
+export { default as PoolCreate } from './widgets/PoolWidget/PoolCreate';
+export { default as PoolModify } from './widgets/PoolWidget/PoolModify';
+export { default as PoolDetail } from './widgets/PoolWidget/PoolDetail';
+export { default as PoolOperateDialog, PoolOperate, } from './widgets/PoolWidget/PoolOperate';
+export type { PoolOperateProps } from './widgets/PoolWidget/PoolOperate';
+export { usePoolBalanceInfo } from './widgets/PoolWidget/hooks/usePoolBalanceInfo';
+export { MiningList } from './widgets/MiningWidget/MiningList';
+export { MiningDetail } from './widgets/MiningWidget/MiningDetail';
+export { MiningCreate } from './widgets/MiningWidget/MiningCreate';
+export { TokenCard } from './components/Swap/components/TokenCard';
+export { default as TokenLogo } from './components/TokenLogo';
+export { FailedList } from './components/List/FailedList';
+export { EmptyList } from './components/List/EmptyList';
+export { getEtherscanPage } from './utils/address';
+export { formatReadableNumber, formatTokenAmountNumber, formatShortNumber, formatPercentageNumber, } from './utils/formatter';
+export declare function SwapWidget(props: SwapWidgetProps): JSX.Element;
+export declare function PoolWidget(props: SwapWidgetProps): JSX.Element;
+export declare function InitSwapWidget(props: SwapWidgetProps): void;

package/dist/types/router/types.d.ts

@@ -0,0 +1,40 @@
+import { ChainId } from '@dodoex/api';
+import { PoolTab } from '../widgets/PoolWidget/PoolList/hooks/usePoolListTabs';
+export declare enum PageType {
+    Pool = "pool",
+    PoolDetail = "poolDetail",
+    CreatePool = "createPool",
+    ModifyPool = "modifyPool",
+    MiningList = "miningList",
+    MiningDetail = "miningDetail"
+}
+interface PageTypeParams {
+    [PageType.Pool]: {
+        tab?: PoolTab;
+    } | undefined;
+    [PageType.PoolDetail]: {
+        address: string;
+        chainId: ChainId;
+    };
+    [PageType.ModifyPool]: {
+        address: string;
+        chainId: ChainId;
+    };
+    [PageType.CreatePool]: {
+        fromAddress?: string;
+        toAddress?: string;
+    } | undefined;
+    [PageType.MiningList]: {
+        chainId: number;
+    };
+    [PageType.MiningDetail]: {
+        chainId: number;
+        miningContractAddress: string | undefined;
+        stakeTokenAddress: string | undefined;
+    };
+}
+export interface Page<T extends PageType = PageType> {
+    type: T;
+    params?: PageTypeParams[T];
+}
+export {};

package/dist/types/store/actions/globals.d.ts

@@ -0,0 +1,9 @@
+import { AppThunkAction } from '.';
+import { ContractStatus } from '../reducers/globals';
+export declare const setContractStatus: (contractStatus: ContractStatus) => AppThunkAction;
+export declare const setAutoConnectLoading: (loading: boolean) => AppThunkAction;
+export declare const setAutoSlippage: (autoSlippage: {
+    loading: boolean;
+    value: number | null;
+}) => AppThunkAction;
+export declare const setAutoSlippageLoading: (loading: boolean) => AppThunkAction;

package/dist/types/store/actions/index.d.ts

@@ -0,0 +1,4 @@
+import { Action, ThunkAction, ThunkDispatch } from '@reduxjs/toolkit';
+import { RootState } from '../reducers';
+export type AppThunkAction<Ret = void> = ThunkAction<Ret, RootState, unknown, Action<string>>;
+export type AppThunkDispatch = ThunkDispatch<RootState, unknown, Action<string>>;

package/dist/types/store/actions/settings.d.ts

@@ -0,0 +1,3 @@
+import { AppThunkAction } from '.';
+import { Slippage } from '../reducers/settings';
+export declare const setSlippage: (slippage: Slippage) => AppThunkAction;

package/dist/types/store/actions/token.d.ts

@@ -0,0 +1,7 @@
+import { AppThunkAction } from '.';
+import { TokenList, TokenInfo } from '../../hooks/Token';
+import { SlippageWithToken } from '../reducers/token';
+export declare const setTokenList: (tokenList: TokenList) => AppThunkAction;
+export declare const setPopularTokenList: (popularTokenList: TokenList) => AppThunkAction;
+export declare const setSlippageWithTokens: (slippageWithTokens: SlippageWithToken[]) => AppThunkAction;
+export declare const setDefaultToToken: (token: TokenInfo) => AppThunkAction;

package/dist/types/store/actions/wallet.d.ts

@@ -0,0 +1,6 @@
+import { AppThunkAction } from '.';
+import { ChainId } from '@dodoex/api';
+import { State } from '../reducers/wallet';
+export declare const setFromTokenChainId: (chainId: ChainId | undefined) => AppThunkAction;
+export declare const setBlockNumber: (blockNumber: number) => AppThunkAction;
+export declare const setOpenConnectWalletInfo: (openConnectWalletInfo: State["openConnectWalletInfo"]) => AppThunkAction;

package/dist/types/store/index.d.ts

@@ -0,0 +1,12 @@
+/** @ts-ignore */
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<import("redux").CombinedState<{
+    settings: import("./reducers/settings").State;
+    wallet: import("./reducers/wallet").State;
+    token: import("./reducers/token").State;
+    globals: import("./reducers/globals").State;
+}>, import("redux").AnyAction, [import("@reduxjs/toolkit").ThunkMiddleware<import("redux").CombinedState<{
+    settings: import("./reducers/settings").State;
+    wallet: import("./reducers/wallet").State;
+    token: import("./reducers/token").State;
+    globals: import("./reducers/globals").State;
+}>, import("redux").AnyAction>]>;

package/dist/types/store/reducers/globals.d.ts

@@ -0,0 +1,21 @@
+import { AnyAction } from 'redux';
+export declare enum ContractStatus {
+    Initial = "Initial",
+    Pending = "Pending",
+    ApproveSuccess = "ApproveSuccess",
+    TxSuccess = "TxSuccess",
+    Failed = "Failed"
+}
+export interface State {
+    contractStatus?: ContractStatus;
+    autoConnectLoading?: boolean;
+    showCoingecko?: boolean;
+    /** source: props.getAutoSlippage */
+    autoSlippage?: {
+        loading: boolean;
+        value: number | null;
+    };
+}
+export declare const initialState: State;
+declare const _default: (state: State | undefined, action: AnyAction) => State;
+export default _default;

package/dist/types/store/reducers/settings.d.ts

@@ -0,0 +1,8 @@
+import { AnyAction } from 'redux';
+export type Slippage = string | null;
+export type State = {
+    slippage: Slippage;
+};
+export declare const initialState: State;
+declare const _default: (state: State | undefined, action: AnyAction) => State;
+export default _default;

package/dist/types/store/reducers/token.d.ts

@@ -0,0 +1,22 @@
+import BigNumber from 'bignumber.js';
+import { AnyAction } from 'redux';
+import type { TokenList } from '../../hooks/Token';
+export type AccountBalance = {
+    tokenBalances?: BigNumber;
+    tokenAllowances?: BigNumber;
+};
+export type AccountBalances = {
+    [key in string]: AccountBalance;
+};
+export type SlippageWithToken = {
+    slippage: string;
+    tokens: string[];
+};
+export type State = {
+    tokenList: TokenList;
+    popularTokenList: TokenList;
+    slippageWithTokens: SlippageWithToken[];
+};
+export declare const initialState: State;
+declare const _default: (state: State | undefined, action: AnyAction) => State;
+export default _default;

package/dist/types/store/reducers/wallet.d.ts

@@ -0,0 +1,13 @@
+import { AnyAction } from 'redux';
+import { ChainId } from '@dodoex/api';
+export type State = {
+    fromTokenChainId?: ChainId;
+    latestBlockNumber: number;
+    openConnectWalletInfo: boolean | {
+        /** Wallet is connected, chainID needs to be switched */
+        chainId?: ChainId;
+    };
+};
+export declare const initialState: State;
+declare const _default: (state: State | undefined, action: AnyAction) => State;
+export default _default;

package/dist/types/store/selectors/globals.d.ts

@@ -0,0 +1,7 @@
+import { RootState } from '../reducers';
+export declare const getContractStatus: (state?: RootState) => import("../reducers/globals").ContractStatus | undefined;
+export declare const getAutoConnectLoading: (state?: RootState) => boolean | undefined;
+export declare const getAutoSlippage: (state?: RootState) => {
+    loading: boolean;
+    value: number | null;
+} | undefined;

package/dist/types/store/selectors/settings.d.ts

@@ -0,0 +1,2 @@
+import { RootState } from '../reducers';
+export declare const getSlippage: (state?: RootState) => import("../reducers/settings").Slippage;

package/dist/types/store/selectors/token.d.ts

@@ -0,0 +1,6 @@
+import { ChainId } from '@dodoex/api';
+import { RootState } from '../reducers';
+export declare const getTokenList: (state?: RootState) => import("../../hooks/Token").TokenList;
+export declare const getAllTokenList: (state?: RootState) => import("../../hooks/Token").TokenInfo[];
+export declare const getPopularTokenList: (chainId: ChainId, state?: RootState) => import("../../hooks/Token").TokenInfo[];
+export declare const getSlippageWithTokens: (state?: RootState) => import("../reducers/token").SlippageWithToken[];

package/dist/types/store/selectors/wallet.d.ts

@@ -0,0 +1,6 @@
+import { RootState } from '../reducers';
+export declare const getFromTokenChainId: (state?: RootState) => import("@dodoex/api").ChainId | undefined;
+export declare const getLatestBlockNumber: (state?: RootState) => number;
+export declare const getOpenConnectWalletInfo: (state?: RootState) => boolean | {
+    chainId?: import("@dodoex/api").ChainId;
+};

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

@@ -0,0 +1,17 @@
+import { ChainId } from '@dodoex/api';
+export declare const isSameAddress: (tokenAddress1: string, tokenAddress2: string) => boolean;
+export declare function isAddress(value: any): boolean;
+export declare function isETHAddress(addr: string): boolean;
+/**
+ * Returns true if the string value is zero in hex
+ * @param hexNumberString
+ */
+export default function isZero(hexNumberString: string): boolean;
+/**
+ * truncate pool address: 0xeBa959390016dd81419A189e5ef6F3B6720e5A90 => 0xeBa9...5A90
+ * @param address pool address
+ */
+export declare function truncatePoolAddress(address: string): string;
+export declare function sortsAddress(address0: string, address1: string): boolean;
+export declare function getEtherscanPage(chainId: ChainId, id?: string | null, prefix?: string): string;
+export declare function openEtherscanPage(path: string | undefined, chainId: ChainId, customUrl?: string): Promise<void>;

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

@@ -0,0 +1,9 @@
+/**
+ * Wait for a certain css selector to be loaded. Make sure that the selector can be loaded before calling it. Otherwise, retryCount should be passed in.
+ * @param selector css selector
+ */
+export declare const waitElement: (selector: string, { time, wrapper, retryCount, }?: {
+    time?: number;
+    wrapper?: Document | Element;
+    retryCount?: number;
+}) => Promise<unknown>;

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

@@ -0,0 +1,2 @@
+export declare const increaseArray: (len: number) => string[];
+export declare function isNotEmpty(str: string | number | null | undefined): boolean;

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 '../hooks/useDexList';
+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/useDexList.d.ts

@@ -0,0 +1,16 @@
+import { DexConfigI } from '../../types';
+import { ChainId } from '@dodoex/api';
+export type DexKey = 'dodo' | 'pancakeV2';
+export declare function useDexList(): {
+    dexListObj: Record<DexKey, DexConfigI>;
+    GetGeneralUniInfo: (chainId: number) => {
+        name: string;
+        factoryAddress: string;
+        initHash: string;
+        fee?: number;
+    }[];
+    getChainDexList: (chainId: ChainId, filterCreateMiningEnable?: boolean) => {
+        key: DexKey;
+        value: JSX.Element;
+    }[];
+};

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