@funkit/connect 0.0.0-20260710210119

package/dist/modals/PolymarketPerpsTransfer/TransferAmountRow.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+export interface TransferAmountRowProps {
+    /** "From" / "To" prefix (already translated). */
+    relationLabel: string;
+    /** Account name, e.g. "Predictions" / "Perps". */
+    accountLabel: string;
+    /** Account balance in USD; rendered floored to the cent as "$X,XXX.XX". */
+    balanceUsd: number;
+    /**
+     * The source row is the editable side: it owns the input + Max button and
+     * gets the active border. The destination row mirrors the amount read-only
+     * and has no Max button.
+     */
+    isSource: boolean;
+    /** Controlled amount string (raw user input; may contain separators). */
+    amount: string;
+    onAmountChange?: (next: string) => void;
+    onMax?: () => void;
+    testId?: string;
+}
+/**
+ * A single From/To account row in the Perps ⇄ Predictions transfer screen.
+ * Top line shows the relation + account name, the account balance, and — on the
+ * source row — a Max button; the bottom line shows the (large) amount and, on
+ * the source row, the `pUSD` denomination.
+ */
+export declare function TransferAmountRow({ relationLabel, accountLabel, balanceUsd, isSource, amount, onAmountChange, onMax, testId, }: TransferAmountRowProps): React.JSX.Element;

package/dist/modals/PolymarketPerpsTransfer/usePerpsTransferContent.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+import type { PerpsTransferDirection, PerpsTransferStatus } from './PolymarketPerpsTransferScreen';
+/**
+ * pUSD has 6 on-chain decimals, so balances carry up to 6 decimal places. We
+ * render only the decimals actually present, up to 6: capping at 2 rounded
+ * `196.867461` *up* to `196.87`, so Max filled a value above the real balance
+ * and tripped the insufficient-balance guard. At 6 decimals the value is
+ * reproduced exactly. There is no minimum, so trailing zeros are trimmed —
+ * a `1.1` balance fills as `1.1`, not `1.100000` (or `1.10`).
+ */
+export declare function formatAmountValue(value: number): string;
+export interface PerpsTransferContentProps {
+    predictionsBalanceUsd: number;
+    perpsBalanceUsd: number;
+    /** Minimum pUSD to transfer *into* predictions (USD). */
+    predictionsMinTransferUsd?: number;
+    /** Minimum pUSD to transfer *into* perps (USD). */
+    perpsMinTransferUsd?: number;
+    initialDirection?: PerpsTransferDirection;
+    initialAmount?: string;
+    status?: PerpsTransferStatus;
+    onTransfer: (params: {
+        /** Exact string the user entered (validated numeric, ≤6 decimals). */
+        amountUsd: string;
+        direction: PerpsTransferDirection;
+    }) => void;
+}
+/**
+ * Owns the Perps ⇄ Predictions transfer state and builds the two pieces of the
+ * screen — the From/To pills (`pills`) and the notice + Transfer button
+ * (`bottomBar`) — so both the standalone {@link PolymarketPerpsTransferScreen}
+ * (Dialog) and the in-modal `PerpsTransferStep` (renders pills inline + portals
+ * the bottom bar) can share identical behavior.
+ */
+export declare function usePerpsTransferContent({ predictionsBalanceUsd, perpsBalanceUsd, predictionsMinTransferUsd, perpsMinTransferUsd, initialDirection, initialAmount, status, onTransfer, }: PerpsTransferContentProps): {
+    pills: ReactNode;
+    bottomBar: ReactNode;
+};

package/dist/modals/PolymarketPerpsTransfer/usePerpsTransferForm.d.ts

@@ -0,0 +1,66 @@
+import type { PerpsTransferDirection, PerpsTransferStatus } from './PolymarketPerpsTransferScreen';
+/**
+ * pUSD has 6 on-chain decimals, so balances carry up to 6 decimal places. We
+ * render only the decimals actually present, up to 6: capping at 2 rounded
+ * `196.867461` *up* to `196.87`, so Max filled a value above the real balance
+ * and tripped the insufficient-balance guard. At 6 decimals the value is
+ * reproduced exactly. There is no minimum, so trailing zeros are trimmed —
+ * a `1.1` balance fills as `1.1`, not `1.100000` (or `1.10`).
+ *
+ * Not `formatCurrencyAndStringify` — that helper produces a 2-decimal `$`
+ * display string, while this fills the editable input with an exact,
+ * re-parsable pUSD amount.
+ */
+export declare function formatAmountValue(value: number): string;
+export interface PerpsTransferFormProps {
+    predictionsBalanceUsd: number;
+    perpsBalanceUsd: number;
+    /** Minimum pUSD to transfer *into* predictions (USD). */
+    predictionsMinTransferUsd?: number;
+    /** Minimum pUSD to transfer *into* perps (USD). */
+    perpsMinTransferUsd?: number;
+    initialDirection?: PerpsTransferDirection;
+    /** Initial amount input string (pUSD). */
+    initialAmountUsd?: string;
+    status?: PerpsTransferStatus;
+    onTransfer: (params: {
+        /** Exact string the user entered (validated numeric, ≤6 decimals). */
+        amountUsd: string;
+        direction: PerpsTransferDirection;
+    }) => void;
+}
+export interface PerpsTransferAccount {
+    /** Localized account name ("Predictions" / "Perps"). */
+    label: string;
+    balanceUsd: number;
+}
+/** Plain form state consumed by `PerpsTransferRows` and `PerpsTransferBottomBar`. */
+export interface PerpsTransferForm {
+    /** Raw amount input string (may contain separators). */
+    amount: string;
+    /** Validated setter — ignores input that isn't numeric with ≤6 decimals. */
+    setAmount: (next: string) => void;
+    /** Fills the amount with the source balance at full 6-decimal precision. */
+    fillMaxAmount: () => void;
+    swapDirection: () => void;
+    /** The editable "From" account. */
+    source: PerpsTransferAccount;
+    /** The read-only "To" account mirroring the source. */
+    destination: PerpsTransferAccount;
+    /** Validation/error notice line; `null` when nothing should be shown. */
+    noticeText: string | null;
+    /** Status for the action button (`error` is remapped to a retry-able idle). */
+    buttonStatus: PerpsTransferStatus;
+    isTransferDisabled: boolean;
+    /** Reports the entered amount + direction via the host's `onTransfer`. */
+    requestTransfer: () => void;
+}
+/**
+ * Owns the Perps ⇄ Predictions transfer form state — amount, direction, and
+ * the derived validation/notice/button values — so both the standalone
+ * {@link PolymarketPerpsTransferScreen} (Dialog) and the in-modal
+ * `PerpsTransferStep` (renders rows inline + portals the bottom bar) share
+ * identical behavior. Returns plain values; `PerpsTransferRows` and
+ * `PerpsTransferBottomBar` render them.
+ */
+export declare function usePerpsTransferForm({ predictionsBalanceUsd, perpsBalanceUsd, predictionsMinTransferUsd, perpsMinTransferUsd, initialDirection, initialAmountUsd, status, onTransfer, }: PerpsTransferFormProps): PerpsTransferForm;

package/dist/modals/ProfileDetails/ActivityTraversalContext.d.ts

@@ -0,0 +1,38 @@
+import React, { type ReactNode } from 'react';
+import type { StateSnapshot } from 'react-virtuoso';
+import type { Hex } from 'viem';
+import type { HistoryContentPages } from '../../utils/checkoutHistory';
+import type { SelectedHomeTab } from './FunProfileViews/Home';
+import type { FunProfileView } from './ProfileDetails';
+export interface ReturnViewPresets {
+    selectedView?: SelectedHomeTab;
+    scrollState?: StateSnapshot;
+}
+export interface BaseActivitySelection {
+    checkoutId: Hex;
+    initialPage: HistoryContentPages;
+    returnViewPresets: ReturnViewPresets;
+}
+export interface ActivitySelection extends BaseActivitySelection {
+    onRedirect: () => void;
+    returnView: FunProfileView;
+}
+export declare const ActivityTraversalContext: React.Context<{
+    selectedPurchaseId: `0x${string}` | undefined;
+    selectedPurchaseInitView: HistoryContentPages | undefined;
+    returnView: FunProfileView | undefined;
+    returnViewPresets: ReturnViewPresets;
+    onSelectActivity: ({ checkoutId, initialPage, returnView, returnViewPresets, onRedirect, }: ActivitySelection) => void;
+    resetActivityTraversal: () => void;
+}>;
+export declare const ActivityTraversalProvider: ({ children, }: {
+    children: ReactNode;
+}) => React.JSX.Element;
+export declare const useActivityTraversal: () => {
+    selectedPurchaseId: `0x${string}` | undefined;
+    selectedPurchaseInitView: HistoryContentPages | undefined;
+    returnView: FunProfileView | undefined;
+    returnViewPresets: ReturnViewPresets;
+    onSelectActivity: ({ checkoutId, initialPage, returnView, returnViewPresets, onRedirect, }: ActivitySelection) => void;
+    resetActivityTraversal: () => void;
+};

package/dist/modals/ProfileDetails/FunProfileViews/Home/BalanceSection.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface BalanceSectionProps {
+    totalBalance: number;
+}
+export declare const BalanceSection: ({ totalBalance }: BalanceSectionProps) => React.JSX.Element;
+export {};

package/dist/modals/ProfileDetails/FunProfileViews/Home/Home.css.d.ts

@@ -0,0 +1,4 @@
+export declare const animateTitleInClass: string;
+export declare const animateTitleOutClass: string;
+export declare const animateVirtuosoInClass: string;
+export declare const tabLabelStyles: string;

package/dist/modals/ProfileDetails/FunProfileViews/Home/HomeCheckoutDisplayRow.css.d.ts

@@ -0,0 +1,2 @@
+export declare const baseStyles: string;
+export declare const homeCheckoutDisplayRowStyle: Record<"hoverBackground" | "defaultBorder" | "defaultBackground", string>;

package/dist/modals/ProfileDetails/FunProfileViews/Home/HomeCheckoutDisplayRow.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Hex } from 'viem';
+import type { MergedCheckoutHistoryItem } from '../../../../utils/checkout';
+import { HistoryContentPages } from '../../../../utils/checkoutHistory';
+export declare const HomeCheckoutDisplayRow: ({ checkoutHistoryItem, onSelect, }: {
+    checkoutHistoryItem: MergedCheckoutHistoryItem;
+    onSelect: (checkoutId: Hex, initialPage: HistoryContentPages) => void;
+}) => React.JSX.Element;
+export declare const HomeCheckoutDisplayRowSkeleton: () => React.JSX.Element;

package/dist/modals/ProfileDetails/FunProfileViews/Home/HomeTokenDisplayRow.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { KnownAssetBalanceInfo } from '../../../../providers/GeneralWalletProvider';
+export declare const HomeTokenBalanceDisplayRow: ({ asset, }: {
+    asset: KnownAssetBalanceInfo;
+}) => React.JSX.Element;
+export declare const HomeTokenBalanceDisplayRowSkeleton: () => React.JSX.Element;

package/dist/modals/ProfileDetails/FunProfileViews/Home/ProfileTitleSection.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { FunkitUserInfo } from '../../../../consts/funkit';
+import type { Config, UseAccountReturnType } from '../../../../wagmi/hooks';
+import { FunProfileView } from '../../ProfileDetails';
+export declare const ProfileTitleSection: ({ animateOut, account, userInfo, onChangeView, onLogout, onClose, }: {
+    animateOut?: boolean;
+    account: UseAccountReturnType<Config>;
+    userInfo: FunkitUserInfo;
+    onChangeView: (newView: FunProfileView) => void;
+    onLogout: () => void;
+    onClose: () => void;
+}) => React.JSX.Element;

package/dist/modals/ProfileDetails/FunProfileViews/Home/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type AnimationState } from '../../../../hooks/useAnimatedNavigation';
+import { type BaseActivitySelection } from '../../ActivityTraversalContext';
+import type { FunProfileView } from '../../ProfileDetails';
+export declare enum SelectedHomeTab {
+    ASSETS = "assets",
+    CHECKOUTS = "checkouts"
+}
+export declare function Home({ onClose, onChangeView, onSelectActivity, defaultHomeTab, animation, }: {
+    onClose: () => void;
+    onChangeView: (newView: FunProfileView) => void;
+    onSelectActivity: (activity: BaseActivitySelection) => void;
+    defaultHomeTab?: SelectedHomeTab;
+    animation: AnimationState;
+}): React.JSX.Element;

package/dist/modals/ProfileDetails/FunProfileViews/Settings/Settings.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare function LineItem({ label, value, valueSuffix, }: {
+    label: string;
+    value: string;
+    valueSuffix?: React.ReactNode;
+}): React.JSX.Element;
+export declare function Settings(): React.JSX.Element;

package/dist/modals/ProfileDetails/ProfileDetails.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { SelectedHomeTab } from './FunProfileViews/Home';
+export declare enum FunProfileView {
+    HOME = 0,
+    SETTINGS = 1,
+    SINGLE_ACTIVITY = 3
+}
+interface ProfileDetailsProps {
+    onClose: () => void;
+    defaultTab: SelectedHomeTab | null;
+}
+export declare function ProfileDetails({ onClose, defaultTab }: ProfileDetailsProps): React.JSX.Element;
+export {};

package/dist/modals/WithdrawalModal/ErrorMessage.d.ts

@@ -0,0 +1,10 @@
+import type { TFunction } from 'i18next';
+import type { ErrorNotification } from '../../components/FunNotification/FunNotification';
+import type { CheckoutConfirmationError } from '../../domains/checkoutErrors';
+export declare function getErrorNotification({ quoteErrorObject, withdrawalError, targetAssetFetchError, riskCheckError, t, }: {
+    quoteErrorObject: Error | null;
+    withdrawalError: CheckoutConfirmationError | null;
+    targetAssetFetchError: Error | null;
+    riskCheckError: Error | null;
+    t: TFunction;
+}): ErrorNotification | null;

package/dist/modals/WithdrawalModal/LighterWithdrawal.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Lighter-specific withdrawal helpers, hooks, and display components.
+ *
+ * Extracted from WithdrawalContent.tsx to keep Lighter-specific logic isolated.
+ */
+import type { LighterAccountIndex } from '@funkit/api-base';
+import React from 'react';
+import type { Address } from 'viem';
+import type { CustomWithdrawalConfig, LighterRouteType, WalletWithdrawalConfig } from '../../providers/FunkitCheckoutContext';
+import type { LighterShare } from '../../utils/customer';
+import type { SourceTokenOption } from './WithdrawAmountInput';
+/** Stable method ids for the Fast / Secure options (used for tracking + switching). */
+export declare const LIGHTER_FAST_METHOD_ID = "lighter-fast";
+export declare const LIGHTER_SECURE_METHOD_ID = "lighter-secure";
+/**
+ * USDC exists twice on a Lighter account: as perps collateral
+ * (`total_asset_value`, withdrawn via route 0) and as a spot asset balance
+ * (asset entry 3, withdrawn via route 1). The Secure dropdown keys selection
+ * by `symbol`, so the spot variant gets a pseudo-symbol to stay selectable
+ * alongside the plain `USDC` (perps) entry.
+ */
+export declare const LIGHTER_USDC_SPOT_SYMBOL = "USDC (Spot)";
+/** Lighter L2 route types (`RouteType` in the withdraw/transfer tx payload). */
+export declare const LIGHTER_ROUTE_TYPE: {
+    readonly PERPS: 0;
+    readonly SPOT: 1;
+};
+/**
+ * Strips the ` (Spot)` / ` (Perps)` variant suffix off a Lighter source-token
+ * selection, returning the real token symbol (e.g. `USDC (Spot)` → `USDC`).
+ * Symbol-keyed lookups (icons, prices, asset indices, min amounts) operate on
+ * the base symbol; only selection identity and route resolution keep the suffix.
+ */
+export declare function getLighterBaseSymbol(symbol: string): string;
+/**
+ * Resolves the Lighter L2 route type for a Secure source-token selection.
+ * Plain `USDC` withdraws perps collateral (route 0); everything else —
+ * including the `USDC (Spot)` pseudo-symbol — is a spot asset (route 1).
+ */
+export declare function resolveLighterSecureRouteType(selectedSourceToken: string): LighterRouteType;
+/**
+ * Mainnet ERC-20 address for a Lighter Secure source token symbol, or undefined
+ * if the symbol isn't a known Secure asset.
+ */
+export declare function getLighterSecureMainnetAddress(symbol: string): Address | undefined;
+/**
+ * Upper bound on a single Lighter Fast withdrawal, in USD. Amounts above this
+ * block the CTA and surface the "submit a Secure withdrawal" footer. Fast is
+ * USDC Perps only (price = 1), so this is also the token-unit cap.
+ * {@link LIGHTER_FAST_MAX_WITHDRAWAL_LABEL} must stay in sync with this value.
+ */
+export declare const LIGHTER_FAST_MAX_WITHDRAWAL_USD = 3000000;
+/**
+ * Footer shown beneath the CTA when a Lighter Fast amount exceeds the $3M cap.
+ * Renders as the `description` of a FunNotification, which supplies the shared
+ * notification typography; offers an inline link to switch to the Secure method.
+ */
+export declare function LighterFastMaxExceededMessage({ onSwitchToSecure, }: {
+    onSwitchToSecure: () => void;
+}): React.JSX.Element;
+/** Free (withdrawable) balance for a single Lighter asset: balance - locked. */
+export declare function freeBalance(balance: string, lockedBalance: string): string;
+/**
+ * Lighter Fast charges an "unstaked" fee — a flat deduction taken off the
+ * withdrawal amount before quoting — for users who aren't sufficiently staked
+ * in Lighter's staking pool. Sufficiently-staked users pay nothing.
+ *
+ * "Sufficiently staked" = the user holds a share in the staking pool with a
+ * principal above the threshold. The staking pool is identified by its index,
+ * hardcoded here (previously read from `systemConfig.staking_pool_index`) since
+ * it's currently the only public pool a withdrawing user holds a share in.
+ * Non-stakers report `shares: []`.
+ */
+export declare const LIGHTER_STAKING_POOL_INDEX = 281474976624800;
+export declare const LIGHTER_UNSTAKED_FEE_TOKENS = 3;
+export declare const LIGHTER_STAKING_PRINCIPAL_THRESHOLD = 100;
+/**
+ * Resolves the Lighter Fast unstaked fee (in source tokens, i.e. USDC) for a
+ * user. Returns 0 when the user's staking-pool principal exceeds the threshold,
+ * otherwise {@link LIGHTER_UNSTAKED_FEE_TOKENS}. A non-staker (`shares: []`,
+ * or no staking-pool share) pays the fee.
+ */
+export declare function resolveLighterUnstakedFeeTokens(shares: LighterShare[]): number;
+/**
+ * Deducts the Lighter Fast unstaked fee from a withdrawal input amount, clamped
+ * at 0. Uses `dnum` fixed-point math so the subtraction stays exact (e.g. the
+ * input is a decimal string straight from the amount field).
+ */
+export declare function deductLighterUnstakedFee(inputAmount: string, feeTokens: number): string;
+/**
+ * Fetches all asset balances for a Lighter account. Returns:
+ *
+ * - `balances` — `Record<SYMBOL, freeBalance>` (uppercased symbol keys)
+ * - `assets` — raw asset list from the API (for building source-token options)
+ */
+export declare function useLighterWithdrawalBalances({ accountIndex, }: {
+    accountIndex: LighterAccountIndex | undefined;
+}): {
+    balances: Record<string, string>;
+    assets: import("../../utils/customer").LighterAsset[];
+    shares: LighterShare[];
+    isLoading: boolean;
+};
+type FunkitWithdrawalConfig = WalletWithdrawalConfig | CustomWithdrawalConfig;
+/**
+ * Resolves the Lighter `asset_id` for a selected source token symbol. Returns
+ * `undefined` when the token isn't in the fetched assets list (e.g. timing
+ * race before balances load, or an invalid selection) — callers should treat
+ * that as "not ready to submit" rather than falling back to `0`, which would
+ * silently target the wrong Lighter asset.
+ */
+export declare function resolveLighterAssetIndex(lighterAssets: {
+    symbol: string;
+    asset_id: number;
+}[], selectedSourceToken: string): number | undefined;
+/**
+ * Builds the source-token options list for the Lighter compound input dropdown.
+ *
+ * - Fast path: only USDC (Perps).
+ * - Secure path: USDC (Perps) (from total_asset_value) + USDC (Spot) when the
+ *   account carries a spot USDC asset + every non-USDC asset on the account.
+ *
+ * Unified Trading accounts (`isUnifiedTradingMode`) have a single USDC balance
+ * — no spot/perps split — so the perps entry is labeled plain `USDC` and the
+ * `USDC (Spot)` entry is hidden on both paths.
+ */
+export declare function buildLighterSourceTokenOptions(config: FunkitWithdrawalConfig, lighterAssets: {
+    symbol: string;
+}[], isUnifiedTradingMode?: boolean): SourceTokenOption[];
+/**
+ * Detects Lighter Secure withdrawal (mainnet source chain), auto-fills the
+ * recipient address with the connected wallet, and fetches the Lighter account
+ * so per-asset balances are available to the withdrawal form.
+ */
+export declare function useLighterWithdrawal(config: FunkitWithdrawalConfig, setRecipientAddress: (addr: string) => void): {
+    isLighterSecure: boolean;
+    isLighterFast: boolean;
+    isUnifiedTradingMode: boolean;
+    connectedAddress: `0x${string}` | undefined;
+    lighterBalances: Record<string, string>;
+    lighterAssets: import("../../utils/customer").LighterAsset[];
+    lighterFastUnstakedFee: number;
+    invalidateLighterAccount: () => void;
+};
+/**
+ * Resolves the source-token dropdown options for a Lighter customer.
+ * Returns `undefined` for non-Lighter customers (no dropdown needed).
+ */
+export declare function useLighterSourceTokenOptions(config: FunkitWithdrawalConfig, apiKey: string, lighterAssets: {
+    symbol: string;
+}[], isUnifiedTradingMode?: boolean): SourceTokenOption[] | undefined;
+/**
+ * Lighter Secure: recipient address, locked to the connected wallet. A
+ * read-only `FunInput` (not a `<div>`) keeps it focusable and announced by
+ * screen readers; the hover tooltip explains the lock.
+ */
+export declare function LighterSecureAddressDisplay({ address }: {
+    address: string;
+}): React.JSX.Element;
+/**
+ * Lighter Secure: display-only receive token + chain. Both are locked — the
+ * token always matches the source asset, and the destination chain is always
+ * Ethereum mainnet. Each field surfaces a hover tooltip explaining the lock.
+ */
+export declare function LighterSecureReceiveDisplay({ sourceTokenSymbol: rawSourceTokenSymbol, }: {
+    sourceTokenSymbol: string;
+}): React.JSX.Element;
+/**
+ * Lighter Secure: receive amount value (1:1 — same token, no swap).
+ */
+export declare function LighterSecureReceiveAmountValue({ amount, tokenSymbol: rawTokenSymbol, }: {
+    amount: string;
+    tokenSymbol: string;
+}): React.JSX.Element;
+export declare function LighterSecureWithdrawalSuccess({ onClose, onNewWithdrawal, amount, tokenSymbol: rawTokenSymbol, txHash, }: {
+    onClose: () => void;
+    onNewWithdrawal: () => void;
+    amount: string;
+    tokenSymbol: string;
+    txHash: string;
+}): React.JSX.Element;
+export {};

package/dist/modals/WithdrawalModal/RecipientAddress.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { FunkitWithdrawalConfig } from '../../providers/FunkitCheckoutContext';
+/**
+ * Whether to offer the "Use connected wallet" recipient shortcut: shown when a
+ * wallet is connected and the integrator hasn't set `disableConnectedWallet`.
+ * Independent of the withdrawal source address — for connected-wallet
+ * withdrawals (e.g. Mallard) the source IS the connected wallet, and
+ * withdrawing to it on the destination chain is valid.
+ */
+export declare function shouldShowUseConnectedWallet({ disableConnectedWallet, isConnected, connectedWalletAddress, }: {
+    disableConnectedWallet: boolean | undefined;
+    isConnected: boolean;
+    connectedWalletAddress: string | undefined;
+}): boolean;
+export declare function WithdrawRecipientAddress({ config, recipientAddress, setRecipientAddress, selectedChainId, selectedToken, isValidAddress, isRiskyAddress, }: {
+    config: FunkitWithdrawalConfig;
+    recipientAddress: string;
+    setRecipientAddress: (s: string) => void;
+    selectedChainId: number | undefined;
+    selectedToken: string | undefined;
+    isValidAddress: boolean;
+    isRiskyAddress: boolean;
+}): React.JSX.Element;

package/dist/modals/WithdrawalModal/WithdrawAmountInput.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { FunkitWithdrawalConfig, MultiMethodWithdrawalConfig } from '../../providers/FunkitCheckoutContext';
+export interface SourceTokenOption {
+    symbol: string;
+    /** Display label (may differ from symbol, e.g. "USDC (Perps)") */
+    label: string;
+    iconSrc?: string;
+}
+export declare function WithdrawAmountInput({ withdrawalInputAmount, setWithdrawalInputAmount, sourceTokenBalance, isWithdrawAmountTooLow, isWithdrawAmountTooHigh, isWithdrawAmountAboveBalance, isWithdrawAmountValid, minWithdrawalDisplayValue, config, sourceTokenOptions, onSourceTokenChange, selectedSourceToken, sourceTokenUsdPrice, }: {
+    config: Exclude<FunkitWithdrawalConfig, MultiMethodWithdrawalConfig>;
+    sourceTokenBalance: string;
+    /** User-entered amount in source-token units (e.g. "0.5" for 0.5 ETH). */
+    withdrawalInputAmount: string;
+    setWithdrawalInputAmount: (s: string) => void;
+    isWithdrawAmountTooLow: boolean;
+    /**
+     * Amount exceeds the configured max. The over-cap explanation lives in the
+     * bottom-bar footer, so the inline input error is suppressed — but only when
+     * the amount is otherwise affordable. If it also exceeds the balance,
+     * "Insufficient balance" still shows (see below).
+     */
+    isWithdrawAmountTooHigh: boolean;
+    /** Amount exceeds the available balance — takes priority over the over-cap hint. */
+    isWithdrawAmountAboveBalance: boolean;
+    isWithdrawAmountValid: boolean;
+    /**
+     * Minimum-withdrawal value formatted for display. Token units when the
+     * config provides `getMinWithdrawalAmount` (Lighter Secure); USD otherwise.
+     * The component picks the rendering style from `isLighter`.
+     */
+    minWithdrawalDisplayValue: number;
+    sourceTokenOptions?: SourceTokenOption[];
+    onSourceTokenChange?: (opt: SourceTokenOption) => void;
+    /** Currently selected source token symbol (drives chip label + icon). */
+    selectedSourceToken?: string;
+    /**
+     * USD price per unit of the source token (e.g. ~1620 for ETH).
+     * When omitted, the USD equivalent is rendered as "-" rather than
+     * assuming a 1:1 stablecoin rate.
+     */
+    sourceTokenUsdPrice?: number;
+}): React.JSX.Element;

package/dist/modals/WithdrawalModal/WithdrawalCallbackSuccess.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { FunkitCheckoutQuoteResult } from '../../domains/quote';
+interface WithdrawalCallbackSuccessProps {
+    bottomBarId: string;
+    onClose: () => void;
+    onNewWithdrawal: () => void;
+    quote: FunkitCheckoutQuoteResult | undefined;
+}
+export declare const WithdrawalCallbackSuccess: ({ bottomBarId, onClose, onNewWithdrawal, quote, }: WithdrawalCallbackSuccessProps) => React.JSX.Element;
+export {};

package/dist/modals/WithdrawalModal/WithdrawalContent.d.ts

@@ -0,0 +1,95 @@
+import type { TFunction } from 'i18next';
+import React from 'react';
+import type { Hex } from 'viem';
+import { type ModalBottomBarIdType } from '../../components/Dialog/Dialog';
+import type { CustomWithdrawalConfig, FunkitActiveWithdrawalItem, FunkitCheckoutConfig, WalletWithdrawalConfig } from '../../providers/FunkitCheckoutContext';
+import { type WithdrawalFormData } from './useWithdrawal';
+/**
+ * WithdrawalContent only operates on concrete single-method withdrawal configs.
+ * Multi-method configs are resolved in WithdrawalModal before reaching here.
+ */
+type FunkitWithdrawalConfig = WalletWithdrawalConfig | CustomWithdrawalConfig;
+interface WithdrawContentProps {
+    onContinue: (withdrawal: WithdrawalFormData, txHash: Hex) => void;
+    config: FunkitWithdrawalConfig;
+    withdrawalItem: FunkitActiveWithdrawalItem | null;
+    /**
+     * Switch a Lighter Fast withdrawal to the Lighter Secure method. Wired by
+     * {@link WithdrawalModal}; used by the over-$3M footer.
+     */
+    onSwitchToSecure?: () => void;
+    /**
+     * Portal target for the CTA. Defaults to the standalone WithdrawalModal's
+     * bottom bar; the unified CheckoutModal cashier flow passes `'checkout'` so
+     * the button lands in the checkout modal's bottom section instead.
+     */
+    bottomBarId?: ModalBottomBarIdType;
+    /**
+     * When true the submit CTA is rendered inert (disabled, no-op click) — no
+     * withdrawal executes and `onContinue` never fires. Used by the cashier amount
+     * step while the continue/success flow is not yet wired. Defaults to false so
+     * the standalone WithdrawalModal is unaffected.
+     */
+    disableSubmit?: boolean;
+}
+/**
+ * Converts a source-token amount string to its USD value using the given unit
+ * price. Returns `undefined` when the price is not yet loaded so callers can
+ * differentiate "still loading" from "actually $0".
+ *
+ * Exported for testing.
+ */
+export declare function toUsdValue(sourceAmount: string, sourceTokenUsdPrice: number | undefined): number | undefined;
+export declare function getWithdrawButtonText({ isWithdrawing, isValidAddress, isRecipientBlacklisted, isRecipientSameAsSource, withdrawalInputAmount, isWithdrawAmountValid, isWithdrawAmountTooHigh, isValidAddressAndChain, selectedToken, selectedChainId, selectedChainName, t, }: {
+    isWithdrawing: boolean;
+    isValidAddress: boolean;
+    isRecipientBlacklisted: boolean;
+    isRecipientSameAsSource: boolean;
+    withdrawalInputAmount: string;
+    isWithdrawAmountValid: boolean;
+    isWithdrawAmountTooHigh: boolean;
+    isValidAddressAndChain: boolean;
+    selectedToken: string | undefined;
+    selectedChainId: number | undefined;
+    selectedChainName: string | undefined;
+    t: TFunction;
+}): string;
+export declare function isValidWithdrawal({ config, checkoutConfig, withdrawalInputAmount, sourceTokenUsdPrice, recipientAddress, selectedChainId, sourceTokenBalance, selectedSourceToken, }: {
+    config: FunkitWithdrawalConfig;
+    checkoutConfig: FunkitCheckoutConfig | undefined;
+    /** User-entered amount in source-token units (e.g. "0.5" for 0.5 ETH). */
+    withdrawalInputAmount: string;
+    /**
+     * USD price per unit of the source token. Hardcoded to 1 for stablecoin
+     * sources; only Lighter Secure resolves a live spot price, and that path
+     * uses `getMinWithdrawalAmount` (per-token) which takes priority over the
+     * USD-min branch — so this field is only meaningfully consumed when it's 1.
+     */
+    sourceTokenUsdPrice: number;
+    sourceTokenBalance: string;
+    recipientAddress: string;
+    selectedChainId: number | undefined;
+    selectedSourceToken: string | undefined;
+}): {
+    isValidAddress: boolean;
+    isValidAddressAndChain: boolean;
+    isWithdrawAmountTooLow: boolean;
+    isWithdrawAmountTooHigh: boolean;
+    isWithdrawAmountAboveBalance: boolean;
+    isWithdrawAmountValid: boolean;
+    minWithdrawalDisplayValue: number;
+};
+export declare const useFrozenSourceTokenBalance: ({ isWithdrawing, sourceTokenBalance, }: {
+    isWithdrawing: boolean;
+    sourceTokenBalance: string;
+}) => {
+    displayedSourceTokenBalance: string;
+    freezeDisplayedSourceTokenBalance(sourceTokenBalance: string): void;
+};
+/**
+ * Builds the source-token options list for the Lighter compound input dropdown.
+ * Currently returns a single option per config; expands when Lighter exposes
+ * multi-asset API support.
+ */
+export declare const WithdrawContent: ({ onContinue, config, withdrawalItem, onSwitchToSecure, bottomBarId, disableSubmit, }: WithdrawContentProps) => React.JSX.Element;
+export {};

package/dist/modals/WithdrawalModal/WithdrawalMethodSelect.d.ts

@@ -0,0 +1,20 @@
+import type { SwappedFormOfPayment } from '@funkit/api-base';
+import React from 'react';
+interface WithdrawalMethodSelectProps {
+    onCryptoSelect: () => void;
+    onCashFopSelect: (fop: SwappedFormOfPayment) => void;
+    sourceChainId: string;
+    sourceTokenAddress: string;
+    /**
+     * Source-token balance in USD. MVP source is USDG (≈ $1) so the token balance
+     * ≈ USD; non-stable sources (e.g. ETH) would need `balance × USD price`.
+     * Omit/0 when unknown — no cap is sent and the iframe stays uncapped.
+     */
+    usdBalance?: number;
+    /**
+     * Hide the "Crypto" / "Cash" section labels. Used by Cashier flow.
+     */
+    hideSectionLabels?: boolean;
+}
+export declare function WithdrawalMethodSelect({ onCryptoSelect, onCashFopSelect, sourceChainId, sourceTokenAddress, usdBalance, hideSectionLabels, }: WithdrawalMethodSelectProps): React.JSX.Element;
+export {};