@flapsdk/vault-runtime 0.1.0

package/sdk.js

@@ -0,0 +1,571 @@
+"use client";
+import { erc20Abi, formatUnits, parseUnits } from 'viem';
+export { erc20Abi } from 'viem';
+import Decimal from 'decimal.js';
+import * as React3 from 'react';
+import { createContext, useState, useRef, useCallback, useEffect, useMemo, useContext } from 'react';
+import { useAccount, useChainId, useConnect, useDisconnect, useSwitchChain, usePublicClient, useWalletClient, useBalance } from 'wagmi';
+import { Loader2, AlertTriangle, CheckCircle2, Info } from 'lucide-react';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { Slot } from '@radix-ui/react-slot';
+import { cva } from 'class-variance-authority';
+
+var standardErc20Abi = erc20Abi;
+function shortenAddress(raw, start = 6, end = 4) {
+  if (!raw) return "";
+  if (raw.length <= start + end) return raw;
+  return `${raw.slice(0, start)}...${raw.slice(-end)}`;
+}
+function formatTokenAmount(value, decimals = 18, precision = 4) {
+  if (value === void 0 || value === null) return "-";
+  const raw = typeof value === "bigint" ? formatUnits(value, decimals) : String(value);
+  return new Decimal(raw).toDecimalPlaces(precision, Decimal.ROUND_DOWN).toString();
+}
+function parseTokenAmount(value, decimals = 18) {
+  if (!/^\d*(\.\d*)?$/.test(value.trim())) {
+    throw new Error("Invalid decimal amount.");
+  }
+  return parseUnits(value || "0", decimals);
+}
+function formatPercentBps(value, precision = 2) {
+  if (value === void 0 || value === null) return "-";
+  return `${new Decimal(String(value)).div(100).toDecimalPlaces(precision).toString()}%`;
+}
+function formatCountdown(targetTimeMs) {
+  if (!targetTimeMs) return "-";
+  const diff = Math.max(0, targetTimeMs - Date.now());
+  const totalSeconds = Math.floor(diff / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  return `${minutes}m ${seconds}s`;
+}
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/ui/Alert.tsx
+var toneClass = {
+  info: "border-[#3f5f8f] bg-[#17243a] text-[#d8e2ef]",
+  success: "border-[#35d39d]/35 bg-[#173c39] text-[#8ff4c8]",
+  warning: "border-[#f2c94c]/35 bg-[#42381f] text-[#fff0b8]",
+  danger: "border-[#ff6b6b]/35 bg-[#4a1f27] text-[#ffc4c4]"
+};
+var iconMap = {
+  info: Info,
+  success: CheckCircle2,
+  warning: AlertTriangle,
+  danger: AlertTriangle
+};
+function Alert({ children, tone = "info", className }) {
+  const Icon = iconMap[tone];
+  return /* @__PURE__ */ React.createElement("div", { className: cn("flex gap-3 rounded-md border p-3 text-sm font-medium leading-6", toneClass[tone], className) }, /* @__PURE__ */ React.createElement(Icon, { className: "mt-0.5 h-4 w-4 shrink-0 opacity-90" }), /* @__PURE__ */ React.createElement("div", { className: "min-w-0 break-words" }, children));
+}
+var buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-semibold transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[#4a90ff]/60 disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "border border-[#4a90ff]/60 bg-[#315fb5] text-white shadow-[inset_0_1px_0_rgba(255,255,255,0.16)] hover:bg-[#3b70d6]",
+        secondary: "border border-[#3a4d66] bg-[#304057] text-white hover:bg-[#3a4c65]",
+        outline: "border border-[#3d6ba8] bg-[#17243a] text-[#d8e8ff] hover:border-[#559cff] hover:bg-[#1d3150]",
+        ghost: "text-[#a8b5c7] hover:bg-[#304057] hover:text-white",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90"
+      },
+      size: {
+        default: "h-10 px-4",
+        sm: "h-8 px-3 text-xs",
+        lg: "h-12 px-5",
+        icon: "h-10 w-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React3.forwardRef(
+  ({ className, variant, size, asChild = false, loading = false, disabled, children, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    if (asChild) {
+      return /* @__PURE__ */ React3.createElement(Comp, { className: cn(buttonVariants({ variant, size, className })), ref, ...props }, children);
+    }
+    return /* @__PURE__ */ React3.createElement(
+      Comp,
+      {
+        className: cn(buttonVariants({ variant, size, className })),
+        ref,
+        disabled: disabled || loading,
+        ...props
+      },
+      loading ? /* @__PURE__ */ React3.createElement(Loader2, { className: "h-4 w-4 animate-spin" }) : null,
+      children
+    );
+  }
+);
+Button.displayName = "Button";
+var Card = React3.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ React3.createElement(
+  "div",
+  {
+    ref,
+    className: cn(
+      "rounded-lg border border-[#3a4d66] bg-[#1d2938] text-white shadow-panel shadow-black/30 backdrop-blur",
+      className
+    ),
+    ...props
+  }
+));
+Card.displayName = "Card";
+var CardHeader = React3.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ React3.createElement("div", { ref, className: cn("flex flex-col gap-1.5 p-5", className), ...props })
+);
+CardHeader.displayName = "CardHeader";
+var CardTitle = React3.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ React3.createElement("h3", { ref, className: cn("text-lg font-semibold leading-tight tracking-normal text-white", className), ...props })
+);
+CardTitle.displayName = "CardTitle";
+var CardDescription = React3.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ React3.createElement("p", { ref, className: cn("text-sm leading-6 text-[#a8b5c7]", className), ...props })
+);
+CardDescription.displayName = "CardDescription";
+var CardContent = React3.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ React3.createElement("div", { ref, className: cn("p-5 pt-0", className), ...props })
+);
+CardContent.displayName = "CardContent";
+var Input = React3.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ React3.createElement(
+  "input",
+  {
+    ref,
+    className: cn(
+      "flex h-11 w-full rounded-md border border-[#aebdd0] bg-[#101827] px-3 py-2 text-sm font-semibold text-white caret-white shadow-[inset_0_1px_0_rgba(255,255,255,0.05)] outline-none transition-colors selection:bg-[#4a90ff]/45 selection:text-white placeholder:text-[#7f8ca0] focus:border-[#64a7ff] focus:bg-[#132033] focus:ring-2 focus:ring-[#4a90ff]/30 disabled:cursor-not-allowed disabled:border-[#40536c] disabled:bg-[#1d2938] disabled:text-[#8d9caf] disabled:opacity-80",
+      className
+    ),
+    ...props
+  }
+));
+Input.displayName = "Input";
+
+// src/sdk/taxInfo.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function isValidAddress(value) {
+  return Boolean(value && /^0x[a-fA-F0-9]{40}$/.test(value));
+}
+function isSameAddress(a, b) {
+  return Boolean(a && b && a.toLowerCase() === b.toLowerCase());
+}
+function resolveManifestBinding(manifest, input) {
+  const bindings = manifest.match.bindings;
+  if (!bindings.length) return null;
+  const resolveUnique = (candidates) => {
+    if (candidates.length === 1) return candidates[0];
+    return null;
+  };
+  if (input.chainId && input.factoryAddress) {
+    return resolveUnique(bindings.filter((binding) => binding.chainId === input.chainId && isSameAddress(binding.factoryAddress, input.factoryAddress)));
+  }
+  if (input.chainId) {
+    return resolveUnique(bindings.filter((binding) => binding.chainId === input.chainId));
+  }
+  if (input.factoryAddress) {
+    return resolveUnique(bindings.filter((binding) => isSameAddress(binding.factoryAddress, input.factoryAddress)));
+  }
+  return null;
+}
+function resolveTokenMarketPhase(tokenInfo) {
+  if (!tokenInfo?.exists) return "unknown";
+  return tokenInfo.status >= 2 ? "dex-listed" : "internal-market";
+}
+function isCustomVaultTaxToken(tokenInfo) {
+  return Boolean(tokenInfo?.exists && tokenInfo.isTaxToken);
+}
+function isActionAvailableForPhase(stage, marketPhase = "unknown") {
+  if (stage === "read-only") return false;
+  if (stage === "both") return true;
+  if (marketPhase === "unknown") return false;
+  return stage === marketPhase;
+}
+function readTaxVaultHostContext(host) {
+  const tokenInfo = host?.tokenInfo;
+  const marketPhase = host?.marketPhase ?? resolveTokenMarketPhase(tokenInfo);
+  const isListed = host?.isListed ?? Boolean(tokenInfo && tokenInfo.status >= 2);
+  const isTaxToken = tokenInfo?.isTaxToken === true;
+  return {
+    tokenInfo,
+    taxInfo: host?.taxInfo ?? null,
+    vaultInfo: host?.vaultInfo ?? null,
+    feeMode: host?.feeMode ?? "unknown",
+    renderSurface: host?.renderSurface ?? "unavailable",
+    vaultType: host?.vaultType,
+    copyScope: host?.copyScope ?? "tax",
+    marketPhase,
+    isListed,
+    isTaxToken,
+    isSupportedCustomVaultToken: isCustomVaultTaxToken(tokenInfo)
+  };
+}
+
+// src/sdk/runtimeContext.ts
+var zeroAddress = "0x0000000000000000000000000000000000000000";
+function explorerForChain(chainId) {
+  if (chainId === 56) return "https://bscscan.com";
+  if (chainId === 97) return "https://testnet.bscscan.com";
+  return void 0;
+}
+function chainLabelForChain(chainId) {
+  if (chainId === 56) return "BNB Chain";
+  if (chainId === 97) return "BNB Testnet";
+  return `Chain ${chainId}`;
+}
+function buildRuntimeExtraConfig(input) {
+  const hostRuntimeResult = input.hostRuntimeResult;
+  const runtimeOverrides = input.runtimeOverrides;
+  return {
+    ...hostRuntimeResult ? {
+      hostRuntimeStatus: hostRuntimeResult.status,
+      hostRuntimePolicy: hostRuntimeResult.policy,
+      hostRuntimeDegradeReason: hostRuntimeResult.degradeReason,
+      hostRuntimeWarnings: hostRuntimeResult.warnings
+    } : {},
+    ...hostRuntimeResult?.presentation?.extraConfig ?? {},
+    ...runtimeOverrides?.extraConfig ?? {}
+  };
+}
+function createVaultRuntimeContext(input) {
+  const runtimeOverrides = input.runtimeOverrides;
+  const resolvedBinding = resolveManifestBinding(input.manifest, {
+    chainId: runtimeOverrides?.chainId ?? input.connectedChainId ?? input.hostRuntimeResult?.addresses.chainId,
+    factoryAddress: runtimeOverrides?.factoryAddress ?? input.hostRuntimeResult?.addresses.factoryAddress
+  });
+  const effectiveChainId = runtimeOverrides?.chainId ?? input.hostRuntimeResult?.addresses.chainId ?? input.connectedChainId ?? resolvedBinding?.chainId ?? input.manifest.match.bindings[0]?.chainId ?? 56;
+  return {
+    chainId: effectiveChainId,
+    factoryAddress: runtimeOverrides?.factoryAddress ?? input.hostRuntimeResult?.addresses.factoryAddress ?? resolvedBinding?.factoryAddress ?? zeroAddress,
+    tokenAddress: runtimeOverrides?.tokenAddress ?? input.hostRuntimeResult?.addresses.tokenAddress ?? zeroAddress,
+    vaultAddress: runtimeOverrides?.vaultAddress ?? input.hostRuntimeResult?.addresses.vaultAddress ?? zeroAddress,
+    userAddress: runtimeOverrides?.userAddress,
+    tokenSymbol: runtimeOverrides?.tokenSymbol ?? input.hostRuntimeResult?.tokenSymbol,
+    tokenName: runtimeOverrides?.tokenName ?? input.hostRuntimeResult?.tokenName,
+    tokenImageUrl: runtimeOverrides?.tokenImageUrl ?? input.hostRuntimeResult?.tokenImageUrl,
+    explorerBaseUrl: runtimeOverrides?.explorerBaseUrl ?? explorerForChain(effectiveChainId),
+    paymentToken: runtimeOverrides?.paymentToken ?? input.hostRuntimeResult?.paymentToken,
+    host: runtimeOverrides?.host ?? input.hostRuntimeResult?.host,
+    extraConfig: buildRuntimeExtraConfig(input),
+    manifest: input.manifest
+  };
+}
+
+// src/sdk/runtime.tsx
+var RuntimeContext = createContext(null);
+function applyParams(value, params) {
+  if (!params) return value;
+  return Object.entries(params).reduce((acc, [key, item]) => acc.replaceAll(`{${key}}`, String(item)), value);
+}
+function getPreviewOracleEndpoint(extraConfig, oracleId) {
+  const oracleEndpoints = extraConfig?.oracleEndpoints;
+  if (!oracleEndpoints || typeof oracleEndpoints !== "object" || Array.isArray(oracleEndpoints)) return void 0;
+  const endpoint = oracleEndpoints[oracleId];
+  return typeof endpoint === "string" ? endpoint : void 0;
+}
+function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtimeOverrides, hostRuntimeResult, locale = "en" }) {
+  const [version, setVersion] = useState(0);
+  const [messages, setMessages] = useState([]);
+  const toastTimersRef = useRef(/* @__PURE__ */ new Map());
+  const { address: accountAddress, isConnected } = useAccount();
+  const connectedChainId = useChainId();
+  const { connect, connectors } = useConnect();
+  const { disconnect } = useDisconnect();
+  const { switchChainAsync, isPending: isSwitchingChain } = useSwitchChain();
+  const effectiveChainId = runtimeOverrides?.chainId ?? hostRuntimeResult?.addresses.chainId ?? connectedChainId ?? manifest.match.bindings[0]?.chainId ?? 56;
+  const publicClient = usePublicClient({ chainId: effectiveChainId });
+  const { data: walletClient } = useWalletClient();
+  const { data: nativeBalance } = useBalance({ address: accountAddress, chainId: isConnected ? connectedChainId : void 0 });
+  const dismissMessage = useCallback((id) => {
+    const timerId = toastTimersRef.current.get(id);
+    if (timerId) {
+      window.clearTimeout(timerId);
+      toastTimersRef.current.delete(id);
+    }
+    setMessages((items) => items.filter((item) => item.id !== id));
+  }, []);
+  useEffect(() => {
+    const timers = toastTimersRef.current;
+    return () => {
+      for (const timerId of timers.values()) {
+        window.clearTimeout(timerId);
+      }
+      timers.clear();
+    };
+  }, []);
+  const runtimeContext = useMemo(() => {
+    return createVaultRuntimeContext({
+      manifest,
+      connectedChainId,
+      hostRuntimeResult,
+      runtimeOverrides: {
+        ...runtimeOverrides,
+        userAddress: runtimeOverrides?.userAddress ?? accountAddress
+      }
+    });
+  }, [accountAddress, connectedChainId, hostRuntimeResult, manifest, runtimeOverrides]);
+  const i18nApi = useMemo(
+    () => ({
+      locale,
+      t(key, fallback, params) {
+        const defaultLocale = manifest.i18n[0];
+        const resolved = i18n[locale]?.[key] ?? i18n[defaultLocale]?.[key] ?? i18n.en?.[key] ?? fallback ?? key;
+        return applyParams(resolved, params);
+      }
+    }),
+    [i18n, locale, manifest.i18n]
+  );
+  const notify = useMemo(() => {
+    const push = (level, message) => {
+      const id = Date.now() + Math.floor(Math.random() * 1e3);
+      setMessages((items) => [{ id, level, message }, ...items].slice(0, 4));
+      const timerId = window.setTimeout(() => {
+        dismissMessage(id);
+      }, 4200);
+      toastTimersRef.current.set(id, timerId);
+    };
+    return {
+      info: (message) => push("info", message),
+      success: (message) => push("success", message),
+      warning: (message) => push("warning", message),
+      error: (message) => push("error", message)
+    };
+  }, [dismissMessage]);
+  const wallet = useMemo(
+    () => ({
+      address: accountAddress,
+      chainId: isConnected ? connectedChainId : void 0,
+      chainLabel: isConnected ? chainLabelForChain(connectedChainId) : void 0,
+      requiredChainId: runtimeContext.chainId,
+      requiredChainLabel: chainLabelForChain(runtimeContext.chainId),
+      isConnected,
+      isWrongNetwork: Boolean(isConnected && connectedChainId !== runtimeContext.chainId),
+      canSwitchChain: Boolean(switchChainAsync),
+      isSwitchingChain,
+      // Real native-token balance from the connected wallet. "0" until a wallet is connected.
+      balance: nativeBalance ? formatUnits(nativeBalance.value, nativeBalance.decimals) : "0",
+      // Wallet connection is host/shell-owned. In this preview the SDK forwards to the
+      // injected wagmi connector so the surface is functional rather than a no-op stub.
+      connect: () => {
+        const connector = connectors[0];
+        if (connector) connect({ connector });
+      },
+      disconnect: () => disconnect(),
+      switchChain: async () => {
+        if (!switchChainAsync) {
+          throw new Error(`Switch wallet to ${chainLabelForChain(runtimeContext.chainId)} before continuing.`);
+        }
+        await switchChainAsync({ chainId: runtimeContext.chainId });
+      }
+    }),
+    [accountAddress, connect, connectedChainId, connectors, disconnect, isConnected, isSwitchingChain, nativeBalance, runtimeContext.chainId, switchChainAsync]
+  );
+  const assertWalletWriteReady = useCallback(
+    (actionLabel) => {
+      if (!accountAddress) throw new Error("Wallet is not connected.");
+      if (isConnected && connectedChainId !== runtimeContext.chainId) {
+        throw new Error(`Wrong network. Switch wallet to ${chainLabelForChain(runtimeContext.chainId)} before ${actionLabel}.`);
+      }
+    },
+    [accountAddress, connectedChainId, isConnected, runtimeContext.chainId]
+  );
+  const readContract = useCallback(
+    async (request) => {
+      if (!publicClient || !request.abi || !request.address) {
+        throw new Error(`Contract read ${request.functionName} requires a public client, ABI, and address.`);
+      }
+      return await publicClient.readContract({
+        address: request.address,
+        abi: request.abi,
+        functionName: request.functionName,
+        args: request.args
+      });
+    },
+    [publicClient]
+  );
+  const simulateContract = useCallback(
+    async (request) => {
+      assertWalletWriteReady(`simulating ${request.functionName}`);
+      if (!publicClient || !request.abi || !request.address) {
+        throw new Error(`Contract simulation ${request.functionName} requires a public client, ABI, and address.`);
+      }
+      const simulation = await publicClient.simulateContract({
+        account: accountAddress,
+        address: request.address,
+        abi: request.abi,
+        functionName: request.functionName,
+        args: request.args,
+        value: request.value
+      });
+      return { request, result: simulation.result };
+    },
+    [accountAddress, assertWalletWriteReady, publicClient]
+  );
+  const writeContract = useCallback(
+    async (request) => {
+      assertWalletWriteReady(`writing ${request.functionName}`);
+      if (!walletClient || !request.abi || !request.address) {
+        throw new Error(`Contract write ${request.functionName} requires a wallet client, ABI, and address.`);
+      }
+      const hash = await walletClient.writeContract({
+        address: request.address,
+        abi: request.abi,
+        functionName: request.functionName,
+        args: request.args,
+        value: request.value
+      });
+      return hash;
+    },
+    [assertWalletWriteReady, walletClient]
+  );
+  const waitForTx = useCallback(
+    async (hash) => {
+      if (!publicClient) throw new Error("Transaction receipt requires a public client.");
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      return { hash, status: receipt.status === "success" ? "success" : "reverted" };
+    },
+    [publicClient]
+  );
+  const readOracle = useCallback(
+    async (oracleId, params) => {
+      const endpoint = getPreviewOracleEndpoint(runtimeContext.extraConfig, oracleId);
+      if (!endpoint) throw new Error(`Oracle ${oracleId} is not provisioned by the preview runtime.`);
+      const url = new URL(endpoint);
+      for (const [key, value] of Object.entries(params ?? {})) {
+        url.searchParams.set(key, value);
+      }
+      const response = await fetch(url.toString(), { cache: "no-store" });
+      if (!response.ok) throw new Error(`Oracle ${oracleId} returned ${response.status}.`);
+      return await response.json();
+    },
+    [runtimeContext.extraConfig]
+  );
+  const refetch = useCallback(async () => {
+    setVersion((item) => item + 1);
+  }, []);
+  const openExplorerTx = useCallback(
+    (hash) => {
+      if (!runtimeContext.explorerBaseUrl) return;
+      window.open(`${runtimeContext.explorerBaseUrl.replace(/\/$/, "")}/tx/${hash}`, "_blank", "noreferrer");
+    },
+    [runtimeContext.explorerBaseUrl]
+  );
+  const sdk = useMemo(
+    () => ({
+      context: runtimeContext,
+      i18n: i18nApi,
+      notify,
+      wallet,
+      readContract,
+      simulateContract,
+      writeContract,
+      waitForTx,
+      readOracle,
+      refetch,
+      refetchNonce: version,
+      openExplorerTx
+    }),
+    [i18nApi, notify, openExplorerTx, readContract, readOracle, refetch, runtimeContext, simulateContract, version, waitForTx, wallet, writeContract]
+  );
+  return /* @__PURE__ */ React.createElement(RuntimeContext.Provider, { value: sdk }, children, /* @__PURE__ */ React.createElement("div", { className: "pointer-events-none fixed bottom-4 right-4 z-50 flex w-[min(360px,calc(100vw-2rem))] flex-col gap-2" }, messages.map((message) => /* @__PURE__ */ React.createElement("div", { key: message.id, className: "pointer-events-auto" }, /* @__PURE__ */ React.createElement(
+    Alert,
+    {
+      tone: message.level === "error" ? "danger" : message.level,
+      className: "cursor-pointer shadow-panel backdrop-blur-sm transition hover:translate-y-[-1px]"
+    },
+    /* @__PURE__ */ React.createElement("button", { type: "button", className: "w-full text-left", onClick: () => dismissMessage(message.id) }, message.message)
+  )))));
+}
+function useFlapSdk() {
+  const sdk = useContext(RuntimeContext);
+  if (!sdk) throw new Error("useFlapSdk must be used within VaultRuntimeProvider.");
+  return sdk;
+}
+function useVaultContext() {
+  return useFlapSdk().context;
+}
+function useFlapI18n() {
+  return useFlapSdk().i18n;
+}
+function useFlapNotify() {
+  return useFlapSdk().notify;
+}
+
+// src/sdk/txError.ts
+var defaultMessages = {
+  userRejected: "You rejected the wallet request.",
+  walletDisconnected: "Connect a wallet before sending this transaction.",
+  wrongNetwork: "Switch the wallet to the required chain before sending this transaction.",
+  insufficientFunds: "Insufficient wallet balance to complete this transaction.",
+  simulationFailed: "The transaction could not pass simulation.",
+  reverted: "The contract rejected this transaction.",
+  unknown: "Transaction failed. Please check your wallet and try again."
+};
+function isObject(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+function collectMessages(error, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (depth > 4 || error == null || seen.has(error)) return [];
+  seen.add(error);
+  if (typeof error === "string") return [error];
+  if (!isObject(error)) return [];
+  const messages = [
+    readString(error.shortMessage),
+    readString(error.message),
+    readString(error.details),
+    readString(error.reason)
+  ].filter(Boolean);
+  return [...messages, ...collectMessages(error.cause, depth + 1, seen)];
+}
+function collectCodes(error, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (depth > 4 || error == null || seen.has(error)) return [];
+  seen.add(error);
+  if (!isObject(error)) return [];
+  const codes = [error.code, error.name].filter((value) => typeof value === "string" || typeof value === "number");
+  return [...codes, ...collectCodes(error.cause, depth + 1, seen)];
+}
+function getTxErrorKind(error) {
+  const message = collectMessages(error).join(" ").toLowerCase();
+  const codes = collectCodes(error).map((value) => String(value).toLowerCase()).join(" ");
+  if (codes.includes("4001") || codes.includes("action_rejected") || codes.includes("userrejectedrequesterror") || /user rejected|user denied|rejected the request|denied transaction|request rejected|cancelled/i.test(message)) {
+    return "userRejected";
+  }
+  if (/wallet is not connected|connector not connected|account not found|no wallet client/i.test(message)) {
+    return "walletDisconnected";
+  }
+  if (/wrong network|switch wallet to|switch network to|required chain/i.test(message)) {
+    return "wrongNetwork";
+  }
+  if (/insufficient funds|exceeds the balance|gas \* price \+ value/i.test(message)) {
+    return "insufficientFunds";
+  }
+  if (/simulation failed|simulatecontract|execution reverted during simulation/i.test(message)) {
+    return "simulationFailed";
+  }
+  if (/execution reverted|reverted with the following reason|contract function .* reverted|call exception/i.test(message)) {
+    return "reverted";
+  }
+  return "unknown";
+}
+function handleTxError(error, messages) {
+  const kind = getTxErrorKind(error);
+  return messages?.[kind] ?? defaultMessages[kind];
+}
+
+// src/sdk/useFlapWallet.ts
+function useFlapWallet() {
+  return useFlapSdk().wallet;
+}
+
+export { VaultRuntimeProvider, ZERO_ADDRESS, formatCountdown, formatPercentBps, formatTokenAmount, getTxErrorKind, handleTxError, isActionAvailableForPhase, isCustomVaultTaxToken, isValidAddress, parseTokenAmount, readTaxVaultHostContext, resolveTokenMarketPhase, shortenAddress, standardErc20Abi, useVaultContext as useFlapChain, useFlapI18n, useFlapNotify, useFlapSdk, useFlapWallet, useVaultContext };
+//# sourceMappingURL=sdk.js.map
+//# sourceMappingURL=sdk.js.map