@dodoex/widgets 3.0.0-taiko.2 → 3.0.0-taiko.20

package/dist/cjs/hooks/Swap/useSlippageLimit.d.ts

@@ -1,2 +1,2 @@
 export declare const maxSlippageWarning = 5;
-export declare const useSlippageLimit: (isBridge: boolean | undefined) => boolean;
+export declare const useSlippageLimit: (slippageSwap?: number) => boolean;

package/dist/cjs/hooks/Swap/useSwapSettingStore.d.ts

@@ -0,0 +1,37 @@
+export interface CustomSwapPairSlippage {
+    account: string;
+    from: string;
+    to: string;
+    /** Should be consistent with fromToken */
+    chainId: number;
+    disabled?: boolean;
+    /** Whether it has been deleted: not necessarily deleted */
+    deleted?: boolean;
+    slippage: string;
+    fromSymbol: string;
+    fromLogo: string | null;
+    toSymbol: string;
+    toLogo: string | null;
+    recommend: string;
+}
+interface SwapSettingState {
+    slippageAdvanced: boolean;
+    customSwapPairSlippages: Array<CustomSwapPairSlippage>;
+    notRemindAgainSlippageHigher: boolean;
+    notRemindAgainSlippageLower: boolean;
+    ddl: string;
+    expertMode: boolean;
+    disableIndirectRouting: boolean;
+}
+export declare const useSwapSettingStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SwapSettingState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SwapSettingState, SwapSettingState>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SwapSettingState) => void) => () => void;
+        onFinishHydration: (fn: (state: SwapSettingState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapSettingState, SwapSettingState>>;
+    };
+}>;
+export {};

package/dist/cjs/hooks/Swap/useSwapSlippage.d.ts

@@ -0,0 +1,174 @@
+import { TokenInfo } from '../Token/type';
+export declare function useSwapSlippage({ fromToken, toToken, }: {
+    fromToken?: TokenInfo | null;
+    toToken?: TokenInfo | null;
+}): {
+    customSlippage: string | undefined;
+    customSlippageNum: number;
+    handleSlippageChange: (newItem: Pick<import("./useSwapSettingStore").CustomSwapPairSlippage, "slippage" | "recommend" | "disabled" | "deleted">) => void;
+    forecastSlippage: number | undefined;
+    forecastSlippageQuery: {
+        data: import("@dodoex/api/dist/gql/graphql").FetchErc20ForecastSlippageQuery;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: true;
+        isSuccess: false;
+        status: "error";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isPlaceholderData: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@dodoex/api/dist/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+        fetchStatus: import("@tanstack/query-core").FetchStatus;
+        slippageData: {
+            recommendSlippage?: undefined;
+            slippageList?: undefined;
+        } | {
+            recommendSlippage: import("./useForecastSlippageList").ForecastSlippageListItem | undefined;
+            slippageList: import("./useForecastSlippageList").ForecastSlippageListItem[];
+        };
+    } | {
+        data: import("@dodoex/api/dist/gql/graphql").FetchErc20ForecastSlippageQuery;
+        error: null;
+        isError: false;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        status: "success";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isPlaceholderData: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@dodoex/api/dist/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+        fetchStatus: import("@tanstack/query-core").FetchStatus;
+        slippageData: {
+            recommendSlippage?: undefined;
+            slippageList?: undefined;
+        } | {
+            recommendSlippage: import("./useForecastSlippageList").ForecastSlippageListItem | undefined;
+            slippageList: import("./useForecastSlippageList").ForecastSlippageListItem[];
+        };
+    } | {
+        data: undefined;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: true;
+        isRefetchError: false;
+        isSuccess: false;
+        status: "error";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isPlaceholderData: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@dodoex/api/dist/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+        fetchStatus: import("@tanstack/query-core").FetchStatus;
+        slippageData: {
+            recommendSlippage?: undefined;
+            slippageList?: undefined;
+        } | {
+            recommendSlippage: import("./useForecastSlippageList").ForecastSlippageListItem | undefined;
+            slippageList: import("./useForecastSlippageList").ForecastSlippageListItem[];
+        };
+    } | {
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoading: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        status: "pending";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isPlaceholderData: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@dodoex/api/dist/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+        fetchStatus: import("@tanstack/query-core").FetchStatus;
+        slippageData: {
+            recommendSlippage?: undefined;
+            slippageList?: undefined;
+        } | {
+            recommendSlippage: import("./useForecastSlippageList").ForecastSlippageListItem | undefined;
+            slippageList: import("./useForecastSlippageList").ForecastSlippageListItem[];
+        };
+    } | {
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        status: "pending";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isPlaceholderData: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@dodoex/api/dist/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+        fetchStatus: import("@tanstack/query-core").FetchStatus;
+        slippageData: {
+            recommendSlippage?: undefined;
+            slippageList?: undefined;
+        } | {
+            recommendSlippage: import("./useForecastSlippageList").ForecastSlippageListItem | undefined;
+            slippageList: import("./useForecastSlippageList").ForecastSlippageListItem[];
+        };
+    };
+    recommendSlippage: number;
+    slippage: number;
+    slippageLoading: boolean;
+};

package/dist/cjs/hooks/Swap/useTradeSwapOrderList.d.ts

@@ -0,0 +1,242 @@
+import BigNumber from 'bignumber.js';
+import { TokenInfo } from '../Token';
+export declare function useTradeSwapOrderList({ account, chainId, limit, }: {
+    account: string | undefined;
+    chainId?: number;
+    limit?: number;
+}): {
+    orderList: {
+        hash: string;
+        fromToken: TokenInfo;
+        toToken: TokenInfo;
+        fromAmount: BigNumber | null;
+        toAmount: string;
+        minAmount: string;
+        fromTokenPrice: string;
+        toTokenPrice: string;
+        createdAt: string;
+        routeData: any;
+        safeTxHash: string | undefined;
+        safeTxUrl: string;
+        status: string;
+        transactionHash: string;
+    }[];
+    data: import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    orderList: {
+        hash: string;
+        fromToken: TokenInfo;
+        toToken: TokenInfo;
+        fromAmount: BigNumber | null;
+        toAmount: string;
+        minAmount: string;
+        fromTokenPrice: string;
+        toTokenPrice: string;
+        createdAt: string;
+        routeData: any;
+        safeTxHash: string | undefined;
+        safeTxUrl: string;
+        status: string;
+        transactionHash: string;
+    }[];
+    data: import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    orderList: {
+        hash: string;
+        fromToken: TokenInfo;
+        toToken: TokenInfo;
+        fromAmount: BigNumber | null;
+        toAmount: string;
+        minAmount: string;
+        fromTokenPrice: string;
+        toTokenPrice: string;
+        createdAt: string;
+        routeData: any;
+        safeTxHash: string | undefined;
+        safeTxUrl: string;
+        status: string;
+        transactionHash: string;
+    }[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    orderList: {
+        hash: string;
+        fromToken: TokenInfo;
+        toToken: TokenInfo;
+        fromAmount: BigNumber | null;
+        toAmount: string;
+        minAmount: string;
+        fromTokenPrice: string;
+        toTokenPrice: string;
+        createdAt: string;
+        routeData: any;
+        safeTxHash: string | undefined;
+        safeTxUrl: string;
+        status: string;
+        transactionHash: string;
+    }[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    orderList: {
+        hash: string;
+        fromToken: TokenInfo;
+        toToken: TokenInfo;
+        fromAmount: BigNumber | null;
+        toAmount: string;
+        minAmount: string;
+        fromTokenPrice: string;
+        toTokenPrice: string;
+        createdAt: string;
+        routeData: any;
+        safeTxHash: string | undefined;
+        safeTxUrl: string;
+        status: string;
+        transactionHash: string;
+    }[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("@dodoex/api/dist/gql/graphql").FetchUserSwapOrderHistoriesQuery, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};

package/dist/cjs/hooks/Token/type.d.ts

@@ -12,7 +12,7 @@ export interface TokenInfo {
 export interface DefaultTokenInfo extends TokenInfo {
     amount?: number;
 }
-export declare type TokenList = TokenInfo[];
+export type TokenList = TokenInfo[];
 export declare enum TokenListType {
     All = "all"
 }
@@ -23,3 +23,9 @@ export declare enum ApprovalState {
     Sufficient = "Sufficient",
     Unchecked = "Unchecked"
 }
+export declare enum BalanceState {
+    Loading = "Loading",
+    Insufficient = "BalanceInsufficient",
+    Sufficient = "Sufficient",
+    Unchecked = "Unchecked"
+}

package/dist/cjs/hooks/Token/useGetTokenStatus.d.ts

@@ -0,0 +1,15 @@
+import BigNumber from 'bignumber.js';
+import { ExecutionResult } from '../Submission/types';
+import { ApprovalState, BalanceState, TokenInfo } from './type';
+export declare const useGetTokenStatus: ({ account, chainId, offset, contractAddress, }: {
+    account?: string;
+    chainId: number | undefined;
+    offset?: BigNumber;
+    contractAddress?: string;
+}) => {
+    getApprovalState: (token: Pick<TokenInfo, "address" | "decimals" | "symbol"> | null, value: string | number | BigNumber, balance: BigNumber | null, allowance: BigNumber | null) => ApprovalState;
+    getPendingRest: (token: Pick<TokenInfo, "address" | "decimals" | "symbol"> | null | undefined, allowance: BigNumber | null) => boolean;
+    getBalanceState: (parsed: BigNumber, token: Pick<TokenInfo, "address" | "decimals" | "symbol"> | null | undefined, balance: BigNumber | null) => BalanceState;
+    submitApprove: (token: TokenInfo | null, isReset?: boolean, submittedBack?: () => void, canceledCallback?: () => void, successBack?: () => void, failedCallback?: () => void) => Promise<ExecutionResult.Canceled | ExecutionResult.Failed | ExecutionResult.Submitted | undefined>;
+    getMaxBalance: (token: TokenInfo | null, balance: BigNumber | null) => BigNumber;
+};

package/dist/cjs/hooks/Token/useSelectChainList.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { ChainListItem } from '../../constants/chainList';
 export declare function useSelectChainList(side?: 'from' | 'to'): {
     chainList: ChainListItem[];

package/dist/cjs/hooks/Token/useTokenList.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="react" />
 import BigNumber from 'bignumber.js';
 import { TokenInfo, TokenList } from './type';
 import { ChainId } from '@dodoex/api';
 export declare const getFuzzySearchTokenSort: (token: TokenInfo, search: string, { matchAddress, }?: {
-    matchAddress?: boolean | undefined;
+    matchAddress?: boolean;
 }) => number;
 export default function useTokenList({ value, onChange, occupiedAddrs, occupiedChainId, hiddenAddrs, showAddrs, side, chainId: chainIdProps, visible, defaultLoadBalance, multiple, }: {
     value?: TokenInfo | null | Array<TokenInfo>;

package/dist/cjs/hooks/contract/useFetchETHBalance.d.ts

@@ -1,4 +1,4 @@
-export default function useFetchETHBalance(chainId?: number): import("@tanstack/react-query/build/legacy/types").UseQueryResult<{
+export default function useFetchETHBalance(chainId?: number): import("@tanstack/react-query").UseQueryResult<{
     symbol: string;
     address: string;
     name: string;

package/dist/cjs/hooks/contract/useFetchTokens.d.ts

@@ -1,6 +1,6 @@
 import { TokenList } from '../Token';
 import BigNumber from 'bignumber.js';
-declare type TokenInfoMap = Map<string, {
+type TokenInfoMap = Map<string, {
     balance: BigNumber;
     allowance: BigNumber;
 }>;

package/dist/cjs/hooks/contract/wallet.d.ts

@@ -2,15 +2,24 @@ import { JsonRpcProvider } from '@ethersproject/providers';
 import type { TransactionRequest } from '@ethersproject/abstract-provider';
 import { BigNumber as EthersBigNumber } from '@ethersproject/bignumber';
 import BigNumber from 'bignumber.js';
-export declare type Deferrable<T> = {
+import { TokenInfo } from '../Token';
+export type Deferrable<T> = {
     [K in keyof T]: T[K] | Promise<T[K]>;
 };
 export declare enum WatchResult {
-    Failed = 0,
-    Success = 1,
+    Failed = 0,// 0:Failure
+    Success = 1,// 1:Success
     Warning = 2
 }
 export declare const getEstimateGas: (params: any, provider: JsonRpcProvider) => Promise<EthersBigNumber | null>;
 export declare const getGasPrice: (provider: JsonRpcProvider) => Promise<EthersBigNumber | null>;
 export declare const sendTransaction: (params: Deferrable<TransactionRequest>, provider: JsonRpcProvider) => Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
 export declare const approve: (tokenAddress: string, accountAddress: string, contractAddress: string, allowance: BigNumber, provider: JsonRpcProvider) => Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+/**
+ * Add custom token to metamask
+ * https://docs.metamask.io/guide/registering-your-token.html#registering-tokens-with-users
+ */
+export declare function registerTokenWithMetamask(provider: JsonRpcProvider | undefined, token: TokenInfo): Promise<{
+    result: boolean;
+    failMsg?: string;
+}>;

package/dist/cjs/hooks/setting/useSetAutoSlippage.d.ts

@@ -1,5 +1,5 @@
 import { TokenInfo } from '../Token';
-export declare type GetAutoSlippage = (options: {
+export type GetAutoSlippage = (options: {
     fromToken: TokenInfo | null;
     toToken: TokenInfo | null;
 }) => Promise<number | undefined> | number | undefined;

package/dist/cjs/hooks/useFetchFiatPriceBatch.d.ts

@@ -0,0 +1,4 @@
+import { TokenInfo } from './Token';
+export declare function useFetchFiatPriceBatch({ tokens }: {
+    tokens: TokenInfo[];
+}): import("@tanstack/react-query").UseQueryResult<Map<string, number>, Error>;

package/dist/cjs/hooks/useGraphQLRequests.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLRequests } from '@dodoex/api';
+export declare const graphQLRequestsLocal: GraphQLRequests;
+export declare function useGraphQLRequests(): GraphQLRequests;

package/dist/cjs/hooks/useMessageState.d.ts

@@ -0,0 +1,17 @@
+interface Notify {
+    message: string;
+    type: 'success' | 'error' | 'warning';
+    timeout?: number;
+    content?: string;
+    link?: {
+        text: string;
+        outerLink?: string;
+    };
+}
+interface MessageState {
+    notify: Notify | null;
+    toast: (notify: Notify) => void;
+    close: () => void;
+}
+export declare const useMessageState: import("zustand").UseBoundStore<import("zustand").StoreApi<MessageState>>;
+export {};

package/dist/cjs/hooks/useRouteVisionData.d.ts

@@ -0,0 +1,15 @@
+export type MidPathType = {
+    fromToken: string;
+    toToken: string;
+    chainId: number;
+    poolDetails: Map<string, {
+        poolPart: string;
+        poolAddress: string | null;
+    }[]>;
+};
+export declare function useRouteVisionData({ rawRouteData, chainId, }: {
+    rawRouteData: string;
+    chainId: number;
+}): {
+    routeData: MidPathType[];
+};