@funkit/connect 9.7.2-next.0 → 9.8.0

package/dist/clients/lighter.js

@@ -0,0 +1,657 @@
+"use client";
+import {
+  AsyncImage,
+  Box,
+  useFunkitTranslation
+} from "./chunk-LMEQD56M.js";
+import {
+  logger
+} from "./chunk-H6F75ULR.js";
+
+// src/clients/lighter.tsx
+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";
+
+// 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 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)));
+}
+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 buildLighterFastWalletWithdrawalConfig({
+  signerClient,
+  accountIndex,
+  modalTitle,
+  disableConnectedWallet,
+  iconSrc
+}) {
+  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");
+    }
+  };
+  return {
+    modalTitle: modalTitle ?? i18next.t("withdrawal.withdraw"),
+    disableConnectedWallet,
+    wallet,
+    sourceChainId: RELAY_LIGHTER_CHAIN_ID,
+    sourceTokenSymbol: "USDC",
+    defaultReceiveToken: "USDC",
+    sourceTokenAddress: LIGHTER_USDC_PERPS_ADDRESS,
+    iconSrc: 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 = buildLighterFastWalletWithdrawalConfig({
+    signerClient: config.signerClient,
+    accountIndex: Number(config.accountIndex),
+    modalTitle: config.modalTitle,
+    disableConnectedWallet: config.disableConnectedWallet,
+    iconSrc: config.fastIconSrc
+  });
+  const secureConfig = createLighterSecureWithdrawalConfig({
+    accountIndex: config.accountIndex,
+    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.accountIndex)
+  });
+  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 {
+  createLighterSecureWithdrawalConfig,
+  createLighterWithdrawalConfig,
+  freeBalance,
+  useLighterWithdrawalBalances,
+  useLighterWithdrawalConfig
+};

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

@@ -2,27 +2,13 @@ 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'>>;
@@ -31,7 +17,7 @@ export interface BaseDropdownProps<T = string, G extends string = never> {
      *
      * _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;