@funkit/connect 9.7.1 → 9.7.2-next.1

package/dist/clients/lighter.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Lighter.xyz withdrawal.
+ *
+ * Lighter supports two withdrawal types — the SDK exposes them as a
+ * multi-method config so the user is shown a selection screen first:
+ *
+ * 1. **Fast** — routed through Fun + Relay. USDC Perps only. Multiple
+ *    destination chains/tokens supported. Completes in seconds.
+ * 2. **Secure** — Lighter's native bridge to Ethereum mainnet. Supports all
+ *    Lighter assets. Destination chain is locked to Ethereum and the
+ *    destination token matches the source. Completion ~60+ minutes.
+ *
+ * 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 { 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 interface LighterWithdrawalConfig {
+    userId: string;
+    /** Title shown on the selection screen. Defaults to "Withdraw". */
+    modalTitle?: string;
+    disableConnectedWallet?: boolean;
+    fastIconSrc?: string;
+    secureIconSrc?: string;
+    sendLighterFastWithdrawal: LighterFastWithdrawalExec;
+    sendLighterSecureWithdrawal: LighterSecureWithdrawalExec;
+    /**
+     * Returns the minimum Secure withdrawal amount in token units for the given symbol.
+     *
+     * ```ts
+     * getSecureMinWithdrawalAmount: (symbol) => ({ USDC: 1, ETH: 0.001 }[symbol] ?? 0)
+     * ```
+     */
+    getSecureMinWithdrawalAmount?: (symbol: string) => number;
+}
+export interface LighterSecureWithdrawalCallbackParams {
+    /** Withdrawal amount in token units (e.g. "1.5" for 1.5 ETH). */
+    amountTokenUnits: string;
+    /** The Lighter asset index (e.g. 1 for ETH, 3 for USDC). */
+    assetIndex: number;
+}
+type LighterSecureWithdrawalExec = (params: LighterSecureWithdrawalCallbackParams) => Promise<string>;
+export interface LighterSecureWithdrawalConfig {
+    userId: string;
+    modalTitle?: string;
+    disableConnectedWallet?: boolean;
+    iconSrc?: string;
+    /**
+     * Submit the Secure withdrawal on Lighter's L2. Funds bridge directly to
+     * Ethereum mainnet. No relay/swap — the token withdrawn is the token received.
+     */
+    sendLighterSecureWithdrawal: LighterSecureWithdrawalExec;
+    /**
+     * Returns the minimum withdrawal amount in token units for the given symbol.
+     *
+     * ```ts
+     * getMinWithdrawalAmount: (symbol) => ({ USDC: 1, ETH: 0.001 }[symbol] ?? 0)
+     * ```
+     */
+    getMinWithdrawalAmount?: (symbol: string) => number;
+}
+/** Free (withdrawable) balance for a single Lighter asset: balance - locked. */
+export declare function freeBalance(balance: string, lockedBalance: string): string;
+/**
+ * Fetches all asset balances for a Lighter account. Returns:
+ *
+ * - `balances` — `Record<SYMBOL, freeBalance>` (uppercased symbol keys)
+ * - `assets` — raw asset list from the API (for building source-token options)
+ */
+export declare function useLighterWithdrawalBalances({ accountIndex, }: {
+    accountIndex: LighterAccountIndex | undefined;
+}): {
+    balances: Record<string, string>;
+    assets: import("../utils/customer").LighterAsset[];
+    isLoading: boolean;
+};
+/** 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
+ * `withdrawalSourceTokenBalance` into each method's config so the withdrawal
+ * form displays and validates against the real Lighter account balance.
+ *
+ * Drop-in replacement for `createLighterWithdrawalConfig` — call it in any
+ * React component/hook and pass the result directly to the withdrawal modal:
+ *
+ * ```tsx
+ * const withdrawalConfig = useLighterWithdrawalConfig({
+ *   userId,
+ *   sendLighterFastWithdrawal: ...,
+ *   sendLighterSecureWithdrawal: ...,
+ * })
+ * <WithdrawalModal config={withdrawalConfig} ... />
+ * ```
+ */
+export declare function useLighterWithdrawalConfig(config: LighterWithdrawalConfig): MultiMethodWithdrawalConfig;
+/**
+ * Creates a full {@link MultiMethodWithdrawalConfig} for Lighter that renders
+ * the Fast vs Secure selection screen before the standard withdrawal flow.
+ *
+ * Usage:
+ * ```ts
+ * const withdrawalConfig = createLighterWithdrawalConfig({
+ *   userId: walletAddress,
+ *   sendLighterFastWithdrawal: async ({ udaAddress, amountBaseUnit }) => { ... },
+ *   sendLighterSecureWithdrawal: async ({ amountTokenUnits, assetIndex }) => { ... },
+ * })
+ * ```
+ */
+export declare function createLighterWithdrawalConfig(config: LighterWithdrawalConfig): MultiMethodWithdrawalConfig;
+export {};

package/dist/clients/lighter.js

@@ -0,0 +1,563 @@
+"use client";
+import {
+  AsyncImage,
+  Box,
+  useFunkitTranslation
+} from "./chunk-3LSYVQXK.js";
+import {
+  generateClientMetadataForTokenTransfer
+} from "./chunk-V526Q43Z.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 i18next from "i18next";
+import React2, { useEffect, useMemo as useMemo2 } from "react";
+import { arbitrum, base, bsc, mainnet as mainnet2, optimism } from "viem/chains";
+
+// src/components/Icons/EvmWallet.tsx
+import React from "react";
+var EvmWallet = ({ size = 20 }) => /* @__PURE__ */ React.createElement(
+  "svg",
+  {
+    width: size,
+    height: size,
+    viewBox: "0 0 20 20",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  },
+  /* @__PURE__ */ React.createElement(
+    "path",
+    {
+      d: "M13.3333 6.66628V3.75016C13.3333 3.05704 13.3333 2.71048 13.1873 2.49751C13.0598 2.31143 12.8622 2.18503 12.6398 2.14718C12.3852 2.10386 12.0706 2.24909 11.4413 2.53955L4.04918 5.95127C3.48792 6.21031 3.20729 6.33984 3.00175 6.54071C2.82005 6.71829 2.68135 6.93507 2.59625 7.17447C2.5 7.44527 2.5 7.75435 2.5 8.3725V12.4996M13.75 12.0829H13.7583M2.5 9.33295L2.5 14.8329C2.5 15.7664 2.5 16.2331 2.68166 16.5896C2.84144 16.9032 3.09641 17.1582 3.41002 17.318C3.76654 17.4996 4.23325 17.4996 5.16667 17.4996H14.8333C15.7668 17.4996 16.2335 17.4996 16.59 17.318C16.9036 17.1582 17.1586 16.9032 17.3183 16.5896C17.5 16.2331 17.5 15.7664 17.5 14.8329V9.33295C17.5 8.39953 17.5 7.93282 17.3183 7.5763C17.1586 7.26269 16.9036 7.00773 16.59 6.84794C16.2335 6.66628 15.7668 6.66628 14.8333 6.66628L5.16667 6.66628C4.23325 6.66628 3.76654 6.66628 3.41002 6.84793C3.09641 7.00772 2.84144 7.26269 2.68166 7.57629C2.5 7.93281 2.5 8.39952 2.5 9.33295ZM14.1667 12.0829C14.1667 12.3131 13.9801 12.4996 13.75 12.4996C13.5199 12.4996 13.3333 12.3131 13.3333 12.0829C13.3333 11.8528 13.5199 11.6663 13.75 11.6663C13.9801 11.6663 14.1667 11.8528 14.1667 12.0829Z",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  )
+);
+
+// src/providers/provideFunkitConnectChains.ts
+import { chainMetadataById } from "@funkit/chains";
+
+// src/utils/customer.ts
+import { useQuery } from "@tanstack/react-query";
+
+// src/consts/customers.ts
+import {
+  AVANTIS_API_KEY,
+  BASED_API_KEY,
+  BSX_API_KEY,
+  ETHEREAL_API_KEY,
+  FANATICS_API_KEY,
+  HYENA_API_KEY,
+  HYPERDASH_API_KEY,
+  LIGHTERXYZ_API_KEY,
+  MONAD_API_KEY,
+  MONKEY_TILT_API_KEY,
+  OSTIUM_API_KEY,
+  PERPL_API_KEY,
+  POLYMARKET_API_KEY
+} from "@funkit/api-base";
+import { mainnet } from "viem/chains";
+function isLighterxyzCustomer(apiKey) {
+  return apiKey === LIGHTERXYZ_API_KEY;
+}
+
+// src/providers/FunkitConfigContext.tsx
+import {
+  createContext,
+  useContext,
+  useMemo
+} from "react";
+var DEFAULT_TEXT_CUSTOMIZATIONS = {
+  virtualFiat: "Deposit with SEPA",
+  brokerageOrExchange: "Connect Exchange",
+  debitOrCredit: "Deposit with Card",
+  accountBalance: "Wallet",
+  selectAccount: "Select an exchange",
+  sourceMethodTitle: "Your source",
+  tokensListTitle: "Your tokens",
+  transferTokens: "Transfer Crypto",
+  receiveDropdownTitle: "",
+  // Default to empty
+  receiveDropdownLabel: "Asset to Receive",
+  confirmationScreen: {
+    payAmountLabel: "You send",
+    receiveAmountLabel: "You receive"
+  },
+  paymentMethodSubtitles: {}
+};
+var DEFAULT_UI_CUSTOMIZATIONS = {
+  alignTitle: "center",
+  alwaysShowTopDivider: false,
+  showModalTitle: true,
+  callToActionsUppercase: false,
+  enableCompactList: false,
+  checkoutHistory: {
+    showGetHelpAsAlert: true,
+    simplifiedUi: false
+  },
+  confirmationScreen: {
+    preferDestinationWhenSame: false,
+    showAmountSummaryAbovePaymentMethod: false,
+    showDisclaimerAsAlert: true,
+    showInstantTimeEstimate: false,
+    showLeftAlignedDollarValueWithLabel: false,
+    showPaymentAmountUsd: false,
+    showReceiveAmountUsd: false,
+    stepIndicatorType: "spinner",
+    showTokenAmount: true,
+    showTransactionDigest: "none"
+  },
+  sourceChangeScreen: {
+    bottomBarCloseButton: {
+      enabled: false,
+      labelKey: "common.close"
+    },
+    showTargetAssetSelection: false,
+    showWalletOnInsufficientBalance: false,
+    paymentMethodIcons: {}
+  },
+  inputAmountScreen: {
+    allowTokenAmountInput: true
+  },
+  selectAssetScreen: {
+    isSecondaryTokenSymbolVisible: true,
+    navigateOnAssetClick: false
+  },
+  transferCryptoScreen: {
+    showYouSendYouReceive: false
+  },
+  withdrawalScreen: {},
+  selectBrokerageScreen: {},
+  connectExchangeScreen: {},
+  customIcons: {},
+  customFontFamily: {
+    primary: "",
+    secondary: "",
+    tertiary: ""
+  }
+};
+var DEFAULT_FUNKIT_CONFIG = {
+  apiKey: "",
+  appName: "",
+  textCustomizations: DEFAULT_TEXT_CUSTOMIZATIONS,
+  uiCustomizations: DEFAULT_UI_CUSTOMIZATIONS
+};
+var FunkitConfigContext = createContext(
+  DEFAULT_FUNKIT_CONFIG
+);
+function useFunkitConfig() {
+  const originalFunkitConfig = useContext(FunkitConfigContext);
+  const { t } = useFunkitTranslation();
+  const translatedDefaults = useMemo(() => {
+    return {
+      virtualFiat: t("textCustomizations.virtualFiat"),
+      brokerageOrExchange: t("textCustomizations.brokerageOrExchange"),
+      debitOrCredit: t("textCustomizations.debitOrCredit"),
+      accountBalance: t("textCustomizations.accountBalance"),
+      selectAccount: t("textCustomizations.selectAccount"),
+      sourceMethodTitle: t("textCustomizations.sourceMethodTitle"),
+      tokensListTitle: t("textCustomizations.tokensListTitle"),
+      transferTokens: t("textCustomizations.transferTokens"),
+      receiveDropdownTitle: t("textCustomizations.receiveDropdownTitle"),
+      receiveDropdownLabel: t("textCustomizations.receiveDropdownLabel"),
+      confirmationScreen: {
+        payAmountLabel: t("textCustomizations.payAmountLabel"),
+        receiveAmountLabel: t("textCustomizations.receiveAmountLabel")
+      },
+      paymentMethodSubtitles: {}
+    };
+  }, [t]);
+  const finalFunkitConfig = useMemo(() => {
+    return {
+      ...DEFAULT_FUNKIT_CONFIG,
+      ...originalFunkitConfig,
+      textCustomizations: {
+        ...translatedDefaults,
+        ...originalFunkitConfig.textCustomizations,
+        confirmationScreen: {
+          ...translatedDefaults.confirmationScreen,
+          ...originalFunkitConfig.textCustomizations?.confirmationScreen
+        },
+        paymentMethodSubtitles: {
+          ...translatedDefaults.paymentMethodSubtitles,
+          ...originalFunkitConfig.textCustomizations?.paymentMethodSubtitles
+        }
+      },
+      uiCustomizations: {
+        ...DEFAULT_FUNKIT_CONFIG.uiCustomizations,
+        ...originalFunkitConfig.uiCustomizations,
+        checkoutHistory: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.checkoutHistory,
+          ...originalFunkitConfig.uiCustomizations?.checkoutHistory
+        },
+        confirmationScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.confirmationScreen,
+          ...originalFunkitConfig.uiCustomizations?.confirmationScreen
+        },
+        connectExchangeScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.connectExchangeScreen,
+          ...originalFunkitConfig.uiCustomizations?.connectExchangeScreen
+        },
+        inputAmountScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.inputAmountScreen,
+          ...originalFunkitConfig.uiCustomizations?.inputAmountScreen
+        },
+        selectAssetScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.selectAssetScreen,
+          ...originalFunkitConfig.uiCustomizations?.selectAssetScreen
+        },
+        selectBrokerageScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.selectBrokerageScreen,
+          ...originalFunkitConfig.uiCustomizations?.selectBrokerageScreen
+        },
+        sourceChangeScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.sourceChangeScreen,
+          ...originalFunkitConfig.uiCustomizations?.sourceChangeScreen,
+          bottomBarCloseButton: {
+            ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.sourceChangeScreen.bottomBarCloseButton,
+            ...originalFunkitConfig.uiCustomizations?.sourceChangeScreen?.bottomBarCloseButton
+          }
+        },
+        transferCryptoScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.transferCryptoScreen,
+          ...originalFunkitConfig.uiCustomizations?.transferCryptoScreen
+        },
+        withdrawalScreen: {
+          ...DEFAULT_FUNKIT_CONFIG.uiCustomizations.withdrawalScreen,
+          ...originalFunkitConfig.uiCustomizations?.withdrawalScreen
+        }
+      }
+    };
+  }, [originalFunkitConfig, translatedDefaults]);
+  return finalFunkitConfig;
+}
+
+// src/utils/customer.ts
+async function getLighterAccount(lookup, activeOnly) {
+  const params = new URLSearchParams({
+    by: lookup.by,
+    value: String(lookup.value),
+    ...activeOnly !== void 0 && { active_only: String(activeOnly) }
+  });
+  const response = await fetch(
+    `https://mainnet.zklighter.elliot.ai/api/v1/account?${params}`
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to fetch lighter account: ${response.statusText}`);
+  }
+  return response.json();
+}
+function useLighterAccount(lookup, options) {
+  const { apiKey } = useFunkitConfig();
+  const isLighter = isLighterxyzCustomer(apiKey);
+  const enabled = isLighter && lookup !== null && (lookup.by === "index" ? true : !!lookup.value && lookup.value !== "0x");
+  const query = useQuery({
+    queryKey: [
+      "lighterAccount",
+      lookup?.by,
+      lookup?.value,
+      options?.activeOnly
+    ],
+    // biome-ignore lint/style/noNonNullAssertion: already checked for null
+    queryFn: () => getLighterAccount(lookup, options?.activeOnly),
+    enabled,
+    staleTime: 3e4,
+    retry: false
+  });
+  return {
+    ...query,
+    account: query.data?.accounts?.[0]
+  };
+}
+
+// src/clients/lighter.tsx
+var ARBITRUM_USDC = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+var MAINNET_USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+function freeBalance(balance, lockedBalance) {
+  return String(Math.max(0, Number(balance) - Number(lockedBalance)));
+}
+function asLighterAccountIndex(s) {
+  if (!/^\d+$/.test(s)) {
+    throw new Error(`Invalid LighterAccountIndex: ${s}`);
+  }
+  return s;
+}
+function useLighterWithdrawalBalances({
+  accountIndex
+}) {
+  const { account, isLoading, error } = useLighterAccount(
+    accountIndex ? { by: "index", value: accountIndex } : null
+  );
+  useEffect(() => {
+    logger.debug("lighter:withdrawal:balances:query", {
+      accountIndex,
+      isLoading,
+      hasAccount: !!account,
+      error: error instanceof Error ? error.message : error
+    });
+  }, [accountIndex, isLoading, account, error]);
+  const balances = useMemo2(() => {
+    if (!account) {
+      return {};
+    }
+    const result = {};
+    for (const asset of account.assets) {
+      const symbol = asset.symbol.toUpperCase();
+      if (symbol === "USDC") {
+        continue;
+      }
+      result[symbol] = freeBalance(asset.balance, asset.locked_balance);
+    }
+    result.USDC = account.total_asset_value;
+    logger.info("lighter:withdrawal:balances:resolved", {
+      accountIndex,
+      balances: result
+    });
+    return result;
+  }, [account, accountIndex]);
+  return {
+    balances,
+    assets: account?.assets ?? [],
+    isLoading
+  };
+}
+function buildSecureWithdrawalCallback({
+  exec
+}) {
+  return async (param) => {
+    const { targetAssetAddress, destinationAddress } = param;
+    const assetIndex = param.lighterAssetIndex;
+    if (assetIndex === void 0) {
+      logger.error(
+        "lighter:withdrawal:secure:missingAssetIndex",
+        new Error("Missing lighterAssetIndex for Secure withdrawal"),
+        { targetAssetAddress, destinationAddress }
+      );
+      return;
+    }
+    const amountTokenUnits = param.userInputAmount;
+    if (!amountTokenUnits) {
+      logger.error(
+        "lighter:withdrawal:secure:missingAmount",
+        new Error("Missing userInputAmount for Secure withdrawal"),
+        { assetIndex, targetAssetAddress, destinationAddress }
+      );
+      return;
+    }
+    logger.info("lighter:withdrawal:secure:start", {
+      assetIndex,
+      amountTokenUnits,
+      targetAssetAddress,
+      destinationAddress
+    });
+    const txHash = await exec({
+      amountTokenUnits,
+      assetIndex
+    });
+    logger.info("lighter:withdrawal:secure:submitted", {
+      amountTokenUnits,
+      assetIndex,
+      txHash
+    });
+    return txHash;
+  };
+}
+function createLighterSecureWithdrawalConfig(config) {
+  return {
+    modalTitle: config.modalTitle ?? i18next.t("withdrawal.withdraw"),
+    disableConnectedWallet: config.disableConnectedWallet,
+    withdrawCallback: buildSecureWithdrawalCallback({
+      exec: config.sendLighterSecureWithdrawal
+    }),
+    sourceChainId: mainnet2.id.toString(),
+    sourceTokenSymbol: "USDC",
+    defaultReceiveToken: "USDC",
+    sourceTokenAddress: MAINNET_USDC,
+    iconSrc: config.iconSrc ?? "https://sdk-cdn.fun.xyz/images/logos/lighter.png",
+    getMinWithdrawalUSD: () => 0,
+    getMinWithdrawalAmount: config.getMinWithdrawalAmount
+  };
+}
+function buildFastWithdrawalCallback({
+  userId,
+  exec
+}) {
+  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;
+    }
+    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(),
+    sourceTokenSymbol: "USDC",
+    defaultReceiveToken: "USDC",
+    sourceTokenAddress: ARBITRUM_USDC,
+    iconSrc: config.iconSrc ?? "https://sdk-cdn.fun.xyz/images/logos/lighter.png",
+    getMinWithdrawalUSD: () => 4
+  };
+}
+function ChainIconStack({ chainIds }) {
+  return /* @__PURE__ */ React2.createElement(Box, { display: "flex", alignItems: "center", justifyContent: "flex-end" }, chainIds.map((chainId, index) => {
+    const metadata = chainMetadataById[chainId];
+    return /* @__PURE__ */ React2.createElement(
+      Box,
+      {
+        key: chainId,
+        position: "relative",
+        style: { right: `${(chainIds.length - index - 1) * -2}px` }
+      },
+      /* @__PURE__ */ React2.createElement(
+        AsyncImage,
+        {
+          alt: metadata?.name ?? "",
+          borderRadius: "full",
+          src: metadata?.iconUrl ?? "",
+          height: 16,
+          width: 16
+        }
+      )
+    );
+  }));
+}
+var LIGHTER_FAST_PREVIEW_CHAIN_IDS = [
+  arbitrum.id,
+  base.id,
+  optimism.id,
+  bsc.id,
+  SOLANA_MAINNET_CHAIN_ID
+];
+var LIGHTER_SECURE_PREVIEW_CHAIN_IDS = [mainnet2.id];
+function buildLighterMultiMethodConfig({
+  config,
+  t,
+  withBalance
+}) {
+  const fastConfig = createLighterFastWithdrawalConfig({
+    userId: config.userId,
+    modalTitle: config.modalTitle,
+    disableConnectedWallet: config.disableConnectedWallet,
+    iconSrc: config.fastIconSrc,
+    sendLighterFastWithdrawal: config.sendLighterFastWithdrawal
+  });
+  const secureConfig = createLighterSecureWithdrawalConfig({
+    userId: config.userId,
+    modalTitle: config.modalTitle,
+    disableConnectedWallet: config.disableConnectedWallet,
+    iconSrc: config.secureIconSrc,
+    sendLighterSecureWithdrawal: config.sendLighterSecureWithdrawal,
+    getMinWithdrawalAmount: config.getSecureMinWithdrawalAmount
+  });
+  const fast = {
+    id: "lighter-fast",
+    keyText: t("withdrawal.methodFast"),
+    subtitleText: t("withdrawal.fastDisclaimer"),
+    icon: /* @__PURE__ */ React2.createElement(EvmWallet, { size: 20 }),
+    valueIcon: /* @__PURE__ */ React2.createElement(ChainIconStack, { chainIds: LIGHTER_FAST_PREVIEW_CHAIN_IDS }),
+    config: withBalance ? {
+      ...fastConfig,
+      withdrawalSourceTokenBalance: withBalance(
+        fastConfig.sourceTokenSymbol
+      )
+    } : fastConfig
+  };
+  const secure = {
+    id: "lighter-secure",
+    keyText: t("withdrawal.methodSecure"),
+    subtitleText: t("withdrawal.secureDisclaimer"),
+    icon: /* @__PURE__ */ React2.createElement(EvmWallet, { size: 20 }),
+    valueIcon: /* @__PURE__ */ React2.createElement(ChainIconStack, { chainIds: LIGHTER_SECURE_PREVIEW_CHAIN_IDS }),
+    config: withBalance ? {
+      ...secureConfig,
+      withdrawalSourceTokenBalance: withBalance(
+        secureConfig.sourceTokenSymbol
+      )
+    } : secureConfig
+  };
+  return {
+    modalTitle: config.modalTitle ?? t("withdrawal.withdraw"),
+    sectionTitle: t("withdrawal.sectionCrypto"),
+    methods: [fast, secure]
+  };
+}
+function useLighterWithdrawalConfig(config) {
+  const { t } = useFunkitTranslation();
+  const { balances } = useLighterWithdrawalBalances({
+    accountIndex: asLighterAccountIndex(config.userId)
+  });
+  return useMemo2(
+    () => buildLighterMultiMethodConfig({
+      config,
+      t,
+      withBalance: (symbol) => () => balances[symbol.toUpperCase()] ?? "0"
+    }),
+    [config, balances, t]
+  );
+}
+function createLighterWithdrawalConfig(config) {
+  return buildLighterMultiMethodConfig({
+    config,
+    t: i18next.t.bind(i18next)
+  });
+}
+export {
+  ARBITRUM_USDC,
+  MAINNET_USDC,
+  createLighterFastWithdrawalConfig,
+  createLighterSecureWithdrawalConfig,
+  createLighterWithdrawalConfig,
+  freeBalance,
+  useLighterWithdrawalBalances,
+  useLighterWithdrawalConfig
+};

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

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