@dodoex/widgets 3.2.2 → 3.2.3

package/dist/types/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: BridgeRouteI['sourceRoute']['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/types/hooks/Bridge/index.d.ts

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

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

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

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

@@ -0,0 +1,102 @@
+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;
+    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;
+    };
+}
+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;
+}
+export declare function useFetchRoutePriceBridge({ toToken, fromToken, fromAmount, }: FetchRoutePrice): {
+    status: RoutePriceStatus;
+    refetch: () => Promise<void>;
+    bridgeRouteList: BridgeRouteI[];
+};

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

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

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

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

package/dist/types/hooks/Chain/useChainList.d.ts

@@ -0,0 +1,2 @@
+import { ChainListItem } from '../../constants/chainList';
+export declare function useChainList(): ChainListItem[];

package/dist/types/hooks/Chain/useChainList.test.d.ts

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

package/dist/types/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/types/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/types/hooks/ConnectWallet/useCurrentChainId.d.ts

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

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

@@ -0,0 +1,13 @@
+import { ChainId } from '@dodoex/api';
+export declare function getPharosTestnetSwitched(): boolean;
+export declare function setPharosTestnetSwitched(isSwitched: boolean): void;
+export declare function updatePharosTestnetRpc(chainId: ChainId, provider?: any): Promise<boolean | undefined>;
+/**
+ * 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/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/useWeb3Connectors.d.ts

@@ -0,0 +1,17 @@
+import { Provider as Eip1193Provider } from '@web3-react/types';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ChainId } from '@dodoex/api';
+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/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/getExecutionErrorMsg.d.ts

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

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,95 @@
+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",
+    createAMMV2Position = "createAMMV2Position",
+    addLiquidityAMMV2Position = "addLiquidityAMMV2Position",
+    removeLiqidityAMMV2Position = "removeLiqidityAMMV2Position",
+    createAMMV3Pool = "createAMMV3Pool",
+    addAMMV3Pool = "addAMMV3Pool",
+    removeAMMV3Pool = "removeAMMV3Pool",
+    claimAMMV3Pool = "claimAMMV3Pool",
+    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"
+}
+type SubmitState = 'loading' | 'submitted';
+export interface Showing {
+    brief: string;
+    subtitle?: string | React.ReactNode;
+    spec: StepSpec;
+    submitState?: SubmitState;
+}
+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
+}
+export {};

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,27 @@
+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;
+    showSubmitLoadingDialog?: boolean;
+    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;
+    setShowing: import("react").Dispatch<import("react").SetStateAction<Showing | null>>;
+    ctxVal: ExecutionCtx;
+    requests: Map<string, [Request, State]>;
+};

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

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

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

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

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

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

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

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