@funkit/connect 9.7.2-next.1 → 9.9.0

package/dist/clients/lighter.d.ts

@@ -13,39 +13,39 @@
  * Both callbacks conform to CustomWithdrawalConfig.withdrawCallback; the
  * caller provides the actual on-chain implementation.
  */
-import { type LighterAccountIndex } from '@funkit/api-base';
-import type { Address } from 'viem';
+import type { LighterAccountIndex } from '@funkit/api-base';
 import type { CustomWithdrawalConfig, MultiMethodWithdrawalConfig } from '../providers/FunkitCheckoutContext/types';
-/** Arbitrum USDC — the source token shown on the Fast withdrawal screen. */
-export declare const ARBITRUM_USDC: Address;
-/** Ethereum mainnet USDC — the source token shown on the Secure withdrawal screen. */
-export declare const MAINNET_USDC: Address;
-export interface LighterFastWithdrawalCallbackParams {
-    /** The UDA address to receive the withdrawn funds on the source chain. */
-    udaAddress: Address;
-    /** Amount in base units (from the quote). */
-    amountBaseUnit: bigint;
-}
-type LighterFastWithdrawalExec = (params: LighterFastWithdrawalCallbackParams) => Promise<void>;
-export interface LighterFastWithdrawalConfig {
-    userId: string;
-    modalTitle?: string;
-    disableConnectedWallet?: boolean;
-    iconSrc?: string;
-    /**
-     * Submit the Fast withdrawal on Lighter targeting the UDA. Routed through
-     * Fun + Relay so the destination can be any supported chain/token.
-     */
-    sendLighterFastWithdrawal: LighterFastWithdrawalExec;
-}
+export type LighterTransferParams = {
+    toAccountIndex: number;
+    assetIndex: number;
+    fromRouteType: number;
+    toRouteType: number;
+    amount: number;
+    usdcFee: number;
+    memo: string;
+    ethSigner?: {
+        signMessage: (message: string) => Promise<string>;
+    };
+    nonce?: number;
+};
+export type LighterTransaction = {
+    hash: string;
+    status: number | 'pending' | 'confirmed' | 'failed';
+    block_height?: number;
+    message?: string;
+};
+export type LighterSigner = {
+    transfer: (params: LighterTransferParams) => Promise<[unknown, string, string | null]>;
+};
 export interface LighterWithdrawalConfig {
-    userId: string;
+    accountIndex: string;
     /** Title shown on the selection screen. Defaults to "Withdraw". */
     modalTitle?: string;
     disableConnectedWallet?: boolean;
     fastIconSrc?: string;
     secureIconSrc?: string;
-    sendLighterFastWithdrawal: LighterFastWithdrawalExec;
+    /** Pre-built Lighter signer. l1Address and accountIndex are resolved internally. */
+    signerClient: LighterSigner;
     sendLighterSecureWithdrawal: LighterSecureWithdrawalExec;
     /**
      * Returns the minimum Secure withdrawal amount in token units for the given symbol.
@@ -64,7 +64,7 @@ export interface LighterSecureWithdrawalCallbackParams {
 }
 type LighterSecureWithdrawalExec = (params: LighterSecureWithdrawalCallbackParams) => Promise<string>;
 export interface LighterSecureWithdrawalConfig {
-    userId: string;
+    accountIndex: string;
     modalTitle?: string;
     disableConnectedWallet?: boolean;
     iconSrc?: string;
@@ -99,12 +99,10 @@ export declare function useLighterWithdrawalBalances({ accountIndex, }: {
 };
 /** Single-method config for Lighter's Secure withdrawal (bridge to Ethereum). */
 export declare function createLighterSecureWithdrawalConfig(config: LighterSecureWithdrawalConfig): CustomWithdrawalConfig;
-/** Single-method config for Lighter's Fast withdrawal. */
-export declare function createLighterFastWithdrawalConfig(config: LighterFastWithdrawalConfig): CustomWithdrawalConfig;
 /**
  * Hook version of {@link createLighterWithdrawalConfig}.
  *
- * Fetches all Lighter asset balances for `config.userId` and injects them as
+ * Fetches all Lighter asset balances for `config.accountIndex` and injects them as
  * `withdrawalSourceTokenBalance` into each method's config so the withdrawal
  * form displays and validates against the real Lighter account balance.
  *
@@ -113,8 +111,7 @@ export declare function createLighterFastWithdrawalConfig(config: LighterFastWit
  *
  * ```tsx
  * const withdrawalConfig = useLighterWithdrawalConfig({
- *   userId,
- *   sendLighterFastWithdrawal: ...,
+ *   accountIndex,
  *   sendLighterSecureWithdrawal: ...,
  * })
  * <WithdrawalModal config={withdrawalConfig} ... />
@@ -128,8 +125,7 @@ export declare function useLighterWithdrawalConfig(config: LighterWithdrawalConf
  * Usage:
  * ```ts
  * const withdrawalConfig = createLighterWithdrawalConfig({
- *   userId: walletAddress,
- *   sendLighterFastWithdrawal: async ({ udaAddress, amountBaseUnit }) => { ... },
+ *   accountIndex: '0',
  *   sendLighterSecureWithdrawal: async ({ amountTokenUnits, assetIndex }) => { ... },
  * })
  * ```

package/dist/clients/lighter.js

@@ -3,20 +3,15 @@ import {
   AsyncImage,
   Box,
   useFunkitTranslation
-} from "./chunk-3LSYVQXK.js";
-import {
-  generateClientMetadataForTokenTransfer
-} from "./chunk-V526Q43Z.js";
+} from "./chunk-LMEQD56M.js";
 import {
   logger
 } from "./chunk-H6F75ULR.js";
 
 // src/clients/lighter.tsx
-import {
-  LIGHTERXYZ_API_KEY as LIGHTERXYZ_API_KEY2,
-  initializeCheckoutTokenTransferAddress
-} from "@funkit/api-base";
 import { SOLANA_MAINNET_CHAIN_ID } from "@funkit/chains";
+import { RELAY_LIGHTER_CHAIN_ID } from "@funkit/fun-relay";
+import { retry } from "@lifeomic/attempt";
 import i18next from "i18next";
 import React2, { useEffect, useMemo as useMemo2 } from "react";
 import { arbitrum, base, bsc, mainnet as mainnet2, optimism } from "viem/chains";
@@ -281,8 +276,132 @@ function useLighterAccount(lookup, options) {
 }
 
 // src/clients/lighter.tsx
-var ARBITRUM_USDC = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+var LIGHTER_USDC_PERPS_ADDRESS = "0x0000000000000000000000000000000000000000";
 var MAINNET_USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+var LIGHTER_API_BASE = "https://mainnet.zklighter.elliot.ai";
+var LIGHTER_TX_STATUS = {
+  PENDING: 0,
+  QUEUED: 1,
+  COMMITTED: 2,
+  EXECUTED: 3,
+  FAILED: 4,
+  REJECTED: 5
+};
+function coerceLighterStatus(status) {
+  if (typeof status === "number") {
+    return status;
+  }
+  switch (status) {
+    case "confirmed":
+      return LIGHTER_TX_STATUS.EXECUTED;
+    case "failed":
+      return LIGHTER_TX_STATUS.FAILED;
+    default:
+      return LIGHTER_TX_STATUS.PENDING;
+  }
+}
+var LighterTerminalError = class extends Error {
+};
+async function pollLighterTransaction(txHash, options) {
+  const { pollIntervalMs, maxAttempts, waitFor } = options;
+  return retry(
+    async () => {
+      const resp = await fetch(
+        `${LIGHTER_API_BASE}/api/v1/tx?by=hash&value=${txHash}`
+      );
+      if (!resp.ok) {
+        throw new Error(`Lighter API error ${resp.status} for tx ${txHash}`);
+      }
+      const tx = await resp.json();
+      if (!tx.hash) {
+        throw new Error(`Lighter tx ${txHash} not found yet`);
+      }
+      const status = coerceLighterStatus(tx.status ?? LIGHTER_TX_STATUS.PENDING);
+      if (status === LIGHTER_TX_STATUS.FAILED || status === LIGHTER_TX_STATUS.REJECTED) {
+        const label = status === LIGHTER_TX_STATUS.FAILED ? "failed" : "rejected";
+        throw new LighterTerminalError(
+          `Lighter transaction ${label}: ${tx.message ?? "unknown error"}`
+        );
+      }
+      if (waitFor === "findable") {
+        return tx;
+      }
+      if (status === LIGHTER_TX_STATUS.COMMITTED || status === LIGHTER_TX_STATUS.EXECUTED) {
+        return tx;
+      }
+      throw new Error(
+        `Lighter transaction ${txHash} did not reach '${waitFor}' after ${maxAttempts} attempts`
+      );
+    },
+    {
+      maxAttempts,
+      delay: pollIntervalMs,
+      factor: 1,
+      jitter: false,
+      handleError: (err, context) => {
+        if (err instanceof LighterTerminalError) {
+          context.abort();
+        }
+      }
+    }
+  );
+}
+function createLighterAdaptedWallet({
+  signerClient,
+  accountIndex
+}) {
+  async function handleSendTransactionStep(_chainId, stepItem) {
+    const action = stepItem.data?.action;
+    if (!action || action.type !== "transfer") {
+      throw new Error(
+        `Unsupported Lighter action: ${action?.type ?? "undefined"}`
+      );
+    }
+    const p = action.parameters;
+    logger.info("lighter:wallet:transfer", p);
+    const [, txHash, error] = await signerClient.transfer({
+      toAccountIndex: p.toAccountIndex,
+      assetIndex: p.assetIndex,
+      fromRouteType: p.fromRouteType,
+      toRouteType: p.toRouteType,
+      amount: p.amount,
+      usdcFee: p.usdcFee,
+      memo: p.memo
+    });
+    if (error) {
+      throw new Error(`Lighter transfer failed: ${error}`);
+    }
+    if (!txHash) {
+      throw new Error("Lighter transfer returned no transaction hash");
+    }
+    logger.info("lighter:wallet:transfer:done", { txHash });
+    return txHash;
+  }
+  return {
+    vmType: "lvm",
+    getChainId: async () => Number(RELAY_LIGHTER_CHAIN_ID),
+    address: async () => accountIndex.toString(),
+    handleSignMessageStep: async () => {
+      throw new Error("Message signing not implemented for Lighter");
+    },
+    handleSendTransactionStep,
+    handleConfirmTransactionStep: async (txHash) => {
+      const tx = await pollLighterTransaction(txHash, {
+        pollIntervalMs: 2e3,
+        maxAttempts: 60,
+        waitFor: "findable"
+      });
+      return {
+        txHash: tx.hash,
+        blockHeight: tx.block_height ?? 0,
+        status: tx.status
+      };
+    },
+    // biome-ignore lint/suspicious/noEmptyBlockStatements: Lighter is single-chain — no switching needed
+    switchChain: async () => {
+    }
+  };
+}
 function freeBalance(balance, lockedBalance) {
   return String(Math.max(0, Number(balance) - Number(lockedBalance)));
 }
@@ -388,63 +507,41 @@ function createLighterSecureWithdrawalConfig(config) {
     getMinWithdrawalAmount: config.getMinWithdrawalAmount
   };
 }
-function buildFastWithdrawalCallback({
-  userId,
-  exec
+function buildLighterFastWalletWithdrawalConfig({
+  signerClient,
+  accountIndex,
+  modalTitle,
+  disableConnectedWallet,
+  iconSrc
 }) {
-  return async (param) => {
-    const { targetAssetAddress, targetChainId, destinationAddress, funQuote } = param;
-    logger.info("lighter:withdrawal:fast:start", {
-      targetChainId,
-      targetAssetAddress,
-      destinationAddress,
-      quoteId: param.quoteId
-    });
-    const transferInit = await initializeCheckoutTokenTransferAddress({
-      apiKey: LIGHTERXYZ_API_KEY2,
-      userId,
-      recipientAddr: destinationAddress,
-      toChainId: targetChainId.toString(),
-      toTokenAddress: targetAssetAddress,
-      logger,
-      clientMetadata: {
-        ...generateClientMetadataForTokenTransfer(),
-        isWithdrawal: true
-      }
-    });
-    const udaAddress = transferInit.depositAddr;
-    const quote = funQuote;
-    const amountStr = quote?.baseQuote?.estTotalFromAmountBaseUnit;
-    if (!amountStr) {
-      logger.error(
-        "lighter:withdrawal:fast:missingAmountInQuote",
-        new Error("Missing withdrawal amount in quote"),
-        { quote, udaAddress, targetChainId, targetAssetAddress }
-      );
-      return;
+  const adaptedWallet = createLighterAdaptedWallet({
+    signerClient,
+    accountIndex
+  });
+  const wallet = {
+    _type: "lighter",
+    adaptedWallet,
+    address: () => String(accountIndex),
+    getChainId: async () => Number(RELAY_LIGHTER_CHAIN_ID),
+    // biome-ignore lint/suspicious/noEmptyBlockStatements: no-op — Lighter has no EVM chain switching
+    switchChain: async () => {
+    },
+    sendTransaction: async () => {
+      throw new Error("Use adaptedWallet for Lighter execution");
+    },
+    confirmTransaction: async () => {
+      throw new Error("Use adaptedWallet for Lighter execution");
     }
-    await exec({ udaAddress, amountBaseUnit: BigInt(amountStr) });
-    logger.info("lighter:withdrawal:fast:submitted", {
-      udaAddress,
-      amountBaseUnit: amountStr
-    });
   };
-}
-function createLighterFastWithdrawalConfig(config) {
   return {
-    modalTitle: config.modalTitle ?? i18next.t("withdrawal.withdraw"),
-    disableConnectedWallet: config.disableConnectedWallet,
-    withdrawCallback: buildFastWithdrawalCallback({
-      userId: config.userId,
-      exec: config.sendLighterFastWithdrawal
-    }),
-    // Fast withdrawals source USDC out of Lighter Perps; Relay takes over
-    // on Arbitrum and routes to any supported destination token/chain.
-    sourceChainId: arbitrum.id.toString(),
+    modalTitle: modalTitle ?? i18next.t("withdrawal.withdraw"),
+    disableConnectedWallet,
+    wallet,
+    sourceChainId: RELAY_LIGHTER_CHAIN_ID,
     sourceTokenSymbol: "USDC",
     defaultReceiveToken: "USDC",
-    sourceTokenAddress: ARBITRUM_USDC,
-    iconSrc: config.iconSrc ?? "https://sdk-cdn.fun.xyz/images/logos/lighter.png",
+    sourceTokenAddress: LIGHTER_USDC_PERPS_ADDRESS,
+    iconSrc: iconSrc ?? "https://sdk-cdn.fun.xyz/images/logos/lighter.png",
     getMinWithdrawalUSD: () => 4
   };
 }
@@ -484,15 +581,15 @@ function buildLighterMultiMethodConfig({
   t,
   withBalance
 }) {
-  const fastConfig = createLighterFastWithdrawalConfig({
-    userId: config.userId,
+  const fastConfig = buildLighterFastWalletWithdrawalConfig({
+    signerClient: config.signerClient,
+    accountIndex: Number(config.accountIndex),
     modalTitle: config.modalTitle,
     disableConnectedWallet: config.disableConnectedWallet,
-    iconSrc: config.fastIconSrc,
-    sendLighterFastWithdrawal: config.sendLighterFastWithdrawal
+    iconSrc: config.fastIconSrc
   });
   const secureConfig = createLighterSecureWithdrawalConfig({
-    userId: config.userId,
+    accountIndex: config.accountIndex,
     modalTitle: config.modalTitle,
     disableConnectedWallet: config.disableConnectedWallet,
     iconSrc: config.secureIconSrc,
@@ -534,7 +631,7 @@ function buildLighterMultiMethodConfig({
 function useLighterWithdrawalConfig(config) {
   const { t } = useFunkitTranslation();
   const { balances } = useLighterWithdrawalBalances({
-    accountIndex: asLighterAccountIndex(config.userId)
+    accountIndex: asLighterAccountIndex(config.accountIndex)
   });
   return useMemo2(
     () => buildLighterMultiMethodConfig({
@@ -552,9 +649,6 @@ function createLighterWithdrawalConfig(config) {
   });
 }
 export {
-  ARBITRUM_USDC,
-  MAINNET_USDC,
-  createLighterFastWithdrawalConfig,
   createLighterSecureWithdrawalConfig,
   createLighterWithdrawalConfig,
   freeBalance,

package/dist/components/ApprovalMethodToggle/ApprovalMethodToggle.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { ApprovalMethod } from '../../providers/FunkitQuoteContext';
+interface ApprovalMethodToggleProps {
+    value: ApprovalMethod;
+    onChange: (next: ApprovalMethod) => void;
+    disabled?: boolean;
+    testId?: string;
+}
+/**
+ * A small dropdown selector for the user's preferred source-side
+ * authorization method ("Approve transaction" vs "Signed message").
+ *
+ * Pure presentation: state lives in `useApprovalMethodSelection`. The
+ * component is screen-agnostic so it can be mounted on either
+ * `ConfirmationStep` (non-native flow) or `InputAmount` (native flow,
+ * future) without changes.
+ */
+export declare function ApprovalMethodToggle({ value, onChange, disabled, testId, }: ApprovalMethodToggleProps): React.JSX.Element;
+export {};

package/dist/components/Dropdown/BaseActiveDropdownItem.d.ts

@@ -14,9 +14,10 @@ export interface BaseActiveDropdownItemProps {
     color?: BoxProps['color'];
     arrowColor?: BoxProps['color'];
     background?: BoxProps['background'];
+    labelStyle?: React.CSSProperties;
 }
 /**
  * Represents the component used to open the dropdown, usually displayed all the time.
  */
-declare function BaseActiveDropdownItem({ iconComponent, label, isOpened, onClick, horizontalIconGap, alwaysVisibleLabel, tagComponent, tagPosition, size, color, arrowColor, background, }: BaseActiveDropdownItemProps): React.JSX.Element;
+declare function BaseActiveDropdownItem({ iconComponent, label, isOpened, onClick, horizontalIconGap, alwaysVisibleLabel, tagComponent, tagPosition, size, color, arrowColor, background, labelStyle, }: BaseActiveDropdownItemProps): React.JSX.Element;
 export default BaseActiveDropdownItem;

package/dist/components/Dropdown/BaseDropdown.d.ts

@@ -2,36 +2,22 @@ import React from 'react';
 import { type BoxProps } from '../Box/Box';
 import { type BaseActiveDropdownItemProps } from './BaseActiveDropdownItem';
 import './BaseDropdownAnimation.css';
+import { type BaseDropdownGroup, type BaseDropdownOption } from './BaseDropdown.utils';
+export type { BaseDropdownGroup, BaseDropdownOption, } from './BaseDropdown.utils';
+export { NO_SELECTION_VALUE } from './BaseDropdown.utils';
 /** gap between the icon and the label of the item */
 export declare const HORIZONTAL_ICON_GAP = "4";
 /** safe spacing, ie. padding, on the left & right of the active item and dropdown item */
 export declare const HORIZONTAL_OUTER_PADDING_X = "12";
-export declare const NO_SELECTION_VALUE = "";
-export interface BaseDropdownOption<T = string, G extends string = never> {
-    label: string;
-    value: T;
-    /**
-     * For grouped dropdowns, this is the {@link BaseDropdownGroup.key} of the group this option belongs to.
-     *
-     * If omitted, or if no group has the key, the option is treated as ungrouped.
-     *
-     * _See {@link BaseDropdownProps.groups} and {@link BaseDropdownProps.showOthersGroup}_
-     */
-    group?: G;
-}
-export interface BaseDropdownGroup<G extends string> {
-    key: G;
-    label: string;
-}
 export interface BaseDropdownProps<T = string, G extends string = never> {
     value: string;
-    activeItemProps?: Partial<Pick<BaseActiveDropdownItemProps, 'iconComponent' | 'label' | 'color' | 'alwaysVisibleLabel' | 'tagComponent' | 'tagPosition' | 'background'>>;
+    activeItemProps?: Partial<Pick<BaseActiveDropdownItemProps, 'iconComponent' | 'label' | 'color' | 'alwaysVisibleLabel' | 'tagComponent' | 'tagPosition' | 'background' | 'labelStyle'>>;
     /**
      * List of groups to show and the corresponding labels, in the expected order.
      *
      * _Defaults to ungrouped dropdown behavior_
      */
-    groups?: BaseDropdownGroup<G>[];
+    groups?: BaseDropdownGroup<T, G>[];
     /**
      * Additional group displayed after configured groups (only if there are non-empty groups).
      * - "all": display all options (grouped options will effectively be shown twice in total)
@@ -56,10 +42,10 @@ export interface BaseDropdownProps<T = string, G extends string = never> {
      * Label for {@link allowUnselect}
      */
     unselectLabel?: string;
-    options: BaseDropdownOption<T, G>[];
+    options: BaseDropdownOption<T>[];
     onOpen?: () => void;
-    onOptionSelected?: (item: BaseDropdownOption<T, G>) => void;
-    renderDropdownOption: (item: BaseDropdownOption<T, G>, isSelected: boolean) => React.ReactNode;
+    onOptionSelected?: (item: BaseDropdownOption<T>) => void;
+    renderDropdownOption: (item: BaseDropdownOption<T>, isSelected: boolean) => React.ReactNode;
     searchableOptions?: boolean;
     searchPlaceholder?: string;
     placeholder?: string;
@@ -79,7 +65,9 @@ export interface BaseDropdownProps<T = string, G extends string = never> {
      * This values should be set so that the last dropdown item is partially visible to indicate that there are more options.
      */
     maxDropdownHeight?: number;
+    dropdownWidth?: number;
+    dropdownAlign?: 'start' | 'center' | 'end';
     testId?: string;
 }
-declare function BaseDropdown<T extends string = string, G extends string = never>({ activeItemProps, value, options, groups, additionalGroup, additionalGroupLabel, allowUnselect, unselectLabel, onOptionSelected, onOpen, renderDropdownOption, searchableOptions, searchPlaceholder, placeholder, resetSearchOnClose, openToTopOnMobile, alwaysOpenToTop, openDropdownFullWidth, isLoading, preloadIconUrls, horizontalIconGap, openDropdownBackgroundColor, size, label, maxDropdownHeight, testId, }: BaseDropdownProps<T, G>): React.JSX.Element;
+declare function BaseDropdown<T extends string = string, G extends string = never>({ activeItemProps, value, options, groups, additionalGroup, additionalGroupLabel, allowUnselect, unselectLabel, onOptionSelected, onOpen, renderDropdownOption, searchableOptions, searchPlaceholder, placeholder, resetSearchOnClose, openToTopOnMobile, alwaysOpenToTop, openDropdownFullWidth, isLoading, preloadIconUrls, horizontalIconGap, openDropdownBackgroundColor, size, label, maxDropdownHeight, dropdownWidth, dropdownAlign, testId, }: BaseDropdownProps<T, G>): React.JSX.Element;
 export default BaseDropdown;

package/dist/components/Dropdown/BaseDropdown.utils.d.ts

@@ -0,0 +1,23 @@
+export declare const NO_SELECTION_VALUE = "";
+export declare const ADDITIONAL_GROUP_KEY = "__additional__";
+export interface BaseDropdownOption<T = string> {
+    label: string;
+    value: T;
+}
+export interface BaseDropdownGroup<T = string, G extends string = never> {
+    key: G;
+    label: string;
+    values: T[];
+}
+export interface OrganizedDropdownGroup<T, G extends string> {
+    key: G | typeof ADDITIONAL_GROUP_KEY | typeof NO_SELECTION_VALUE;
+    label: string | undefined;
+    options: BaseDropdownOption<T>[];
+}
+export interface OrganizeDropdownGroupsResult<T, G extends string> {
+    organizedGroups: OrganizedDropdownGroup<T, G>[];
+    organizedOptions: BaseDropdownOption<T>[];
+}
+export declare function buildAllOptions<T extends string>(options: BaseDropdownOption<T>[], allowUnselect: boolean, unselectLabel?: string): BaseDropdownOption<T>[];
+export declare function filterOptions<T extends string>(allOptions: BaseDropdownOption<T>[], searchInput: string): BaseDropdownOption<T>[];
+export declare function organizeDropdownGroups<T extends string, G extends string>(filteredOptions: BaseDropdownOption<T>[], groups: BaseDropdownGroup<T, G>[] | undefined, additionalGroup: 'all' | 'others', additionalGroupLabel: string | undefined): OrganizeDropdownGroupsResult<T, G>;

package/dist/components/Dropdown/ChainDropdown.d.ts

@@ -23,7 +23,8 @@ interface ChainDropdownProps {
     alwaysOpenToTop?: BaseDropdownProps['alwaysOpenToTop'];
     maxDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
     tagComponent?: (value: string) => React.ReactNode;
+    placeholder?: string;
     testId?: string;
 }
-export declare const ChainDropdown: ({ assets, chainIdSortOrder, selectedChainId: propSelectedChainId, selectedToken, allowUnselect, onChainSelected, activeItemProps, size, openDropdownBackgroundColor, openDropdownFullWidth, isLoading, alwaysOpenToTop, maxDropdownHeight, tagComponent, testId, }: ChainDropdownProps) => React.JSX.Element;
+export declare const ChainDropdown: ({ assets, chainIdSortOrder, selectedChainId: propSelectedChainId, selectedToken, allowUnselect, onChainSelected, activeItemProps, size, openDropdownBackgroundColor, openDropdownFullWidth, isLoading, alwaysOpenToTop, maxDropdownHeight, tagComponent, placeholder, testId, }: ChainDropdownProps) => React.JSX.Element;
 export {};

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

@@ -3,8 +3,8 @@ import type { TokenTransferSourceChainsAndAssets } from '../../modals/CheckoutMo
 import type { BaseDropdownProps } from './BaseDropdown';
 interface TokenAndChainDropdownProps {
     isLoading: boolean;
-    selectedToken: string;
-    selectedChainId: number;
+    selectedToken: string | undefined;
+    selectedChainId: number | undefined;
     assets: TokenTransferSourceChainsAndAssets;
     /**
      * Callback fired after token selection
@@ -16,6 +16,10 @@ interface TokenAndChainDropdownProps {
     onChainSelected: (chainId?: number, autoUpdate?: boolean) => void;
     tokenLabel?: string;
     chainLabel?: string;
+    /** Placeholder shown in the token dropdown when no token is selected */
+    tokenPlaceholder?: string;
+    /** Placeholder shown in the chain dropdown when no chain is selected */
+    chainPlaceholder?: string;
     chainLabelAddon?: ReactNode;
     alwaysOpenToTop?: boolean;
     maxTokenDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
@@ -26,11 +30,13 @@ interface TokenAndChainDropdownProps {
      * Override to hide the new token badge
      */
     hideNewTokenBadge?: boolean;
+    /** Token symbols to show in a separate "Popular" group */
+    popularTokenSymbols?: string[];
     /** Token symbols to prioritize at top of dropdown */
     priorityTokenSymbols?: string[];
     /** Determines the chain display order */
     chainIdSortOrder?: number[];
 }
 /** Combines together chain and token dropdowns */
-export declare const TokenAndChainDropdown: ({ isLoading, selectedToken, selectedChainId, assets, onTokenSelected, onChainSelected, tokenLabel, chainLabel, chainLabelAddon, alwaysOpenToTop, maxTokenDropdownHeight, maxChainDropdownHeight, openChainDropdownFullWidth, chainTagComponent, hideNewTokenBadge, priorityTokenSymbols, chainIdSortOrder, }: TokenAndChainDropdownProps) => React.JSX.Element;
+export declare const TokenAndChainDropdown: ({ isLoading, selectedToken, selectedChainId, assets, onTokenSelected, onChainSelected, tokenLabel, chainLabel, tokenPlaceholder, chainPlaceholder, chainLabelAddon, alwaysOpenToTop, maxTokenDropdownHeight, maxChainDropdownHeight, openChainDropdownFullWidth, chainTagComponent, hideNewTokenBadge, popularTokenSymbols, priorityTokenSymbols, chainIdSortOrder, }: TokenAndChainDropdownProps) => React.JSX.Element;
 export {};

package/dist/components/Dropdown/TokenDropdown.d.ts

@@ -2,14 +2,14 @@ import React from 'react';
 import type { TokenTransferSourceChainsAndAssets } from '../../modals/CheckoutModal/TransferToken/TransferToken';
 import { type BaseDropdownProps } from './BaseDropdown';
 interface TokenDropdownProps {
-    selectedChainId: number;
+    selectedChainId: number | undefined;
     assets: TokenTransferSourceChainsAndAssets;
     onTokenSelected: (token: string, chainId?: number, 
     /**
      * If true, it will trigger automatic updates for the matching chain in the parent component.
      */
     autoUpdate?: boolean) => void;
-    selectedToken?: string;
+    selectedToken: string | undefined;
     isLoading?: BaseDropdownProps['isLoading'];
     alwaysOpenToTop?: BaseDropdownProps['alwaysOpenToTop'];
     maxDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
@@ -17,12 +17,16 @@ interface TokenDropdownProps {
      * Override to hide the new token badge
      */
     hideNewTokenBadge?: boolean;
+    /** Token symbols to show in a separate "Popular" group */
+    popularTokenSymbols?: string[];
     /** Token symbols to prioritize at top of dropdown */
     priorityTokenSymbols?: string[];
+    /** Placeholder shown when no token is selected */
+    placeholder?: string;
     /**
      * Test ID for the token dropdown
      */
     testId?: string;
 }
-export declare const TokenDropdown: ({ assets, selectedChainId, selectedToken, onTokenSelected, isLoading, alwaysOpenToTop, maxDropdownHeight, hideNewTokenBadge, priorityTokenSymbols, testId, }: TokenDropdownProps) => React.JSX.Element;
+export declare const TokenDropdown: ({ assets, selectedChainId, selectedToken, onTokenSelected, isLoading, alwaysOpenToTop, maxDropdownHeight, hideNewTokenBadge, popularTokenSymbols, priorityTokenSymbols, placeholder, testId, }: TokenDropdownProps) => React.JSX.Element;
 export {};

package/dist/domains/asset.d.ts

@@ -8,7 +8,6 @@ import { PaymentMethod } from '../domains/paymentMethods';
  * Accounts for the customer's configured minimum deposit and a global floor.
  */
 export declare function getMinValueThreshold(config: FunkitCheckoutConfig | undefined, minUsdRequired?: number): number;
-export declare const isStablecoin: (symbol: string) => boolean;
 export declare function isPreferredChain(chainId: number, additionalChains?: number[]): boolean;
 export declare function isNativeTokenAddress(address: Address): boolean;
 export declare function isDefaultToken(asset: AssetHoldingsItem, checkoutConfig: FunkitCheckoutConfig): boolean;

package/dist/domains/quote.d.ts

@@ -13,7 +13,15 @@ export interface FunkitCheckoutQuoteResult extends Omit<ApiFunkitCheckoutQuoteRe
     finalSpreadUsd: string;
     finalFeesBreakdown: CheckoutFees;
 }
-export declare function getCheckoutBaseQuote(checkoutItem: FunkitActiveCheckoutItem, userId: string, walletAddress: Address, apiKey: string, wagmiConfig: Config, directExecutionInfo: FunkitDirectExecutionInfo, senderAddress?: Address, isWithdrawal?: boolean, quoteBuilder?: QuoteBuilder): Promise<CheckoutQuoteResponse>;
+export declare function getCheckoutBaseQuote(checkoutItem: FunkitActiveCheckoutItem, userId: string, walletAddress: Address, apiKey: string, wagmiConfig: Config, directExecutionInfo: FunkitDirectExecutionInfo, senderAddress?: Address, isWithdrawal?: boolean, quoteBuilder?: QuoteBuilder, 
+/**
+ * User-driven preference for the source-side authorization step. Forwarded
+ * to the direct-execution branch (`getDirectExecutionQuote` →
+ * `getCheckoutQuoteV2`) where Relay's `usePermit` flag actually flows. The
+ * legacy `getApiCheckoutQuote` branch ignores this; the permit toggle is
+ * scoped to Wallet (Relay direct-execution) only.
+ */
+usePermit?: boolean): Promise<CheckoutQuoteResponse>;
 export declare function getQuoteFinalEstimation(baseQuote: CheckoutQuoteResponse, checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, wagmiConfig: Config, apiKey: string, loginType: LoginType, isWithdrawal?: boolean, brokerageQuote?: BluvoBrokerageQuote): Promise<{
     finalEstimation: FunkitCheckoutQuoteResult;
     brokerage?: BrokerageDetails;

package/dist/domains/quoteMode/exactOut.d.ts

@@ -1,2 +1,3 @@
+import type { IsStablecoinFn } from '../../hooks/useIsStablecoin';
 import { type QuoteBuilder } from './types';
-export declare function createExactOutBuilder(): QuoteBuilder;
+export declare function createExactOutBuilder(isStablecoin: IsStablecoinFn): QuoteBuilder;

package/dist/domains/quoteMode/resolveQuoteMode.d.ts

@@ -1,7 +1,9 @@
+import type { IsStablecoinFn } from '../../hooks/useIsStablecoin';
 import { type QuoteBuilder } from './types';
 export interface ResolveQuoteBuilderParams {
     hasPostAction: boolean | undefined;
     isExactInEnabled: boolean;
+    isStablecoin: IsStablecoinFn;
     providerSupportsExactInWithActions?: boolean;
 }
 /**
@@ -17,4 +19,4 @@ export interface ResolveQuoteBuilderParams {
  * Note: ONE_TO_ONE (subsidized routes) is not yet auto-detected.
  * It will be enabled in a future phase when subsidy detection is implemented.
  */
-export declare function resolveQuoteBuilder({ hasPostAction, isExactInEnabled, providerSupportsExactInWithActions, }: ResolveQuoteBuilderParams): QuoteBuilder;
+export declare function resolveQuoteBuilder({ hasPostAction, isExactInEnabled, isStablecoin, providerSupportsExactInWithActions, }: ResolveQuoteBuilderParams): QuoteBuilder;