@rash2x/bridge-widget 0.1.0 → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,624 @@
+import { JSX } from 'react/jsx-runtime';
+import { StoreApi } from 'zustand';
+import { TronWeb } from 'tronweb';
+import { UseBoundStore } from 'zustand';
+
+export declare function addrForApi(chainKey: string, addr: string): string;
+
+export declare type AssetMatrix = Record<string, Record<string, Token>>;
+
+declare interface BalanceData {
+    balance: number;
+    isLoading: boolean;
+}
+
+export declare type BalancesMap = Record<string, {
+    balance: number;
+    address: string;
+}>;
+
+declare interface BridgeQuoteActions {
+    setInputAmount: (v: string) => void;
+    setLoading: () => void;
+    setQuote: (q?: Quote) => void;
+    setError: (e?: string) => void;
+    setNoRoute: (v: boolean) => void;
+    triggerRefetch: () => void;
+    reset: () => void;
+    resetWithIdle: () => void;
+}
+
+declare interface BridgeQuoteState {
+    inputAmount: string;
+    status: BridgeQuoteStatus;
+    quote?: Quote;
+    error?: string;
+    noRoute: boolean;
+    refetchTrigger: number;
+}
+
+declare type BridgeQuoteStatus = "idle" | "loading" | "success" | "error";
+
+declare type BridgeQuoteStore = BridgeQuoteState & BridgeQuoteActions;
+
+export declare function buildAssetMatrix(tokens: Token[]): AssetMatrix;
+
+/**
+ * Calculate minimum received amount with custom slippage
+ */
+export declare function calculateMinReceived(quote: Quote | undefined, slippageBps: number, dstToken: Token | undefined): number;
+
+export declare interface Chain {
+    chainId: number;
+    chainKey: string;
+    chainType: string;
+    name: string;
+    nativeCurrency: {
+        address: string;
+        chainKey: string;
+        decimals: number;
+        name: string;
+        symbol: string;
+    };
+    shortName: string;
+}
+
+declare interface ChainActions {
+    setChains: (data?: Chain[]) => Promise<void>;
+    setFromChain: (data?: Chain) => void;
+    setToChain: (data?: Chain) => void;
+    setAllowedFromChains: (data?: Chain[]) => void;
+    setAllowedToChains: (data?: Chain[]) => void;
+    setIsLoadingToChains: (v: boolean) => void;
+    swapChains: () => void;
+}
+
+export declare interface ChainChangeData {
+    type: "from" | "to";
+    chain: Chain;
+}
+
+export declare type ChainKey = "TON" | "EVM" | "TRON" | string;
+
+declare interface chainState {
+    chains?: Chain[];
+    fromChain?: Chain;
+    toChain?: Chain;
+    allowedFromChains?: Chain[];
+    allowedToChains?: Chain[];
+    isLoadingToChains: boolean;
+}
+
+declare type ChainStoreType = chainState & ChainActions;
+
+export declare function computeFeesUsdFromArray(fees: Array<{
+    amount?: string;
+    token?: string;
+    chainKey?: string;
+    type?: string;
+    usd?: number;
+}> | undefined, tokens: Token[] | undefined, chains: Chain[] | undefined): {
+    totalUsd: number;
+    protocolFeeUsd?: number;
+    messageFeeUsd?: number;
+    serviceUsd?: number;
+    blockchainUsd?: number;
+};
+
+declare interface ConnectedWalletActions {
+    setTonConnected: (connected: boolean) => void;
+    setMetaMaskConnected: (connected: boolean) => void;
+    setTronConnected: (connected: boolean) => void;
+    hasAnyWallet: () => boolean;
+}
+
+declare interface ConnectedWalletState {
+    tonConnected: boolean;
+    metaMaskConnected: boolean;
+    tronConnected: boolean;
+}
+
+declare type ConnectedWalletStore = ConnectedWalletState & ConnectedWalletActions;
+
+declare interface CurrentTransaction {
+    quote: Quote;
+    status: TxStatus_2;
+    srcTxHash?: string;
+    dstTxHash?: string;
+    messageId?: string;
+    createdAt: number;
+    updatedAt: number;
+    error?: string;
+    monitorReceipt?: MonitorReceipt;
+    metadata?: TransactionMetadata;
+}
+
+/**
+ * Stores custom destination address override when user enables "Send to another address"
+ */
+declare interface CustomAddressState {
+    customDstAddress?: string;
+    setCustomDstAddress: (address?: string) => void;
+    clearCustomDstAddress: () => void;
+}
+
+export declare const DEFAULT_SLIPPAGE_BPS = 50;
+
+declare type DeliveryStatus = {
+    status: 'pending' | 'delivered' | 'failed';
+    srcTxHash?: string;
+    dstTxHash?: string;
+    raw?: unknown;
+};
+
+declare interface DeliveryStatusParams {
+    srcChainKey: string;
+    dstChainKey?: string;
+    srcTxHash: string;
+}
+
+export declare function dollarsFromNativeFees(feeNative: string, feeLzToken: string, chain: Chain | undefined, tokens: Token[] | undefined): number;
+
+export declare const EvaaBridge: (props: EvaaBridgeProps) => JSX.Element;
+
+export declare interface EvaaBridgeProps {
+    className?: string;
+    onInitialized?: () => void;
+    onSwapStart?: (data: SwapStartData) => void;
+    onSwapSuccess?: (data: SwapSuccessData) => void;
+    onSwapError?: (error: SwapErrorData) => void;
+    onAmountChange?: (amount: string) => void;
+    onChainChange?: (data: ChainChangeData) => void;
+}
+
+declare interface EvmMonitorReceipt {
+    status?: string | number | boolean;
+    blockNumber?: string;
+    logs?: Array<{
+        address?: string;
+        topics?: string[];
+        data?: string;
+    }>;
+}
+
+export declare interface Fees {
+    token: string;
+    chainKey: string;
+    amount: string;
+    type: string;
+}
+
+export declare function findNativeMeta(tokens: Token[] | undefined, chain: Chain | undefined): {
+    decimals: number;
+    priceUsd?: number;
+};
+
+/**
+ * Formats balance with specified decimal precision
+ * Returns "0.00" for zero/invalid values
+ */
+export declare const formatBalance: (amount: number, decimals?: number) => string;
+
+/**
+ * Formats transaction hash for display
+ * Shows first 4 and last 4 characters with ellipsis
+ * @param hash - Transaction hash
+ * @param startChars - Number of characters to show at start (default: 4)
+ * @param endChars - Number of characters to show at end (default: 4)
+ */
+export declare const formatHash: (hash: string | undefined, startChars?: number, endChars?: number) => string;
+
+/**
+ * Formats percentage from basis points (bps)
+ * @param bps - Basis points (e.g., 50 = 0.5%)
+ * @param decimals - Number of decimal places (default: 2)
+ */
+export declare const formatPercentage: (bps: number, decimals?: number) => string;
+
+/**
+ * Formats token amount with symbol-aware logic
+ * Stablecoins show as integers when >= 1, other tokens use adaptive decimals
+ */
+export declare const formatTokenAmount: (amount: number, symbol?: string, options?: {
+    decimals?: number;
+}) => string;
+
+/**
+ * Formats USD values with adaptive decimal precision
+ */
+export declare const formatUsd: (value?: number) => string;
+
+export declare function fromLD(ld: string, decimals: number): number;
+
+declare type GasPreset = "auto" | "none" | "medium" | "max";
+
+export declare function getChains(): Promise<Chain[]>;
+
+export declare function getDeliveryStatus(params: DeliveryStatusParams): Promise<DeliveryStatus | null>;
+
+export declare function getDestTokens(srcChainKey: string, srcTokenAddr: string): Promise<TokenWithDestination[]>;
+
+export declare function getEvmBalances(address: string, tokens: Token[]): Promise<WalletBalances>;
+
+/**
+ * Get human-readable amounts from quote
+ */
+export declare function getQuoteAmounts(quote: Quote | undefined, srcToken: Token | undefined, dstToken: Token | undefined): {
+    inputHuman: number;
+    outputHuman: number;
+    outputHumanRounded: string;
+    minReceivedHuman: number;
+};
+
+/**
+ * Get complete quote details for UI display
+ */
+export declare function getQuoteDetails(quote: Quote | undefined, srcToken: Token | undefined, dstToken: Token | undefined, tokens: Token[] | undefined, chains: Chain[] | undefined, slippageBps: number): {
+    inputAmount: number;
+    outputAmount: number;
+    outputAmountRounded: string;
+    minimumReceived: number;
+    etaSeconds: number | undefined;
+    fees: {
+        totalUsd: number;
+        protocolFeeUsd: number | undefined;
+        messageFeeUsd: number | undefined;
+        serviceUsd: number | undefined;
+        blockchainUsd: number | undefined;
+        inSrcToken: number | undefined;
+        inDstToken: number | undefined;
+    };
+};
+
+/**
+ * Get aggregated fees from quote
+ */
+export declare function getQuoteFees(quote: Quote | undefined, tokens: Token[] | undefined, chains: Chain[] | undefined, srcToken: Token | undefined, dstToken: Token | undefined): {
+    totalUsd: number;
+    protocolFeeUsd: number | undefined;
+    messageFeeUsd: number | undefined;
+    serviceUsd: number | undefined;
+    blockchainUsd: number | undefined;
+    inSrcToken: number | undefined;
+    inDstToken: number | undefined;
+};
+
+/**
+ * Get quote by priority preference
+ * If API returns single route, use it directly
+ * If multiple routes available, select based on user's priority
+ */
+export declare function getQuotesByPriority(req: QuoteRequest): Promise<Quote | null>;
+
+export declare function getSwapBalances(accountFriendly: string): Promise<BalancesMap>;
+
+export declare function getTokens(): Promise<Token[]>;
+
+export declare function getTronBalances(tronWeb: TronWeb, address: string, tokens: Token[]): Promise<WalletBalances>;
+
+export declare function isAddressValidForChain(chainKey?: string, addr?: string): boolean;
+
+export declare const isEvmAddress: (a?: string) => boolean;
+
+export declare function isNativeAddrEqual(chain: Chain | undefined, tokenAddr?: string): boolean;
+
+export declare const isTronAddress: (a?: string) => boolean;
+
+export declare const isZeroAddr: (a?: string) => boolean;
+
+export declare function listAssetsForSelect(tokens: Token[]): Token[];
+
+export declare function lookupTokenMeta(tokens: Token[] | undefined, chains: Chain[] | undefined, chainKey?: string, tokenAddr?: string): {
+    decimals: number;
+    priceUsd?: number;
+};
+
+export declare interface Message {
+    payload: string;
+    amount: string;
+    address: string;
+}
+
+declare type MonitorReceipt = EvmMonitorReceipt | TronMonitorReceipt | TonMonitorReceipt;
+
+export declare interface MonitorResult {
+    status: TxStatus;
+    reason?: string | null;
+    receipt?: unknown;
+    confirmations?: number;
+}
+
+export declare function normalizeTickerSymbol(s: string): string;
+
+export declare function pollUntilDelivered(args: PollUntilDeliveredParams): Promise<DeliveryStatus>;
+
+declare interface PollUntilDeliveredParams {
+    srcChainKey: string;
+    dstChainKey?: string;
+    srcTxHash: string;
+    intervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onUpdate?: (st: DeliveryStatus) => void;
+}
+
+export declare interface Quote {
+    route: string;
+    error: string | null;
+    srcAmount: string;
+    dstAmount: string;
+    srcAmountMax: string;
+    dstAmountMin: string;
+    srcToken: string;
+    dstToken: string;
+    srcAddress: string;
+    dstAddress: string;
+    srcChainKey: string;
+    dstChainKey: string;
+    dstNativeAmount: string;
+    duration: {
+        estimated: number;
+    };
+    fees: Fees[];
+    steps: TransactionStep[];
+}
+
+export declare type QuoteRequest = {
+    srcChainKey: string;
+    dstChainKey: string;
+    srcToken: string;
+    dstToken: string;
+    srcAmountLD: string;
+    dstAmountMinLD?: string;
+    srcAddress?: string;
+    dstAddress?: string;
+    dstNativeAmount?: string;
+    slippage?: number;
+    routePriority?: RoutePriority;
+};
+
+export declare type QuoteSendRequest = {
+    srcChainKey: string;
+    dstChainKey: string;
+    srcToken: string;
+    toAddressBytes32: string;
+    amountLD: string;
+    minAmountLD: string;
+    payInLzToken?: boolean;
+};
+
+export declare type QuoteSendResponse = {
+    fee: {
+        nativeFee: string;
+        lzTokenFee: string;
+    };
+};
+
+export declare function resolveTokenOnChain(tokens: Token[], assetSymbol: string, chainKey: string): Token | undefined;
+
+export declare function resolveTokenOnChainFromMatrix(assetMatrix: Record<string, Record<string, Token>> | undefined, assetSymbol: string | undefined, chainKey: string | undefined): Token | undefined;
+
+export declare const RoutePriority: {
+    readonly RECOMMENDED: "recommended";
+    readonly FASTEST: "fastest";
+    readonly CHEAPEST: "cheapest";
+};
+
+export declare type RoutePriority = (typeof RoutePriority)[keyof typeof RoutePriority];
+
+export declare const RouteType: {
+    readonly STARGATE_V2_FAST: "STARGATE_V2_FAST";
+    readonly OFT: "OFT";
+    readonly STARGATE_V1: "STARGATE_V1";
+};
+
+export declare type RouteType = (typeof RouteType)[keyof typeof RouteType];
+
+declare interface SettingsState {
+    slippageBps: number;
+    routePriority: RoutePriority;
+    gasPreset: GasPreset;
+    setSlippageBps: (bps: number) => void;
+    setRoutePriority: (priority: RoutePriority) => void;
+    setGasPreset: (preset: GasPreset) => void;
+    getDstNativeAmount: (chainKey?: string) => string;
+    getSourceGasReserveHuman: (chainKey?: string) => number;
+    getSlippageDecimal: () => number;
+}
+
+declare type Store = TransactionState & TransactionActions;
+
+export declare function sumFeeByTokenLD(fees: Array<{
+    amount?: string;
+    token?: string;
+    chainKey?: string;
+}> | undefined, dstTokenAddr?: string, dstChainKey?: string): string;
+
+export declare interface SwapErrorData {
+    error: string;
+    fromChain: string;
+    toChain: string;
+    amount: string;
+    tokenSymbol: string;
+}
+
+export declare interface SwapStartData {
+    fromChain: string;
+    toChain: string;
+    amount: string;
+    tokenSymbol: string;
+}
+
+export declare interface SwapSuccessData {
+    fromChain: string;
+    toChain: string;
+    amount: string;
+    tokenSymbol: string;
+    transactionHash?: string;
+}
+
+export declare interface Token {
+    address: string;
+    symbol: string;
+    chainKey: string;
+    name: string;
+    decimals: number;
+    isBridgeable: boolean;
+    price?: TokenPrice;
+}
+
+export declare interface TokenPrice {
+    usd: number;
+}
+
+declare interface TokensState {
+    tokens?: Token[];
+    assetMatrix?: AssetMatrix;
+    selectedToken?: Token;
+    selectedAssetSymbol?: string;
+}
+
+declare interface TokensStateActions {
+    setTokens: (data: Token[]) => Promise<void>;
+    setSelectedToken: (data?: Token) => void;
+    setSelectedAssetSymbol: (data: string) => void;
+}
+
+declare type TokensStoreType = TokensState & TokensStateActions;
+
+declare interface TokenWithDestination extends Token {
+    dstChainKey?: string;
+}
+
+export declare function toLD(human: string, decimals: number): string;
+
+declare interface TonMonitorReceipt {
+    aborted?: boolean;
+    transaction?: {
+        aborted?: boolean;
+        compute_phase?: {
+            exit_code?: number;
+        };
+    };
+    compute_phase?: {
+        exit_code?: number;
+    };
+    success?: boolean;
+    ok?: boolean;
+    status?: string;
+}
+
+export declare function tonNorm(addr?: string): string | null;
+
+export declare interface Transaction {
+    data?: string;
+    to?: string;
+    from?: string;
+    value?: string;
+    network?: string;
+    messages?: Message[];
+}
+
+declare interface TransactionActions {
+    setTransaction: (quote: Quote, status?: TxStatus_2, metadata?: TransactionMetadata) => void;
+    updateStatus: (status: TxStatus_2) => void;
+    setSrcHash: (hash?: string) => void;
+    setDstHash: (hash?: string) => void;
+    setError: (error: string) => void;
+    reset: () => void;
+}
+
+declare interface TransactionMetadata {
+    srcChainName: string;
+    dstChainName: string;
+    srcTokenSymbol: string;
+    dstTokenSymbol: string;
+    srcAmountHuman: number;
+    dstAmountHuman: number;
+    totalFeeValue?: number;
+    totalFeeSymbol?: string;
+}
+
+declare interface TransactionState {
+    current?: CurrentTransaction;
+    successModalOpen: boolean;
+    history: CurrentTransaction[];
+}
+
+export declare interface TransactionStep {
+    type: string;
+    sender: string;
+    chainKey: string;
+    transaction: Transaction;
+}
+
+export declare interface TronLinkApi {
+    ready?: boolean;
+    tronWeb?: TronWeb;
+    request?: (args: {
+        method: string;
+        params?: unknown[];
+    }) => Promise<unknown>;
+    on?: (event: string, handler: (...args: unknown[]) => void) => void;
+    off?: (event: string, handler: (...args: unknown[]) => void) => void;
+}
+
+declare interface TronMonitorReceipt {
+    receipt?: {
+        result?: string;
+    };
+}
+
+/**
+ * Обрезает число до указанного количества десятичных знаков без округления
+ * Например: truncateToDecimals(3.389, 2) = "3.38" (не "3.39")
+ */
+export declare const truncateToDecimals: (num: number, decimals: number) => string;
+
+export declare type TxStatus = "success" | "failed" | "timeout";
+
+declare type TxStatus_2 = "idle" | "pending" | "executing" | "processing" | "completed" | "failed" | "expired";
+
+export declare const useBridgeQuoteStore: UseBoundStore<StoreApi<BridgeQuoteStore>>;
+
+export declare const useChainsStore: UseBoundStore<StoreApi<ChainStoreType>>;
+
+export declare const useConnectedWalletsStore: UseBoundStore<StoreApi<ConnectedWalletStore>>;
+
+export declare const useCustomAddressStore: UseBoundStore<StoreApi<CustomAddressState>>;
+
+export declare const useSettingsStore: UseBoundStore<StoreApi<SettingsState>>;
+
+export declare function useSwapModel(): {
+    amount: string;
+    loadingQuote: boolean;
+    fromBalance: BalanceData;
+    receiveBalance: BalanceData;
+    allowedFromChains: Chain[] | undefined;
+    allowedToChains: Chain[] | undefined;
+    isLoadingToChains: boolean;
+    actions: {
+        readonly setFromChain: (data?: Chain) => void;
+        readonly setToChain: (data?: Chain) => void;
+        readonly setAmount: (v: string) => void;
+        readonly swapSides: () => void;
+    };
+    fromChain: Chain | undefined;
+    toChain: Chain | undefined;
+    selectedAssetSymbol: string | undefined;
+};
+
+export declare const useTokensStore: UseBoundStore<StoreApi<TokensStoreType>>;
+
+export declare const useTransactionStore: UseBoundStore<StoreApi<Store>>;
+
+export declare interface WalletBalance {
+    balance: number;
+    address: string;
+}
+
+export declare type WalletBalances = Record<string, WalletBalance>;
+
+export declare type WalletKind = "ton" | "evm" | "tron" | null;
+
+export { }