@funkit/connect 9.15.1 → 9.17.0

package/dist/interfaces/identity.d.ts

@@ -0,0 +1,41 @@
+import type { Address } from 'viem';
+import type { LoginType } from '../utils/userInfo';
+/**
+ * Platform-agnostic **user** identity surface consumed by core hooks.
+ *
+ * Deliberately scoped to who the *end user* is — `apiKey` (the *customer*
+ * identity, set by the integrator) is kept on `useFunkitConfig` so the two
+ * concerns don't get conflated. Core hooks that need both read each from its
+ * own seam.
+ *
+ * On web this is derived from wagmi + `GeneralWalletProvider`; on React Native
+ * it will be derived from host-app props. Widen this surface only when a core
+ * hook genuinely needs more — keep it free of DOM- and wagmi-bound types so it
+ * can move to `@funkit/connect-core` untouched.
+ */
+export interface FunkitIdentity {
+    /**
+     * Stable user id used to key user-scoped API calls. Equals the configured
+     * `externalUserId` (or a synthetic namespaced id derived from it) when one is
+     * present, otherwise the connected wallet address, or the `'0x'` placeholder
+     * when neither is present. Mirrors `userInfo.id`.
+     */
+    userId: string;
+    /**
+     * Effective wallet address user-scoped flows transact against, or `''` when
+     * there is no connected/trusted address. Distinct from a display address:
+     * this is the resolved address (`effectiveAddress`), not `userInfo.address`,
+     * which carries the `'0x'` placeholder for guests.
+     */
+    walletAddress: Address | '';
+    /** How the user authenticated (guest vs web3). */
+    loginType: LoginType;
+}
+/**
+ * Contract a platform implements to feed identity into core. Each platform
+ * supplies a `useIdentity` hook: web wraps wagmi + `GeneralWalletProvider`
+ * (see `useIdentity` there); React Native will wrap host-app-provided props.
+ */
+export interface IdentityProvider {
+    useIdentity(): FunkitIdentity;
+}

package/dist/interfaces/logTransport.d.ts

@@ -0,0 +1,51 @@
+/** Severity levels emitted by `FunLogger`. */
+export type LogLevel = 'info' | 'debug' | 'warn' | 'error';
+/** User tracking consent, mirroring the Datadog browser SDK's values. */
+export type TrackingConsent = 'granted' | 'not-granted';
+/**
+ * The structured context `FunLogger` assembles for every record: the caller's
+ * data plus the logger's resolved user/session fields. Concrete (rather than
+ * `object`) so transport implementors get property access and autocomplete.
+ */
+export interface LogContext {
+    /** Caller-supplied structured data for this log line, if any. */
+    data?: object;
+    apiKey: string | null;
+    userId: string | null;
+    userName: string | null;
+    userAddress: string | null;
+    userLoginType: string | null;
+    typeLabel: string | null;
+    sdkVersion: string | null;
+}
+/** A single fully-assembled log record handed to a transport. */
+export interface LogRecord {
+    level: LogLevel;
+    title: string;
+    /** Assembled by `FunLogger` so transports stay dumb sinks. */
+    context: LogContext;
+    /** Present only for `error`-level records. */
+    error?: Error;
+}
+/**
+ * Platform sink for `FunLogger`. The logger (queueing, env detection, level
+ * routing, console fallback, context tracking) is platform-agnostic; everything
+ * platform-specific about *emitting* lives behind this interface.
+ *
+ * Part of the React Native split (see docs/connect-rn-architecture.md): web
+ * implements it with `DatadogBrowserLogsTransport`, React Native will implement
+ * it with a Datadog React Native transport (`@datadog/mobile-react-native`).
+ * Kept free of DOM/`@datadog/browser-logs` types so it can move to
+ * `@funkit/connect-core` untouched.
+ */
+export interface LogTransport {
+    /** Emit one record to the platform sink. */
+    log(record: LogRecord): void;
+    /**
+     * Reflect the resolved environment (e.g. `'development'` | `'production'`).
+     * Optional — sinks that don't segment by environment can omit it.
+     */
+    setEnv?(environment: string): void;
+    /** Reflect user tracking consent. Optional. */
+    setTrackingConsent?(consent: TrackingConsent): void;
+}

package/dist/interfaces/swapped-transport.d.ts

@@ -0,0 +1,78 @@
+import type { PaymentGroupType } from '@funkit/api-base';
+import type { SwappedTheme } from '../utils/swapped';
+/**
+ * Typed contract for the message bridge between the SDK and the embedded
+ * Swapped flow. On web this is bridged over an `<iframe>` + `window.postMessage`
+ * (see {@link createIframeSwappedTransport}); React Native will bridge the same
+ * messages over a `WebView`. Freezing the event catalog here lets both
+ * platforms share the `SwappedProvider` state machine and turns any drift in
+ * the message shapes into a compile-time error.
+ *
+ * Reference: the inbound switch in `SwappedIframeController` and the sends in
+ * `SwappedProvider`.
+ *
+ * This module is platform-agnostic and is slated to move to
+ * `@funkit/connect-core/interfaces/` during the RN extraction.
+ */
+/**
+ * Navigation steps reported by the Swapped embed. Open-ended — the embed may
+ * emit steps we don't enumerate, which fall through to the default handler.
+ */
+export type SwappedStep = 'EMPTY' | 'KYC_ADDRESS' | 'KYC_AWAITING_IDENTITY' | 'KYC_IDENTITY' | 'KYC_PERSONAL' | 'KYC_SUMSUB' | 'LOGIN_EMAIL' | 'LOGIN_EMAIL_VERIFICATION' | 'PAYMENT' | 'ORDER_CONFIRMATION' | (string & {});
+/**
+ * Opaque payloads — the SDK never introspects these, it only forwards them to
+ * analytics via `JSON.stringify`. Typed as `unknown` so callers must stringify
+ * rather than read fields.
+ */
+export type SwappedErrorPayload = unknown;
+export type SwappedTxPayload = unknown;
+/** embed → parent */
+export type SwappedInboundMessage = {
+    type: 'SWAPPED_READY';
+} | {
+    type: 'SWAPPED_GO_BACK';
+} | {
+    type: 'SWAPPED_CLOSE';
+} | {
+    type: 'SWAPPED_NEW_DEPOSIT';
+} | {
+    type: 'SWAPPED_ERROR';
+    data?: SwappedErrorPayload;
+} | {
+    type: 'SWAPPED_NAVIGATION';
+    data?: {
+        step?: SwappedStep;
+    };
+} | {
+    type: 'SWAPPED_ORDER_DATA';
+    data?: unknown;
+} | {
+    type: 'SWAPPED_TRANSACTION_SUCCESSFUL';
+    data?: SwappedTxPayload;
+} | {
+    type: 'SWAPPED_LOGOUT';
+};
+/** parent → embed */
+export type SwappedOutboundMessage = {
+    type: 'SWAPPED_METHOD';
+    method: PaymentGroupType;
+} | {
+    type: 'SWAPPED_THEME';
+    data: SwappedTheme;
+} | {
+    type: 'SWAPPED_FOCUS';
+};
+export interface SwappedTransport {
+    /**
+     * Send a message to the embed. Returns `true` if the message was dispatched,
+     * `false` if the embed isn't reachable yet (so callers can mirror today's
+     * behavior of logging only on a successful send).
+     */
+    send(msg: SwappedOutboundMessage): boolean;
+    /**
+     * Subscribe to messages from the embed. The handler is only invoked for
+     * messages whose origin has already been validated by the transport. Returns
+     * an unsubscribe function.
+     */
+    onMessage(handler: (msg: SwappedInboundMessage) => void): () => void;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Centralized "fire-and-forget" prefetches that run at modal open so
+ * downstream screens read from warm React Query cache. Hooks added here
+ * must set a `staleTime` long enough to survive modal close/reopen, or
+ * the prefetch is wasted on the next session.
+ */
+export declare function CheckoutModalPrefetchedHooks(): null;

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

@@ -7,6 +7,7 @@ export declare enum FunCheckoutStep {
     CHECKOUT_COMPLETE = "checkout_complete",
     CHECKOUT_HELP = "checkout_help",
     TRANSFER_TOKEN = "transfer_token",
+    LIGHTNING_INVOICE = "lightning_invoice",
     CREATE_FIAT_ACCOUNT = "create_fiat_account",
     BRIDGE_CUSTOMER = "bridge_customer",
     BRIDGE_KYC = "bridge_kyc",

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

@@ -14,5 +14,5 @@ interface InputAmountLoadedProps extends ModalStepComponentProps<FunCheckoutStep
     /** Live gas price in wei for native token gas buffer, null for ERC-20s */
     gasPriceWei: bigint | null;
 }
-export declare function InputAmountLoaded({ checkoutConfig, modalState, onNext, onClose, setModalState, sourceHolding, unitPrice, defaultFiatCurrency, textCustomizations, gasPriceWei, }: InputAmountLoadedProps): React.JSX.Element;
+export declare function InputAmountLoaded({ checkoutConfig, modalState, onNext, setModalState, sourceHolding, unitPrice, defaultFiatCurrency, textCustomizations, gasPriceWei, }: InputAmountLoadedProps): React.JSX.Element;
 export {};

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

@@ -1,11 +1,13 @@
 /**
- * Aave V3 native-supply fast-path: routes same-token same-chain
- * deposits straight to Pool.supply via @aave/client, bypassing Relay.
+ * Native-supply fast-path: same-token same-chain deposits go straight to the
+ * Aave Pool, bypassing Relay. `permitSupported` is exposed because the toggle
+ * visibility gate is in `InputAmountLoaded`, not here.
  */
+import { type ERC712Signature, type SupplyRequest } from '@aave/client';
+import type { ApiFunkitCheckoutConfig } from '@funkit/utils';
 import type { Dnum } from 'dnum';
-import type { Hex } from 'viem';
-import type { FunkitActiveCheckoutItem } from '../../../providers/FunkitCheckoutContext';
-import type { FunkitCheckoutConfig } from '../../../providers/FunkitCheckoutContext';
+import { type Address, type Hex, type WalletClient } from 'viem';
+import type { FunkitActiveCheckoutItem, FunkitCheckoutConfig } from '../../../providers/FunkitCheckoutContext';
 interface AaveNativeSupplyContextArgs {
     apiKey: string;
     sourceAsset: {
@@ -30,15 +32,81 @@ export declare function isAaveNativeSupplyContext({ apiKey, sourceAsset, checkou
  * raw JS-number string when the Dnum isn't populated (EXACT_OUT path).
  */
 export declare function formatSupplyAmount(tokenAmountBaseUnit: Dnum | null, fallbackAssetAmount: number | undefined): string;
-interface UseAaveNativeSupplyArgs {
-    checkoutItem: FunkitActiveCheckoutItem | null;
+/**
+ * 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;
+/**
+ * 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(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: (humanAmount: string) => Promise<{
+    submit: (amount: AaveNativeSupplyAmount) => Promise<{
         txHash: Hex;
     } | null>;
     isPending: boolean;
     error: Error | null;
 }
-export declare function useAaveNativeSupply({ checkoutItem, }: UseAaveNativeSupplyArgs): UseAaveNativeSupplyResult;
+export declare function useAaveNativeSupply(): UseAaveNativeSupplyResult;
 export {};

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

@@ -1,14 +1,13 @@
-import { type MeldQuote, MeldServiceProvider } from '@funkit/api-base';
+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, onClose, }: {
+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;
-    onClose: () => void;
 }): {
     getMeldFooter: () => React.JSX.Element;
     handleMeldContinue: () => Promise<void>;
@@ -20,7 +19,7 @@ export declare function useMeld(meldEnabled: boolean, manuallySelectedQuote: Mel
     meldQuotesQuery: import("@tanstack/react-query").UseQueryResult<MeldQuote[]> & {
         isOutdated: boolean;
     };
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@funkit/api-base").MeldCreateCryptoWidgetResponse, Error, MeldServiceProvider, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@funkit/api-base").MeldCreateCryptoWidgetResponse, Error, import("@funkit/api-base").MeldServiceProvider, unknown>;
     isMeldLinkPending: boolean;
     meldLimitError: {
         issue: string;
@@ -29,7 +28,6 @@ export declare function useMeld(meldEnabled: boolean, manuallySelectedQuote: Mel
     bestRateQuote: MeldQuote | undefined;
     selectedQuote: MeldQuote | undefined;
     isSelectedQuoteUnavailable: boolean | undefined;
-    isMeldMoonpaySelected: boolean;
     isMeldContinueDisabled: boolean | undefined;
     getMeldError: () => ErrorNotification | undefined;
 };

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { PaymentMethodBitcoinLightningInfo } from '../../../domains/paymentMethods';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type LightningInvoiceState = CheckoutModalCommonState & {
+    paymentMethodInfo: PaymentMethodBitcoinLightningInfo;
+};
+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,8 @@
+import React from 'react';
+import { type BoxProps } from '../../../components/Box/Box';
+interface LightningInvoiceQrCodeProps {
+    qrCodeUri: string | undefined;
+    marginY?: BoxProps['marginY'];
+}
+export declare function LightningInvoiceQrCode({ qrCodeUri, marginY, }: LightningInvoiceQrCodeProps): React.JSX.Element;
+export {};

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

@@ -1,6 +1,9 @@
+import type { IndexedDynamicRoutingConfig } from '@funkit/fun-relay';
 import React from 'react';
 import { type PaymentMethodAccountInfo, type PaymentMethodBrokerageInfo } from '../../../domains/paymentMethods';
+import type { AssetHoldingsItem } from '../../../domains/wallet';
 import type { TransferTokenDefault } from '../../../hooks/useTokenAndChainDropdown';
+import { type DynamicTargetAssetCandidate } from '../../../providers/FunkitCheckoutContext';
 import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
 export type SelectAssetState = CheckoutModalCommonState & {
     paymentMethodInfo: PaymentMethodBrokerageInfo | PaymentMethodAccountInfo;
@@ -12,3 +15,4 @@ export type SelectAssetNext = {
 };
 export declare const SelectAssetInfo: ModalStepInfo<FunCheckoutStep.SELECT_ASSET>;
 export declare function SelectAsset({ modalState, onNext, onClose, }: ModalStepComponentProps<FunCheckoutStep.SELECT_ASSET>): React.JSX.Element;
+export declare function isTreatedAsNativeToken(apiKey: string, asset: AssetHoldingsItem, dynamicTargetAssetCandidates: DynamicTargetAssetCandidate[], findDynamicPath: IndexedDynamicRoutingConfig[string]['findPath']): boolean;

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

@@ -1,6 +1,6 @@
 import { type SwappedFormOfPayment } from '@funkit/api-base';
 import React from 'react';
-import { type ConnectablePaymentMethodInfo, PaymentMethod, type PaymentMethodCardInfo, type PaymentMethodVirtualBankIncompleteInfo } from '../../../domains/paymentMethods';
+import { type ConnectablePaymentMethodInfo, PaymentMethod, type PaymentMethodBitcoinLightningInfo, type PaymentMethodCardInfo, type PaymentMethodVirtualBankIncompleteInfo } from '../../../domains/paymentMethods';
 import { type PaymentMethodType } from '../../../hooks/usePaymentSources';
 import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
 export type SourceChangeState = CheckoutModalCommonState & {
@@ -14,7 +14,12 @@ export type SourceChangeNext = {
     brokerageFailed: false;
 } | {
     connectNew: true;
-    paymentMethod: Exclude<PaymentMethod, PaymentMethod.CARD | PaymentMethod.VIRTUAL_BANK>;
+    paymentMethod: Exclude<PaymentMethod, PaymentMethod.CARD | PaymentMethod.VIRTUAL_BANK | PaymentMethod.BITCOIN_LIGHTNING>;
+    brokerageFailed: false;
+} | {
+    connectNew: true;
+    paymentMethod: PaymentMethod.BITCOIN_LIGHTNING;
+    paymentMethodInfo: PaymentMethodBitcoinLightningInfo;
     brokerageFailed: false;
 } | {
     connectNew: true;

package/dist/modals/CheckoutModal/SourceChange/SourceChangeLoading.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-export declare function SourceChangeLoading({ onClose, }: {
+export declare function SourceChangeLoading({ onClose }: {
     onClose: () => void;
 }): React.JSX.Element;

package/dist/modals/CheckoutModal/TransferToken/CheckoutNotifications.d.ts

@@ -1,9 +1,3 @@
-import type { DirectExecution } from '@funkit/api-base';
 import React from 'react';
-import { type MergedMultiStepDirectExecution } from '../../../hooks/queries/useRecentDeposits';
 import type { CheckoutNotificationsProps } from './types';
 export declare const CheckoutNotifications: ({ onHelp, isVisible, variant, }: CheckoutNotificationsProps) => React.JSX.Element | null;
-/**
- * @returns checkouts that are either not present in the initial checkouts or the data changed somehow
- */
-export declare const getUpdatedDirectExecutions: (directExecutions: MergedMultiStepDirectExecution[], initialDirectExecutions?: DirectExecution[]) => MergedMultiStepDirectExecution[];

package/dist/modals/CheckoutModal/TransferToken/DirectExecutionNotification.d.ts

@@ -1,7 +1,7 @@
 import type { TFunction } from 'i18next';
 import React from 'react';
 import type { Address } from 'viem';
-import type { MergedMultiStepDirectExecution } from '../../../hooks/queries/useRecentDeposits';
+import type { MergedMultiStepDirectExecution } from '../../../domains/checkoutNotifications';
 interface DirectExecutionNotificationProps {
     directExecution: MergedMultiStepDirectExecution;
     onClose: (id: string) => void;

package/dist/modals/CheckoutModal/TransferToken/types.d.ts

@@ -1,12 +1,12 @@
 import type { CheckoutHistoryItem } from '@funkit/api-base';
 import type { Address } from 'viem';
-import type { MergedMultiStepDirectExecution } from '../../../hooks/queries/useRecentDeposits';
+import type { MergedMultiStepDirectExecution, NotificationVariant } from '../../../domains/checkoutNotifications';
+export type { NotificationVariant };
 export type NotificationItem = (MergedMultiStepDirectExecution & {
     isDirectExecution: true;
 }) | (CheckoutHistoryItem & {
     isDirectExecution: false;
 });
-export type NotificationVariant = 'deposit' | 'withdrawal' | 'token_transfer';
 export interface CheckoutNotificationsProps {
     onHelp: (depositAddress: Address) => void;
     /** To control notifications visibility on specific pages, without changing internal dismissal state */

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

@@ -0,0 +1,29 @@
+import { FunCheckoutStep } from './FunCheckoutStep';
+/**
+ * Decide whether the checkout-complete success background should paint.
+ *
+ * The post-checkout `CHECKOUT_COMPLETE` step is the *page*, which also covers
+ * pending and failed states — so step alone is not enough. We additionally
+ * require:
+ *  - the Statsig feature gate to be ON (kill-switch / per-customer rollout),
+ *  - and the underlying checkout/direct-execution to have actually settled.
+ *
+ * Pure function (no hooks) so the gating contract is easy to unit-test.
+ * The caller is responsible for deriving `isCompleted` from whichever hook
+ * is appropriate for the path (deposit-address checkout vs direct execution).
+ */
+export declare function selectSuccessScreenBackground({ step, isCompleted, isFeatureGateEnabled, themeBackgroundOverlay, }: {
+    step: FunCheckoutStep;
+    /** Whether the underlying checkout/direct-execution has reached COMPLETED. */
+    isCompleted: boolean;
+    /** Statsig gate (`enable-checkout-success-screen-background`). */
+    isFeatureGateEnabled: boolean;
+    /**
+     * The theme variable reference for the success-screen overlay
+     * (`themeVars.colors.modalBackgroundCheckoutComplete`). Resolves at runtime
+     * to whatever the active theme defines — Aave's translucent gradient
+     * stack, or by default the regular modal background (which renders as a
+     * no-op overlay).
+     */
+    themeBackgroundOverlay: string;
+}): string | undefined;

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

@@ -14,6 +14,7 @@ import { type CheckoutHelpState } from './CheckoutHelp/CheckoutHelp';
 import { type ConfirmationStepNext, type ConfirmationStepState } from './ConfirmationStep/ConfirmationStep';
 import { FunCheckoutStep } from './FunCheckoutStep';
 import { type InputAmountNext, type InputAmountState } from './InputAmount/InputAmount';
+import { type LightningInvoiceNext, type LightningInvoiceState } from './LightningInvoice/LightningInvoice';
 import { type LoadingAccountNext, type LoadingAccountState } from './LoadingAccount';
 import { type MeldCurrencySelectNext, type MeldCurrencySelectState } from './MeldCurrencySelect/MeldCurrencySelect';
 import { type MeldQuotesNext, type MeldQuotesState } from './MeldQuotes/MeldQuotes';
@@ -82,6 +83,7 @@ export type CheckoutModalState<S extends FunCheckoutStep = FunCheckoutStep> = {
         [FunCheckoutStep.SELECT_ASSET]: SelectAssetState;
         [FunCheckoutStep.SOURCE_CHANGE]: SourceChangeState;
         [FunCheckoutStep.TRANSFER_TOKEN]: TransferTokenState;
+        [FunCheckoutStep.LIGHTNING_INVOICE]: LightningInvoiceState;
         [FunCheckoutStep.CREATE_FIAT_ACCOUNT]: VirtualFiatAccountState;
         [FunCheckoutStep.BRIDGE_KYC]: BridgeKycState;
         [FunCheckoutStep.KYC_IFRAME]: KycIframeState;
@@ -110,6 +112,7 @@ export type NextPayload<S extends FunCheckoutStep = FunCheckoutStep> = {
     [FunCheckoutStep.SELECT_ASSET]: SelectAssetNext;
     [FunCheckoutStep.SOURCE_CHANGE]: SourceChangeNext;
     [FunCheckoutStep.TRANSFER_TOKEN]: TransferTokenNext;
+    [FunCheckoutStep.LIGHTNING_INVOICE]: LightningInvoiceNext;
     [FunCheckoutStep.CREATE_FIAT_ACCOUNT]: VirtualFiatAccountNext;
     [FunCheckoutStep.BRIDGE_KYC]: BridgeKycNext;
     [FunCheckoutStep.KYC_IFRAME]: KycIframeNext;

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

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

package/dist/providers/FunkitCheckoutContext/types.d.ts

@@ -27,6 +27,26 @@ export interface DynamicTargetAssetCandidate extends TokenInfo {
     finalizedTokenRate?: number;
     dynamicRoutingId?: string;
 }
+/**
+ * A token to offer adding to the user's wallet (EIP-747 `wallet_watchAsset`) on
+ * the post-checkout success screen.
+ *
+ * Set this when the token the user ends up holding differs from the checkout's
+ * destination token — e.g. a vault receipt token (Aave's aUSDT) minted by a
+ * post-swap supply action, where the checkout's `toTokenAddress` is the
+ * intermediate underlying (USDT), not the token the wallet should track.
+ *
+ * Purely a post-checkout UX affordance: nothing in quoting, routing, or amount
+ * display reads this field, so setting it cannot perturb a checkout's quote.
+ */
+export interface AddToWalletToken extends TokenInfo {
+    /** Symbol shown in the wallet prompt (e.g. "aUSDT"). */
+    tokenSymbol: string;
+    /** Token decimals. If omitted, the button reads `decimals()` on-chain. */
+    decimals?: number;
+    /** Optional token icon, passed to the wallet as `image`. */
+    iconSrc?: string;
+}
 export declare enum FunCheckoutStartingStep {
     SOURCE_CHANGE = "source_change",
     CONFIRMATION = "confirmation",
@@ -47,6 +67,20 @@ export interface FunkitCheckoutConfig extends Omit<ApiFunkitCheckoutConfig, 'gen
     modalTitle?: string | ((asset: TokenInfo) => string);
     /** Additional information to show in the title of the checkout modal. Blank by default **/
     modalTitleMeta?: string;
+    /**
+     * Integrator-provided, display-only yield metadata for the destination
+     * (e.g. an Aave/Felix/Benqi supply). The SDK never computes these — the
+     * integrator resolves them from their own data source and passes a snapshot
+     * at checkout-init time. When present, the confirmation screen renders it as
+     * Supply APY / Collateralization rows (`DestinationYieldRows`). Omitted
+     * segments are simply not rendered.
+     */
+    destinationYieldInfo?: {
+        /** Supply APY as a display string without the % sign (e.g. "2.79"). */
+        supplyApy?: string;
+        /** Whether the supply is/will be enabled as collateral for the user. */
+        collateralizationEnabled?: boolean;
+    };
     /** Icon to show in the checkout modal (50px x 50px). If not specified, no icon will be shown. **/
     iconSrc?: null | string;
     /** Title of the item being checked out. e.g. Staked Ether, XYZ Option, Solar Bond ABC **/
@@ -86,6 +120,13 @@ export interface FunkitCheckoutConfig extends Omit<ApiFunkitCheckoutConfig, 'gen
      * Set via dynamic routing rules.
      */
     bridgeOverride?: 'across' | 'relay';
+    /**
+     * Token to offer adding to the user's wallet on the post-checkout success
+     * screen via EIP-747 `wallet_watchAsset`. Set when the held token differs
+     * from the checkout's destination token (e.g. an Aave aUSDT receipt). See
+     * {@link AddToWalletToken}.
+     */
+    addToWalletToken?: AddToWalletToken;
 }
 export interface WithdrawalConfigBase {
     /** Title to show in the checkout modal. Defaults to "Checkout" **/

package/dist/providers/FunkitConfigContext.d.ts

@@ -127,8 +127,15 @@ export interface FunkitUiCustomizationsConfig {
         /** Whether to show "Instant" instead of "< 1 min" for time estimates under 1 minute - defaults to false */
         showInstantTimeEstimate?: boolean;
         /**
-         * Config for "Selected Route" row. When defined, the row is shown.
-         * Omit to hide the selected route row (default).
+         * Whether to show the "Selected Route" row (Relay / Across / passthrough).
+         * Defaults to false. Providing {@link selectedRouteConfig} also shows the
+         * row, for passthrough-branding back-compat.
+         */
+        showSelectedRoute?: boolean;
+        /**
+         * Passthrough-route branding (image + label) for the "Selected Route" row.
+         * Defining it also shows the row; to show the row without passthrough
+         * branding, use {@link showSelectedRoute} instead.
          */
         selectedRouteConfig?: FunkitUiSelectedRouteConfig;
         /**

package/dist/providers/FunkitHistoryContext.d.ts

@@ -38,7 +38,7 @@ export declare function useCheckoutListenerByCheckoutId(checkoutId: Hex | undefi
 /**
  * Internal hook to handle post-checkout, PER-BACKEND-CHECKOUT ITEM.
  */
-export declare const useFunkitPostCheckoutInternal: (checkoutId: string) => {
+export declare const useFunkitPostCheckoutInternal: (checkoutId: string | undefined) => {
     isLoading: boolean;
     checkoutHistoryInfo: CheckoutHistoryItem | undefined;
     directExecutionInfo: DirectExecution | undefined;

package/dist/providers/FunkitQuoteContext.d.ts

@@ -45,7 +45,23 @@ interface FunkitQuoteContextInterface extends CheckoutQuoteState {
     usePermit: boolean | undefined;
     preferredApprovalMethod: ApprovalMethod;
     setPreferredApprovalMethod: (next: ApprovalMethod) => void;
-    showApprovalToggle: boolean;
+    showApprovalMethodToggle: boolean;
+    /**
+     * Per-checkout EIP-2612 permit capability of the target asset. `undefined` =
+     * unknown (loading or feature-agnostic — Relay falls back server-side), set
+     * by prefetch hooks (e.g., Aave's `useAaveTargetReservePermit`). Folded into
+     * `showApprovalMethodToggle` so consumers don't need their own asset gate.
+     */
+    targetAssetSupportsPermit: boolean | undefined;
+    setTargetAssetSupportsPermit: (value: boolean | undefined) => void;
+    /**
+     * Current on-chain ERC-20 allowance from the user to the destination spender
+     * (e.g. the Aave Pool). When ≥ the supply amount, no approve / permit is
+     * needed and the toggle is hidden via `showApprovalMethodToggle`. `undefined`
+     * = unknown (loading or not applicable to this flow).
+     */
+    targetAssetPoolAllowance: bigint | undefined;
+    setTargetAssetPoolAllowance: (value: bigint | undefined) => void;
 }
 export declare function FunkitQuoteProvider({ children }: {
     children: ReactNode;

package/dist/providers/FunkitThemeProvider.d.ts

@@ -38,6 +38,7 @@ export declare const useActiveTheme: () => {
             chainIconBorder: string;
             modalBackdrop: string;
             modalBackground: string;
+            modalBackgroundCheckoutComplete: string;
             modalBorder: string;
             offBackground: string;
             offBackgroundInverse: string;
@@ -563,6 +564,7 @@ export declare const useActiveTheme: () => {
             chainIconBorder: string;
             modalBackdrop: string;
             modalBackground: string;
+            modalBackgroundCheckoutComplete: string;
             modalBorder: string;
             offBackground: string;
             offBackgroundInverse: string;
@@ -1086,6 +1088,7 @@ export declare const useActiveTheme: () => {
             chainIconBorder: string;
             modalBackdrop: string;
             modalBackground: string;
+            modalBackgroundCheckoutComplete: string;
             modalBorder: string;
             offBackground: string;
             offBackgroundInverse: string;