@dodoex/widgets 3.0.0-beta.31 → 3.0.0-beta.32

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

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+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 | undefined;
+        }>;
+        link: string;
+    };
+    walletConnect: {
+        name: string;
+        type: WalletType;
+        icon: import("react").FunctionComponent<import("react").SVGProps<SVGSVGElement> & {
+            title?: string | undefined;
+        }>;
+    };
+};

package/dist/src/hooks/Bridge/createBridgeOrder.d.ts

@@ -0,0 +1,28 @@
+import { BridgeRouteI } from './useFetchRoutePriceBridge';
+export interface BridgeOrderCreateParams {
+    fromChainId: number;
+    fromAmount: string;
+    fromTokenAddress: string;
+    toChainId: number;
+    toAmount: string;
+    toTokenAddress: string;
+    fromAddress: string;
+    toAddress: string;
+    slippage: number;
+    hash: string;
+    product: string | null;
+    extend: {
+        lifiBridge: Exclude<BridgeRouteI['sourceRoute'], undefined>['step']['tool'];
+        route: BridgeRouteI['sourceRoute'];
+        productParams: BridgeRouteI['productParams'];
+        encodeId: string;
+        source: string;
+    };
+}
+export declare function createBridgeOrder({ apikey, tx, route, bridgeCreateRouteAPI, encodeId, }: {
+    apikey?: string;
+    tx: string;
+    route: BridgeRouteI;
+    bridgeCreateRouteAPI: string;
+    encodeId: string;
+}): Promise<any>;

package/dist/src/hooks/Bridge/index.d.ts

@@ -0,0 +1,4 @@
+export * from './createBridgeOrder';
+export * from './useExecuteBridgeRoute';
+export * from './useFetchRoutePriceBridge';
+export * from './useSendRoute';

package/dist/src/hooks/Bridge/useExecuteBridgeRoute.d.ts

@@ -0,0 +1,6 @@
+import { BridgeTXRequest } from '../../components/Bridge/BridgeSummaryDialog';
+import { BridgeRouteI } from './useFetchRoutePriceBridge';
+export default function useExecuteBridgeRoute({ route, bridgeOrderTxRequest, }: {
+    route?: BridgeRouteI;
+    bridgeOrderTxRequest?: BridgeTXRequest;
+}): () => Promise<import("../Submission/types").ExecutionResult> | undefined;

package/dist/src/hooks/Bridge/useFetchRoutePriceBridge.d.ts

@@ -0,0 +1,113 @@
+import { TokenInfo } from '../Token';
+import BigNumber from 'bignumber.js';
+export interface BridgeRouteI {
+    /** update */
+    key: string;
+    /** only one */
+    id: string;
+    fromToken: TokenInfo;
+    toToken: TokenInfo;
+    fromChainId: number;
+    toChainId: number;
+    /** from parameter  */
+    fromAmount: string;
+    toTokenAmount: BigNumber;
+    /** from parameter  */
+    fromAddress: string;
+    toAddress: string;
+    /** from parameter  */
+    product: string | null;
+    slippage?: number;
+    /** in seconds */
+    roundedRouteCostTime: number;
+    /** approve contract address */
+    spenderContractAddress?: string;
+    /** USD */
+    feeUSD: string | null;
+    /** in seconds */
+    executionDuration: number | null;
+    /** one-click */
+    step: BridgeStep;
+    encodeParams?: any;
+    encodeResultData?: {
+        data: string;
+        to: string;
+        value: string;
+        from: string;
+        chainId: number;
+        encodeId?: string;
+    };
+    productParams: any;
+    sourceRoute?: {
+        toAmount: string;
+        feeUSD: string | null;
+        executionDuration: number | null;
+        step: {
+            tool: string;
+            toolDetails: {
+                logoURI: string | null;
+                name: string | null;
+                key: string | null;
+            };
+            type: string | null;
+            approvalAddress: string;
+            includedSteps: any;
+        };
+        fee: any;
+    };
+    minAmt?: string;
+    maxAmt?: string;
+}
+export interface BridgeTokenI {
+    id: number;
+    symbol: string;
+    name: string;
+    address: string;
+    decimals: number;
+    logoUrl: string;
+    chainId: number;
+    stableCurrencyToken: boolean;
+    mainCurrencyToken: boolean;
+}
+export interface BridgeStepTool {
+    name: string;
+    logoURI: string;
+}
+export interface BridgeStepEstimate {
+    fromToken: Pick<BridgeTokenI, 'address' | 'symbol' | 'chainId' | 'decimals'>;
+    toToken: Pick<BridgeTokenI, 'address' | 'symbol' | 'chainId' | 'decimals'>;
+    fromTokenAmount: BigNumber;
+    toTokenAmount: BigNumber;
+}
+export interface BridgeStep {
+    tool: string;
+    toolDetails: BridgeStepTool;
+    type: string | null;
+    includedSteps?: Array<{
+        id: string;
+        /**
+         *  bridge or swap
+         */
+        tool: string;
+        toolDetails: BridgeStepTool;
+        type: string;
+        estimate: BridgeStepEstimate;
+    }>;
+}
+export declare enum RoutePriceStatus {
+    Initial = "Initial",
+    Loading = "Loading",
+    Failed = "Failed",
+    Success = "Success"
+}
+export interface FetchRoutePrice {
+    fromToken: TokenInfo | null;
+    toToken: TokenInfo | null;
+    fromAmount: string;
+    fromFiatPrice: string;
+}
+export declare function useFetchRoutePriceBridge({ toToken, fromToken, fromAmount, fromFiatPrice, }: FetchRoutePrice): {
+    status: RoutePriceStatus;
+    refetch: () => Promise<void>;
+    bridgeRouteList: BridgeRouteI[];
+};

package/dist/src/hooks/Bridge/useFetchRoutePriceBridge.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+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 | undefined;
+        fromEtherTokenBalance: BigNumber | null;
+        goNext: () => void;
+    }) => Promise<void>;
+};

package/dist/src/hooks/Bridge/useSwitchBridgeOrSwapSlippage.d.ts

@@ -0,0 +1 @@
+export declare function useSwitchBridgeOrSwapSlippage(isBridge: boolean | undefined): boolean;

package/dist/src/hooks/ConnectWallet/Connectors/JsonRpcConnector.d.ts

@@ -0,0 +1,9 @@
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { Actions, Connector } from '@web3-react/types';
+export default class JsonRpcConnector extends Connector {
+    customProvider: JsonRpcProvider;
+    constructor(actions: Actions, customProvider: JsonRpcProvider, onError?: (error: Error) => void);
+    private activateAccounts;
+    connectEagerly(): Promise<void>;
+    activate(): Promise<void>;
+}

package/dist/src/hooks/ConnectWallet/TonConnect/index.d.ts

@@ -0,0 +1,26 @@
+import { TonConnectUI } from '@tonconnect/ui';
+import { TonClient, TonClient4 } from 'ton';
+import BigNumber from 'bignumber.js';
+/**
+ * https://ton-community.github.io/ton/modules.html
+ * https://ton-org.github.io/ton-core/modules.html
+ * https://toncenter.com/api/v2/
+ */
+interface TonConnectState {
+    enabled: boolean;
+    client?: TonClient;
+    clientV4?: TonClient4;
+    tonConnectUI?: TonConnectUI;
+    connected?: {
+        chainId: number;
+        account: string;
+    };
+    initialize: () => void;
+    connect: () => Promise<void>;
+    getBlockNumber: () => Promise<number>;
+    getJettonWallet: (jettonMasterAddress: string) => Promise<string>;
+    getBalance: (account: string) => Promise<BigNumber>;
+    getTokenBalance: (jettonMasterAddress: string, decimals: number) => Promise<BigNumber>;
+}
+declare const useTonConnectStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TonConnectState>>;
+export default useTonConnectStore;

package/dist/src/hooks/ConnectWallet/index.d.ts

@@ -0,0 +1,3 @@
+export { connectToWallet, useWeb3Connectors } from './useWeb3Connectors';
+export { useCurrentChainId } from './useCurrentChainId';
+export type { Web3ConnectorsProps } from './useWeb3Connectors';

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

@@ -0,0 +1,2 @@
+import { ChainId } from '../../constants/chains';
+export declare function useCurrentChainId(): ChainId;

package/dist/src/hooks/ConnectWallet/useSwitchChain.d.ts

@@ -0,0 +1,10 @@
+import { ChainId } from '../../constants/chains';
+/**
+ * switch wallet chain
+ *  @see https://docs.metamask.io/guide/rpc-api.html#usage-with-wallet-switchethereumchain
+ */
+export declare function registerNetworkWithMetamask({ chainId, provider, }: {
+    chainId: ChainId;
+    provider?: any;
+}): Promise<boolean>;
+export declare function useSwitchChain(chainId?: ChainId): (() => Promise<boolean>) | undefined;

package/dist/src/hooks/ConnectWallet/useWalletState.d.ts

@@ -0,0 +1,24 @@
+import BigNumber from 'bignumber.js';
+export declare function useWalletState({ isTon, }?: {
+    isTon?: boolean;
+}): {
+    isTon: boolean;
+    chainId: number | undefined;
+    account: string | undefined;
+    isMetamask: boolean;
+    autoConnect: (chainId?: number) => Promise<void>;
+    connect: () => Promise<void>;
+    getLastBlockNumber: () => Promise<number>;
+    getBalance: (account: string) => Promise<BigNumber>;
+    provider?: undefined;
+} | {
+    isTon: boolean;
+    chainId: number | undefined;
+    account: string | undefined;
+    isMetamask: boolean | undefined;
+    autoConnect: (chainId?: number) => Promise<void>;
+    connect: () => void | Promise<void>;
+    provider: import("@ethersproject/providers").Web3Provider | undefined;
+    getLastBlockNumber: (() => Promise<number>) | undefined;
+    getBalance: ((account: string) => Promise<BigNumber | undefined>) | undefined;
+};

package/dist/src/hooks/ConnectWallet/useWeb3Connectors.d.ts

@@ -0,0 +1,17 @@
+import { Provider as Eip1193Provider } from '@web3-react/types';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ChainId } from '../../constants/chains';
+import { Web3Connection } from './web3';
+import { WalletType } from '../../constants/wallet';
+export interface Web3ConnectorsProps {
+    provider?: Eip1193Provider | JsonRpcProvider;
+    jsonRpcUrlMap?: {
+        [chainId: number]: string[];
+    };
+    defaultChainId?: ChainId;
+}
+export declare function useWeb3Connectors({ provider, jsonRpcUrlMap: jsonRpcUrlMapProps, defaultChainId, }: Web3ConnectorsProps): {
+    connectors: Web3Connection[];
+    key: number;
+};
+export declare function connectToWallet(type: WalletType, chainId: number | undefined, onError: (error: Error) => void): Promise<void>;

package/dist/src/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 type { ChainId } from '../../constants/chains';
+export declare 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/src/hooks/Submission/getExecutionErrorMsg.d.ts

@@ -0,0 +1,2 @@
+import { ChainId } from '../../constants/chains';
+export default function getExecutionErrorMsg(chainId: ChainId, message: string): string;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+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/src/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 declare type TokenData = {
+    address: string;
+};
+export declare 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 declare type TXStep = {
+    opcode: OpCode.TX;
+    value: number | string;
+    to: string;
+    data: string;
+    swapType?: SwapType;
+    gasLimit?: EthersBigNumber;
+    gasPrice?: number;
+    ddlSecRel?: number;
+};
+export declare type TypedSignStep = {
+    opcode: OpCode.TypedSign;
+    swapType?: SwapType;
+    signer?: string;
+    typedData: Record<string, unknown>;
+};
+export declare type Step = ApprovalStep | TXStep | TypedSignStep;
+export declare type Steps = Step[];

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

@@ -0,0 +1,50 @@
+/// <reference types="react" />
+import { Step as StepSpec } from './spec';
+import { ExecutionProps } from './useExecution';
+export declare enum State {
+    Running = 0,
+    Success = 1,
+    Failed = 2,
+    Warning = 3
+}
+export declare type Request = {
+    brief: string;
+    spec: StepSpec;
+    subtitle?: string | React.ReactNode | null;
+    tx: string;
+    nonce?: number;
+};
+export declare 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 declare 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: dismiss callback
+     */
+    execute: (brief: string, spec: StepSpec, subtitle?: string | React.ReactNode | null, early?: boolean, submittedBack?: () => void, mixpanelProps?: Record<string, any>, submittedConfirmBack?: () => void, successBack?: (tx: string, callback?: ExecutionProps['onTxSuccess']) => void) => Promise<ExecutionResult>;
+    /**
+     * order
+     */
+    requests?: Requests;
+    setShowing?: React.Dispatch<React.SetStateAction<Showing | null>>;
+    waitingSubmit: boolean;
+};
+export declare enum WatchResult {
+    Failed = 0,
+    Success = 1
+}

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

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import { Step as StepSpec } from './spec';
+import { ExecutionResult, State, Request, Showing } from './types';
+export interface ExecutionProps {
+    onTxFail?: (error: Error, data: any) => void;
+    onTxSubmit?: (tx: string, data: any) => void;
+    onTxSuccess?: (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, }?: ExecutionProps): {
+    showing: Showing | null;
+    showingDone: boolean;
+    transactionTx: string;
+    errorMessage: string | null;
+    setErrorMessage: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    closeShowing: () => void;
+    ctxVal: {
+        execute: (brief: string, spec: StepSpec, subtitle?: string | React.ReactNode | null, early?: boolean, submittedBack?: () => void, mixpanelProps?: Record<string, any>, submittedConfirmBack?: () => void, successBack?: ((tx: string, callback?: ExecutionProps['onTxSuccess']) => void) | undefined) => Promise<ExecutionResult.Failed | ExecutionResult.Success | ExecutionResult.Submitted>;
+        requests: Map<string, [Request, State]>;
+        setShowing: import("react").Dispatch<import("react").SetStateAction<Showing | null>>;
+        waitingSubmit: boolean;
+    };
+    requests: Map<string, [Request, State]>;
+};

package/dist/src/hooks/Submission/useInflights.d.ts

@@ -0,0 +1,5 @@
+import { Request } from './types';
+export default function useInflights(): {
+    runningRequests: Request[];
+    isInflight: boolean;
+};

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

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

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

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

package/dist/src/hooks/Swap/useFetchFiatPrice.d.ts

@@ -0,0 +1,13 @@
+import { ChainId } from '../../constants/chains';
+import { TokenInfo } from '../Token';
+export interface FetchFiatPriceProps {
+    chainId: ChainId | undefined;
+    fromToken: TokenInfo | null;
+    toToken: TokenInfo | null;
+}
+export declare function useFetchFiatPrice({ fromToken, toToken, chainId, }: FetchFiatPriceProps): {
+    loading: boolean;
+    refetch: () => void;
+    toFiatPrice: string;
+    fromFiatPrice: string;
+};

package/dist/src/hooks/Swap/useFetchFiatPrice.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,37 @@
+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;
+}
+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, }: FetchRoutePrice): {
+    status: RoutePriceStatus;
+    rawBrief: IRouteResponse | null;
+    refetch: () => Promise<void>;
+    executeSwap: (subtitle: React.ReactNode) => void;
+    reset: () => void;
+};
+export {};

package/dist/src/hooks/Swap/useFetchRoutePrice.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { TokenInfo } from '../Token';
+export declare function useInitDefaultToken({ fromToken, toToken, setFromToken, setToToken, updateFromAmt, updateToAmt, }: {
+    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;
+}): void;

package/dist/src/hooks/Swap/useMarginAmount.d.ts

@@ -0,0 +1,8 @@
+import { TokenInfo } from '../Token';
+export interface MarginAmountProps {
+    token: TokenInfo | null;
+    fiatPrice: string;
+}
+export declare function useMarginAmount({ token, fiatPrice }: MarginAmountProps): {
+    marginAmount: string;
+};

package/dist/src/hooks/Swap/useMarginAmount.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/Swap/usePriceTimer.d.ts

@@ -0,0 +1,5 @@
+export interface PriceTimerProps {
+    refetch: () => void;
+    interval?: number;
+}
+export declare function usePriceTimer({ refetch, interval }: PriceTimerProps): void;

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

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

package/dist/src/hooks/Token/index.d.ts

@@ -0,0 +1,4 @@
+export { default as useInitTokenList } from './useInitTokenList';
+export { default as useFindTokenByAddress } from './useFindTokenByAddress';
+export { default as useTokenList } from './useTokenList';
+export type { TokenList, TokenInfo, DefaultTokenInfo } from './type';

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

@@ -0,0 +1,26 @@
+export interface TokenInfo {
+    readonly chainId: number;
+    readonly address: string;
+    readonly name: string;
+    readonly decimals: number;
+    readonly symbol: string;
+    readonly logoURI?: string;
+    readonly tags?: string[];
+    readonly extensions?: any;
+    readonly side?: 'from' | 'to';
+    readonly canBridgeToTon?: boolean;
+}
+export interface DefaultTokenInfo extends TokenInfo {
+    amount?: number;
+}
+export declare type TokenList = TokenInfo[];
+export declare enum TokenListType {
+    All = "all"
+}
+export declare enum ApprovalState {
+    Loading = "Loading",
+    Insufficient = "ApprovalInsufficient",
+    Approving = "Approving",
+    Sufficient = "Sufficient",
+    Unchecked = "Unchecked"
+}

package/dist/src/hooks/Token/useDisabledTokenSwitch.d.ts

@@ -0,0 +1,5 @@
+import { TokenInfo } from './type';
+export declare function useDisabledTokenSwitch({ fromToken, toToken, }: {
+    fromToken: TokenInfo | undefined | null;
+    toToken: TokenInfo | undefined | null;
+}): boolean;

package/dist/src/hooks/Token/useFetchTokenAllowance.d.ts

@@ -0,0 +1,13 @@
+import BigNumber from 'bignumber.js';
+import { TokenInfo } from './type';
+export declare function useFetchTokenAllowance({ chainId, account, token, proxyContractAddress, }: {
+    chainId?: number;
+    account?: string;
+    token?: TokenInfo;
+    proxyContractAddress: string;
+}): {
+    allowance: BigNumber | null;
+    loading: boolean;
+    error: boolean;
+    refetch: () => Promise<void>;
+};

package/dist/src/hooks/Token/useFindTokenByAddress.d.ts

@@ -0,0 +1 @@
+export default function useFindTokenByAddress(address?: string): import("./type").TokenInfo | undefined;

package/dist/src/hooks/Token/useFindTokenByAddress.test.d.ts

@@ -0,0 +1 @@
+export {};