@cetusprotocol/terminal 0.0.0-experimental-1737427725035

package/dist/hooks/common/useExplorer.d.ts

@@ -0,0 +1,4 @@
+export type ExplorerType = "account" | "token" | "tx" | "poolAddress" | "nftAddress" | "coin";
+export default function useExplorer(): {
+    getExplorerUrl: (address?: string, type?: ExplorerType, explorer?: string) => string;
+};

package/dist/hooks/common/useFetch.d.ts

@@ -0,0 +1,3 @@
+export declare function useFetch(): {
+    fetchByApi: (path: string, type: "GET" | "POST", options?: any, domain?: string) => Promise<any>;
+};

package/dist/hooks/common/useFindBestRouting.d.ts

@@ -0,0 +1,11 @@
+import { SwapRouterData, Token } from '../../types';
+export declare function useFindBestRouting(): {
+    findBestRouters: (options: {
+        fromToken: Token;
+        toToken: Token;
+        amount: string;
+        providersKeys: string[];
+        by_amount_in: boolean;
+        uuid: string;
+    }) => Promise<SwapRouterData>;
+};

package/dist/hooks/common/useGetPoolListByCoinType.d.ts

@@ -0,0 +1,3 @@
+export declare function useGetPoolListByCoinType(useLocal?: boolean): {
+    getPoolListByCoinType: (fromCoin: string, toCoin: string) => Promise<any[]>;
+};

package/dist/hooks/common/useGetRouterConfig.d.ts

@@ -0,0 +1,3 @@
+export default function useGetRouterConfig(): {
+    fetchRouterConfig: () => Promise<void>;
+};

package/dist/hooks/common/useInterval.d.ts

@@ -0,0 +1,9 @@
+type IntervalHookOptions = {
+    interval: number;
+    callback: (timestamp: number) => void;
+};
+export declare function useInterval({ interval, callback }: IntervalHookOptions): {
+    startTimer: () => void;
+    stopTimer: () => void;
+};
+export {};

package/dist/hooks/common/useSigner.d.ts

@@ -0,0 +1,8 @@
+import { SuiTransactionBlockResponse } from '@mysten/sui/client';
+import { Transaction } from '@mysten/sui/transactions';
+import { SignedTransaction } from '@mysten/wallet-standard';
+export declare function useSigner(): {
+    signAndExecuteTransactionBlock: (transactionBlock: Transaction, useDevInspect?: boolean) => Promise<SuiTransactionBlockResponse>;
+    signTransactionBlock: (transactionBlock: Uint8Array | Transaction | string) => Promise<SignedTransaction>;
+    executeTransactionBlock: (rawBytes: string, signature: string | string[], useDevInspect?: boolean) => Promise<SuiTransactionBlockResponse>;
+};

package/dist/hooks/common/useSyncedRef.d.ts

@@ -0,0 +1 @@
+export declare function useSyncedRef<T>(value: T): React.MutableRefObject<T>;

package/dist/hooks/common/useTransaction.d.ts

@@ -0,0 +1,5 @@
+import { ToastType, TransactionOption } from '../../types';
+import { Transaction } from '@mysten/sui/transactions';
+export default function useTransaction(): {
+    signAndExecuteTransaction: (tx: Transaction, toastType: ToastType, option?: TransactionOption) => Promise<any>;
+};

package/dist/hooks/common/useWindowWidth.d.ts

@@ -0,0 +1,4 @@
+export default function useWindowWidth(): {
+    windowWidth: number;
+    isApp: boolean;
+};

package/dist/hooks/demo/useDisplayMode.d.ts

@@ -0,0 +1,15 @@
+import { DisplayMode, WidgetBtnSize, WidgetDirection } from '../../types';
+export default function useDisplayMode(): {
+    DisplayModeList: DisplayMode[];
+    displayMode: DisplayMode;
+    handleChangeDisplayMode: (value: DisplayMode) => void;
+    currentDisplayModeDesc: string;
+    isOpenSwapModal: boolean;
+    handleCloseSwapModal: () => void;
+    handleOpenSwapModal: () => void;
+    handleChangeWidgetDirection: (value: WidgetDirection) => void;
+    widgetCurrentDirection: WidgetDirection;
+    widgetBtnSize: WidgetBtnSize;
+    handleChangeWidgetBtnSize: (value: WidgetBtnSize) => void;
+    isIndependentWallet: boolean;
+};

package/dist/hooks/demo/useRpcConfiguration.d.ts

@@ -0,0 +1,10 @@
+export default function useRpcConfiguration(): {
+    customRpcList: any[];
+    handleAdd: () => void;
+    handleInputChange: (index: number, value: string) => void;
+    handleDelete: (index: number) => void;
+    handleSave: (index: number) => void;
+    handleEdit: (index: number) => void;
+    handleSetDefault: (index: number) => void;
+    defaultRpcIndex: number;
+};

package/dist/hooks/swap/usePriceImpact.d.ts

@@ -0,0 +1,13 @@
+import { Token } from '../../types/common';
+export declare function usePriceImpact(fromToken?: Token, toToken?: Token, fromValue?: string, toValue?: string): {
+    swapPrice: string;
+    marketPrice: string | undefined;
+    priceImpact: string | undefined;
+    sources: string[];
+    showPriceImpactTips: boolean;
+    showPriceImpactWarn: boolean;
+    priceImpactTextInfo: {
+        priceImpactText: string | undefined;
+        textColor: string;
+    };
+};

package/dist/hooks/swap/useSwap.d.ts

@@ -0,0 +1,13 @@
+import { SwapRouterData, Token } from '../../types';
+export declare function useSwapHook(): {
+    handleAmountChange: (amount: string, by_amount_in: boolean, resetOtherInput?: boolean) => void;
+    handleSelectToken: (coin: Token, isFrom?: boolean) => void;
+    fromBalanceInfo: import('../../types').TokenBalance | undefined;
+    toBalanceInfo: import('../../types').TokenBalance | undefined;
+    fromAmountValue: string;
+    toAmountValue: string;
+    doSwapAction: (data: SwapRouterData, partner?: string) => Promise<void>;
+    reCalculateRouteData: () => void;
+    refreshMarketPrice: () => void;
+    scamsText: string | undefined;
+};

package/dist/hooks/swap/useSwapButtonStatus.d.ts

@@ -0,0 +1,4 @@
+export declare function useSwapButtonStatus(fromBalance?: string): {
+    btnText: string | undefined;
+    btnDisabled: boolean;
+};

package/dist/hooks/swap/useSwapHelper.d.ts

@@ -0,0 +1,49 @@
+import { SwapRouterData, SwapRouterFormat, Token } from '../../types';
+/**
+ * 获取展示PriceAccept RouterData
+ * @param originData
+ * @returns
+ */
+export declare function useGetPriceAcceptRouterData(originData?: SwapRouterData): {
+    priceAcceptRouterData: SwapRouterData | undefined;
+};
+/**
+ * 计算交易的amountLimit
+ * @param slippage
+ * @param routerData
+ * @returns
+ */
+export declare function useGetAmountLimit(slippage: string | number, routerData?: SwapRouterData): {
+    amountLimit: string | undefined;
+};
+/**
+ * 对RouterData 进行格式化处理
+ * @returns
+ */
+export declare function useFormatSwapRouter(routerData?: SwapRouterData): {
+    formatSwapRouter: SwapRouterFormat | undefined;
+};
+/**
+ * 得到 swap 降级 池子地址列表
+ * @returns
+ */
+export declare function useGetSwapPoolAddressList(): {
+    getSwapPoolAddress: () => Promise<any[]>;
+};
+/**
+ * 计算swap 价格ß
+ * @param fromAmount
+ * @param toAmount
+ */
+export declare function useGetSwapPrice(direct: boolean, fromAmount?: string, toAmount?: string): string;
+/**
+ * token 风险提示检查
+ * @returns
+ */
+export default function useCheckTokenScamsAlert(coinInfo?: Token): {
+    isScamsCoin: boolean | undefined;
+};
+export declare function useCheckCustomCoinPair(fromCoinType?: string, toCoinType?: string): {
+    isCustomMode: boolean;
+    customWarnTokenList: Token[];
+};

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,4 @@
+type noop = (...args: any[]) => any;
+export declare function useDebounceFunction<T extends noop>(callback: T, delay?: number): (...args: Parameters<T>) => void;
+export declare function useDebounceValue(value: string, delay: number): string;
+export {};

package/dist/hooks/useGetPoolList.d.ts

@@ -0,0 +1,22 @@
+export type GetPoolListParams = {
+    is_vaults?: boolean;
+    display_all_pools?: boolean;
+    has_mining?: boolean;
+    has_farming?: boolean;
+    no_incentives?: boolean;
+    order_by?: string;
+    limit?: number;
+    offset?: number;
+    coin_type?: string;
+    pool?: string;
+};
+export default function useGetPoolList(): {
+    getPoolList: (params: GetPoolListParams) => Promise<{
+        list: any[];
+        total: number;
+    }>;
+    getLocalJsonPoolList: (params: GetPoolListParams) => Promise<{
+        list: any[];
+        total: number;
+    }>;
+};

package/dist/hooks/useGetTokenBalance.d.ts

@@ -0,0 +1,5 @@
+import { TokenBalance } from '../types';
+export default function useGetTokenBalance(coinType?: string): {
+    getOwnerCoinBalances: (account?: string, coinType?: string) => Promise<void>;
+    balanceInfo: TokenBalance | undefined;
+};

package/dist/hooks/useInitWidget.d.ts

@@ -0,0 +1,3 @@
+export default function useInitWidget(initProps: any, customWallet?: any): {
+    handleSetDefaultPair: (from: string, to: string) => Promise<void>;
+};

package/dist/hooks/useSuiClient.d.ts

@@ -0,0 +1 @@
+export default function useSuiClient(): void;

package/dist/hooks/useToast.d.ts

@@ -0,0 +1,7 @@
+import { ToastType, TransactionStatusType } from '../types';
+export declare const useToast: (containerId?: string) => {
+    addCommonToast: (message: string, status?: TransactionStatusType) => void;
+    addTxToast: (toastType: ToastType) => number;
+    ToastContainer: () => import('react').ReactPortal;
+    removeToast: (id: number) => void;
+};

package/dist/hooks/useTokenCollect.d.ts

@@ -0,0 +1,6 @@
+import { Token } from '../types';
+export default function useTokenCollect(): {
+    handleCollectToken: (value: Token) => void;
+    isCollectToken: (token: Token) => boolean;
+    collectTokenMap: Map<string, Token>;
+};

package/dist/hooks/useTokenPrice.d.ts

@@ -0,0 +1,6 @@
+import { TokenPrice } from '../types';
+export default function useTokenPrice(): {
+    fetchTokenPrices: (coinTypeList: string[]) => Promise<TokenPrice[] | null>;
+    getTokenPrice: (coinType?: string) => TokenPrice | undefined;
+    getTokenAmountValue: (coinType?: string, amount?: string, defaultReturn?: string) => string;
+};

package/dist/hooks/useTokenSelect.d.ts

@@ -0,0 +1,11 @@
+import { Token } from '../types';
+export default function useTokenSelect(currCoin?: string): {
+    showTokenList: any[];
+    handleSearch: (keyword: string) => void;
+    handleChangePlatform: (platform: string) => void;
+    currentImportTokenData: any;
+    handleChangeType: (type: string) => void;
+    handleImportClick: () => void;
+    handleDeleteImportClick: (token: Token) => void;
+    isNoData: boolean;
+};

package/dist/hooks/useTokens.d.ts

@@ -0,0 +1,8 @@
+import { Token } from '../types';
+import { CoinMetadata } from '@mysten/sui/client';
+export declare function coinMetadataToCoinInfo(metadata: CoinMetadata, coinType: string): Token;
+export declare function useTokens(): {
+    getTokens: () => Promise<void>;
+    fetchTokenInfo: (coinType: string) => Promise<Token | undefined>;
+    getTokenInfo: (coinType?: string) => Token | undefined;
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { default as SwapWidget } from './Com.tsx';
+export declare const CetusSwap: typeof SwapWidget;

package/dist/stores/account.d.ts

@@ -0,0 +1,16 @@
+import { TokenBalance } from '../types';
+import { WalletAccount } from '@wallet-standard/base';
+interface AccountState {
+    accounts: WalletAccount[];
+    currentAccount: WalletAccount | undefined;
+    saveCurrentAccount: (account: WalletAccount | undefined) => void;
+    saveAccounts: (accounts: WalletAccount[]) => void;
+    isOpenWalletModal: boolean;
+    onWalletModal: (isOpen: boolean) => void;
+    isOpenAccountList: boolean;
+    setIsOpenAccountList: (value: boolean) => void;
+    tokenBalanceObj: Record<string, TokenBalance>;
+    setTokenBalanceObj: (data: Record<string, TokenBalance>) => void;
+}
+declare const useAccountStore: import('zustand').UseBoundStore<import('zustand').StoreApi<AccountState>>;
+export { useAccountStore };

package/dist/stores/client.d.ts

@@ -0,0 +1,10 @@
+import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
+import { SuiClient } from '@mysten/sui/client';
+interface ClientState {
+    suiClient: SuiClient;
+    setSuiClient: (value: SuiClient) => void;
+    aggregatorSDK: AggregatorClient;
+    setAggregatorSDK: (client: AggregatorClient) => void;
+}
+declare const useClientStore: import('zustand').UseBoundStore<import('zustand').StoreApi<ClientState>>;
+export { useClientStore };

package/dist/stores/common.d.ts

@@ -0,0 +1,8 @@
+import { ToastType } from '../types';
+interface AccountState {
+    toasts: ToastType[];
+    setToasts: (value: ToastType) => void;
+    removeToast: (id: number) => void;
+}
+declare const useCommonStore: import('zustand').UseBoundStore<import('zustand').StoreApi<AccountState>>;
+export { useCommonStore };

package/dist/stores/demo.d.ts

@@ -0,0 +1,27 @@
+import { DefaultPairType, DefaultSlippageType, DisplayMode, WidgetBtnSize, WidgetDirection } from '../types';
+interface DemoState {
+    defaultPairType: DefaultPairType;
+    setDefaultPairType: (value: DefaultPairType) => void;
+    defaultSlippageType: DefaultSlippageType;
+    setDefaultSlippageType: (value: DefaultSlippageType) => void;
+    isIndependentWallet: boolean;
+    customSlippage: string;
+    setCustomSlippage: (value: string) => void;
+    setIsIndependentWallet: (value: boolean) => void;
+    customRpcList: any[];
+    setCustomRpcList: (value: any) => void;
+    defaultRpcIndex: number;
+    setDefaultRpcIndex: (value: number) => void;
+    displayMode: DisplayMode;
+    setDisplayMode: (value: DisplayMode) => void;
+    isOpenSwapModal: boolean;
+    setIsOpenSwapModal: (value: boolean) => void;
+    widgetCurrentDirection: WidgetDirection;
+    setWidgetCurrentDirection: (value: WidgetDirection) => void;
+    widgetBtnSize: WidgetBtnSize;
+    setWidgetBtnSize: (value: WidgetBtnSize) => void;
+    isOpenSwapWidgetModal: boolean;
+    setIsOpenSwapWidgetModal: (value: boolean) => void;
+}
+declare const useDemoStore: import('zustand').UseBoundStore<import('zustand').StoreApi<DemoState>>;
+export default useDemoStore;

package/dist/stores/global.d.ts

@@ -0,0 +1,52 @@
+import { AggregatorProvider } from '../config/provider';
+import { ConfigLinkItem } from '../types';
+interface GlobalState {
+    currentExplorer: string;
+    setCurrentExplorer: (value: string) => void;
+    rpcList: ConfigLinkItem[];
+    setRpcList: (list: ConfigLinkItem[]) => void;
+    currentRpc: ConfigLinkItem;
+    setCurrentRpc: (value: ConfigLinkItem) => void;
+    customRpc: string;
+    setCustomRpc: (value: string) => void;
+    slippage: string;
+    setSlippage: (value: string) => void;
+    isOpenSlippageDialog: boolean;
+    setIsOpenSlippageDialog: (value: boolean) => void;
+    providers: AggregatorProvider[];
+    setProviders: (providers: AggregatorProvider[]) => void;
+    poolApiMap: Record<string, any[]>;
+    setPoolApiMap: (key: string, poolAddress: any[]) => void;
+    mevProtect: boolean;
+    setMevProtect: (value: boolean) => void;
+    ignoreWarnTokenMap: Record<string, boolean>;
+    setIgnoreWarnToken: (coin_type: string) => void;
+}
+declare const useGlobalStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<GlobalState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<GlobalState, {
+            currentExplorer: string;
+            currentRpc: ConfigLinkItem;
+            slippage: string;
+            customRpc: string;
+            providers: AggregatorProvider[];
+            mevProtect: boolean;
+            ignoreWarnTokenMap: Record<string, boolean>;
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: GlobalState) => void) => () => void;
+        onFinishHydration: (fn: (state: GlobalState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<GlobalState, {
+            currentExplorer: string;
+            currentRpc: ConfigLinkItem;
+            slippage: string;
+            customRpc: string;
+            providers: AggregatorProvider[];
+            mevProtect: boolean;
+            ignoreWarnTokenMap: Record<string, boolean>;
+        }>>;
+    };
+}>;
+export { useGlobalStore };

package/dist/stores/price.d.ts

@@ -0,0 +1,8 @@
+import { TokenPrice } from '../types';
+interface TokenState {
+    coinPriceObj: Record<string, TokenPrice>;
+    setPriceObj: (obj: Record<string, TokenPrice>) => void;
+    clearPriceObj: (coinTypeList: string[]) => void;
+}
+declare const useTokenPriceStore: import('zustand').UseBoundStore<import('zustand').StoreApi<TokenState>>;
+export default useTokenPriceStore;

package/dist/stores/swap.d.ts

@@ -0,0 +1,26 @@
+import { SwapRouterData, Token } from '../types/common';
+interface SwapState {
+    defaultFromCoinType?: string;
+    defaultToCoinCoinType?: string;
+    setDefaultCoin: (from?: string, to?: string) => void;
+    fromCoin: Token | undefined;
+    toCoin: Token | undefined;
+    setFromCoin: (value: Token | undefined) => void;
+    setToCoin: (value: Token | undefined) => void;
+    byAmountIn: boolean;
+    setByAmountIn: (byAmountIn: boolean) => void;
+    fromAmount: string;
+    toAmount: string;
+    setFromAmount: (amount: string) => void;
+    setToAmount: (amount: string) => void;
+    findRouterLoading: boolean;
+    setFindRouterLoading: (loading: boolean) => void;
+    routerData?: SwapRouterData;
+    setRouterData: (data?: SwapRouterData) => void;
+    isOpenSecondary: boolean;
+    setIsOpenSecondary: (isOpen: boolean) => void;
+    isOpenTokensDialog: boolean;
+    setIsOpenTokensDialog: (isOpen: boolean) => void;
+}
+declare const useSwapStore: import('zustand').UseBoundStore<import('zustand').StoreApi<SwapState>>;
+export default useSwapStore;

package/dist/stores/token.d.ts

@@ -0,0 +1,13 @@
+import { Token } from '../types';
+interface TokenState {
+    requestTokenList: string[];
+    addRequestTokenList: (coinType: string) => void;
+    setToken: (info: Token) => void;
+    tokenMap: Map<string, Token>;
+    setTokenMap: (data: Map<string, Token>, notSave?: boolean) => void;
+    trustedTokenList: Token[];
+    setTrustedTokenList: (data: Token[], notSave?: boolean) => void;
+    tokenMapIsInit: boolean;
+}
+declare const useTokenStore: import('zustand').UseBoundStore<import('zustand').StoreApi<TokenState>>;
+export default useTokenStore;

package/dist/stores/tokenSelect.d.ts

@@ -0,0 +1,30 @@
+import { Token } from '../types';
+interface AccountState {
+    currentTypeTab: string;
+    setCurrentTypeTab: (value: string) => void;
+    currentPlatformTab: string;
+    setCurrentPlatformTab: (value: string) => void;
+    platformList: string[];
+    setPlatformList: (value: string[]) => void;
+    isOpenImportDialog: boolean;
+    setIsOpenImportDialog: (value: boolean) => void;
+    collectTokenMap: Map<string, Token>;
+    setCollectTokenMap: (data: Map<string, Token>, notSave?: boolean) => void;
+    showTokenList: any[];
+    setShowTokenList: (data: any[]) => void;
+    combineTokenList: any[];
+    setComBineTokenList: (data: any[]) => void;
+    currentImportTokenData: any;
+    setCurrentImportTokenData: (data: any) => void;
+    importTokenList: Token[];
+    setImportToken: (token: Token, isAdd: boolean) => Token[];
+    setImportTokenList: (tokenList: Token[]) => void;
+    importTokenIsLoading: boolean;
+    setImportTokenIsLoading: (value: boolean) => void;
+    searchInput: string;
+    setSearchInput: (value: string) => void;
+    showTokenListIsLoading: boolean;
+    setShowTokenListIsLoading: (value: boolean) => void;
+}
+declare const useTokenSelectStore: import('zustand').UseBoundStore<import('zustand').StoreApi<AccountState>>;
+export { useTokenSelectStore };

package/dist/stores/transaction.d.ts

@@ -0,0 +1,7 @@
+import { ToastType } from '../types';
+interface TransactionState {
+    transactionData?: ToastType | undefined;
+    setTransactionData: (data?: ToastType) => void;
+}
+declare const useTransactionStore: import('zustand').UseBoundStore<import('zustand').StoreApi<TransactionState>>;
+export { useTransactionStore };