@dodoex/widgets 2.6.12-beta.8 → 2.6.12

package/dist/types/components/chart/liquidity-chart/useLiquidityLine.d.ts

@@ -0,0 +1,17 @@
+import BigNumber from 'bignumber.js';
+import { ColorMap } from './LiquidityChartKonva';
+import { StatAreaPoint } from './usePoints';
+export declare function useLiquidityLine({ leftStatAreaPoints, rightStatAreaPoints, minXLN10, maxXLN10, maxLeftHeight, maxRightHeight, gridAreaWidth, gridAreaHeight, colorMap, }: {
+    leftStatAreaPoints: Array<StatAreaPoint>;
+    rightStatAreaPoints: Array<StatAreaPoint>;
+    minXLN10: BigNumber;
+    maxXLN10: BigNumber;
+    maxLeftHeight: BigNumber;
+    maxRightHeight: BigNumber;
+    gridAreaWidth: number;
+    gridAreaHeight: number;
+    colorMap: ColorMap;
+}): {
+    leftLine: JSX.Element;
+    rightLine: JSX.Element;
+};

package/dist/types/components/chart/liquidity-chart/useMiddleLine.d.ts

@@ -0,0 +1,5 @@
+export declare function useMiddleLine({ gridAreaHeight, gridAreaWidth, color, }: {
+    gridAreaHeight: number;
+    gridAreaWidth: number;
+    color?: string;
+}): JSX.Element;

package/dist/types/components/chart/liquidity-chart/usePoints.d.ts

@@ -0,0 +1,39 @@
+import { PmmModelParams } from '@dodoex/api';
+import BigNumber from 'bignumber.js';
+/**
+ * data point
+ */
+export type StatPoint = {
+    giveAmount: BigNumber;
+    getAmount: BigNumber;
+    price: BigNumber;
+};
+/**
+ * Drawing method:
+  Substitute the minimum value to get the height of the center point, which is the bottom edge of the area chart. Substitute the maximum value to get the vertex of the area chart. The length of the bottom edge from the vertex is the price range.
+
+  Divide the total area into one hundred equal parts. Calculate each part on the basis of the previous part. Substitute the new area into the formula to get a new price. The difference from the previous price is the width of the rectangle. The area is divided by The width is the height of the rectangle, which is the ordinate.
+
+  First, calculate a series of points as a point set based on the rectangular accumulation method.
+
+  When the mouse hovers, the abscissa is the price. Find the closest price in the point set. Use this price as the end point and the center line as the starting point to get a subset of the point set. You can draw a line by combining the center line and the abscissa. The area of ​​the trapezoid can be drawn.
+
+  Update: Taking Δl as the ordinate, Δl = (the difference between the quantity passed in from the previous point and the next point) * (the difference between the quantity obtained from the previous point and the next point)
+ */
+export type StatAreaPoint = {
+    area: BigNumber;
+    price: BigNumber;
+    middlePrice: BigNumber;
+    rectangleHeight: BigNumber;
+};
+export declare function usePoints({ params }: {
+    params: PmmModelParams;
+}): {
+    leftStatAreaPoints: StatAreaPoint[];
+    rightStatAreaPoints: StatAreaPoint[];
+    maxLeftHeight: BigNumber;
+    maxRightHeight: BigNumber;
+    minXLN10: BigNumber;
+    maxXLN10: BigNumber;
+    middlePriceLN10: BigNumber;
+};

package/dist/types/constants/api.d.ts

@@ -0,0 +1,19 @@
+import { ContractRequests, TokenApi, ChainId } from '@dodoex/api';
+export declare enum APIServiceKey {
+    routePrice = "routePrice",
+    fiatPrice = "fiatPrice",
+    bridgeRoutePrice = "bridgeRoutePrice",
+    bridgeEncode = "bridgeEncode",
+    bridgeCreateRoute = "bridgeCreateRoute"
+}
+export type APIServices = {
+    [key in APIServiceKey]: string;
+};
+export declare const AppUrl = "https://app.dodoex.io";
+export declare const getCGTokenListAPI: (chainId: ChainId) => any;
+export declare const RoutePriceAPI = "https://api.dodoex.io/route-service/v2/widget/getdodoroute";
+export declare const FiatPriceAPI = "https://api.dodoex.io/frontend-price-api/current/batch";
+export declare function getAPIService(key: APIServiceKey, serviceProps?: Partial<APIServices>): string;
+export declare const contractRequests: ContractRequests;
+export declare const tokenContractRequests: ContractRequests;
+export declare const tokenApi: TokenApi;

package/dist/types/constants/chains.d.ts

@@ -0,0 +1,20 @@
+import { ChainId } from '@dodoex/api';
+export { etherTokenAddress, basicTokenMap } from '@dodoex/api';
+export declare const rpcServerMap: {
+    [key in ChainId]: Array<string>;
+};
+export declare const getRpcSingleUrlMap: (newRpcServerMap?: {
+    [chainId: number]: string[];
+}) => { [key in ChainId]: string; };
+export declare const scanUrlDomainMap: {
+    [key in ChainId]: string;
+};
+export declare const ThegraphKeyMap: {
+    [key in ChainId]: string;
+};
+export declare const blockTimeMap: {
+    [key in ChainId]: number;
+};
+export declare const dexKeysMap: {
+    [key in ChainId]: string[];
+};

package/dist/types/constants/locales.d.ts

@@ -0,0 +1,3 @@
+export declare const supportedLang: string[];
+export type SupportedLang = typeof supportedLang[number];
+export declare const defaultLang: SupportedLang;

package/dist/types/constants/wallet.d.ts

@@ -0,0 +1,22 @@
+export declare enum WalletType {
+    INTEGRATOR = "integrator",
+    METAMASK = "metamask",
+    WALLET_CONNECT = "walletConnect"
+}
+export declare const WalletMap: {
+    metamask: {
+        name: string;
+        type: WalletType;
+        icon: import("react").FunctionComponent<import("react").SVGProps<SVGSVGElement> & {
+            title?: string;
+        }>;
+        link: string;
+    };
+    walletConnect: {
+        name: string;
+        type: WalletType;
+        icon: import("react").FunctionComponent<import("react").SVGProps<SVGSVGElement> & {
+            title?: string;
+        }>;
+    };
+};

package/dist/types/hooks/Bridge/useSendRoute.d.ts

@@ -0,0 +1,15 @@
+import BigNumber from 'bignumber.js';
+import { BridgeRouteI } from './useFetchRoutePriceBridge';
+import { BridgeTXRequest } from '../../components/Bridge/BridgeSummaryDialog';
+export declare function useSendRoute(): {
+    apikey: string | undefined;
+    sendRouteLoading: boolean;
+    sendRouteError: string;
+    setSendRouteError: import("react").Dispatch<import("react").SetStateAction<string>>;
+    bridgeOrderTxRequest: BridgeTXRequest | undefined;
+    handleClickSend: ({ selectedRoute, fromEtherTokenBalance, goNext, }: {
+        selectedRoute?: BridgeRouteI;
+        fromEtherTokenBalance: BigNumber | null;
+        goNext: () => void;
+    }) => Promise<void>;
+};

package/dist/types/hooks/ConnectWallet/useCurrentChainId.d.ts

@@ -0,0 +1 @@
+export declare function useCurrentChainId(): import("@dodoex/api").ChainId;

package/dist/types/hooks/ConnectWallet/useWalletInfo.d.ts

@@ -0,0 +1,8 @@
+import { ChainId } from '@dodoex/api';
+export declare function useWalletInfo(): {
+    account: string | undefined;
+    chainId: ChainId;
+    connectedChainId: number | undefined;
+    defaultChainId: ChainId | undefined;
+    onlyChainId: ChainId | undefined;
+};

package/dist/types/hooks/ConnectWallet/web3.d.ts

@@ -0,0 +1,10 @@
+import { Web3ReactHooks } from '@web3-react/core';
+import { Connector, Provider as Eip1193Provider } from '@web3-react/types';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ChainId } from '@dodoex/api';
+export type Web3Connection = [Connector, Web3ReactHooks];
+export declare function getConnectionFromProvider(onError: (error: Error) => void, provider?: JsonRpcProvider | Eip1193Provider): Web3Connection | undefined;
+export declare function getConnectionFromWalletConnect(useDefault: boolean, jsonRpcUrlMap: {
+    [chainId: number]: string[];
+}, defaultChainId: ChainId | undefined, onError: (error: Error) => void): Web3Connection;
+export declare function getConnectionFromMetaMask(onError: (error: Error) => void): Web3Connection;

package/dist/types/hooks/Submission/index.d.ts

@@ -0,0 +1,9 @@
+import { ExecutionCtx } from './types';
+export { default as useExecution } from './useExecution';
+export type { ExecutionProps } from './useExecution';
+export { default as useInflights } from './useInflights';
+export declare const ExecutionContext: import("react").Context<ExecutionCtx>;
+/**
+ * Get the submission context
+ */
+export declare function useSubmission(): ExecutionCtx;

package/dist/types/hooks/Submission/spec.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Let's pretend that typescript has ADT
+ */
+import { BigNumber } from 'bignumber.js';
+import { BigNumber as EthersBigNumber } from '@ethersproject/bignumber';
+/**
+ * All supported opcodes, as tagged union discriminants
+ */
+export declare enum OpCode {
+    Approval = "APPROVAL",
+    TX = "TX",
+    TypedSign = "TypedSign"
+}
+export declare enum SwapType {
+    Normal = "Normal",
+    Privacy = "Privacy",
+    LimitOrder = "LimitOrder",
+    RFQ = "RFQ"
+}
+export type TokenData = {
+    address: string;
+};
+export type ApprovalStep = {
+    opcode: OpCode.Approval;
+    /**
+     * The address of the token
+     */
+    token: TokenData;
+    /**
+     * The approved contract address
+     */
+    contract: string;
+    /**
+     * The amount to set the allowance to, in Wei, in base-10. If omitted, a (very) big constants is used
+     * TODO(meow): bigint shows a 87% support rate. Can we use it here?
+     */
+    amt?: BigNumber;
+};
+export type TXStep = {
+    opcode: OpCode.TX;
+    value: number | string;
+    to: string;
+    data: string;
+    swapType?: SwapType;
+    gasLimit?: EthersBigNumber;
+    gasPrice?: number;
+    ddlSecRel?: number;
+};
+export type TypedSignStep = {
+    opcode: OpCode.TypedSign;
+    swapType?: SwapType;
+    signer?: string;
+    typedData: Record<string, unknown>;
+};
+export type Step = ApprovalStep | TXStep | TypedSignStep;
+export type Steps = Step[];

package/dist/types/hooks/Submission/types.d.ts

@@ -0,0 +1,85 @@
+import { Step as StepSpec } from './spec';
+import { ExecutionProps } from './useExecution';
+export declare enum State {
+    Running = 0,
+    Success = 1,
+    Failed = 2,
+    Warning = 3
+}
+export declare enum MetadataFlag {
+    swap = "swap",
+    crossChain = "crossChain",
+    addLiquidity = "addLiquidity",
+    removeLiquidity = "removeLiquidity",
+    createDPPPool = "createDPPPool",
+    createDSPPool = "createDSPPool",
+    createGSPPool = "createGSPPool",
+    createDVMPool = "createDVMPool",
+    stakeMining = "stakeMining",
+    unstakeMining = "unstakeMining",
+    claimMining = "claimMining",
+    submissionCreateMetaKey = "submissionCreateMetaKey",
+    approve = "approve",
+    reset = "reset"
+}
+export type Metadata = Record<string, any>;
+export type Request = {
+    brief: string;
+    spec: StepSpec;
+    subtitle?: string | React.ReactNode | null;
+    metadata?: Metadata;
+    tx: string;
+    nonce?: number;
+    doneTime?: number;
+};
+export type TextUpdater = (request: Request) => null | {
+    brief: string;
+    subtitle?: string;
+    metadata?: Metadata;
+};
+export type Requests = Map<string, [Request, State]>;
+export declare enum ExecutionResult {
+    Canceled = "canceled",
+    Failed = "failed",
+    Success = "success",
+    Submitted = "submitted"
+}
+export interface Showing {
+    brief: string;
+    subtitle?: string | React.ReactNode;
+    spec: StepSpec;
+}
+export type ExecutionCtx = {
+    /**
+     * Execute an on-chain operation
+     * @param breif: TX title. e.g.: "Swap"
+     * @param spec: TX specification.
+     * @param subtitle: Additional hint text. e.g.: "10 USDT to 10 USDC"
+     * @param early: When given, the returned promise resolves when user confirmed in their wallet.
+     * @param mixpanelProps: mixpanel properties
+     * @param submittedConfirmBack: submittedConfirmBack
+     * @param successBack: successBack
+     * @param metadata: metadata
+     */
+    execute: (brief: string, spec: StepSpec, params?: {
+        subtitle?: string | React.ReactNode | null;
+        early?: boolean;
+        submittedBack?: () => void;
+        mixpanelProps?: Record<string, any>;
+        submittedConfirmBack?: () => void;
+        successBack?: (tx: string, callback?: ExecutionProps['onTxSuccess']) => void;
+        metadata?: Metadata;
+    }) => Promise<ExecutionResult>;
+    /**
+     * order
+     */
+    requests?: Requests;
+    updateText: (upd: TextUpdater) => void;
+    setShowing?: React.Dispatch<React.SetStateAction<Showing | null>>;
+    waitingSubmit: boolean;
+    errorMessage: string | null;
+};
+export declare enum WatchResult {
+    Failed = 0,
+    Success = 1
+}

package/dist/types/hooks/Submission/useBalanceUpdateLoading.d.ts

@@ -0,0 +1,16 @@
+import BigNumber from 'bignumber.js';
+export type BalanceData = {
+    [address: string]: string;
+};
+/**
+ * Record the loading status of the balance waiting to be updated after the chain is successfully uploaded
+ * Insert token data into logBalance in metadata when uploading, within 5 minutes after successful uploading. If the newly passed in balance is consistent with the previously recorded balance, loading will be returned
+ * After the balance is updated, or after 5 minutes, loading will return false. And delete the recorded metadata information to avoid calculating this data next time
+ * The 5-minute time limit is to avoid operations on other terminals or other tabs, which will cause the balance comparison to be invalid and keep loading.
+ */
+export declare const useBalanceUpdateLoading: () => {
+    balanceData: BalanceData;
+    balanceDataDone: BalanceData;
+    isTokenLoading: (address: string, balance: BigNumber | number | string) => boolean;
+    isTokenLoadingDone: (address: string, balance: BigNumber | number | string) => boolean;
+};

package/dist/types/hooks/Submission/useExecution.d.ts

@@ -0,0 +1,25 @@
+import { State, Request, Showing, ExecutionCtx } from './types';
+export interface ExecutionProps {
+    onTxFail?: (error: Error, data: any) => void;
+    onTxSubmit?: (tx: string, data: any) => void;
+    onTxSuccess?: (tx: string, data: any) => void;
+    onTxReverted?: (tx: string, data: any) => void;
+    executionStatus?: {
+        showing?: Showing | null;
+        showingDone?: boolean;
+        transactionTx?: string;
+        errorMessage?: string;
+        setErrorMessage?: (msg?: string | null) => void;
+        closeShowing?: () => void;
+    };
+}
+export default function useExecution({ onTxFail, onTxSubmit, onTxSuccess, onTxReverted, }?: ExecutionProps): {
+    showing: Showing | null;
+    showingDone: boolean;
+    transactionTx: string;
+    errorMessage: string | null;
+    setErrorMessage: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    closeShowing: () => void;
+    ctxVal: ExecutionCtx;
+    requests: Map<string, [Request, State]>;
+};

package/dist/types/hooks/Submission/useSubmissionStatusColor.d.ts

@@ -0,0 +1,18 @@
+export declare enum StateText {
+    Running = "pending",
+    Success = "success",
+    Failed = "failed",
+    /** Accelerated or canceled tx warning handling */
+    Warning = "reset"
+}
+export declare function useSubmissionStatusColor({ status, stateTextMap, }: {
+    status: string | number;
+    stateTextMap?: {
+        [key: string | number]: StateText;
+    };
+}): {
+    state: StateText;
+    statusText: string;
+    statusColor: string;
+    statusAlphaColor: number | undefined;
+};

package/dist/types/hooks/Swap/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useMarginAmount';
+export * from './useFetchFiatPrice';
+export * from './useFetchRoutePrice';
+export { default as useExecuteSwap } from './useExecuteSwap';

package/dist/types/hooks/Swap/useCustomSlippage.d.ts

@@ -0,0 +1,10 @@
+import { TokenInfo } from '../Token';
+import { CustomSwapPairSlippage } from './useSwapSettingStore';
+export declare function useCustomSlippage({ fromToken, toToken, }: {
+    fromToken?: TokenInfo | null;
+    toToken?: TokenInfo | null;
+}): {
+    customSlippageNum: number;
+    customSlippage: string | undefined;
+    handleSlippageChange: (newItem: Pick<CustomSwapPairSlippage, "slippage" | "recommend" | "disabled" | "deleted">) => void;
+};

package/dist/types/hooks/Swap/useExecuteSwap.d.ts

@@ -0,0 +1,13 @@
+import { BigNumber as EthersBigNumber } from '@ethersproject/bignumber';
+import React from 'react';
+export default function useExecuteSwap(): ({ to, data, useSource, duration, ddl, gasLimit, subtitle, value, mixpanelProps, }: {
+    value: string;
+    to: string;
+    data: string;
+    useSource?: string;
+    duration?: number;
+    ddl: number;
+    gasLimit?: EthersBigNumber;
+    subtitle: React.ReactNode;
+    mixpanelProps?: Record<string, any>;
+}) => void;

package/dist/types/hooks/Swap/useFetchRoutePrice.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import { TokenInfo } from '../Token';
+export declare enum RoutePriceStatus {
+    Initial = "Initial",
+    Loading = "Loading",
+    Failed = "Failed",
+    Success = "Success"
+}
+export interface FetchRoutePrice {
+    fromToken: TokenInfo | null;
+    toToken: TokenInfo | null;
+    marginAmount?: string;
+    fromAmount: string;
+    toAmount: string;
+    estimateGas?: boolean;
+    isReverseRouting?: boolean;
+    slippage?: number;
+    slippageLoading?: boolean;
+}
+interface IRouteResponse {
+    resAmount: number;
+    priceImpact: number;
+    baseFeeAmount: number;
+    additionalFeeAmount: number;
+    resPricePerToToken: number;
+    resPricePerFromToken: number;
+    to: string;
+    data: string;
+    value: string;
+    useSource: string;
+    duration: number;
+}
+export declare function useFetchRoutePrice({ toToken, fromToken, fromAmount, toAmount, marginAmount, estimateGas, isReverseRouting, slippage, slippageLoading, }: FetchRoutePrice): {
+    status: RoutePriceStatus;
+    rawBrief: IRouteResponse | null;
+    refetch: () => Promise<void>;
+    executeSwap: (subtitle: React.ReactNode) => void;
+    reset: () => void;
+};
+export {};

package/dist/types/hooks/Swap/useForecastSlippageList.d.ts

@@ -0,0 +1,172 @@
+import { TokenInfo } from '../Token';
+export interface ForecastSlippageListItem {
+    forecastSlippage?: number;
+    forecastValue?: number;
+    confidenceRatio?: number;
+    confidenceIntervalUpper?: number;
+    confidenceIntervalLower?: number;
+}
+export declare function useForecastSlippageList({ fromToken, toToken, }: {
+    fromToken: TokenInfo | undefined | null;
+    toToken: TokenInfo | undefined | null;
+}): {
+    data: import("@dodoex/api/dist/types/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/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    slippageData: {
+        recommendSlippage?: undefined;
+        slippageList?: undefined;
+    } | {
+        recommendSlippage: ForecastSlippageListItem | undefined;
+        slippageList: ForecastSlippageListItem[];
+    };
+} | {
+    data: import("@dodoex/api/dist/types/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/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    slippageData: {
+        recommendSlippage?: undefined;
+        slippageList?: undefined;
+    } | {
+        recommendSlippage: ForecastSlippageListItem | undefined;
+        slippageList: 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/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    slippageData: {
+        recommendSlippage?: undefined;
+        slippageList?: undefined;
+    } | {
+        recommendSlippage: ForecastSlippageListItem | undefined;
+        slippageList: 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/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    slippageData: {
+        recommendSlippage?: undefined;
+        slippageList?: undefined;
+    } | {
+        recommendSlippage: ForecastSlippageListItem | undefined;
+        slippageList: 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/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").FetchErc20ForecastSlippageQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    slippageData: {
+        recommendSlippage?: undefined;
+        slippageList?: undefined;
+    } | {
+        recommendSlippage: ForecastSlippageListItem | undefined;
+        slippageList: ForecastSlippageListItem[];
+    };
+};

package/dist/types/hooks/Swap/useInitDefaultToken.d.ts

@@ -0,0 +1,10 @@
+import { TokenInfo } from '../Token';
+export declare function useInitDefaultToken({ fromToken, toToken, setFromToken, setToToken, updateFromAmt, updateToAmt, setIsReverseRouting, }: {
+    fromToken: TokenInfo | null;
+    toToken: TokenInfo | null;
+    setFromToken: (value: React.SetStateAction<TokenInfo | null>) => void;
+    setToToken: (value: React.SetStateAction<TokenInfo | null>) => void;
+    updateFromAmt: (v: string | number) => void;
+    updateToAmt: (v: string | number) => void;
+    setIsReverseRouting: React.Dispatch<React.SetStateAction<boolean>>;
+}): void;

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

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