@funkit/connect 9.9.0 → 9.11.0-next.0

package/dist/clients/lighter.d.ts

@@ -14,6 +14,7 @@
  * caller provides the actual on-chain implementation.
  */
 import type { LighterAccountIndex } from '@funkit/api-base';
+import type { Address } from 'viem';
 import type { CustomWithdrawalConfig, MultiMethodWithdrawalConfig } from '../providers/FunkitCheckoutContext/types';
 export type LighterTransferParams = {
     toAccountIndex: number;
@@ -38,13 +39,18 @@ export type LighterSigner = {
     transfer: (params: LighterTransferParams) => Promise<[unknown, string, string | null]>;
 };
 export interface LighterWithdrawalConfig {
-    accountIndex: string;
+    /**
+     * The connected user's L1 address. The hook resolves the Lighter account
+     * index from this internally — get it from `useFunkitUserInfo` (or your
+     * own wallet hook) in the caller and pass it through.
+     */
+    l1Address: Address;
     /** Title shown on the selection screen. Defaults to "Withdraw". */
     modalTitle?: string;
     disableConnectedWallet?: boolean;
     fastIconSrc?: string;
     secureIconSrc?: string;
-    /** Pre-built Lighter signer. l1Address and accountIndex are resolved internally. */
+    /** Pre-built Lighter signer. */
     signerClient: LighterSigner;
     sendLighterSecureWithdrawal: LighterSecureWithdrawalExec;
     /**
@@ -54,8 +60,14 @@ export interface LighterWithdrawalConfig {
      * getSecureMinWithdrawalAmount: (symbol) => ({ USDC: 1, ETH: 0.001 }[symbol] ?? 0)
      * ```
      */
-    getSecureMinWithdrawalAmount?: (symbol: string) => number;
+    getSecureMinWithdrawalAmount?: (symbol: string) => number | undefined;
 }
+/**
+ * Default minimum Secure-withdrawal amounts (token units) for known Lighter
+ * assets. Used as a fallback when `LighterWithdrawalConfig.getSecureMinWithdrawalAmount`
+ * is omitted or returns `undefined` for a symbol.
+ */
+export declare const LIGHTER_DEFAULT_SECURE_MIN_WITHDRAWAL_AMOUNTS: Record<string, number>;
 export interface LighterSecureWithdrawalCallbackParams {
     /** Withdrawal amount in token units (e.g. "1.5" for 1.5 ETH). */
     amountTokenUnits: string;
@@ -100,35 +112,30 @@ export declare function useLighterWithdrawalBalances({ accountIndex, }: {
 /** Single-method config for Lighter's Secure withdrawal (bridge to Ethereum). */
 export declare function createLighterSecureWithdrawalConfig(config: LighterSecureWithdrawalConfig): CustomWithdrawalConfig;
 /**
- * Hook version of {@link createLighterWithdrawalConfig}.
+ * The single React entry point for Lighter withdrawals. Returns a
+ * `MultiMethodWithdrawalConfig` ready to hand to the withdrawal modal, or
+ * `null` while the inputs aren't ready yet.
  *
- * Fetches all Lighter asset balances for `config.accountIndex` and injects them as
- * `withdrawalSourceTokenBalance` into each method's config so the withdrawal
- * form displays and validates against the real Lighter account balance.
+ * The hook owns every Lighter-specific concern that requires React context:
+ *   - the user's Lighter account index (resolved from `config.l1Address`)
+ *   - all Lighter asset balances (so the form validates against the real
+ *     account)
+ *   - the live Secure-withdrawal delay (`/api/v1/withdrawalDelay`)
+ *   - the active locale (so the disclaimer renders correctly)
  *
- * Drop-in replacement for `createLighterWithdrawalConfig` — call it in any
- * React component/hook and pass the result directly to the withdrawal modal:
+ * Pass `null` while prerequisites (wallet, signer, etc.) aren't ready — the
+ * hook always invokes its inner hooks (Rules of Hooks) and returns `null`
+ * until you supply a real config and the account resolves:
  *
  * ```tsx
- * const withdrawalConfig = useLighterWithdrawalConfig({
- *   accountIndex,
- *   sendLighterSecureWithdrawal: ...,
- * })
- * <WithdrawalModal config={withdrawalConfig} ... />
- * ```
- */
-export declare function useLighterWithdrawalConfig(config: LighterWithdrawalConfig): MultiMethodWithdrawalConfig;
-/**
- * Creates a full {@link MultiMethodWithdrawalConfig} for Lighter that renders
- * the Fast vs Secure selection screen before the standard withdrawal flow.
- *
- * Usage:
- * ```ts
- * const withdrawalConfig = createLighterWithdrawalConfig({
- *   accountIndex: '0',
- *   sendLighterSecureWithdrawal: async ({ amountTokenUnits, assetIndex }) => { ... },
- * })
+ * const { address: l1Address } = useFunkitUserInfo()
+ * const lighter = useLighterWithdrawalConfig(
+ *   userId && walletClient
+ *     ? { l1Address, signerClient, sendLighterSecureWithdrawal, ... }
+ *     : null,
+ * )
+ * if (!lighter) return { ready: false, disabledReason: '...' }
  * ```
  */
-export declare function createLighterWithdrawalConfig(config: LighterWithdrawalConfig): MultiMethodWithdrawalConfig;
+export declare function useLighterWithdrawalConfig(config: LighterWithdrawalConfig | null): MultiMethodWithdrawalConfig | null;
 export {};

package/dist/clients/lighter.js

@@ -3,7 +3,7 @@ import {
   AsyncImage,
   Box,
   useFunkitTranslation
-} from "./chunk-LMEQD56M.js";
+} from "./chunk-GCAV3VTB.js";
 import {
   logger
 } from "./chunk-H6F75ULR.js";
@@ -12,6 +12,7 @@ import {
 import { SOLANA_MAINNET_CHAIN_ID } from "@funkit/chains";
 import { RELAY_LIGHTER_CHAIN_ID } from "@funkit/fun-relay";
 import { retry } from "@lifeomic/attempt";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
 import i18next from "i18next";
 import React2, { useEffect, useMemo as useMemo2 } from "react";
 import { arbitrum, base, bsc, mainnet as mainnet2, optimism } from "viem/chains";
@@ -238,6 +239,16 @@ function useFunkitConfig() {
 }
 
 // src/utils/customer.ts
+async function getLighterAccountsByL1Address(address) {
+  const response = await fetch(
+    `https://mainnet.zklighter.elliot.ai/api/v1/accountsByL1Address?l1_address=${address}`
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to fetch lighter accounts: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data;
+}
 async function getLighterAccount(lookup, activeOnly) {
   const params = new URLSearchParams({
     by: lookup.by,
@@ -274,11 +285,75 @@ function useLighterAccount(lookup, options) {
     account: query.data?.accounts?.[0]
   };
 }
+function useLighterAccounts({
+  address
+}) {
+  const { apiKey } = useFunkitConfig();
+  const isLighter = isLighterxyzCustomer(apiKey);
+  const enabled = !!address && address !== "0x" && isLighter;
+  const query = useQuery({
+    queryKey: ["lighterAccounts", address],
+    queryFn: () => getLighterAccountsByL1Address(address),
+    enabled,
+    staleTime: Number.POSITIVE_INFINITY,
+    gcTime: Number.POSITIVE_INFINITY,
+    retry: false,
+    // allows us to always refetch the data but return the previous data until the new data is fetched
+    refetchOnMount: "always"
+  });
+  return {
+    ...query,
+    mainAccountIndex: query.data?.sub_accounts?.[0]?.index?.toString(),
+    subAccounts: query.data?.sub_accounts
+  };
+}
+
+// src/utils/timeFormat.ts
+import { formatSecondsToReadableForm } from "@funkit/utils";
+function formatSecondsTranslated(seconds, t, specifyUnderMinute = false, omitSeconds = false) {
+  return formatSecondsToReadableForm(seconds, specifyUnderMinute, omitSeconds, {
+    lessThanOneMin: t("time.lessThanOneMin"),
+    seconds: (count) => t("time.seconds", { count }),
+    minutes: (count) => t("time.minutes", { count }),
+    hours: (count) => t("time.hours", { count }),
+    secondsShort: (count) => t("time.secondsShort", { count })
+  });
+}
 
 // src/clients/lighter.tsx
 var LIGHTER_USDC_PERPS_ADDRESS = "0x0000000000000000000000000000000000000000";
 var MAINNET_USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
 var LIGHTER_API_BASE = "https://mainnet.zklighter.elliot.ai";
+async function getLighterWithdrawalDelay() {
+  const response = await fetch(`${LIGHTER_API_BASE}/api/v1/withdrawalDelay`);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch Lighter withdrawal delay: ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+function useLighterSecureDelayText() {
+  const { t } = useFunkitTranslation();
+  const query = useQuery2({
+    queryKey: ["lighterWithdrawalDelay"],
+    queryFn: getLighterWithdrawalDelay,
+    staleTime: 6e4,
+    retry: 2
+  });
+  const seconds = query.data?.seconds;
+  if (seconds === void 0 || !Number.isFinite(seconds) || seconds <= 0) {
+    return void 0;
+  }
+  return formatSecondsTranslated(
+    seconds,
+    t,
+    /*specifyUnderMinutes*/
+    false,
+    /*omitSeconds*/
+    true
+  );
+}
 var LIGHTER_TX_STATUS = {
   PENDING: 0,
   QUEUED: 1,
@@ -402,15 +477,20 @@ function createLighterAdaptedWallet({
     }
   };
 }
+var LIGHTER_DEFAULT_SECURE_MIN_WITHDRAWAL_AMOUNTS = {
+  USDC: 1,
+  ETH: 1e-3,
+  LIT: 1,
+  LINK: 0.1,
+  UNI: 0.2,
+  AAVE: 0.01,
+  SKY: 20,
+  LDO: 2,
+  AZTEC: 100
+};
 function freeBalance(balance, lockedBalance) {
   return String(Math.max(0, Number(balance) - Number(lockedBalance)));
 }
-function asLighterAccountIndex(s) {
-  if (!/^\d+$/.test(s)) {
-    throw new Error(`Invalid LighterAccountIndex: ${s}`);
-  }
-  return s;
-}
 function useLighterWithdrawalBalances({
   accountIndex
 }) {
@@ -578,23 +658,31 @@ var LIGHTER_FAST_PREVIEW_CHAIN_IDS = [
 var LIGHTER_SECURE_PREVIEW_CHAIN_IDS = [mainnet2.id];
 function buildLighterMultiMethodConfig({
   config,
+  accountIndex,
   t,
-  withBalance
+  withBalance,
+  secureDelayText
 }) {
   const fastConfig = buildLighterFastWalletWithdrawalConfig({
     signerClient: config.signerClient,
-    accountIndex: Number(config.accountIndex),
+    accountIndex: Number(accountIndex),
     modalTitle: config.modalTitle,
     disableConnectedWallet: config.disableConnectedWallet,
     iconSrc: config.fastIconSrc
   });
   const secureConfig = createLighterSecureWithdrawalConfig({
-    accountIndex: config.accountIndex,
+    accountIndex,
     modalTitle: config.modalTitle,
     disableConnectedWallet: config.disableConnectedWallet,
     iconSrc: config.secureIconSrc,
     sendLighterSecureWithdrawal: config.sendLighterSecureWithdrawal,
-    getMinWithdrawalAmount: config.getSecureMinWithdrawalAmount
+    getMinWithdrawalAmount: (symbol) => {
+      const userMin = config.getSecureMinWithdrawalAmount?.(symbol);
+      if (userMin !== void 0) {
+        return userMin;
+      }
+      return LIGHTER_DEFAULT_SECURE_MIN_WITHDRAWAL_AMOUNTS[symbol.toUpperCase()] ?? 0;
+    }
   });
   const fast = {
     id: "lighter-fast",
@@ -612,7 +700,12 @@ function buildLighterMultiMethodConfig({
   const secure = {
     id: "lighter-secure",
     keyText: t("withdrawal.methodSecure"),
-    subtitleText: t("withdrawal.secureDisclaimer"),
+    subtitleText: t("withdrawal.secureDisclaimer", {
+      // Until the live value loads, show the localized "60+ minutes"
+      // historical estimate. The "+" lives in the per-locale fallback string
+      // so it doesn't bleed into live values, which are exact.
+      delay: secureDelayText ?? t("withdrawal.secureFallbackDelay")
+    }),
     icon: /* @__PURE__ */ React2.createElement(EvmWallet, { size: 20 }),
     valueIcon: /* @__PURE__ */ React2.createElement(ChainIconStack, { chainIds: LIGHTER_SECURE_PREVIEW_CHAIN_IDS }),
     config: withBalance ? {
@@ -630,27 +723,30 @@ function buildLighterMultiMethodConfig({
 }
 function useLighterWithdrawalConfig(config) {
   const { t } = useFunkitTranslation();
+  const { mainAccountIndex } = useLighterAccounts({
+    address: config?.l1Address
+  });
+  const accountIndex = mainAccountIndex && /^\d+$/.test(mainAccountIndex) ? mainAccountIndex : void 0;
   const { balances } = useLighterWithdrawalBalances({
-    accountIndex: asLighterAccountIndex(config.accountIndex)
+    accountIndex
   });
-  return useMemo2(
-    () => buildLighterMultiMethodConfig({
+  const secureDelayText = useLighterSecureDelayText();
+  return useMemo2(() => {
+    if (!config || !accountIndex) {
+      return null;
+    }
+    return buildLighterMultiMethodConfig({
       config,
+      accountIndex,
       t,
-      withBalance: (symbol) => () => balances[symbol.toUpperCase()] ?? "0"
-    }),
-    [config, balances, t]
-  );
-}
-function createLighterWithdrawalConfig(config) {
-  return buildLighterMultiMethodConfig({
-    config,
-    t: i18next.t.bind(i18next)
-  });
+      withBalance: (symbol) => () => balances[symbol.toUpperCase()] ?? "0",
+      secureDelayText
+    });
+  }, [config, accountIndex, balances, t, secureDelayText]);
 }
 export {
+  LIGHTER_DEFAULT_SECURE_MIN_WITHDRAWAL_AMOUNTS,
   createLighterSecureWithdrawalConfig,
-  createLighterWithdrawalConfig,
   freeBalance,
   useLighterWithdrawalBalances,
   useLighterWithdrawalConfig

package/dist/clients/rolly.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Rolly deposit via VaultDepositor.
+ *
+ * Deposit flow wraps Rolly's `depositToken()` call inside the VaultDepositor
+ * proxy so it composes with EXACT_INPUT quoting:
+ *   1. approve(USDT, VAULT_DEPOSITOR[mainnet], MAX)
+ *   2. VAULT_DEPOSITOR[mainnet].deposit(USDT, ROLLY_VAULT,
+ *        depositToken(recipient, AMOUNT_PLACEHOLDER), 0)
+ * VaultDepositor pulls the msg.sender's full USDT balance at exec time and
+ * substitutes AMOUNT_PLACEHOLDER with the actual amount before calling
+ * Rolly.depositToken, so the arrival amount doesn't need to be known at quote
+ * time.
+ */
+import { type Address } from 'viem';
+import type { FunkitCheckoutActionParams } from '../providers/FunkitCheckoutContext/types';
+/** Rolly rollup deposit contract on Ethereum mainnet (UUPS proxy). */
+export declare const ROLLY_VAULT_ADDRESS: `0x${string}`;
+/** Ethereum mainnet USDT — Rolly's source deposit token. */
+export declare const MAINNET_USDT: `0x${string}`;
+/** VaultDepositor on Ethereum mainnet — same address used by other VaultDepositor flows. */
+export declare const VAULT_DEPOSITOR_MAINNET: `0x${string}`;
+/** Sentinel value the VaultDepositor replaces with the actual deposit amount at exec time. */
+export declare const AMOUNT_PLACEHOLDER = 115792089237316195423570985008687907853269984665640564039457584007912570601199n;
+export interface RollyDepositActionsConfig {
+    /** Address credited on the Rolly rollup (typically the connected wallet). */
+    recipientAddress: Address | undefined;
+}
+/**
+ * Builds the `generateActionsParams` callback for a Rolly deposit routed
+ * through VaultDepositor.
+ *
+ * Usage:
+ * ```ts
+ * const checkoutConfig: FunkitCheckoutConfig = {
+ *   // ...
+ *   generateActionsParams: createRollyDepositActions({
+ *     recipientAddress: walletAddress,
+ *   }),
+ * }
+ * ```
+ */
+export declare function createRollyDepositActions(config: RollyDepositActionsConfig): () => Promise<FunkitCheckoutActionParams[]>;

package/dist/clients/rolly.js

@@ -0,0 +1,91 @@
+"use client";
+
+// src/clients/rolly.tsx
+import {
+  encodeFunctionData,
+  erc20Abi,
+  getAddress,
+  maxUint256
+} from "viem";
+var ROLLY_VAULT_ADDRESS = getAddress(
+  "0x6e6B003F801c4532350858431d893B04317734C4"
+);
+var MAINNET_USDT = getAddress(
+  "0xdAC17F958D2ee523a2206206994597C13D831ec7"
+);
+var VAULT_DEPOSITOR_MAINNET = getAddress(
+  "0x64Aa32cd125FB32F4286d2bAC3a7346edFffEe2A"
+);
+var AMOUNT_PLACEHOLDER = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffdeadbeefn;
+var ROLLY_VAULT_ABI = [
+  {
+    name: "depositToken",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var VAULT_DEPOSITOR_ABI = [
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "vault", type: "address" },
+      { name: "callData", type: "bytes" },
+      { name: "minAmountOut", type: "uint256" }
+    ],
+    outputs: [{ name: "returnData", type: "bytes" }]
+  }
+];
+function createRollyDepositActions(config) {
+  const { recipientAddress } = config;
+  return async () => {
+    if (!recipientAddress) {
+      throw new Error(
+        "Please connect your wallet before starting a Rolly deposit"
+      );
+    }
+    const depositCalldata = encodeFunctionData({
+      abi: ROLLY_VAULT_ABI,
+      functionName: "depositToken",
+      args: [recipientAddress, AMOUNT_PLACEHOLDER]
+    });
+    return [
+      // Step 1: Reset USDT approval
+      {
+        contractAbi: erc20Abi,
+        contractAddress: MAINNET_USDT,
+        functionName: "approve",
+        functionArgs: [VAULT_DEPOSITOR_MAINNET, 0n]
+      },
+      // Step 2: Approve USDT to VaultDepositor (infinite)
+      {
+        contractAbi: erc20Abi,
+        contractAddress: MAINNET_USDT,
+        functionName: "approve",
+        functionArgs: [VAULT_DEPOSITOR_MAINNET, maxUint256]
+      },
+      // Step 3: VaultDepositor pulls USDT, swaps placeholder, forwards to
+      // Rolly.depositToken → credits recipient on the rollup
+      {
+        contractAbi: VAULT_DEPOSITOR_ABI,
+        contractAddress: VAULT_DEPOSITOR_MAINNET,
+        functionName: "deposit",
+        functionArgs: [MAINNET_USDT, ROLLY_VAULT_ADDRESS, depositCalldata, 0n]
+      }
+    ];
+  };
+}
+export {
+  AMOUNT_PLACEHOLDER,
+  MAINNET_USDT,
+  ROLLY_VAULT_ADDRESS,
+  VAULT_DEPOSITOR_MAINNET,
+  createRollyDepositActions
+};

package/dist/components/Dropdown/TokenAndChainDropdown.css.d.ts

@@ -0,0 +1 @@
+export declare const hideOnXsmallScreenSize: string;

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/statsig/checkFeatureGate.d.ts

@@ -0,0 +1,19 @@
+import fallbackFeatureGates from '../../__generated__/default_feature_gates';
+type FeatureGateName = keyof typeof fallbackFeatureGates;
+/**
+ * Synchronous, non-hook variant of {@link useFeatureGate}. Reads the gate
+ * value directly from the connect package's Statsig client singleton.
+ *
+ * Use this from non-React contexts (event handlers, async callbacks created
+ * outside render) where calling a hook is not possible. Behavior:
+ * - Returns the live gate value once `FunkitStatsigProvider`'s async init
+ *   has resolved (typical case for event-driven calls — by the time a user
+ *   clicks a button, init has long since completed).
+ * - Returns the bundled default if called before init completes or if the
+ *   provider has not been mounted (graceful fallback rather than throw).
+ *
+ * For render-time consumers, prefer {@link useFeatureGate} so the consumer
+ * re-renders when values update mid-session.
+ */
+export declare function checkFeatureGate(name: FeatureGateName): boolean;
+export {};

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

@@ -0,0 +1,60 @@
+import React, { type ReactNode } from 'react';
+import type { FunCheckoutStep } from '../../modals/CheckoutModal/FunCheckoutStep';
+/**
+ * Read-only per-session metadata auto-attached by {@link useTrack} to every
+ * Statsig event emitted inside the checkout modal tree. All three fields
+ * already exist on the state machine — this context just surfaces them:
+ *
+ *   - `checkoutId`    — `modalState.checkoutId` (client-generated UUID from
+ *                       `initNewCheckout`). Joins Statsig events to
+ *                       `analytics.checkouts` in Redshift.
+ *   - `step`          — `modalState.step` (current `FunCheckoutStep`).
+ *   - `modalOpenedAt` — `checkoutItem.startTimestampMs`. `useTrack` derives
+ *                       `time_since_modal_ms` = `Date.now() - modalOpenedAt`
+ *                       at emission time.
+ *
+ * Outside the provider (e.g. `useTrack` called from a non-checkout surface)
+ * every field is `null` and `useTrack` elides the attachment.
+ */
+export interface CheckoutTrackingContextValue {
+    checkoutId: string | null;
+    step: FunCheckoutStep | null;
+    modalOpenedAt: number | null;
+}
+interface CheckoutTrackingProviderProps extends CheckoutTrackingContextValue {
+    children: ReactNode;
+}
+/**
+ * Root provider. Memoizes `value` against the three primitive fields so
+ * consumers only re-render when one of them actually changes (not on
+ * every parent render). The three fields are already-derived state owned
+ * by `FunCheckoutModal` / `useCheckoutModalTransition`; we surface them
+ * here rather than duplicating storage.
+ */
+export declare function CheckoutTrackingProvider({ children, checkoutId, step, modalOpenedAt, }: CheckoutTrackingProviderProps): React.JSX.Element;
+export declare function useCheckoutTrackingContext(): CheckoutTrackingContextValue;
+/**
+ * Build the shared-metadata fields (`checkoutId`, `step`,
+ * `time_since_modal_ms`) inline at emission sites that run *outside* this
+ * provider and therefore can't use `useTrack`'s auto-attach.
+ *
+ * Those sites are:
+ *  - `FunkitCheckoutContext.initNewCheckout` — modal not mounted yet
+ *  - `FunkitCheckoutContext.confirmCheckout` — app-level, above the modal
+ *  - `useCheckoutModalTransition.{trackNextState,onBack,onCloseWrapper}` —
+ *    the hook that *produces* the provider's value; it cannot also
+ *    consume it
+ *
+ * Keep this as a pure helper — no hooks. The three fields mirror the
+ * contract in {@link CheckoutTrackingContextValue}; any new auto-attached
+ * field should be added to both in the same commit.
+ */
+export declare function buildCheckoutSessionMetadata(checkoutItem: {
+    id: string;
+    startTimestampMs: number;
+}, step: FunCheckoutStep): {
+    checkoutId: string;
+    step: FunCheckoutStep;
+    time_since_modal_ms: string;
+};
+export {};

package/dist/hooks/useExchangeOptions.d.ts

@@ -0,0 +1,10 @@
+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;
+}): BrokerageOption[];

package/dist/hooks/useTokenChain.d.ts

@@ -0,0 +1,21 @@
+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;
+    handleChainChange: (chainId?: number, autoUpdate?: boolean) => void;
+    selectedToken: string;
+    selectedChainName: string;
+    handleTokenChange: (token: string, chainId?: number, autoUpdate?: boolean) => void;
+}
+/**
+ * Semi reusable hook (tied into token transfer configuration)
+ * ensures token&chain dropdown preselection logic is reusable
+ * @param transferInit - used for chain&token solana filtering, can be omitted if not needed
+ */
+export declare const useTokenAndChainSelection: (transferInit: CheckoutInitTokenTransferResponse | undefined, defaultValues?: TransferTokenDefault, isWithdrawal?: boolean) => UseTokenChainResult;
+export {};