@funkit/connect 0.0.0-20260710210119

package/dist/hooks/queries/useRecentCheckouts.d.ts

@@ -0,0 +1,13 @@
+import { PaymentMethod } from '../../domains/paymentMethods';
+interface RecentCheckoutsQuery {
+    isVisible: boolean;
+    paymentMethod?: PaymentMethod;
+}
+/**
+ * @returns recent checkouts tied to a recipient address used in the token transfer flow
+ *
+ * Thin web adapter over `@funkit/connect-core`'s params-shaped query: pulls
+ * identity + refresh interval from context and supplies the web logger.
+ */
+export declare const useRecentCheckouts: ({ paymentMethod, isVisible, }: RecentCheckoutsQuery) => import("@tanstack/react-query").UseQueryResult<import("@funkit/api-base").CheckoutHistoryItem[]>;
+export {};

package/dist/hooks/queries/useRecentDeposits.d.ts

@@ -0,0 +1,83 @@
+import type { DirectExecution } from '@funkit/api-base';
+import { type RecentDepositsApiQueryParams } from '@funkit/connect-core';
+import type { UseQueryResult } from '@tanstack/react-query';
+import { type PurifiedCheckoutHistoryItem } from '../../utils/purifyCheckoutHistoryItem';
+type RecentDepositsApiQuery = Omit<RecentDepositsApiQueryParams, 'logger'>;
+type DefaultDEQueryKey = 'apiKey' | 'userId' | 'refreshIntervalMs';
+export type RecentDEQuerySimplified = {
+    isVisible: boolean;
+    fetchSize?: number;
+};
+/**
+ * @returns raw direct executions for the current user (no filtering or transforms applied)
+ */
+export declare const useRecentDeposits: ({ isVisible, fetchSize, }: RecentDEQuerySimplified) => UseQueryResult<DirectExecution[]>;
+/**
+ * Full explicit-params version of `useRecentDeposits` for use outside FunkitProvider context.
+ * Used by SDK wrappers.
+ */
+interface RecentDirectExecutionsQuery extends RecentDepositsApiQuery {
+    cutOffTimeMs?: number;
+    /**
+     * Optional filter function to further refine which deposits are returned.
+     * WARNING: Must be a stable reference (wrap in useMemo), otherwise the hook will constantly re-render.
+     * @param de - The DirectExecution to filter
+     * @returns true to include the deposit, false to exclude it
+     */
+    memoizedFilterFunc?: (de: DirectExecution) => boolean;
+}
+/**
+ * Hook for SDK users to fetch recent deposits/direct executions with automatic context integration.
+ *
+ * **Requirements**: Must be used inside FunkitProvider context as it automatically retrieves:
+ * - API key, User ID, Refresh interval from Fun
+ *
+ * Returns checkout history items
+ *
+ * @param query - Simplified query parameters (excludes apiKey, userId, refreshIntervalMs)
+ * @returns Object with `data` property containing array of purified direct executions or undefined if not loaded
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { data: recentDeposits } = useFunkitRecentDeposits({
+ *     isVisible: true,
+ *     fetchSize: 10,
+ *     cutOffTimeMs: 24 * 60 * 60 * 1000, // Last 24 hours
+ *   })
+ *   return <div>{recentDeposits?.length} recent deposits</div>
+ * }
+ * ```
+ */
+export declare function useFunkitRecentDeposits(query: Omit<RecentDirectExecutionsQuery, DefaultDEQueryKey>): {
+    data: PurifiedCheckoutHistoryItem[] | undefined;
+};
+/**
+ * Implementation hook for SDK users to fetch recent deposits with explicit parameters.
+ *
+ * **Requirements**: Does NOT require FunkitProvider context. All parameters must be provided explicitly.
+ * This is useful for custom implementations or when using outside the standard Funkit provider hierarchy.
+ *
+ * Returns purified checkout history items
+ *
+ * @param query - Complete query parameters including apiKey, userId, and refreshIntervalMs
+ * @returns Object with `data` property containing array of purified direct executions or undefined if not loaded
+ *
+ * @example
+ * ```tsx
+ * function MyCustomComponent() {
+ *   const { data: recentDeposits } = useFunkitRecentDepositsImpl({
+ *     isVisible: true,
+ *     apiKey: 'your-api-key',
+ *     userId: 'user-wallet-address',
+ *     refreshIntervalMs: 5000,
+ *     fetchSize: 10,
+ *   })
+ *   return <div>{recentDeposits?.length} recent deposits</div>
+ * }
+ * ```
+ */
+export declare function useFunkitRecentDepositsImpl(query: RecentDirectExecutionsQuery): {
+    data: PurifiedCheckoutHistoryItem[] | undefined;
+};
+export {};

package/dist/hooks/queries/useSwappedDefaultCurrency.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fetches Swapped supported countries and maps the user's country (alpha2)
+ * to get the currency code.
+ */
+export declare const useSwappedDefaultCurrency: () => import("@tanstack/react-query").UseQueryResult<string, Error>;

package/dist/hooks/queries/useSwappedExchanges.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Fetches Swapped exchange options by calling /fops with a CRYPTO_TO_CRYPTO
+ * rail config. The rail config is what causes the backend to return exchange
+ * FOPs (e.g. Bybit); however, this hook does not guard against the backend
+ * returning non-Swapped or non-exchange FOPs in the future — callers should
+ * be aware that the response may evolve as the BE adds rail types.
+ *
+ * Gated by the `enable-swapped-exchanges` Statsig feature gate — when off,
+ * the query is disabled and the response is empty.
+ */
+export declare const useSwappedExchanges: () => import("@tanstack/react-query").UseQueryResult<{
+    genericFormsOfPayments: import("@funkit/api-base").GenericFormOfPayment[];
+    savedFormsOfPayments: never[];
+}, Error>;

package/dist/hooks/queries/useWithdrawFops.d.ts

@@ -0,0 +1,21 @@
+import { type GetFopsResponse } from '@funkit/api-base';
+export declare const SWAPPED_MIN_SELL_EUR = 7;
+/**
+ * Hook to fetch available withdrawal (off-ramp) forms of payment from /fops.
+ * Sends a CRYPTO_TO_FIAT rail config to get sell/payout methods.
+ */
+export declare const useWithdrawFops: (params: {
+    sourceChainId: string;
+    sourceTokenAddress: string;
+    /** Best-effort max sell amount in EUR; capped to the user's source balance. */
+    defaultMaxAmount?: number;
+    /**
+     * Gate the fetch. Default true. Pass false to hold the request until the cap
+     * is resolved, so the first /fops call never goes out uncapped.
+     */
+    enabled?: boolean;
+}) => {
+    data: GetFopsResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+};

package/dist/hooks/queries/useWithdrawalQuote.d.ts

@@ -0,0 +1,237 @@
+import { type FunkitWithdrawalConfig } from '../../providers/FunkitCheckoutContext';
+interface CheckoutQuoteParams {
+    recipientAddress: string;
+    selectedChainId: string | undefined;
+    selectedTokenAddress: string | null | undefined;
+    selectedTokenSymbol: string | undefined;
+    config: FunkitWithdrawalConfig;
+    /** Extra gate ANDed into the internal enabled conditions (default true). */
+    isEnabled?: boolean;
+}
+/**
+ * Simplified quoting logic used for withdrawal UI only.
+ */
+export declare function useWithdrawalQuote({ recipientAddress, selectedChainId, selectedTokenAddress, selectedTokenSymbol, config, isEnabled, }: CheckoutQuoteParams): {
+    quoteEnabled: boolean;
+    data: {
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null;
+    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<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null>;
+} | {
+    quoteEnabled: boolean;
+    data: {
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null;
+    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<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null>;
+} | {
+    quoteEnabled: boolean;
+    data: 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<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null>;
+} | {
+    quoteEnabled: boolean;
+    data: 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<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null>;
+} | {
+    quoteEnabled: 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;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null>;
+} | {
+    quoteEnabled: boolean;
+    data: {
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null;
+    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<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<{
+        baseQuote: import("@funkit/utils").CheckoutQuoteResponse;
+        checkedAssetAmount: import("../../domains/quote").CheckedAssetAmount;
+        finalEstimation: import("../../domains/quote").FunkitCheckoutQuoteResult;
+    } | null>;
+};
+export {};

package/dist/hooks/queries/useWithdrawalRisk.d.ts

@@ -0,0 +1 @@
+export declare const useWithdrawalRisk: (apiKey: string, receiveAddress: string, chainId: number | undefined) => import("@tanstack/react-query").UseQueryResult<boolean, Error>;

package/dist/hooks/statsig/index.d.ts

@@ -0,0 +1,3 @@
+export { useDynamicConfig } from './useDynamicConfig';
+export { useExperiment } from './useExperiment';
+export { useFeatureGate } from './useFeatureGate';

package/dist/hooks/statsig/useDynamicConfig.d.ts

@@ -0,0 +1,5 @@
+import { type DynamicConfigName, type DynamicConfigValue } from '@funkit/connect-core';
+export type { DynamicConfigName, DynamicConfigValue };
+export declare const useDynamicConfig: <Name extends DynamicConfigName>(name: Name, options?: {
+    bypassCountryCode?: boolean;
+}) => DynamicConfigValue<Name>;

package/dist/hooks/statsig/useExperiment.d.ts

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

package/dist/hooks/statsig/useFeatureGate.d.ts

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

package/dist/hooks/track/CheckoutModalEvent.d.ts

@@ -0,0 +1,81 @@
+export declare enum CheckoutModalEvent {
+    MODAL_OPENED = "fc::modal_opened",
+    MODAL_READY = "fc::modal_ready",
+    MODAL_CLOSED = "fc::modal_closed",
+    NAVIGATE_SOURCE_CHANGE = "fc::navigate::source_change",
+    NAVIGATE_SELECT_ASSET = "fc::navigate::select_asset",
+    NAVIGATE_CONFIRMATION = "fc::navigate::confirmation",
+    NAVIGATE_CHECKOUT_COMPLETE = "fc::navigate::checkout_complete",
+    NAVIGATE_TRANSFER_TOKEN = "fc::navigate::transfer_token",
+    NAVIGATE_LIGHTNING_INVOICE = "fc::navigate::lightning_invoice",
+    NAVIGATE_INPUT_AMOUNT = "fc::navigate::input_amount",
+    NAVIGATE_ERROR_SCREEN = "fc::navigate::error_screen",
+    NAVIGATE_FIAT_ACCOUNT_DETAIL = "fc::navigate::fiat_account_detail",
+    NAVIGATE_BRIDGE_KYC = "fc::navigate::bridge_kyc",
+    NAVIGATE_BRIDGE_CUSTOMER = "fc::navigate::bridge_customer",
+    NAVIGATE_MELD_QUOTES = "fc::navigate::meld_quotes",
+    NAVIGATE_MELD_REDIRECT = "fc::navigate::meld_redirect",
+    NAVIGATE_MELD_CURRENCY_SELECT = "fc::navigate::meld_currency_select",
+    NAVIGATE_KYC_IFRAME = "fc::navigate::kyc_iframe",
+    NAVIGATE_CREATE_FIAT_ACCOUNT = "fc::navigate::create_fiat_account",
+    NAVIGATE_LOADING_ACCOUNT = "fc::navigate::loading_account",
+    NAVIGATE_SELECT_BROKERAGE = "fc::navigate::select_brokerage",
+    NAVIGATE_CONNECT_EXCHANGE = "fc::navigate::connect_exchange",
+    NAVIGATE_BROKERAGE_TWO_FA = "fc::navigate::brokerage_two_fa",
+    NAVIGATE_BROKERAGE_SUCCESS = "fc::navigate::brokerage_success",
+    NAVIGATE_SWAPPED_IFRAME = "fc::navigate::swapped_iframe",
+    NAVIGATE_PERPS_TRANSFER = "fc::navigate::perps_transfer",
+    READY_CONFIRMATION = "fc::ready::confirmation",
+    READY_INPUT_AMOUNT = "fc::ready::input_amount",
+    READY_SELECT_ASSET = "fc::ready::select_asset",
+    READY_SOURCE_CHANGE = "fc::ready::source_change",
+    READY_TRANSFER_TOKEN = "fc::ready::transfer_token",
+    READY_LOADING_ACCOUNT = "fc::ready::loading_account",
+    READY_SWAPPED_IFRAME = "fc::ready::swapped_iframe",
+    SOURCE_CHANGE_CRYPTO_TAB = "fc::source_change::crypto_tab",
+    SOURCE_CHANGE_CASH_TAB = "fc::source_change::cash_tab",
+    SOURCE_CHANGE_WITHDRAW_TAB = "fc::source_change::withdraw_tab",
+    QUERY_FROG_SUB_ACCOUNTS = "fc::query::frog_sub_accounts",
+    QUERY_UDA_ADDRESS = "fc::query::uda_address",
+    QUERY_WALLET_ASSETS = "fc::query::wallet_assets",
+    QUERY_VIRTUAL_FIAT_ACCOUNTS = "fc::query::virtual_fiat_accounts",
+    BASE_QUOTE = "fc::quote::base_quote",
+    FINAL_QUOTE = "fc::quote::final_quote",
+    QUOTE_MODE_RESOLVED = "fc::quote::mode_resolved",
+    VIEW_TRANSACTION_BREAKDOWN = "fc::quote::view_transaction_breakdown",
+    ACCOUNT_BALANCE_SUCCESS = "fc::success::account_balance",
+    TOKEN_TRANSFER_SUCCESS = "fc::success::token_transfer",
+    BLUVO_WITHDRAWAL_COMPLETED = "fc::success::bluvo_withdrawal_completed",
+    QUICK_OPTION_SELECTED = "fc::input_amount::quick_option_selected",
+    SWAPPED_IFRAME_NAVIGATION = "fc::swapped_iframe::navigation",
+    SWAPPED_IFRAME_NAVIGATION_INITIAL = "fc::swapped_iframe::navigation::initial",
+    SWAPPED_IFRAME_NAVIGATION_LOGIN = "fc::swapped_iframe::navigation::login",
+    SWAPPED_IFRAME_NAVIGATION_2FA = "fc::swapped_iframe::navigation::2fa",
+    SWAPPED_IFRAME_NAVIGATION_KYC = "fc::swapped_iframe::navigation::kyc",
+    SWAPPED_IFRAME_NAVIGATION_PAYMENT = "fc::swapped_iframe::navigation::payment",
+    SWAPPED_IFRAME_NAVIGATION_CONFIRMATION = "fc::swapped_iframe::navigation::confirmation",
+    SWAPPED_IFRAME_COMPLETE = "fc::swapped_iframe::complete",
+    SWAPPED_IFRAME_ERROR = "fc::swapped_iframe::error",
+    SWAPPED_IFRAME_BACK = "fc::swapped_iframe::back",
+    SWAPPED_IFRAME_NEW_DEPOSIT_BACK = "fc::swapped_iframe::new_deposit_back",
+    SWAPPED_IFRAME_EXIT = "fc::swapped_iframe::exit",
+    SWAPPED_IFRAME_ORDER_DATA = "fc::swapped_iframe::order_data",
+    SWAPPED_IFRAME_TRANSACTION_SUCCESSFUL = "fc::swapped_iframe::transaction_successful",
+    SWAPPED_IFRAME_LOGOUT = "fc::swapped_iframe::logout",
+    DEPOSIT_TRANSFER_ADDRESS_LOADED = "fc::deposit::transfer::address::loaded",
+    DEPOSIT_TRANSFER_ADDRESS_COPIED = "fc::deposit::transfer::address::copied",
+    DEPOSIT_TRANSFER_CHAIN_CHANGED = "fc::deposit::transfer::chain::changed",
+    DEPOSIT_TRANSFER_TOKEN_CHANGED = "fc::deposit::transfer::token::changed",
+    DEPOSIT_TRANSFER_IMPACT_VIEWED = "fc::deposit::transfer::impact::viewed",
+    DEPOSIT_TRANSFER_DEPOSIT_DETECTED = "fc::deposit::transfer::deposit::detected",
+    DEPOSIT_TRANSFER_DEPOSIT_CREDITED = "fc::deposit::transfer::deposit::credited",
+    DEPOSIT_TRANSFER_NOTIFICATION_DISPLAYED = "fc::deposit::transfer::notification::displayed",
+    DEPOSIT_TRANSFER_NOTIFICATION_DISMISSED = "fc::deposit::transfer::notification::dismissed",
+    DEPOSIT_TRANSFER_NOTIFICATION_EXPANDED = "fc::deposit::transfer::notification::expanded",
+    DEPOSIT_TRANSFER_NOTIFICATION_HIDDEN = "fc::deposit::transfer::notification::hidden",
+    COMPLIANCE_REVIEW_BANNER_SHOWN = "fc::compliance_review::banner_shown",
+    COMPLIANCE_REVIEW_GET_HELP_CLICKED = "fc::compliance_review::get_help_clicked",
+    ADD_TOKEN_TO_WALLET_REQUESTED = "fc::add_token_to_wallet::requested",
+    ADD_TOKEN_TO_WALLET_ADDED = "fc::add_token_to_wallet::added",
+    ADD_TOKEN_TO_WALLET_FAILED = "fc::add_token_to_wallet::failed"
+}

package/dist/hooks/track/WithdrawModalEvent.d.ts

@@ -0,0 +1,20 @@
+export declare enum WithdrawModalEvent {
+    MODAL_OPENED = "fw::modal_opened",
+    MODAL_READY = "fw::modal_ready",
+    MODAL_CLOSED = "fw::modal_closed",
+    ENTER_AMOUNT_VIEWED = "fw::enter_amount_viewed",
+    CRYPTO_ADDRESS_SELECTED = "fw::crypto_address_selected",
+    CASH_FOP_SELECTED = "fw::cash_fop_selected",
+    FINAL_QUOTE = "fw::quote::final_quote",
+    VIEW_TRANSACTION_BREAKDOWN = "fw::quote::view_transaction_breakdown",
+    PENDING_CALLBACK = "fw::pending_callback",
+    SUCCESS = "fw::success",
+    SWAPPED_IFRAME_READY = "fw::swapped::ready",
+    SWAPPED_IFRAME_BACK = "fw::swapped::back",
+    SWAPPED_IFRAME_EXIT = "fw::swapped::exit",
+    SWAPPED_IFRAME_ERROR = "fw::swapped::error",
+    SWAPPED_IFRAME_ORDER_DATA = "fw::swapped::order_data",
+    SWAPPED_IFRAME_NAVIGATION = "fw::swapped::navigation",
+    SWAPPED_IFRAME_NEW_WITHDRAWAL = "fw::swapped::new_withdrawal",
+    SWAPPED_IFRAME_WITHDRAWAL_SUCCESSFUL = "fw::swapped::withdrawal_successful"
+}

package/dist/hooks/track/useTrack.d.ts

@@ -0,0 +1,17 @@
+import type { FunkitUserInfo } from '../../consts/funkit';
+import type { CheckoutModalEvent } from './CheckoutModalEvent';
+import type { WithdrawModalEvent } from './WithdrawModalEvent';
+export interface TrackEventData {
+    eventName: CheckoutModalEvent | WithdrawModalEvent;
+    value?: string | number;
+    metadata?: object;
+}
+export declare const eventCounts: Partial<Record<CheckoutModalEvent | WithdrawModalEvent, number>>;
+export declare const useTrack: () => {
+    logEvent: (eventNameOrTrackEventData: CheckoutModalEvent | TrackEventData) => void;
+    logMeasuredEvent: (trackEventData: Omit<TrackEventData, "value">) => void;
+    startMeasuredEvent: (eventName: CheckoutModalEvent | WithdrawModalEvent) => void;
+    updateUserAsync: (userInfo: FunkitUserInfo & {
+        l2Address?: string;
+    }, apiKey: string) => Promise<import("@statsig/react-bindings").StatsigUpdateDetails>;
+};

package/dist/hooks/useAllowedAssets.d.ts

@@ -0,0 +1,12 @@
+import type { Address } from 'viem';
+interface AllowedAssetsHookResult {
+    allowedAssets: {
+        [chainId in string]?: Address[];
+    } | undefined;
+    isAllowed: (chainId: number | string, tokenAddress: Address) => boolean;
+    isLoading: boolean;
+}
+export declare function useAllowedAssets({ enabled, }?: {
+    enabled?: boolean;
+}): AllowedAssetsHookResult;
+export {};

package/dist/hooks/useAnimatedNavigation.d.ts

@@ -0,0 +1,27 @@
+export declare const ANIMATION_DELAY = 75;
+/**
+ * @param isInitialStep utilizes the old scale-in for initial display. Based on this boolean and animation state.
+ * @returns className to be applied on the animatable content
+ */
+export declare const getContentAnimation: ({ isOut, isReversed, isSkipped }: AnimationState, isInitialStep?: boolean) => string | undefined;
+interface AnimatedNavigationResponse<T> {
+    animation: AnimationState;
+    navigateTo: (page: T, params?: AnimationParams) => void;
+    animate: (callback: () => void, params?: AnimationParams) => void;
+}
+/**
+ * Logic for easier animations during navigation
+ * @param callback - Called when utilizing the navigateTo function. Without providing it the navigateTo function will not work
+ * animate is a more generic version of navigateTo that can be used if the callback is not known during hook initialization. Or if it differs.
+ */
+export declare function useAnimatedNavigation<T>(callback: ((page: T) => void) | undefined): AnimatedNavigationResponse<T>;
+interface AnimationParams {
+    reverse?: boolean;
+    skip?: boolean;
+}
+export interface AnimationState {
+    isOut: boolean;
+    isSkipped: boolean;
+    isReversed: boolean;
+}
+export {};

package/dist/hooks/useAssetPrice.d.ts

@@ -0,0 +1,37 @@
+import { type Erc20AssetInfo, type GetAssetPriceInfoResponse } from '@funkit/api-base';
+import type { Address } from 'viem';
+export declare function getAssetPriceInfoWithFallback({ apiKey, chainId, assetTokenAddress, }: {
+    apiKey: string;
+    chainId: string;
+    assetTokenAddress: Address;
+}): Promise<GetAssetPriceInfoResponse>;
+interface UseAssetAddressPriceParams {
+    chainId: string | undefined;
+    assetTokenAddress: Address | undefined;
+    /** Pass `false` to fetch once and disable interval polling. */
+    refetchInterval?: number | false;
+    /** defaults to 1 hence price returned is unit price */
+    amount?: number;
+    /** Asset symbol — when provided and the symbol is a stablecoin, price is hardcoded to 1 */
+    symbol?: string;
+    /** Disable the query without changing other inputs. Defaults to true. */
+    enabled?: boolean;
+}
+type AssetPriceResult = {
+    error: Error | null;
+    isLoading: boolean;
+    /** unit price if custom amount is not provided */
+    price: number | undefined;
+};
+export declare function useAssetAddressPrice({ chainId, assetTokenAddress, amount, refetchInterval, symbol, enabled, }: UseAssetAddressPriceParams): AssetPriceResult;
+type AssetSymbolPriceParams = {
+    chainId: string | undefined;
+    symbol: string | undefined;
+    refetchInterval?: number | false;
+    /** Disable the query without changing other inputs. Defaults to true. */
+    enabled?: boolean;
+};
+export declare const useAssetSymbolPrice: ({ chainId, symbol, refetchInterval, enabled, }: AssetSymbolPriceParams) => AssetPriceResult & {
+    asset?: Erc20AssetInfo | null;
+};
+export {};

package/dist/hooks/useAutoClearState.d.ts

@@ -0,0 +1,4 @@
+export declare function useAutoClearState<T>(initialValue?: T | null): [
+    state: T | null,
+    setState: (newState: T | null, durationMs?: number) => void
+];