@funkit/connect 0.0.0-20260710210119

package/dist/hooks/useInjectedAssetHoldings.d.ts

@@ -0,0 +1,20 @@
+import type { Address } from 'viem';
+import type { AssetHoldingsMap } from '../domains/wallet';
+/**
+ * Merges payable sources the wallet-assets API doesn't index — an xStock the
+ * user holds + its wrapper — into the holdings map.
+ *
+ * Note: xStock/Nado-only today; possibly deprecate once backend supports these natively.
+ *
+ * - Gated by `enable-rpc-xstock-assets` (off by default) → no RPC reads, nothing injected.
+ * - Single seam in `useWalletAssetHoldings` so keys can't drift across consumers.
+ * - Injects only what the API omits (never clobbers its price/USD); gating lives upstream.
+ */
+export declare function useInjectedAssetHoldings({ targetChainId, existingHoldings, xstockWrappedTokenAddress, }: {
+    targetChainId: string;
+    existingHoldings: AssetHoldingsMap | undefined;
+    xstockWrappedTokenAddress?: Address;
+}): {
+    holdings: AssetHoldingsMap;
+    isLoading: boolean;
+};

package/dist/hooks/useInterval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(callback: () => void, delay: number): void;

package/dist/hooks/useIsBlacklisted.d.ts

@@ -0,0 +1,6 @@
+import type { FunAddress } from '@funkit/api-base';
+import type { GeneralWalletContextProps } from '../providers/GeneralWalletProvider';
+export declare const useIsBlacklisted: (walletAddress: GeneralWalletContextProps["walletAddress"], customRecipient?: FunAddress) => {
+    isWalletBlacklisted: boolean;
+    isCustomRecipientBlacklisted: boolean;
+};

package/dist/hooks/useIsBlacklistedWithdrawalAddress.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Attempt to safeguard user from irrecoverable losses
+ */
+export declare function useIsBlacklistedWithdrawalAddress(address: string): boolean;

package/dist/hooks/useIsCheckoutComplete.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns `true` when the checkout for `depositAddress` has reached the
+ * `COMPLETED` terminal state. Returns `false` while pending / failed /
+ * not-yet-loaded / no address.
+ *
+ * Composes the same hooks the post-checkout detail components use, so the
+ * direct-execution path gets its real polling-driven status (the merged
+ * list's `state` is hardcoded to `COMPLETED` for DEs — unreliable).
+ *
+ * `depositAddress` is either a deposit address (bridged checkouts) or a tx
+ * hash (direct executions); the underlying hooks pick the right branch.
+ */
+export declare function useIsCheckoutComplete(depositAddress: string | undefined): boolean;

package/dist/hooks/useIsDynamicRoutingEnabled.d.ts

@@ -0,0 +1,4 @@
+import { type FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+export declare const useIsDynamicRoutingEnabled: ({ checkoutConfig: _checkoutConfig, }?: {
+    checkoutConfig?: FunkitCheckoutConfig;
+}) => boolean;

package/dist/hooks/useIsMainnetConfigured.d.ts

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

package/dist/hooks/useIsMounted.d.ts

@@ -0,0 +1 @@
+export declare function useIsMounted(): () => boolean;

package/dist/hooks/useIsStablecoin.d.ts

@@ -0,0 +1,2 @@
+export type IsStablecoinFn = (symbol: string) => boolean;
+export declare const useIsStablecoin: () => IsStablecoinFn;

package/dist/hooks/useIsTokenWhitelisted.d.ts

@@ -0,0 +1,30 @@
+import { type FlagKey } from '@funkit/utils';
+export declare const MATCH_ALL = "*";
+export type MatchAll = typeof MATCH_ALL;
+export interface TokenWhitelist {
+    [chainId: string | MatchAll]: string[] | [MatchAll] | MatchAll;
+}
+/**
+ * Helper to check if a token is whitelisted for a given flag
+ * Expects a flag value to be a JSON string of the following format (see {@link TokenWhitelist}):
+ * ```json
+ * {
+ *   "137": ["0xaf88d065e77c8cC2239327C5EDb3A432268e5831"],
+ *   "8453": ["0xaf88d065e77c8cC2239327C5EDb3A432268e5831"]
+ * }
+ * ```
+ * Does also support wildcard entries, for example:
+ * ```json
+ * {
+ *   "137": ["*"],
+ *   "8453": "*",
+ * }
+ * ```
+ * or even:
+ * ```json
+ * {
+ *   "*": "*"
+ * }
+ * ```
+ */
+export declare const useIsTokenWhitelisted: <T extends FlagKey>(flagKey: T) => (chainId: string, tokenAddress: string) => boolean;

package/dist/hooks/useIsUsUser.d.ts

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

package/dist/hooks/useIsUserUnderComplianceReview.d.ts

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

package/dist/hooks/useIsomorphicEffect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from 'react';
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/hooks/useMainnetEnsAvatar.d.ts

@@ -0,0 +1,2 @@
+import { type GetEnsNameReturnType } from 'viem/ens';
+export declare function useMainnetEnsAvatar(name: GetEnsNameReturnType | undefined): import("viem").GetEnsAvatarReturnType | undefined;

package/dist/hooks/useMainnetEnsName.d.ts

@@ -0,0 +1,2 @@
+import type { Address } from 'viem';
+export declare function useMainnetEnsName(address: Address | undefined): import("viem").GetEnsNameReturnType | undefined;

package/dist/hooks/useMinDeposit.d.ts

@@ -0,0 +1,5 @@
+import { PaymentMethod } from '../domains/paymentMethods';
+export declare function useMinCheckoutDeposit({ currency, paymentMethod, }: {
+    currency?: string;
+    paymentMethod?: PaymentMethod;
+}): number;

package/dist/hooks/useNewTokenBanner.d.ts

@@ -0,0 +1,7 @@
+export type AssetSelectionBannerConfig = {
+    chainId: number;
+    symbol: string;
+    name: string;
+    isChainNew?: boolean;
+};
+export declare function useNewTokenBanner(): AssetSelectionBannerConfig | undefined;

package/dist/hooks/useOnNewNotification.d.ts

@@ -0,0 +1,8 @@
+import type { NotificationItem } from '../modals/CheckoutModal/TransferToken/types';
+/**
+ * This might not work if multiple instances of this hook are used in the same page
+ * since it uses sessionStorage to store the processed notifications
+ *
+ * Warning: If QR Code screen is open in multiple tabs, cb will be called multiple times (once for each tab) for the same notification.
+ */
+export declare const useOnNewNotification: (combinedNotifications: NotificationItem[], cb: (item: NotificationItem) => void) => void;

package/dist/hooks/usePaymentMethodIcon.d.ts

@@ -0,0 +1,17 @@
+import React, { type ReactNode } from 'react';
+import { PaymentMethod, type PaymentMethodInfo } from '../domains/paymentMethods';
+export declare const PAYMENT_METHOD_ICONS: Record<Exclude<PaymentMethod, PaymentMethod.ACCOUNT_BALANCE>, (size: number) => ReactNode>;
+/**
+  Reference ENG-716
+  * EOA wallet users
+    * detect connectors and show builtin icon in SDK
+    * if no SDK icons available, show icon from wagmi
+  * otherwise show fallback icon EVM
+*/
+export declare function usePaymentMethodIcon(paymentMethod: PaymentMethod, iconSize?: number): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+interface PaymentMethodInfoLabel {
+    text: string;
+    icon: ReactNode;
+}
+export declare const usePaymentMethodInfoLabel: (methodInfo: PaymentMethodInfo, iconSize?: number) => PaymentMethodInfoLabel;
+export {};

package/dist/hooks/usePaymentMethodTabs.d.ts

@@ -0,0 +1,8 @@
+import { type PaymentMethodType } from '../hooks/usePaymentSources';
+export declare function usePaymentMethodTabs({ hasWithdrawalConfig, }: {
+    hasWithdrawalConfig: boolean;
+}): {
+    defaultTab: PaymentMethodType;
+    isWithdrawalTabEnabled: boolean;
+    tabOrder: PaymentMethodType[];
+};

package/dist/hooks/usePaymentSources.d.ts

@@ -0,0 +1,22 @@
+import { type ConnectablePaymentMethodInfo, PaymentMethod } from '../domains/paymentMethods';
+export declare function usePaymentMethodEnablement(): {
+    isSwappedEnabled: boolean;
+    isFiatEnabled: boolean;
+    isTokenTransferEnabled: boolean;
+    isMeldEnabled: boolean;
+    isBrokerageEnabled: boolean;
+    isLightningEnabled: boolean;
+    isCashAppLightningEnabled: boolean;
+};
+export type PaymentMethodType = 'crypto' | 'fiat' | 'withdraw';
+export type UnavailablePaymentSource = {
+    method: PaymentMethod;
+    reason: 'geoblocked' | 'comingSoon';
+};
+export declare const usePaymentSources: (currentPaymentMethodInfo: ConnectablePaymentMethodInfo | null, targetChainId: string) => {
+    isFallback: boolean;
+    preferred: (import("../domains/paymentMethods").PaymentMethodBrokerageInfo | import("../domains/paymentMethods").PaymentMethodAccountInfo | import("../domains/paymentMethods").PaymentMethodVirtualBankInfo)[] | PaymentMethod[];
+    moreSources: PaymentMethod[];
+    unavailable: UnavailablePaymentSource[];
+    hasUsableBalance: boolean;
+};

package/dist/hooks/usePolymarketAccountBalances.d.ts

@@ -0,0 +1,66 @@
+import { type QueryClient } from '@tanstack/react-query';
+import type { Address } from 'viem';
+/**
+ * Shared query key for a Polymarket account's USD balance, keyed by address.
+ * Keying by address (not by the opaque getter fn) is what lets the "Deposit to"
+ * dropdown and the in-modal transfer step dedupe into a single cache entry — so
+ * navigating between them reuses the already-loaded balance instead of
+ * refetching from scratch (no loading flash on entry).
+ */
+export declare const polymarketAccountBalanceQueryKey: (address: Address | undefined) => readonly ["polymarket", "accountBalanceUsd", `0x${string}` | null];
+/**
+ * Optimistically moves a transfer's amount between the two accounts' displayed
+ * balances — call right after the integrator accepts the transfer. `amountUsd`
+ * is the exact string the user entered (validated numeric, ≤6 decimals), the
+ * same string handed to `transfer` — the math runs in 6-decimal fixed point,
+ * never through a float round-trip.
+ *
+ * This is the standard TanStack optimistic-update sequence: cancel in-flight
+ * fetches, write the new values with `setQueryData` so every reader (deposit
+ * picker, transfer step) updates immediately, and let the server win again
+ * later. "Later" is a settlement window rather than the next poll because the
+ * integrator's backend is eventually consistent — it keeps reporting the
+ * pre-transfer balances for a few seconds after accepting the transfer, so
+ * polls inside the window keep the displayed value instead of flashing back.
+ */
+export declare function applyOptimisticTransferBalances(queryClient: QueryClient, transfer: {
+    fromAddress: Address;
+    toAddress: Address;
+    /** Exact entered amount (validated numeric string, ≤6 decimals). */
+    amountUsd: string;
+}): void;
+/** The fields a balance reader needs from a Polymarket account. */
+export interface PolymarketBalanceAccount {
+    address: Address;
+    /** Integrator-owned live balance fetcher (USD). */
+    getBalanceUsd: () => Promise<number>;
+}
+export interface PolymarketAccountBalance {
+    /** Latest polled balance, or `undefined` until the first fetch resolves. */
+    balanceUsd: number | undefined;
+}
+export interface UsePolymarketAccountBalancesOptions {
+    /**
+     * How often (ms) to poll each account's balance. Defaults to
+     * {@link DEFAULT_BALANCE_REFETCH_MS}. A short interval reconciles the
+     * displayed balance with the server soon after a transfer settles.
+     */
+    refetchIntervalMs?: number;
+}
+/**
+ * Live USD balances for the Polymarket Predictions and Perps accounts, backed
+ * by a single TanStack Query cache keyed by account address. Both the "Deposit
+ * to" dropdown and the in-modal transfer step read through this hook, so they
+ * share one store: whichever screen loads first populates the balance, and the
+ * other reads it instantly on navigation. After a transfer,
+ * {@link applyOptimisticTransferBalances} shifts the cached values immediately
+ * and the short poll reconciles them with the server once the settlement
+ * window closes.
+ */
+export declare function usePolymarketAccountBalances(accounts: {
+    predictions: PolymarketBalanceAccount | undefined;
+    perps: PolymarketBalanceAccount | undefined;
+}, options?: UsePolymarketAccountBalancesOptions): {
+    predictions: PolymarketAccountBalance;
+    perps: PolymarketAccountBalance;
+};

package/dist/hooks/useReceiveAmountLabel.d.ts

@@ -0,0 +1,5 @@
+import type { DirectExecutionType } from '@funkit/api-base';
+export declare function useReceiveAmountLabel(_: {
+    directExecutionType?: DirectExecutionType | null;
+    isSameToken?: boolean;
+}): string;

package/dist/hooks/useRelayBypass.d.ts

@@ -0,0 +1,10 @@
+import { PaymentMethod } from '../domains/paymentMethods';
+interface GetIsRelayEnabledParams {
+    paymentMethod: PaymentMethod | undefined;
+    isAdditionalActionsRequired: boolean;
+}
+export interface UseRelayBypassReturn {
+    getIsRelayEnabled: (params: GetIsRelayEnabledParams) => boolean;
+}
+export declare function useRelayBypass(): UseRelayBypassReturn;
+export {};

package/dist/hooks/useScrollDivider.d.ts

@@ -0,0 +1,19 @@
+export type UseScrollDividerResult = {
+    hasBottomDivider: boolean;
+    hasTopDivider: boolean;
+    isAtBottom: boolean;
+    isScrollable: boolean;
+    isScrolling: boolean;
+    ref: (node: HTMLElement | null) => void;
+};
+/**
+ * @returns information about which dividers to display based on whether an observed content is scrolled to the top or bottom
+ */
+export declare const useScrollDivider: () => {
+    ref: (node: HTMLElement | null) => void;
+    hasTopDivider: boolean;
+    hasBottomDivider: boolean;
+    isAtBottom: boolean;
+    isScrolling: boolean;
+    isScrollable: boolean;
+};

package/dist/hooks/useSkipSwappedPreload.d.ts

@@ -0,0 +1,7 @@
+/**
+ * When true, useSwappedPreload is silenced — it won't call setIframeUrl.
+ * SourceChange sets this around the leaving tab overlay during transitions
+ * to prevent the leaving tab's preload from racing the active tab's.
+ */
+export declare const SkipSwappedPreloadContext: import("react").Context<boolean>;
+export declare function useSkipSwappedPreload(): boolean;

package/dist/hooks/useStartBitcoinLightning.d.ts

@@ -0,0 +1,11 @@
+import { type PaymentMethodBitcoinLightningInfo } from '../domains/paymentMethods';
+/**
+ * Enters the Bitcoin Lightning checkout flow: builds the Bitcoin Lightning
+ * payment method info and sets it, plus the BTC source asset, on the checkout
+ * context. Mirrors the selection path in `SourceChange` so any entry point
+ * (e.g. the Transfer Crypto banner) lands the user in the same flow.
+ *
+ * Returns the built `paymentMethodInfo` so the caller can navigate to the next
+ * step (Input Amount, which then routes to the Lightning Invoice screen).
+ */
+export declare function useStartBitcoinLightning(): () => PaymentMethodBitcoinLightningInfo;

package/dist/hooks/useStepQueryReadiness.d.ts

@@ -0,0 +1,32 @@
+import type { CheckoutModalEvent } from '../hooks/track/CheckoutModalEvent';
+import type { useTrack } from '../hooks/track/useTrack';
+import type { FunCheckoutStep } from '../modals/CheckoutModal/FunCheckoutStep';
+export interface StepQueryMeta extends Record<string, unknown> {
+    /** Checkout steps that depend on this query being loaded */
+    dependentSteps: FunCheckoutStep[];
+    /** camelCase identifier for this query, used as key in timing metadata */
+    name: string;
+    /** Statsig event to emit with this query's individual timing */
+    timingEvent: CheckoutModalEvent;
+}
+export declare function stepQueryMeta(params: {
+    name: string;
+    timingEvent: CheckoutModalEvent;
+    dependentSteps: FunCheckoutStep[];
+}): StepQueryMeta;
+/**
+ * Ensures all React Query dependencies for a checkout step are loaded before
+ * marking the step as ready. Queries opt in via `stepQueryMeta()` in their
+ * query options.
+ *
+ * Emits:
+ * - A per-query Statsig event (the query's `timingEvent`) with duration as value
+ * - A step-level measured event (`fc::ready::*`) with per-query timing metadata
+ *
+ * Steps without dependencies are skipped — no event is emitted and
+ * `isStepReady` is set immediately.
+ */
+export declare function useStepQueryReadiness(logEvent: ReturnType<typeof useTrack>['logEvent'], logMeasuredEvent: ReturnType<typeof useTrack>['logMeasuredEvent']): {
+    isStepReady: boolean;
+    ensureStepQueries: (step: FunCheckoutStep) => Promise<void>;
+};

package/dist/hooks/useSupportedAssets.d.ts

@@ -0,0 +1,9 @@
+import { type GetSupportedAssetsResponse } from '@funkit/api-base';
+interface UseSupportedAssetsOptions {
+    enabled?: boolean;
+}
+/**
+ * Fetches and caches the /assets/supported endpoint.
+ */
+export declare function useSupportedAssets(options?: UseSupportedAssetsOptions): import("@tanstack/react-query").UseQueryResult<GetSupportedAssetsResponse, Error>;
+export {};

package/dist/hooks/useSwappedIframeLifecycle.d.ts

@@ -0,0 +1,12 @@
+import type { FormOfPaymentType } from '@funkit/api-base';
+/**
+ * Shared lifecycle hook for Swapped iframe containers (deposit + withdrawal).
+ * Handles activate/deactivate on mount/unmount and timeout error detection.
+ *
+ * `onTimeout` is stabilized internally via useEffectEvent — callers do not
+ * need to memoize it.
+ */
+export declare function useSwappedIframeLifecycle({ fopType, onTimeout, }: {
+    fopType: FormOfPaymentType;
+    onTimeout: () => void;
+}): void;

package/dist/hooks/useSwappedPreload.d.ts

@@ -0,0 +1,15 @@
+import type { GetFopsResponse } from '@funkit/api-base';
+/**
+ * Feeds fops data into the SwappedProvider for single-iframe preloading.
+ * Extracts the first (highest priority) embeddedFlowUrl and sets it on the provider.
+ *
+ * When a parent wraps the component tree in `<SkipSwappedPreloadContext.Provider
+ * value={true}>`, this hook skips the URL set (icon preloading still runs).
+ * SourceChange uses this around the leaving-tab overlay to prevent the stale
+ * tab's preload from racing the active tab's.
+ *
+ * Pass `disabled=true` to bypass the effect entirely (no setIframeUrl call at all,
+ * not even null). Use when another component owns the preload for the active context
+ * (e.g. SourceChange defers to WithdrawalMethodSelect on the withdraw tab).
+ */
+export declare function useSwappedPreload(fopsData: GetFopsResponse | undefined, disabled?: boolean): void;

package/dist/hooks/useSymbolRefresh.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Provides a unique identifier (a symbol in this case) that can be refreshed when necessary.
+ * Components using this hook will receive the initial symbol value and the refresh function to trigger a change in the symbol.
+ * This can be helpful in scenarios where you want to force a re-render or update.
+ */
+export declare function useSymbolRefresh(): [symbol: symbol, refresh: () => void];
+export default useSymbolRefresh;

package/dist/hooks/useTextMeasurer.d.ts

@@ -0,0 +1,3 @@
+export declare function useTextMeasurer(inputRef: React.RefObject<HTMLInputElement | null>): {
+    measureText: (text: string, fontSize?: number) => number | undefined;
+};

package/dist/hooks/useTokenAndChainDropdown.d.ts

@@ -0,0 +1,32 @@
+import type { CheckoutInitTokenTransferResponse } from '@funkit/api-base';
+import type { TokenTransferSourceChainsAndAssets } from '../modals/CheckoutModal/TransferToken/TransferToken';
+export type TransferTokenDefault = {
+    token: string;
+    chainId: number;
+};
+interface UseTokenChainResult {
+    assets: TokenTransferSourceChainsAndAssets;
+    selectedChainId: number | undefined;
+    handleChainChange: (chainId?: number, autoUpdate?: boolean) => void;
+    selectedToken: string | undefined;
+    selectedChainName: string | undefined;
+    handleTokenChange: (token: string, chainId?: number, autoUpdate?: boolean) => void;
+    isLoadingAssets: boolean;
+    chainIdSortOrder: number[];
+    popularTokenSymbols: string[];
+    priorityTokenSymbols: string[];
+}
+export interface UseTokenAndChainDropdownOptions {
+    transferInit?: CheckoutInitTokenTransferResponse;
+    defaultValues?: TransferTokenDefault;
+    /** When true, resolves the withdrawal Statsig config instead of the token-transfer one. Defaults to false. */
+    isWithdrawal?: boolean;
+    /** When true, starts with no chain/token pre-selected (user must pick both). Defaults to false. */
+    noDefaultSelection?: boolean;
+}
+/**
+ * Semi reusable hook (tied into token transfer configuration)
+ * ensures token&chain dropdown preselection logic is reusable
+ */
+export declare const useTokenAndChainDropdown: ({ defaultValues, isWithdrawal, noDefaultSelection, transferInit, }: UseTokenAndChainDropdownOptions) => UseTokenChainResult;
+export {};

package/dist/hooks/useTokenTransfer.d.ts

@@ -0,0 +1,28 @@
+import type { FunAddress } from '@funkit/api-base';
+import { type MinTransferConfig, getMinTransferValueForChain } from '@funkit/connect-core';
+import { type QRCodeUri } from '../utils/transfer';
+export type FeeValue = {
+    label: string;
+    value: number;
+};
+export type { MinTransferConfig };
+export { getMinTransferValueForChain };
+interface UseTokenTransferResult {
+    /** where money goes to first */
+    depositAddress: FunAddress | undefined;
+    depositAddressTooltip: string;
+    /** the final destination of the money */
+    recipientAddr: string;
+    minTransferUsd: number;
+    minTransferUsdPerChain: {
+        [chainId: string]: number;
+    };
+    showOriginalRecipient: boolean;
+    estPriceImpact: FeeValue | undefined;
+    maxSlippage: FeeValue | undefined;
+    qrCodeUri: QRCodeUri | undefined;
+    blockchain: 'ethereum' | 'solana' | 'bitcoin' | 'tron';
+}
+export declare const useTokenTransfer: (selectedChainId: number | undefined, selectedToken: string | undefined, chainIds?: number[]) => UseTokenTransferResult;
+export declare const useMinTransferValueUsd: (selectedChainId: number | undefined) => number;
+export declare const useMinTransferValueEur: (selectedChainId: number | undefined) => number;

package/dist/hooks/useTokenTransferConfig.d.ts

@@ -0,0 +1,9 @@
+import type { TokenTransferConfig } from '../utils/tokenTransfer/types';
+/**
+ * Resolve the token-transfer (UDA deposit) token list: the curated Statsig
+ * `tokentransferconfig` chains/assets, filtered by the disabled list and merged
+ * with `/assets/supported` metadata. The pure resolution lives in
+ * `@funkit/connect-core` (shared with React Native); this hook supplies the
+ * platform reads (Statsig + react-query) and the loading state.
+ */
+export declare function useTokenTransferConfig(isWithdrawal?: boolean): TokenTransferConfig;

package/dist/hooks/useUDAParams.d.ts

@@ -0,0 +1,3 @@
+import type { UDAConfig } from '@funkit/connect-core';
+export type { UDAConfig };
+export declare const useUDAParams: (_dynamicRoutingId?: string) => UDAConfig | undefined;

package/dist/hooks/useUpdateActiveFunkitCheckout.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @external
+ * Allows clients to update the active funkit checkout item's displayable fields.
+ * DANGER: Sensitive fields like asset and amounts should not be updateable by clients
+ */
+export declare const useUpdateActiveFunkitCheckout: () => {
+    updateModalTitleMeta: (newMeta: string) => void;
+};

package/dist/hooks/useUserIpInfo.d.ts

@@ -0,0 +1,19 @@
+import type { FunkitUserIpInfo } from '../providers/FunkitMoonpayProvider';
+export interface UserIpInfoFromMoonpay {
+    /** https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 */
+    alpha2: 'AU' | 'CA' | 'US' | string;
+    state: string;
+    alpha3: string;
+    country: string;
+    ipAddress: string;
+    isAllowed: boolean;
+    isBuyAllowed: boolean;
+    isNftAllowed: boolean;
+    isSellAllowed: boolean;
+    isBalanceLedgerWithdrawAllowed: boolean;
+    isLowLimitEnabled: boolean;
+}
+export declare function useUserIpInfo(): {
+    userIpInfo: FunkitUserIpInfo | undefined;
+    isLoadingGeoCheck: boolean;
+};

package/dist/hooks/useWalletAssetHoldings.d.ts

@@ -0,0 +1,10 @@
+import { type AssetHoldingsMap } from '../utils/assets';
+interface UseWalletAssetHoldingsResponse {
+    data: AssetHoldingsMap | undefined;
+    isLoading: boolean;
+    totalBalance: number;
+    hasUsableBalance: boolean;
+    minValueThreshold: number;
+}
+export declare function useWalletAssetHoldings(targetChain: string): UseWalletAssetHoldingsResponse;
+export {};

package/dist/hooks/useWalletAssets.d.ts

@@ -0,0 +1,14 @@
+import type { KnownAssetBalanceInfo } from '../providers/GeneralWalletProvider';
+export type WalletAssets = Record<string, KnownAssetBalanceInfo>;
+/**
+ * Returns wallet assets that are above the {@link ASSETS_LOW_VALUE_THRESHOLD} threshold with their total USD value.
+ */
+export declare const useWalletAssets: ({ enableRefetchInterval, refetchOnMount, }?: {
+    enableRefetchInterval?: boolean | undefined;
+    refetchOnMount?: boolean | undefined;
+}) => {
+    walletAssets: WalletAssets | undefined;
+    totalWalletAssetsUsd: number;
+    isLoading: boolean;
+    isFetching: boolean;
+};

package/dist/hooks/useWalletLabel.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple wrapper around `getWalletLabel`
+ * @returns a static text for Ostium customers with connected wallet
+ */
+export declare const useWalletLabel: () => string;

package/dist/hooks/useXstockAssetHoldings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reads the active xStock target token + its wrapper balances on-chain (the
+ * wallet-assets API indexes neither).
+ *
+ * - Fetch only. Scoped to xStock targets (`assetClass === 'xstock'`) so we don't
+ *   fire RPC reads when there's nothing to read.
+ */
+import type { Address } from 'viem';
+import type { AssetHoldingsItem } from '../domains/wallet';
+export declare function useXstockAssetHoldings({ targetChainId, wrappedTokenAddress, enabled, }: {
+    targetChainId: string;
+    wrappedTokenAddress?: Address;
+    enabled?: boolean;
+}): {
+    data: AssetHoldingsItem[];
+    isLoading: boolean;
+};

package/dist/hooks/useXstocksWrappedTokenAddress.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolves the active target's xStocks wrapped token address (e.g. wSPYx for
+ * SPYx) from xStocks metadata — an equivalent direct-transfer source the
+ * wallet-assets API doesn't return. Balance read + injection live in
+ * `useXstockAssetHoldings`.
+ *
+ * - Scoped by `assetClass === 'xstock'` (not a customer), so the xStocks API is
+ *   only hit for xStock targets.
+ */
+import type { Address } from 'viem';
+export declare function useXstocksWrappedTokenAddress({ enabled }?: {
+    enabled?: boolean | undefined;
+}): {
+    data: Address | undefined;
+    isLoading: boolean;
+};

package/dist/imTokenWallet-UPA7ADZ2.js

@@ -0,0 +1,7 @@
+"use client";
+
+// src/wallets/walletConnectors/imTokenWallet/imTokenWallet.svg
+var imTokenWallet_default = 'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 28 28"><path fill="url(%23a)" d="M0 0h28v28H0z"/><path fill="%23fff" d="M14.193 20.693c-4.435.374-8.547-2.224-8.87-6.26-.298-3.326 1.825-4.758 3.504-4.885a2.91 2.91 0 0 1 3.282 2.376c.12 1.325-.742 1.952-1.343 1.996a1.007 1.007 0 0 1-1.128-.83c-.044-.513.165-.583.101-1.121a1.172 1.172 0 0 0-1.432-1.033c-.57.044-1.622.703-1.489 2.332.134 1.628 1.774 2.94 3.903 2.743a4.346 4.346 0 0 0 4.03-4.372c0-.128.03-.254.088-.367q.04-.066.09-.127.084-.134.196-.247l.209-.21c1-.911 4.637-3.104 8.052-2.42a.14.14 0 0 1 .076 0c.133 0 .21.09.222.222.539 7.996-4.745 11.785-9.49 12.203Z"/><defs><linearGradient id="a" x1="27.236" x2=".05" y1=".889" y2="27.978" gradientUnits="userSpaceOnUse"><stop stop-color="%2311C4D1"/><stop offset="1" stop-color="%230062AD"/></linearGradient></defs></svg>';
+export {
+  imTokenWallet_default as default
+};