@funkit/connect 0.0.0-20260710210119

package/dist/modals/CheckoutModal/FunCheckoutStep.d.ts

@@ -0,0 +1,27 @@
+export declare enum FunCheckoutStep {
+    LOADING_ACCOUNT = "loading_account",
+    INPUT_AMOUNT = "input_amount",
+    SOURCE_CHANGE = "source_change",
+    CONFIRMATION = "confirmation",
+    SELECT_ASSET = "select_asset",
+    CHECKOUT_COMPLETE = "checkout_complete",
+    TRANSFER_TOKEN = "transfer_token",
+    LIGHTNING_INVOICE = "lightning_invoice",
+    CREATE_FIAT_ACCOUNT = "create_fiat_account",
+    BRIDGE_CUSTOMER = "bridge_customer",
+    BRIDGE_KYC = "bridge_kyc",
+    KYC_IFRAME = "KYC_IFRAME",
+    FIAT_ACCOUNT_DETAIL = "fiat_account_detail",
+    ERROR_SCREEN = "error_screen",
+    MELD_QUOTES = "meld_quotes",
+    MELD_REDIRECT = "meld_redirect",
+    MELD_CURRENCY_SELECT = "meld_currency_select",
+    SELECT_BROKERAGE = "select_brokerage",
+    CONNECT_EXCHANGE = "connect_exchange",
+    BROKERAGE_TWO_FA = "brokerage_two_fa",
+    BROKERAGE_SUCCESS = "brokerage_success",
+    SWAPPED_IFRAME = "swapped_iframe",
+    PERPS_TRANSFER = "perps_transfer",
+    WITHDRAWAL_ENTER_AMOUNT = "withdrawal_enter_amount",
+    WITHDRAWAL_COMPLETE = "withdrawal_complete"
+}

package/dist/modals/CheckoutModal/InputAmount/InputAmount.d.ts

@@ -0,0 +1,28 @@
+import type { MeldQuote, MeldServiceProvider } from '@funkit/api-base';
+import React from 'react';
+import type { Hex } from 'viem';
+import { type PaymentMethodInfo } from '../../../domains/paymentMethods';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type InputAmountState = CheckoutModalCommonState & {
+    paymentMethodInfo: PaymentMethodInfo;
+    fiatAmount?: number;
+    fiatCurrency?: string;
+    quote?: MeldQuote;
+    isInputInFiat?: boolean;
+    /** Preserved token amount from a previous visit (source of truth in EXACT_IN) */
+    assetAmount?: number;
+    /** Source token identifier — used to detect asset changes and discard stale values */
+    sourceTokenKey?: string;
+};
+export type InputAmountNext = Record<string, never> | {
+    fiatAmount: number | undefined;
+    fiatCurrency?: string;
+    provider?: MeldServiceProvider;
+    quote?: MeldQuote;
+    nextStep?: FunCheckoutStep.SOURCE_CHANGE | FunCheckoutStep.MELD_CURRENCY_SELECT | FunCheckoutStep.MELD_QUOTES | FunCheckoutStep.MELD_REDIRECT;
+} | {
+    nextStep: FunCheckoutStep.CHECKOUT_COMPLETE;
+    txHash: Hex;
+};
+export declare const InputAmountInfo: ModalStepInfo<FunCheckoutStep.INPUT_AMOUNT>;
+export declare function InputAmount(props: ModalStepComponentProps<FunCheckoutStep.INPUT_AMOUNT>): React.JSX.Element;

package/dist/modals/CheckoutModal/InputAmount/InputAmountLayout.d.ts

@@ -0,0 +1,20 @@
+import React, { type ReactNode } from 'react';
+import type { FunButtonProps } from '../../../components/FunButton/FunButton';
+import { type ErrorNotification } from '../../../components/FunNotification/FunNotification';
+interface InputAmountLayoutProps {
+    actionButtonProps: FunButtonProps;
+    fiatCurrencySelector?: ReactNode;
+    amountOptions?: ReactNode;
+    amountInput: ReactNode;
+    amountInputSwitch: ReactNode;
+    /** Symbol of the token the switcher displays — mode-dependent (EXACT_IN →
+     *  input, EXACT_OUT → output), resolved upstream via computeSwitcherDisplayToken.
+     *  When the `hide-stablecoin-amount-switch` gate is on and this is a recognized
+     *  stablecoin, the switcher is auto-hidden. */
+    switcherTokenSymbol?: string;
+    header?: ReactNode;
+    footer?: ReactNode;
+    error?: ErrorNotification;
+}
+export declare function InputAmountLayout({ actionButtonProps, amountOptions, fiatCurrencySelector, amountInput, amountInputSwitch, switcherTokenSymbol, header, footer, error, }: InputAmountLayoutProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/InputAmount/InputAmountLoaded.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { type FunkitTextCustomizationsConfig } from '../../../providers/FunkitConfigContext';
+import type { AssetHoldingsItem } from '../../../utils/assets';
+import type { FunkitCheckoutConfig } from '../../../providers/FunkitCheckoutContext';
+import { FunCheckoutStep, type ModalStepComponentProps } from '../stepTransition';
+interface InputAmountLoadedProps extends ModalStepComponentProps<FunCheckoutStep.INPUT_AMOUNT> {
+    sourceHolding: AssetHoldingsItem | null;
+    checkoutConfig: FunkitCheckoutConfig;
+    /** unit price of target asset */
+    unitPrice: number;
+    /** default fiat currency to be used*/
+    defaultFiatCurrency?: string;
+    textCustomizations: FunkitTextCustomizationsConfig['confirmationScreen'];
+    /** Live gas price in wei for native token gas buffer, null for ERC-20s */
+    gasPriceWei: bigint | null;
+}
+export declare function InputAmountLoaded({ checkoutConfig, modalState, onNext, setModalState, sourceHolding, unitPrice, defaultFiatCurrency, textCustomizations, gasPriceWei, }: InputAmountLoadedProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/InputAmount/InputAmountLoading.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { FunCheckoutStep, ModalStepComponentProps } from '../stepTransition';
+interface InputAmountLoadingProps extends ModalStepComponentProps<FunCheckoutStep.INPUT_AMOUNT> {
+    sourceHoldingError: Error | null;
+    unitPriceError: Error | null;
+}
+export declare function InputAmountLoading({ modalState, sourceHoldingError, unitPriceError, }: InputAmountLoadingProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/InputAmount/QuickOptions.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export declare const USD_AMOUNT_OPTIONS_PCT: number[];
+export declare const BITCOIN_LIGHTNING_USD_AMOUNT_OPTIONS: number[];
+interface QuickOptionsProps {
+    currency?: string;
+    disabled?: boolean;
+    onSelect?: (percentage: number) => void;
+    options?: number[];
+    percentMode?: boolean;
+}
+export declare function useFiatAmountOptions(currency: string | undefined): number[];
+export declare const QuickOptions: ({ currency, disabled, onSelect, options, percentMode, }: QuickOptionsProps) => React.JSX.Element[] | undefined;
+export {};

package/dist/modals/CheckoutModal/InputAmount/aaveClient.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Aave V3 client singleton for the native fast-path supply flow.
+ *
+ * The PoC uses `@aave/client` (V3 SDK) directly via its action functions, with
+ * the viem adapter for signing. We don't mount `<AaveProvider>` because the
+ * funkit tree doesn't need the React-bound hooks.
+ *
+ * NOTE on location: this file is co-located with its only current caller
+ * (`useAaveNativeSupply.ts`). It does NOT belong in `~/clients/` — that
+ * directory is reserved for customer-specific code exported via the
+ * `./clients/*` subpath; pulling Aave SDK setup in from there would bloat
+ * the main bundle for every customer. Pure Aave constants and predicates
+ * live in `~/domains/aave.ts` (importable without running SDK init).
+ */
+import { AaveClient } from '@aave/client';
+export declare const aaveClient: AaveClient;

package/dist/modals/CheckoutModal/InputAmount/state.d.ts

@@ -0,0 +1,163 @@
+import type { Dnum } from 'dnum';
+import type { Address } from 'viem';
+import { type PaymentMethodInfo } from '../../../domains/paymentMethods';
+import type { QuoteBuilder } from '../../../domains/quoteMode/types';
+import type { AssetHoldingsItem } from '../../../utils/assets';
+import type { FunkitCheckoutConfig } from '../../../providers/FunkitCheckoutContext';
+export interface AmountInputInitOptions {
+    checkoutConfig: FunkitCheckoutConfig;
+    paymentMethodInfo: PaymentMethodInfo;
+    sourceHolding: AssetHoldingsItem | null;
+    /** Default amount, in fiat since that's the default mode */
+    defaultAmount: number | undefined;
+    /** Target asset unit price, in USD */
+    unitPrice: number;
+    /** Maximum checkout amount, in USD */
+    maxUsd: number;
+    /** Minimum checkout amount, in USD */
+    minUsd?: number;
+    /** Currency code for the currently selected fiat currency. Defaults to USD */
+    fiatCurrency?: string;
+    /** Locale */
+    locale: Intl.LocalesArgument;
+    /** Quick options, in fiat (not %) */
+    quickOptions?: number[];
+    /** Whether meld is enabled */
+    meldEnabled: boolean;
+    apiKey: string;
+    /** Default value for isInputInFiat (preserved from modal state when navigating back) */
+    defaultIsInputInFiat?: boolean;
+    /** Preserved token amount (in human-readable form) from a previous visit */
+    defaultAssetAmount?: number;
+    /** Quote builder adapter (EXACT_IN / EXACT_OUT / ONE_TO_ONE) */
+    quoteBuilder: QuoteBuilder;
+    /** Whether the source token is the chain's native gas token */
+    isNativeToken: boolean;
+    /** Current gas price in wei (for native token gas buffer calculation) */
+    gasPriceWei: bigint | null;
+    /** Gas-unit buffer reserved for the checkout tx (from Statsig dynamic config) */
+    gasUnits: bigint;
+}
+export interface AmountInputState {
+    /** Current amount, in target asset. Undefined if input is empty */
+    assetAmount: number | undefined;
+    /** Current amount, in fiat. Undefined if input is empty */
+    fiatAmount: number | undefined;
+    /** Fiat currency */
+    fiatCurrency: string;
+    /** Current input value (with leading currency symbol if in fiat) */
+    inputValue: string;
+    /** Whether the input is currently in fiat */
+    isInputInFiat: boolean;
+    /** Locale */
+    locale: Intl.LocalesArgument;
+    /** Estimated available amount, in USD (defaults to unlimited) */
+    usdAvailableAmount: number | null;
+    /** Maximum amount, in USD (defaults to unlimited) */
+    usdMaxAmount: number | null;
+    /** Minimum amount, in USD (defaults to 0) */
+    usdMinAmount: number | null;
+    /** Whether meld is enabled */
+    meldEnabled: boolean;
+    /** Frozen token→USD exchange rate, set on InputAmount screen mount */
+    frozenUnitPrice?: number;
+    /** Exact token balance as a Dnum (decimals embedded) */
+    tokenBalanceBaseUnit: Dnum | null;
+    /** Whether quote mode is EXACT_IN (token amount is source of truth) */
+    isExactIn: boolean;
+    /** Canonical token amount as a Dnum, set by setTokenAmount for lossless balance comparison */
+    tokenAmountBaseUnit: Dnum | null;
+    /** Maximum sendable token amount, accounting for gas buffer on native tokens */
+    maxSendableAmount: Dnum | null;
+}
+/** Derived state includes additional fields that are pure functions of base state */
+export interface AmountInputDerivedState extends AmountInputState {
+    inputDecimals: number;
+    inputError: AmountInputError | null;
+    inputAffix: {
+        content: string;
+        type: 'prefix' | 'suffix';
+    };
+    isValid: boolean;
+    placeholder: string;
+    /** Decimal separator based on locale (e.g., '.' for en-US, ',' for de-DE) */
+    decimalSeparator: string;
+}
+export type AmountInputAction = {
+    /** Switches between fiat and crypto input mode */
+    type: 'toggleInputInFiat';
+} | {
+    /** Sets the input value as string */
+    type: 'setInputValue';
+    inputValue: string;
+    unitPrice: number;
+} | {
+    /** Sets the input value as fiat amount */
+    type: 'setFiatAmount';
+    fiatAmount: number;
+    unitPrice: number;
+} | {
+    /** Changes formatting to new currency code */
+    type: 'setFiatCurrency';
+    fiatCurrency: string;
+} | {
+    /** Sets the input value as an exact token amount (for EXACT_IN max button) */
+    type: 'setTokenAmount';
+    /** Exact token amount as a Dnum (decimals embedded) */
+    tokenAmountBaseUnit: Dnum;
+    frozenUnitPrice: number;
+} | {
+    /** Sets the input value as a target asset amount (for EXACT_OUT token-mode quick options) */
+    type: 'setAssetAmount';
+    assetAmount: number;
+    unitPrice: number;
+};
+export type AmountInputError = {
+    /** Current amount is above available balance */
+    type: 'aboveAvailable';
+    usdAvailableAmount: number;
+} | {
+    /** Current amount is above maximum */
+    type: 'aboveMax';
+    usdMaxAmount: number;
+} | {
+    /** Current amount is below minimum */
+    type: 'belowMin';
+    usdMinAmount: number;
+} | {
+    /** Available balance is 0 */
+    type: 'noAvailableBalance';
+} | {
+    /** Input is empty */
+    type: 'noInput';
+};
+/**
+ * Calculate initial input amount for account balance deposits.
+ * Return half the balance and round up to nearest 10, 100, 1000 etc
+ */
+export declare function calcInitialFiatAmount(balance: number): number;
+/** Minimal source-token identity needed to resolve the default input mode. */
+export interface SourceTokenRef {
+    chainId: string;
+    address: Address;
+}
+/**
+ * Resolves whether the amount screen should open in fiat (`true`) or token
+ * (`false`) entry.
+ *
+ * Precedence: card and BTC Lightning payments always force fiat (ramps are
+ * fiat-denominated, and Lightning's amount input only supports fiat today).
+ * Lighter **spot** deposits paid with the same asset open in token entry —
+ * perps deposits (and every other customer) keep the fiat default.
+ * A value preserved from prior navigation (`defaultIsInputInFiat`) is handled
+ * by the caller and wins over this.
+ */
+export declare function resolveDefaultIsInputInFiat({ checkoutConfig, paymentMethodInfo, sourceToken, apiKey, }: {
+    checkoutConfig: FunkitCheckoutConfig;
+    paymentMethodInfo: PaymentMethodInfo;
+    sourceToken: SourceTokenRef | null;
+    apiKey: string;
+}): boolean;
+export declare function initializeState({ checkoutConfig, defaultAmount, fiatCurrency, quoteBuilder, locale, maxUsd, minUsd, paymentMethodInfo, quickOptions, sourceHolding, unitPrice: realUnitPrice, meldEnabled, apiKey, defaultAssetAmount, defaultIsInputInFiat, isNativeToken, gasPriceWei, gasUnits, }: AmountInputInitOptions): AmountInputState;
+export declare function reduceState(state: AmountInputState, action: AmountInputAction): AmountInputState;
+export declare function getDerivedState(state: AmountInputState, _targetAssetTicker: string): AmountInputDerivedState;

package/dist/modals/CheckoutModal/InputAmount/useAaveNativeSupply.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Native-supply fast-path: same-token same-chain deposits go straight to the
+ * Aave Pool, bypassing Relay. Toggle visibility is gated centrally in
+ * `FunkitQuoteContext` (`showApprovalMethodToggle`), not here.
+ */
+import { type ERC712Signature, type SupplyRequest } from '@aave/client';
+import type { ApiFunkitCheckoutConfig } from '@funkit/utils';
+import type { Dnum } from 'dnum';
+import { type Address, type Hex, type WalletClient } from 'viem';
+import { type CheckoutConfirmationError } from '../../../domains/checkoutErrors';
+import type { FunkitActiveCheckoutItem, FunkitCheckoutConfig } from '../../../providers/FunkitCheckoutContext';
+import { type Config } from '../../../wagmi/hooks';
+/**
+ * Stringify an amount for Aave's `bigDecimal()`. Prefers the precise
+ * base-unit Dnum (carries the token's real decimals) so we don't ship
+ * float noise like "0.30000000000000004" to the API. Falls back to the
+ * raw JS-number string when the Dnum isn't populated (EXACT_OUT path).
+ */
+export declare function formatSupplyAmount(tokenAmountBaseUnit: Dnum | null, fallbackAssetAmount: number | undefined): string;
+/**
+ * Base-unit string for the DE record's `fromAmountBaseUnit` /
+ * `toAmountBaseUnit`. Dnum present → `[0]` exact. Dnum null
+ * (EXACT_OUT) → derive from `assetAmount` + `decimals`. Neither →
+ * `'0'` + warn (would corrupt volume metrics).
+ */
+export declare function getSupplyAmountBaseUnit(tokenAmountBaseUnit: Dnum | null, fallbackAssetAmount: number | undefined, decimals: number | null): string;
+/**
+ * Serializable checkout config persisted on the Aave native DE record.
+ * Overrides the init-time `targetAssetAmount` (undefined on this path —
+ * no Relay quote populates it) with the fresh input amount so the success
+ * screen's "You receive" doesn't read 0, and drops the non-serializable
+ * `generateActionsParams`.
+ */
+export declare function buildAaveNativeSupplyConfig(config: FunkitCheckoutConfig, assetAmount: number): ApiFunkitCheckoutConfig;
+/** Upper bound on waiting for the USDT zero-reset to mine before giving up. */
+export declare const USDT_RESET_RECEIPT_TIMEOUT_MS = 90000;
+/**
+ * USDT's `approve` reverts on a non-zero → non-zero change — zeroing first
+ * lets the SDK's approve(amount) succeed. Same quirk handled by the
+ * VaultDepositor path (`createAaveSupplyActions`).
+ */
+export declare function resetUsdtAllowanceIfNeeded(wagmiConfig: Config, walletClient: WalletClient, { owner, market, currency, targetChainNum, }: {
+    owner: Address;
+    market: Address;
+    currency: Address;
+    targetChainNum: number;
+}): Promise<void>;
+/**
+ * `undefined` user preference (toggle not surfaced) defaults to
+ * permit-when-capable — preserves the auto behavior that pre-dated the toggle.
+ * An explicit `false` always wins. When `allowanceCoversAmount`, no permit is
+ * needed at all (the SDK will return a plain TransactionRequest) — skipping
+ * the signature saves the user one popup, matching aave/interface.
+ */
+export declare function shouldUsePermitForSupply(userPreference: boolean | undefined, reservePermitSupported: boolean | undefined, allowanceCoversAmount: boolean): boolean;
+/**
+ * `permitSig` presence is what drives the SDK to build a single
+ * `supplyWithPermit` tx vs an `ApprovalRequired` plan (approve + supply).
+ */
+export declare function buildAaveSupplyRequest({ targetChainNum, market, currency, humanAmount, walletAddress, permitSig, }: {
+    targetChainNum: number;
+    market: Address;
+    currency: Address;
+    humanAmount: string;
+    walletAddress: Address;
+    permitSig?: ERC712Signature;
+}): SupplyRequest;
+/** Amount inputs passed from the call site (not read from
+ *  `checkoutItem`, to avoid closure staleness after `flushSync`). */
+export interface AaveNativeSupplyAmount {
+    /** `null` in EXACT_OUT mode; see `state.ts:373`. */
+    tokenAmountBaseUnit: Dnum | null;
+    /** Call site guards `assetAmount === undefined` upstream. */
+    assetAmount: number;
+    decimals: number | null;
+    /** USD the user saw at input. `null` → `0` at the API boundary. */
+    usdAmount: number | null;
+}
+/**
+ * Pre-fetches the on-chain ERC-20 allowance from the user to the Aave Pool, so
+ * `showApprovalMethodToggle` can hide the toggle when an existing approval
+ * already covers the supply amount (matches aave/interface's behavior — a
+ * supply that needs no approval/permit is a single tx, no toggle).
+ */
+export declare function useAaveTargetPoolAllowance(checkoutItem: FunkitActiveCheckoutItem | null, owner: Address | undefined): bigint | undefined;
+/**
+ * Pre-fetches reserve permit capability so the InputAmount toggle's
+ * visibility is decidable synchronously when the user lands there.
+ */
+export declare function useAaveTargetReservePermit(checkoutItem: FunkitActiveCheckoutItem | null): boolean | undefined;
+interface UseAaveNativeSupplyResult {
+    submit: (amount: AaveNativeSupplyAmount) => Promise<{
+        txHash: Hex;
+    } | null>;
+    isPending: boolean;
+    error: CheckoutConfirmationError | null;
+}
+export declare function useAaveNativeSupply(): UseAaveNativeSupplyResult;
+export {};

package/dist/modals/CheckoutModal/InputAmount/useAmountInput.d.ts

@@ -0,0 +1,19 @@
+import type { Dnum } from 'dnum';
+import { type RefObject } from 'react';
+import type { FunInputChangeEvent } from '../../../components/FunInput/FunInput';
+import { type AmountInputDerivedState, type AmountInputInitOptions } from './state';
+import { type InputAmountSuggestion } from './utils';
+export interface UseAmountInputResult extends AmountInputDerivedState {
+    fontSize: number;
+    inputHeight: number;
+    inputWidth: number | undefined;
+    onChange(event: FunInputChangeEvent): void;
+    ref: RefObject<HTMLInputElement | null>;
+    setAssetAmount(assetAmount: number): AmountInputDerivedState;
+    setFiatAmount(usdAmount: number): AmountInputDerivedState;
+    setTokenAmount(tokenAmountBaseUnit: Dnum, frozenUnitPrice: number): AmountInputDerivedState;
+    /** Possible user action to recover from the current error */
+    suggestion: InputAmountSuggestion | undefined;
+    toggleInputInFiat: () => void;
+}
+export declare function useAmountInput(options: AmountInputInitOptions): UseAmountInputResult;

package/dist/modals/CheckoutModal/InputAmount/useAvailableBalanceForCheckout.d.ts

@@ -0,0 +1,4 @@
+import type { AssetHoldingsItem } from '../../../utils/assets';
+import { type PaymentMethodInfo } from '../../../domains/paymentMethods';
+import type { QueryResult } from '../../../types/utils';
+export declare function useAvailableBalanceForCheckout(paymentMethodInfo: PaymentMethodInfo, targetChainId: string, assetChainId: string, assetSymbol: string | null): QueryResult<AssetHoldingsItem>;

package/dist/modals/CheckoutModal/InputAmount/useCheckoutAmountLimits.d.ts

@@ -0,0 +1,17 @@
+import { PaymentMethod } from '../../../domains/paymentMethods';
+import type { FunkitCheckoutConfig } from '../../../providers/FunkitCheckoutContext';
+export interface CheckoutAmountLimitsUsd {
+    minUsd: number | undefined;
+    maxUsd: number;
+}
+/**
+ * Resolves the min/max USD bounds for the amount input based on the active
+ * payment method:
+ * - Bitcoin Lightning and brokerage checkouts carry their own floors/ceilings.
+ * - Everything else uses the customer-configured min deposit and the global
+ *   max-checkout dynamic config.
+ */
+export declare const useCheckoutAmountLimits: ({ checkoutConfig, paymentMethod, }: {
+    checkoutConfig: FunkitCheckoutConfig;
+    paymentMethod: PaymentMethod;
+}) => CheckoutAmountLimitsUsd;

package/dist/modals/CheckoutModal/InputAmount/useMeld.d.ts

@@ -0,0 +1,36 @@
+import type { MeldQuote } from '@funkit/api-base';
+import React from 'react';
+import type { ErrorNotification } from '../../../components/FunNotification/FunNotification';
+import { FunCheckoutStep, type NextPayload } from '../stepTransition';
+export declare function useMeldUI({ meldEnabled, manuallySelectedQuote, fiatAmount, fiatCurrency, onNext, }: {
+    meldEnabled: boolean;
+    manuallySelectedQuote: MeldQuote | undefined;
+    fiatAmount: number | undefined;
+    fiatCurrency: string | undefined;
+    onNext: (data: NextPayload<FunCheckoutStep.INPUT_AMOUNT>) => void;
+}): {
+    getMeldFooter: () => React.JSX.Element;
+    handleMeldContinue: () => Promise<void>;
+    isMeldContinueDisabled: boolean | undefined;
+    isMeldLinkPending: boolean;
+    getMeldError: () => ErrorNotification | undefined;
+};
+export declare function useMeld(meldEnabled: boolean, manuallySelectedQuote: MeldQuote | undefined, usdAmount: number | undefined, fiatCurrency: string | undefined): {
+    meldQuotesQuery: import("@tanstack/react-query").UseQueryResult<MeldQuote[]> & {
+        isOutdated: boolean;
+    };
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@funkit/api-base").MeldCreateCryptoWidgetResponse, Error, import("@funkit/api-base").MeldServiceProvider, unknown>;
+    isMeldLinkPending: boolean;
+    meldLimitError: {
+        issue: string;
+        suggestion: string;
+    } | undefined;
+    bestRateQuote: MeldQuote | undefined;
+    selectedQuote: MeldQuote | undefined;
+    isSelectedQuoteUnavailable: boolean | undefined;
+    isMeldContinueDisabled: boolean | undefined;
+    getMeldError: () => ErrorNotification | undefined;
+};
+export declare function openMeldPopup(linkGetter: () => Promise<{
+    widgetUrl: string;
+}>): Promise<boolean>;

package/dist/modals/CheckoutModal/InputAmount/useNadoDirectTransfer.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Nado direct-transfer fast-path: a same-token same-chain deposit is a single
+ * ERC-20 transfer to the subaccount DDA (`customRecipient`), bypassing
+ * Relay/quoteV2 (which can't price a QQQx → QQQx "route"). Signs the transfer
+ * and records a direct execution for history parity. Mirrors `useAaveNativeSupply`.
+ */
+import type { Dnum } from 'dnum';
+import { type Hex } from 'viem';
+import { type CheckoutConfirmationError } from '../../../domains/checkoutErrors';
+import type { FunkitCheckoutConfig } from '../../../providers/FunkitCheckoutContext';
+/**
+ * Base-unit string for the transfer + DE record. Dnum present → exact;
+ * otherwise derive from `assetAmount` + `decimals`. Neither → `'0'` + warn.
+ */
+export declare function getTransferAmountBaseUnit(tokenAmountBaseUnit: Dnum | null, fallbackAssetAmount: number | undefined, decimals: number | null): bigint;
+interface UseNadoDirectTransferResult {
+    /** Reads the committed amount/source from `checkoutItem` and executes. */
+    submit: () => Promise<{
+        txHash: Hex;
+    } | null>;
+    isPending: boolean;
+    error: CheckoutConfirmationError | null;
+    /**
+     * Whether this checkout takes the direct-transfer fast-path — see
+     * `isNadoDirectTransferContext`. False until a source is selected and, for a
+     * wrapper source, until the wrapper address resolves.
+     */
+    isApplicable: boolean;
+}
+interface NadoDirectTransferContextArgs {
+    apiKey: string;
+    sourceAsset: {
+        chainId: string | number;
+        address: string;
+    };
+    checkoutConfig: Pick<FunkitCheckoutConfig, 'targetChain' | 'targetAsset' | 'customRecipient'>;
+    /**
+     * Whether the target is an xStock asset (`assetClass === 'xstock'`). Gates the
+     * fast-path to xStocks so a same-token route like USDT → USDT keeps using Relay.
+     */
+    isXstockTarget: boolean;
+    /**
+     * Target token's wrapped version (xStocks `wrapperAddressV2`) on the target
+     * chain — a held balance (e.g. wSPYx for SPYx) is an equivalent source. From
+     * `useXstocksWrappedTokenAddress`; omit when there's none.
+     */
+    wrappedTokenAddress?: string;
+}
+/**
+ * True when the customer is Nado, the target is an xStock, the checkout has an
+ * explicit recipient (the subaccount DDA), and the source matches the target
+ * token or its wrapper (same chain) — a direct ERC-20 transfer, not a Relay swap.
+ *
+ * - Customer-gated (not config-driven) to bound blast radius to Nado.
+ * - xStocks-gated so a same-token route (USDT → USDT) keeps using Relay.
+ */
+export declare function isNadoDirectTransferContext({ apiKey, sourceAsset, checkoutConfig, isXstockTarget, wrappedTokenAddress, }: NadoDirectTransferContextArgs): boolean;
+/**
+ * Predicate over a source asset: does it qualify for the Nado direct-transfer fast-path?
+ */
+export declare function useIsNadoDirectTransferSource(): (source: {
+    chainId: string | number;
+    address: string;
+}) => boolean;
+export declare function useNadoDirectTransfer(): UseNadoDirectTransferResult;
+export {};

package/dist/modals/CheckoutModal/InputAmount/utils.d.ts

@@ -0,0 +1,68 @@
+import type { ErrorNotification } from '../../../components/FunNotification/FunNotification';
+import type { useFunkitTranslation } from '../../../hooks/useFunkitTranslation';
+import type { AmountInputError } from './state';
+type TFunction = ReturnType<typeof useFunkitTranslation>['t'];
+export declare const ASSET_DECIMALS = 5;
+export declare const USD_DECIMALS = 2;
+export declare const USD_INITIAL_AMOUNT = 100;
+export declare function getDefaultAmountFromQuickOptions(quickOptions: number[] | undefined): number | undefined;
+export declare function getUsdMaxAmount(maxUsd: number): number | null;
+export declare function getUsdMinAmount(minUsd?: number): number;
+export interface InputAmountSuggestion {
+    autoConfirm: boolean;
+    buttonLabel: string;
+    usdAmount: number;
+}
+/**
+ * Get suggested amount from error
+ * Allow recovery actions to user in the CTA Continue button
+ */
+export declare const getInputAmountSuggestion: (error: AmountInputError | null, t: TFunction) => InputAmountSuggestion | undefined;
+export declare const getInputErrorNotification: (error: AmountInputError | null, t: TFunction) => ErrorNotification | undefined;
+export type NumberSeparators = {
+    decimalSeparator: string;
+    groupSeparator: RegExp;
+};
+export declare function getNumberSeparators(locale: Intl.LocalesArgument): NumberSeparators;
+export declare function parseNumberInputValue(inputValue: string, separators: NumberSeparators): {
+    amount: number | undefined;
+    amountString: string;
+    amountStringNormalized: string;
+    decimalPart: string | null;
+    integerPart: string;
+};
+export declare function getCurrencyFormattingOptions(fiatCurrency: string, locale: Intl.LocalesArgument): {
+    currencySymbol: string;
+    currencySymbolWithSpacing: string;
+    decimals: number;
+};
+export declare function formatAssetAmountWithLocale(value: number, options: {
+    locale: Intl.LocalesArgument;
+}): string;
+export declare function formatCurrencyAmountWithLocale(value: number, options: {
+    fiatCurrency: string;
+    locale: Intl.LocalesArgument;
+}): string;
+/**
+ * Canonical fiat display formatter for the InputAmount UI.
+ *
+ * Combines our decimal rules with the utility library's suffix abbreviations:
+ * - Adds locale-aware currency symbol prefix (e.g. `$` for USD, `Kč ` for CZK)
+ * - Min 2, max ASSET_DECIMALS decimal places — trailing zeros trimmed beyond minimum
+ * - Thousands separators (e.g. `$1,234.00`)
+ * - M / B / T suffix abbreviation for amounts ≥ 1,000,000 (e.g. `$1.23M`)
+ *
+ * State-stored fiatAmounts are already floor-rounded to ASSET_DECIMALS precision,
+ * so this function does not apply additional rounding.
+ *
+ * Note: the suffix path (≥ 1M) always uses USD `$` — acceptable since only USD
+ * is currently supported in this flow.
+ */
+export declare function formatFiatAmountAndStringify(value: number, options: {
+    fiatCurrency: string;
+    locale: Intl.LocalesArgument;
+}): string;
+export declare function replaceStringRange(original: string, replacement: string, start: number, end: number): string;
+export declare function reformatDecimalPart(decimalPart: string, decimals: number): string;
+export declare function reformatIntegerPart(integerPart: string, locale: Intl.LocalesArgument, preserveLeadingZeroes: boolean): string;
+export {};

package/dist/modals/CheckoutModal/LightningInvoice/LightningInvoice.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type PaymentMethodBitcoinLightningInfo, type PaymentMethodCashAppLightningInfo } from '../../../domains/paymentMethods';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type LightningInvoiceState = CheckoutModalCommonState & {
+    paymentMethodInfo: PaymentMethodBitcoinLightningInfo | PaymentMethodCashAppLightningInfo;
+};
+export type LightningInvoiceNext = Record<string, never>;
+export declare const LightningInvoiceInfo: ModalStepInfo<FunCheckoutStep.LIGHTNING_INVOICE>;
+export declare function LightningInvoice(props: ModalStepComponentProps<FunCheckoutStep.LIGHTNING_INVOICE>): React.JSX.Element;

package/dist/modals/CheckoutModal/LightningInvoice/LightningInvoiceQrCode.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type BoxProps } from '../../../components/Box/Box';
+interface LightningInvoiceQrCodeProps {
+    isCashApp?: boolean;
+    bolt11?: string;
+    marginY?: BoxProps['marginY'];
+}
+export declare function LightningInvoiceQrCode({ isCashApp, bolt11, marginY, }: LightningInvoiceQrCodeProps): React.JSX.Element;
+export {};