@funkit/connect 0.0.0-20260710210119

package/dist/hooks/useCheckoutDirectExecution.d.ts

@@ -0,0 +1,62 @@
+import { DirectExecutionType } from '@funkit/api-base';
+import type { RelayTxHash, RelayVmType } from '@funkit/fun-relay';
+import type { CheckoutQuoteResponse } from '@funkit/utils';
+import type { Address, Hex } from 'viem';
+import type { FunkitCheckoutQuoteResult } from '../domains/quote';
+import type { FunkitActiveCheckoutItem, FunkitCheckoutActionParams } from '../providers/FunkitCheckoutContext';
+import { type WithdrawalClient, type WithdrawalTransaction } from '../wallets/Wallet';
+interface DirectExecutionQuoteRequestParamsBase {
+    actionParams: FunkitCheckoutActionParams[];
+    bridgeOverride?: 'across' | 'relay';
+    fromChainId: string;
+    fromTokenAddress: Address;
+    isExactIn?: boolean;
+    toChainId: string;
+    toTokenAddress: Address;
+    recipientAddress: Address;
+    senderAddress?: Address;
+    /**
+     * Explicit permit preference for the source-side authorization step.
+     * Forwarded as `usePermit` on the v2 quote request body. When defined,
+     * takes priority over the legacy auto-gasless-fallback (see frog's
+     * getUsePermit for the full resolution order).
+     */
+    usePermit?: boolean;
+}
+interface RegularDEQuoteRequest extends DirectExecutionQuoteRequestParamsBase {
+    toTokenAmount: number;
+    toTokenDecimals: number;
+    isExactIn?: false;
+}
+interface WithdrawalDEQuoteRequest extends DirectExecutionQuoteRequestParamsBase {
+    fromTokenAmount: string;
+    isExactIn: true;
+    fromTokenDecimals: number;
+}
+type DirectExecutionQuoteRequestParams = RegularDEQuoteRequest | WithdrawalDEQuoteRequest;
+interface DirectExecutionStartParams {
+    checkoutItem: FunkitActiveCheckoutItem;
+    stepMessageSetter: (m: string) => void;
+    actionsParams: FunkitCheckoutActionParams[];
+    latestQuote: FunkitCheckoutQuoteResult;
+    onTransactionConfirmed: (txHash: RelayTxHash<RelayVmType>) => void;
+    withdrawalClient?: WithdrawalClient;
+    /**
+     * Transactions returned by `WalletWithdrawalConfig.preWithdrawalAction`.
+     * Prepended to the SDK's withdrawal txn and broadcast as a single
+     * atomic batch via `withdrawalClient.sendTransactions`.
+     */
+    preWithdrawalTxs?: WithdrawalTransaction[];
+}
+export interface FunkitDirectExecutionInfo {
+    isDirectExecution: boolean;
+    directExecutionType: DirectExecutionType | null;
+    getDirectExecutionQuote: (params: DirectExecutionQuoteRequestParams) => Promise<CheckoutQuoteResponse | null>;
+    executeDirectExecution: (params: DirectExecutionStartParams) => Promise<Hex | null>;
+}
+interface UseCheckoutDirectExecutionReturn {
+    getDirectExecutionInfo: (checkoutItem: FunkitActiveCheckoutItem | null) => FunkitDirectExecutionInfo;
+    getWithdrawalDirectExecution: () => FunkitDirectExecutionInfo;
+}
+export declare function useCheckoutDirectExecution(): UseCheckoutDirectExecutionReturn;
+export {};

package/dist/hooks/useCheckoutDirectExecutionHistory.d.ts

@@ -0,0 +1,28 @@
+import { CheckoutRefundState, CheckoutState, type DirectExecution, RelayExecutionStatus } from '@funkit/api-base';
+import type { MergedMultiStepDirectExecution } from '../domains/checkoutNotifications';
+export declare function mapRelayExecutionStatusToCheckoutState(status: RelayExecutionStatus): CheckoutState;
+export declare function mapRelayExecutionStatusToRefundState(status: RelayExecutionStatus): CheckoutRefundState | undefined;
+export declare function useCheckoutDirectExecutionHistory({ initDirectExecution, disabled, }: {
+    initDirectExecution?: DirectExecution;
+    disabled?: boolean;
+}): {
+    state: CheckoutState;
+    refundState: CheckoutRefundState | undefined;
+    isAcross: boolean;
+    isLayerZero: boolean | null | undefined;
+    isRefunded: boolean;
+    isCompleted: boolean;
+    isFailed: boolean;
+    isDelayed: boolean;
+    isProcessing: boolean;
+    directExecution: DirectExecution | undefined;
+};
+export declare function useMultiStepDirectExecutionStatus(multiStepDirectExecution: MergedMultiStepDirectExecution, disabled?: boolean): {
+    isCompleted: boolean;
+    isDelayed: boolean;
+    isFailed: boolean;
+    isFinalStep: boolean;
+    isProcessing: boolean;
+    isRefunded: boolean;
+    latestDirectExecution: DirectExecution;
+};

package/dist/hooks/useCheckoutItemDisplay.d.ts

@@ -0,0 +1,8 @@
+import type { ServerCheckoutConfig } from '../domains/clientMetadata';
+import type { FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+interface UseCheckoutItemDisplay {
+    checkoutConfig: FunkitCheckoutConfig | ServerCheckoutConfig | undefined;
+    hideAmount?: boolean;
+}
+export declare function useCheckoutItemDisplay({ checkoutConfig, hideAmount, }: UseCheckoutItemDisplay): string;
+export {};

package/dist/hooks/useCheckoutModalTitle.d.ts

@@ -0,0 +1,2 @@
+import type { Address } from 'viem';
+export declare function useCheckoutModalTitle(depositAddress: Address, defaultTitle: string): string;

package/dist/hooks/useCheckoutQuoteNotification.d.ts

@@ -0,0 +1,13 @@
+export declare function useCheckoutQuoteNotification(): {
+    quoteNotification: {
+        readonly messageType: "error";
+        readonly quoteMessage: string | number | bigint | true | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | import("react").ReactPortal | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined>;
+    } | {
+        readonly messageType: "step";
+        readonly quoteMessage: string;
+    } | {
+        readonly messageType: "none";
+        readonly quoteMessage: undefined;
+    };
+    clearCheckoutQuoteMessages: () => void;
+};

package/dist/hooks/useCheckoutTimeEstimate.d.ts

@@ -0,0 +1,14 @@
+import { PaymentMethod } from '../domains/paymentMethods';
+import type { FunkitCheckoutQuoteResult } from '../domains/quote';
+export declare const LAYERZEO_OFT_TIME_ESTIMATE_SECONDS = 180;
+/**
+ * https://linear.app/funxyz/issue/PE-775/sdkconnectwith-next-pm-requests
+ * @param originalTimeEstimationMs time estimation in milliseconds
+ * @param paymentMethod payment method
+ * @param bypassFlag whether to ignore flag value and return the original time estimation fallback even if flag is defined
+ * @returns time estimation in seconds
+ */
+export declare function useCheckoutTimeEstimate(latestQuote: FunkitCheckoutQuoteResult | null, originalTimeEstimationMs: number | undefined, paymentMethod: PaymentMethod, bypassFlag: boolean): {
+    estimatedTime: number;
+    estimatedTimeText: string;
+};

package/dist/hooks/useCheckoutTransferInit.d.ts

@@ -0,0 +1,20 @@
+import { type CheckoutInitTokenTransferAddressParams, type CheckoutInitTokenTransferResponse, type FunAddress } from '@funkit/api-base';
+import { getCheckoutTokenTransferParams } from '@funkit/connect-core';
+export { getCheckoutTokenTransferParams };
+interface UseCheckoutTransferInitResponse {
+    transferInit: CheckoutInitTokenTransferResponse | undefined;
+    recipientAddr: FunAddress;
+    isLoading: boolean;
+    isFetching: boolean;
+}
+type CheckoutTokenTransferParams = Omit<CheckoutInitTokenTransferAddressParams, 'logger' | 'clientMetadata'>;
+export declare function checkoutTransferFetch(params: CheckoutTokenTransferParams): Promise<CheckoutInitTokenTransferResponse>;
+export declare function useIsQRCodeTransferEnabled(): {
+    enabled: boolean;
+    comingSoon: boolean;
+    geoblocked: boolean;
+};
+/**
+ * creates QR code transfer EOA
+ */
+export declare const useCheckoutTransferInit: (enabled?: boolean) => UseCheckoutTransferInitResponse;

package/dist/hooks/useConnectionStatus.d.ts

@@ -0,0 +1,2 @@
+export type ConnectionStatus = 'disconnected' | 'loading' | 'unauthenticated' | 'connected';
+export declare function useConnectionStatus(): ConnectionStatus;

package/dist/hooks/useCopyToClipboard.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Handles copy action on provided text
+ * isCopied state is reverted to default value after provided delay
+ */
+export declare const useCopyToClipboard: (text: string, delay?: number) => {
+    isCopied: boolean;
+    handleCopy: () => void;
+};

package/dist/hooks/useCountdown.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import { type FunCountdownProps } from '../components/FunCountdown/FunCountdown';
+export interface UseCountdownResult {
+    countdown: ReactNode;
+    isLastSecond: boolean;
+    restartCountdown(): void;
+}
+interface UseCountdownOptions extends Omit<FunCountdownProps, 'onCountdownLastSecond'> {
+    autoRestart?: boolean;
+}
+export declare function useCountdown({ onCountdownEnded, autoRestart, ...props }: UseCountdownOptions): UseCountdownResult;
+export {};

package/dist/hooks/useDirectExecutionInfoPolling.d.ts

@@ -0,0 +1,8 @@
+import { type DirectExecution } from '@funkit/api-base';
+export declare function useDirectExecutionInfoPolling({ initDirectExecution, disabled, }: {
+    initDirectExecution: DirectExecution | undefined;
+    disabled?: boolean;
+}): {
+    directExecution: DirectExecution | undefined;
+    isLoading: boolean;
+};

package/dist/hooks/useDynamicRoutes.d.ts

@@ -0,0 +1,4 @@
+import type { IndexedDynamicRoutingConfig } from '@funkit/fun-relay';
+export declare const useDynamicRoutes: (_dynamicRoutingId?: string) => {
+    findPath: IndexedDynamicRoutingConfig[string]["findPath"];
+};

package/dist/hooks/useEffectEvent.d.ts

@@ -0,0 +1 @@
+export { useEffectEvent } from '@funkit/connect-core';

package/dist/hooks/useEnabledTokenTransferChainTokens.d.ts

@@ -0,0 +1,3 @@
+import type { CheckoutInitTokenTransferResponse } from '@funkit/api-base';
+import type { TokenTransferSourceChainsAndAssets } from '../modals/CheckoutModal/TransferToken/TransferToken';
+export declare function useEnabledTokenTransferChainTokens(transferInit?: CheckoutInitTokenTransferResponse | null, isWithdrawal?: boolean): TokenTransferSourceChainsAndAssets;

package/dist/hooks/useExchangeOptions.d.ts

@@ -0,0 +1,19 @@
+import { type BrokerageOption } from '../consts/bluvo';
+/**
+ * Unified brokerage list combining static Bluvo exchanges and dynamic
+ * Swapped Connect FOPs (CRYPTO_TO_CRYPTO). Used by SelectBrokerage and the
+ * payment-method preview row. Live entries come first; ComingSoon (and
+ * FOPs that came back without an embeddedFlowUrl) follow.
+ */
+export declare function useExchangeOptions({ iconSize }: {
+    iconSize: number;
+}): {
+    options: BrokerageOption[];
+    /**
+     * True while the Swapped FOPs are stale placeholder data (kept visible during
+     * a refetch triggered by a recipient/destination change). Callers that act on
+     * a selection should gate Swapped options on this, since a stale FOP's
+     * embedded flow URL may still target the previous recipient.
+     */
+    isPlaceholderData: boolean;
+};

package/dist/hooks/useFiatExchangeRates.d.ts

@@ -0,0 +1,5 @@
+export declare function useFiatExchangeRates(enabled?: boolean): {
+    data: import("@funkit/api-base").ExchangeRates | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useFrogAccount.d.ts

@@ -0,0 +1,337 @@
+import { type BridgeVirtualBankAccount, type Guid } from '@funkit/api-base';
+import { type AllFiatAccounts } from '../domains/bridge';
+export declare function useIsSepaUser(): boolean;
+export declare function useFiatEnabled(): boolean;
+export declare function useFrogAccounts(): import("@tanstack/react-query").UseQueryResult<import("@funkit/api-base").SubAccount[] | null, Error>;
+export declare function useClearFrogAccountsCache(): {
+    clearFrogAccounts: () => void;
+    clearVirtualFiatAccounts: () => void;
+};
+export declare function useVirtualFiatAccounts(): {
+    isLoading: boolean;
+    data: AllFiatAccounts;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: AllFiatAccounts;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: AllFiatAccounts;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+};
+export declare function useMatchingVirtualFiatAccount(accounts: AllFiatAccounts | undefined): BridgeVirtualBankAccount | undefined;
+export type KycLinkLoad = {
+    kycLink?: string;
+    guid: Guid;
+};
+export declare function useLoadKycLink(linkLoad: KycLinkLoad): {
+    data: string | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: 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;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+};
+type Result<T, E> = {
+    type: 'success';
+    data: T;
+} | {
+    type: 'error';
+    error: E;
+};
+export declare function useCreateVirtualBankAccount(): () => Promise<Result<BridgeVirtualBankAccount, Error>>;
+export {};

package/dist/hooks/useFunListeners.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from 'viem';
+/**
+ * Handles the starting and stopping of checkout history listeners based on the calling component's mount/unmount status
+ * Each hook will store and track its own intervalId
+ */
+export declare function useCheckoutHistoryListener(activate?: boolean, singleDepositAddr?: Address | undefined): void;

package/dist/hooks/useFunkitMaxCheckoutUsdInfo.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Retrieves the maximum checkout amount in USD and formats the limit text.
+ *
+ * @description
+ * This hook uses a Statsig dynamic config to determine the maximum checkout amount.
+ * If the amount is negative (e.g. -1), it returns 'no' as the limit text (no limit).
+ * Otherwise, it formats the amount as a currency string with specific formatting options.
+ *
+ * @returns {Object} An object containing:
+ * - `value`: The maximum checkout amount in USD (number). Defaults to Number.MAX_VALUE (no limit).
+ * - `limitLabel`: A formatted string representing the checkout limit
+ *   - Returns 'no' if the limit is negative (no limit, e.g. -1)
+ *   - Otherwise, returns a formatted currency string (e.g., '$1k')
+ *
+ * @example
+ * // Example usage in a component
+ * const { value, limitLabel } = useFunkitMaxCheckoutUsdInfo();
+ * console.log(value); // e.g., 1000
+ * console.log(limitLabel); // e.g., '$1k'
+ * console.log(limitLabel); // e.g., 'no'
+ */
+export declare const useFunkitMaxCheckoutUsdInfo: () => {
+    value: number;
+    limitLabel: string;
+};

package/dist/hooks/useFunkitTranslation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Custom hook for accessing translations in Funkit components
+ * Wrapper around react-i18next's useTranslation hook
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { t } = useFunkitTranslation()
+ *   return <button>{t('common.confirm')}</button>
+ * }
+ * ```
+ *
+ * @example With interpolation
+ * ```tsx
+ * function MyComponent() {
+ *   const { t } = useFunkitTranslation()
+ *   return <div>{t('checkout.minAmount', { amount: '10 USDC' })}</div>
+ * }
+ * ```
+ */
+export declare function useFunkitTranslation(): import("react-i18next").UseTranslationResponse<"translation", undefined>;

package/dist/hooks/useGetAssetHoldingsFromRpc.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reads one ERC-20 holding (balance + best-effort USD price) on-chain.
+ *
+ * - For tokens the wallet-assets API doesn't index, so they still appear as a
+ *   payable source. Caller owns customer/flow gating.
+ * - Fails soft: a read failure drops the row, a price failure keeps it price-less
+ *   — a flaky RPC never blocks the list.
+ */
+import { type Address } from 'viem';
+import type { AssetHoldingsItem } from '../domains/wallet';
+export type GetAssetHoldingsFromRpcParams = {
+    /** Chain to read on, as a string chain id (e.g. "57073"). */
+    chainId: string | undefined;
+    /** ERC-20 token address to read the balance of. */
+    tokenAddress: Address | undefined;
+    /** Holder address whose balance to read. */
+    walletAddress: Address | undefined;
+    /** Symbol to label the holding with — `symbol()` is never read on-chain. */
+    symbolHint?: string;
+    iconSrc?: string;
+    enabled?: boolean;
+};
+export declare function useGetAssetHoldingsFromRpc({ chainId, tokenAddress, walletAddress, symbolHint, iconSrc, enabled, }: GetAssetHoldingsFromRpcParams): import("@tanstack/react-query").UseQueryResult<AssetHoldingsItem | null, Error>;

package/dist/hooks/useHasHover.d.ts

@@ -0,0 +1 @@
+export declare function useHasHover(): boolean;