provider-connect 1.0.2

package/dist/index.mjs

@@ -0,0 +1,2373 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// components/ConnectWalletHandler.tsx
+import { useEffect as useEffect2, useState as useState2, useCallback as useCallback2 } from "react";
+
+// components/ui/dialog.tsx
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import { X } from "lucide-react";
+
+// lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// components/ui/dialog.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var Dialog = DialogPrimitive.Root;
+var DialogTrigger = DialogPrimitive.Trigger;
+var DialogPortal = DialogPrimitive.Portal;
+var DialogClose = DialogPrimitive.Close;
+var DialogOverlay = React.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(DialogPortal, { children: /* @__PURE__ */ jsx(
+    DialogPrimitive.Overlay,
+    __spreadValues({
+      ref,
+      className: cn(
+        "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+        className
+      )
+    }, props)
+  ) });
+});
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
+var DialogContent = React.forwardRef((_a, ref) => {
+  var _b = _a, { className, children } = _b, props = __objRest(_b, ["className", "children"]);
+  return /* @__PURE__ */ jsxs(DialogPortal, { children: [
+    /* @__PURE__ */ jsx(DialogOverlay, {}),
+    /* @__PURE__ */ jsxs(
+      DialogPrimitive.Content,
+      __spreadProps(__spreadValues({
+        ref,
+        className: cn(
+          "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+          className
+        )
+      }, props), {
+        children: [
+          children,
+          /* @__PURE__ */ jsxs(DialogPrimitive.Close, { className: "absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground", children: [
+            /* @__PURE__ */ jsx(X, { className: "h-4 w-4" }),
+            /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Close" })
+          ] })
+        ]
+      })
+    )
+  ] });
+});
+DialogContent.displayName = DialogPrimitive.Content.displayName;
+var DialogHeader = (_a) => {
+  var _b = _a, {
+    className
+  } = _b, props = __objRest(_b, [
+    "className"
+  ]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    __spreadValues({
+      className: cn(
+        "flex flex-col space-y-1.5 text-center sm:text-left",
+        className
+      )
+    }, props)
+  );
+};
+DialogHeader.displayName = "DialogHeader";
+var DialogFooter = (_a) => {
+  var _b = _a, {
+    className
+  } = _b, props = __objRest(_b, [
+    "className"
+  ]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    __spreadValues({
+      className: cn(
+        "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+        className
+      )
+    }, props)
+  );
+};
+DialogFooter.displayName = "DialogFooter";
+var DialogTitle = React.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    DialogPrimitive.Title,
+    __spreadValues({
+      ref,
+      className: cn(
+        "text-lg font-semibold leading-none tracking-tight",
+        className
+      )
+    }, props)
+  );
+});
+DialogTitle.displayName = DialogPrimitive.Title.displayName;
+var DialogDescription = React.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    DialogPrimitive.Description,
+    __spreadValues({
+      ref,
+      className: cn("text-sm text-muted-foreground", className)
+    }, props)
+  );
+});
+DialogDescription.displayName = DialogPrimitive.Description.displayName;
+
+// components/ConnectWalletHandler.tsx
+import { VisuallyHidden } from "@radix-ui/react-visually-hidden";
+import { toast as toast2 } from "sonner";
+
+// components/ui/button.tsx
+import * as React2 from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var buttonVariants = cva(
+  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 rounded-md px-8",
+        icon: "h-10 w-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React2.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className, variant, size, asChild = false } = _b, props = __objRest(_b, ["className", "variant", "size", "asChild"]);
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ jsx2(
+      Comp,
+      __spreadValues({
+        className: cn(buttonVariants({ variant, size, className })),
+        ref
+      }, props)
+    );
+  }
+);
+Button.displayName = "Button";
+
+// components/ConnectWalletHandler.tsx
+import { motion } from "framer-motion";
+import {
+  Loader2,
+  X as X2,
+  ExternalLink
+} from "lucide-react";
+
+// hooks/useSupraMultiWallet.ts
+import { useState, useEffect, useCallback } from "react";
+import nacl from "tweetnacl";
+import { useRouter } from "next/navigation";
+import { toast } from "sonner";
+import {
+  SupraChainId,
+  initSdk
+} from "ribbit-wallet-connect";
+
+// lib/logger.ts
+var Logger = class {
+  constructor() {
+    this.isDevelopment = process.env.NODE_ENV === "development";
+  }
+  log(level, message, context, error) {
+    if (!this.isDevelopment && level === "debug") {
+      return;
+    }
+    const entry = {
+      level,
+      message,
+      timestamp: Date.now(),
+      context,
+      error
+    };
+    const logMethod = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+    if (error) {
+      logMethod(`[${level.toUpperCase()}] ${message}`, __spreadProps(__spreadValues({}, context), {
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      }));
+    } else {
+      logMethod(`[${level.toUpperCase()}] ${message}`, context || {});
+    }
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, error, context) {
+    this.log("error", message, context, error);
+  }
+};
+var logger = new Logger();
+
+// lib/errors.ts
+var WalletError = class _WalletError extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "WalletError";
+    Object.setPrototypeOf(this, _WalletError.prototype);
+  }
+};
+var WalletConnectionError = class _WalletConnectionError extends WalletError {
+  constructor(message, cause) {
+    super(message, "WALLET_CONNECTION_ERROR", cause);
+    this.name = "WalletConnectionError";
+    Object.setPrototypeOf(this, _WalletConnectionError.prototype);
+  }
+};
+var TransactionError = class _TransactionError extends WalletError {
+  constructor(message, txHash, cause) {
+    super(message, "TRANSACTION_ERROR", cause);
+    this.txHash = txHash;
+    this.name = "TransactionError";
+    Object.setPrototypeOf(this, _TransactionError.prototype);
+  }
+};
+var SignMessageError = class _SignMessageError extends WalletError {
+  constructor(message, cause) {
+    super(message, "SIGN_MESSAGE_ERROR", cause);
+    this.name = "SignMessageError";
+    Object.setPrototypeOf(this, _SignMessageError.prototype);
+  }
+};
+var WalletNotInstalledError = class _WalletNotInstalledError extends WalletError {
+  constructor(walletType) {
+    super(`Wallet ${walletType} is not installed`, "WALLET_NOT_INSTALLED");
+    this.name = "WalletNotInstalledError";
+    Object.setPrototypeOf(this, _WalletNotInstalledError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends WalletError {
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR", cause);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+
+// lib/storage.ts
+function setStorageItem(key, value, preferredType = "localStorage") {
+  const types = preferredType === "localStorage" ? ["localStorage", "sessionStorage", "cookie"] : preferredType === "sessionStorage" ? ["sessionStorage", "localStorage", "cookie"] : ["cookie", "localStorage", "sessionStorage"];
+  for (const type of types) {
+    try {
+      switch (type) {
+        case "localStorage":
+          if (typeof window !== "undefined" && window.localStorage) {
+            window.localStorage.setItem(key, value);
+            return true;
+          }
+          break;
+        case "sessionStorage":
+          if (typeof window !== "undefined" && window.sessionStorage) {
+            window.sessionStorage.setItem(key, value);
+            return true;
+          }
+          break;
+        case "cookie":
+          if (typeof document !== "undefined") {
+            document.cookie = `${key}=${encodeURIComponent(value)}; path=/; max-age=${60 * 60 * 24 * 30}; SameSite=Lax`;
+            return true;
+          }
+          break;
+      }
+    } catch (error) {
+      logger.warn(`Failed to set ${key} in ${type}`, { error });
+    }
+  }
+  return false;
+}
+function getStorageItem(key) {
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      const value = window.localStorage.getItem(key);
+      if (value !== null) return value;
+    }
+  } catch (error) {
+    logger.warn(`Failed to read ${key} from localStorage`, { error });
+  }
+  try {
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      const value = window.sessionStorage.getItem(key);
+      if (value !== null) return value;
+    }
+  } catch (error) {
+    logger.warn(`Failed to read ${key} from sessionStorage`, { error });
+  }
+  try {
+    if (typeof document !== "undefined") {
+      const match = document.cookie.split("; ").find((r) => r.startsWith(key + "="));
+      if (match) {
+        return decodeURIComponent(match.split("=").slice(1).join("="));
+      }
+    }
+  } catch (error) {
+    logger.warn(`Failed to read ${key} from cookie`, { error });
+  }
+  return null;
+}
+function removeStorageItem(key) {
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      window.localStorage.removeItem(key);
+    }
+  } catch (error) {
+  }
+  try {
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      window.sessionStorage.removeItem(key);
+    }
+  } catch (error) {
+  }
+  try {
+    if (typeof document !== "undefined") {
+      document.cookie = `${key}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+    }
+  } catch (error) {
+  }
+}
+
+// lib/constants.ts
+var STORAGE_KEYS = {
+  SELECTED_WALLET: "multiwallet.selectedWallet",
+  RECENT_WALLET: "recent_wallet_type",
+  USER_PROFILE_CACHE: "user_profile_cache",
+  USER_PROFILE_CACHE_TIMESTAMP: "user_profile_cache_timestamp",
+  IS_SIGNING_WALLET: "isSigningWallet",
+  STARKEY_ACCOUNTS: "starkey.accounts.0"
+};
+var CACHE_TTL = {
+  PROFILE: 600 * 1e3,
+  // 10 minutes
+  BALANCE: 30 * 1e3
+  // 30 seconds
+};
+var TIMEOUTS = {
+  WALLET_DETECTION_POLL: 3e3,
+  // 3 seconds (reduced from 5s)
+  WALLET_CHECK_INTERVAL: 2e3,
+  // 2 seconds
+  WALLET_CHECK_MAX_DURATION: 3e4,
+  // 30 seconds
+  CONNECTION_TIMEOUT: 3e4,
+  // 30 seconds
+  BALANCE_POLL_INTERVAL: 3e4,
+  // 30 seconds
+  MODAL_CLOSE_DELAY: 2500,
+  // 2.5 seconds
+  CLICK_OUTSIDE_DELAY: 2e3
+  // 2 seconds
+};
+var WALLET_DOWNLOAD_URLS = {
+  starkey: "https://chromewebstore.google.com/detail/starkey-wallet-the-offici/hcjhpkgbmechpabifbggldplacolbkoh",
+  ribbit: "https://ribbitwallet.com"
+};
+var DEFAULT_CHAIN_IDS = {
+  TESTNET: "6",
+  MAINNET: "8"
+};
+var ERROR_MESSAGES = {
+  WALLET_NOT_INSTALLED: "Wallet extension not installed",
+  CONNECTION_FAILED: "Failed to connect wallet",
+  CONNECTION_REJECTED: "Connection rejected by user",
+  NO_ACCOUNT_FOUND: "No account found",
+  SIGNING_FAILED: "Message signing failed",
+  SIGNING_REJECTED: "Message signing rejected",
+  TRANSACTION_FAILED: "Transaction failed",
+  TRANSACTION_REJECTED: "Transaction rejected",
+  NETWORK_ERROR: "Network error occurred",
+  UNSUPPORTED_WALLET: "Unsupported wallet type",
+  INVALID_ADDRESS: "Invalid wallet address"
+};
+var CONNECTION_MESSAGES = {
+  CONNECTING: "Connecting to wallet...",
+  SIGNING: "Please sign the message to verify your account",
+  SUCCESS: "Successfully connected",
+  ERROR: "Connection failed",
+  CONNECTED_NOT_SIGNED: "Connected but signature rejected"
+};
+
+// lib/crypto.ts
+function generateNonce() {
+  if (typeof window !== "undefined" && window.crypto && window.crypto.getRandomValues) {
+    const array = new Uint32Array(1);
+    window.crypto.getRandomValues(array);
+    return array[0].toString(36) + Date.now().toString(36);
+  }
+  return Math.random().toString(36).substring(2) + Date.now().toString(36);
+}
+
+// lib/config.ts
+var defaultConfig = {
+  rpcUrl: {
+    testnet: "https://rpc-testnet.supra.com",
+    mainnet: "https://rpc-mainnet.supra.com"
+  },
+  chainId: process.env.NEXT_PUBLIC_SUPRA_CHAIN_ID || DEFAULT_CHAIN_IDS.TESTNET,
+  enableLogging: process.env.NODE_ENV === "development",
+  balancePollInterval: 3e4,
+  walletDetectionTimeout: 3e3
+};
+var config = __spreadValues({}, defaultConfig);
+function initConfig(userConfig) {
+  var _a, _b, _c;
+  config = {
+    rpcUrl: {
+      testnet: ((_a = userConfig == null ? void 0 : userConfig.rpcUrl) == null ? void 0 : _a.testnet) || defaultConfig.rpcUrl.testnet,
+      mainnet: ((_b = userConfig == null ? void 0 : userConfig.rpcUrl) == null ? void 0 : _b.mainnet) || defaultConfig.rpcUrl.mainnet
+    },
+    chainId: (userConfig == null ? void 0 : userConfig.chainId) || defaultConfig.chainId,
+    enableLogging: (_c = userConfig == null ? void 0 : userConfig.enableLogging) != null ? _c : defaultConfig.enableLogging,
+    balancePollInterval: (userConfig == null ? void 0 : userConfig.balancePollInterval) || defaultConfig.balancePollInterval,
+    walletDetectionTimeout: (userConfig == null ? void 0 : userConfig.walletDetectionTimeout) || defaultConfig.walletDetectionTimeout
+  };
+}
+function getRpcUrl(chainId) {
+  const targetChainId = chainId || config.chainId;
+  const isMainnet = targetChainId === DEFAULT_CHAIN_IDS.MAINNET;
+  return isMainnet ? config.rpcUrl.mainnet : config.rpcUrl.testnet;
+}
+function getChainId() {
+  return config.chainId;
+}
+initConfig();
+
+// hooks/useSupraMultiWallet.ts
+var WALLET_CONFIGS = {
+  starkey: {
+    capabilities: {
+      signMessage: true,
+      accountSwitching: true,
+      networkSwitching: true,
+      rawTransactions: true,
+      eventListeners: true,
+      tokenRevalidation: true
+    },
+    provider: () => {
+      var _a;
+      return typeof window !== "undefined" && ((_a = window == null ? void 0 : window.starkey) == null ? void 0 : _a.supra);
+    }
+  },
+  ribbit: {
+    capabilities: {
+      signMessage: true,
+      accountSwitching: false,
+      // Ribbit doesn't support account switching
+      networkSwitching: false,
+      // Ribbit network switching happens in-app
+      rawTransactions: true,
+      eventListeners: false,
+      tokenRevalidation: false
+      // Ribbit doesn't support token revalidation
+    },
+    provider: () => initSdk()
+  }
+};
+var WALLET_EVENTS = {
+  CONNECTED: "wallet-connected",
+  PRESIGNED_STATE: "presigned-state",
+  POSTSIGNED_STATE: "postsigned-state",
+  ERROR: "wallet-error"
+};
+var setStoredWalletType = (walletType) => {
+  setStorageItem(STORAGE_KEYS.SELECTED_WALLET, walletType);
+};
+var getStoredWalletType = () => {
+  const stored = getStorageItem(STORAGE_KEYS.SELECTED_WALLET);
+  if (stored && ["starkey", "ribbit"].includes(stored)) {
+    return stored;
+  }
+  return "starkey";
+};
+var clearStoredWalletType = () => {
+  removeStorageItem(STORAGE_KEYS.SELECTED_WALLET);
+};
+var useSupraMultiWallet = (enabledWallets) => {
+  const router = useRouter();
+  const [selectedWallet, setSelectedWallet] = useState("starkey");
+  const [walletCapabilities, setWalletCapabilities] = useState(
+    WALLET_CONFIGS["starkey"].capabilities
+  );
+  useEffect(() => {
+    const stored = getStoredWalletType();
+    if (stored !== "starkey") {
+      setSelectedWallet(stored);
+      setWalletCapabilities(WALLET_CONFIGS[stored].capabilities);
+    }
+  }, []);
+  const [supraProvider, setSupraProvider] = useState(
+    WALLET_CONFIGS.starkey.provider()
+  );
+  const [ribbitProvider, setRibbitProvider] = useState(
+    WALLET_CONFIGS.ribbit.provider()
+  );
+  const [isExtensionInstalled, setIsExtensionInstalled] = useState(false);
+  const [accounts, setAccounts] = useState([]);
+  const [networkData, setNetworkData] = useState();
+  const [balance, setBalance] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [justRequestedRelative, setJustRequestedRelative] = useState(false);
+  const [transactions, setTransactions] = useState([]);
+  const [selectedChainId, setSelectedChainId] = useState("");
+  const addTransactions = (hash) => {
+    setTransactions((prev) => [{ hash }, ...prev]);
+  };
+  const getCurrentProvider = () => {
+    switch (selectedWallet) {
+      case "starkey": {
+        return supraProvider;
+      }
+      case "ribbit": {
+        return ribbitProvider;
+      }
+      default: {
+        return supraProvider;
+      }
+    }
+  };
+  const checkExtensionInstalled = useCallback(async () => {
+    switch (selectedWallet) {
+      case "starkey": {
+        const provider = WALLET_CONFIGS.starkey.provider();
+        setSupraProvider(provider);
+        setIsExtensionInstalled(!!provider);
+        return !!provider;
+      }
+      case "ribbit": {
+        const provider = WALLET_CONFIGS.ribbit.provider();
+        if (!provider) {
+          setRibbitProvider(null);
+          setIsExtensionInstalled(false);
+          return false;
+        }
+        try {
+          setRibbitProvider(provider);
+          setIsExtensionInstalled(true);
+          return true;
+        } catch (error) {
+          logger.error("Error checking Ribbit wallet readiness", error);
+          setRibbitProvider(null);
+          setIsExtensionInstalled(false);
+          return false;
+        }
+      }
+      default: {
+        return false;
+      }
+    }
+  }, [selectedWallet]);
+  const updateAccounts = useCallback(async () => {
+    const provider = getCurrentProvider();
+    if (!provider) return;
+    try {
+      switch (selectedWallet) {
+        case "starkey": {
+          const responseAcc = await provider.account();
+          const newAccounts = responseAcc.length > 0 ? responseAcc : [];
+          setAccounts(newAccounts);
+          if (responseAcc.length > 0) {
+            setStorageItem(STORAGE_KEYS.STARKEY_ACCOUNTS, responseAcc[0]);
+          }
+          if (newAccounts.length > 0) {
+            const balance2 = await provider.balance();
+            if (balance2) {
+              setBalance(`${balance2.formattedBalance} ${balance2.displayUnit}`);
+            }
+            const networkData2 = await provider.getChainId();
+            setNetworkData(networkData2 || {});
+          }
+          break;
+        }
+        case "ribbit": {
+          const wallet = provider.getWalletInfo();
+          if (wallet == null ? void 0 : wallet.connected) {
+            setAccounts([wallet.walletAddress]);
+            const walletBalanceRequest = {
+              chainId: parseInt(getChainId()),
+              resourceType: "0x1::supra_coin::SupraCoin",
+              decimals: 8
+            };
+            const balanceStr = await provider.getWalletBalance(walletBalanceRequest);
+            logger.debug("Ribbit balance response", { balance: balanceStr });
+            setBalance(`${(balanceStr == null ? void 0 : balanceStr.balance) || 0} SUPRA`);
+          } else {
+            setAccounts([]);
+          }
+          break;
+        }
+        default: {
+          setAccounts([]);
+          break;
+        }
+      }
+    } catch (error) {
+      logger.error("Failed to update accounts", error, { walletType: selectedWallet });
+      setAccounts([]);
+      switch (selectedWallet) {
+        case "starkey": {
+          removeStorageItem(STORAGE_KEYS.STARKEY_ACCOUNTS);
+          break;
+        }
+        case "ribbit": {
+          break;
+        }
+      }
+    }
+  }, [selectedWallet]);
+  useEffect(() => {
+    let mounted = true;
+    const initProvider = async () => {
+      const isInstalled = await checkExtensionInstalled();
+      if (mounted && isInstalled) {
+        updateAccounts();
+      }
+    };
+    initProvider();
+    return () => {
+      mounted = false;
+    };
+  }, [selectedWallet, checkExtensionInstalled, updateAccounts]);
+  useEffect(() => {
+    const checkExtension = async () => {
+      return await checkExtensionInstalled();
+    };
+    checkExtension().then((isInstalled) => {
+      if (isInstalled && selectedWallet === "ribbit") {
+        updateAccounts();
+      }
+    });
+    const intv = setInterval(async () => {
+      const isInstalled = await checkExtension();
+      if (isInstalled) {
+        clearInterval(intv);
+        if (selectedWallet === "ribbit") {
+          updateAccounts();
+        }
+      }
+    }, 1e3);
+    setTimeout(() => {
+      clearInterval(intv);
+    }, TIMEOUTS.WALLET_DETECTION_POLL);
+    return () => clearInterval(intv);
+  }, [selectedWallet, updateAccounts, checkExtensionInstalled]);
+  const checkIsExtensionInstalled = useCallback(() => {
+    const intervalId = setInterval(async () => {
+      const isInstalled = await checkExtensionInstalled();
+      if (isInstalled) {
+        clearInterval(intervalId);
+        updateAccounts();
+      }
+    }, 500);
+    setTimeout(() => clearInterval(intervalId), TIMEOUTS.WALLET_DETECTION_POLL);
+  }, [updateAccounts, checkExtensionInstalled]);
+  const updateBalance = useCallback(async () => {
+    const provider = getCurrentProvider();
+    if (!provider || !accounts.length) {
+      setBalance("");
+      return;
+    }
+    try {
+      switch (selectedWallet) {
+        case "starkey": {
+          const balance2 = await provider.balance();
+          if (balance2) {
+            setBalance(`${balance2.formattedBalance} ${balance2.displayUnit}`);
+          }
+          break;
+        }
+        case "ribbit": {
+          const walletBalanceRequest = {
+            chainId: parseInt(getChainId()),
+            resourceType: "0x1::supra_coin::SupraCoin",
+            decimals: 8
+          };
+          const balanceStr = await provider.getWalletBalance(
+            walletBalanceRequest
+          );
+          logger.debug("Ribbit balance response", { balance: balanceStr });
+          setBalance(`${(balanceStr == null ? void 0 : balanceStr.balance) || 0} SUPRA`);
+          break;
+        }
+        default: {
+          setBalance("");
+          break;
+        }
+      }
+    } catch (error) {
+      logger.error("Failed to update balance", error, { walletType: selectedWallet });
+      setBalance("");
+    }
+  }, [selectedWallet, accounts]);
+  const getNetworkData = useCallback(async () => {
+    const provider = getCurrentProvider();
+    if (!provider) return {};
+    try {
+      switch (selectedWallet) {
+        case "starkey": {
+          const data = await provider.getChainId();
+          setNetworkData(data || {});
+          return data || {};
+        }
+        case "ribbit": {
+          const chainId = parseInt(getChainId());
+          const mockNetworkData = { chainId: chainId.toString() };
+          setNetworkData(mockNetworkData);
+          return mockNetworkData;
+        }
+        default: {
+          setNetworkData({});
+          return {};
+        }
+      }
+    } catch (error) {
+      logger.error("Failed to get network data", error, { walletType: selectedWallet });
+      setNetworkData({});
+      return {};
+    }
+  }, [selectedWallet]);
+  const connectWallet = async (walletType) => {
+    if (walletType) {
+      updateSelectedWallet(walletType);
+    }
+    const provider = walletType ? WALLET_CONFIGS[walletType].provider() : getCurrentProvider();
+    if (!provider) {
+      const error = new WalletNotInstalledError(walletType || selectedWallet);
+      logger.warn("Wallet not installed", { walletType: walletType || selectedWallet });
+      toast.error(ERROR_MESSAGES.WALLET_NOT_INSTALLED, {
+        description: `Please install the ${walletType || selectedWallet} extension`
+      });
+      return false;
+    }
+    setLoading(true);
+    try {
+      switch (walletType || selectedWallet) {
+        case "starkey": {
+          await provider.connect();
+          logger.info("Starkey wallet connection approved");
+          await updateAccounts();
+          const responseAcc = await provider.account();
+          if (responseAcc.length === 0) {
+            throw new WalletConnectionError(ERROR_MESSAGES.NO_ACCOUNT_FOUND);
+          }
+          if (responseAcc.length) {
+            setAccounts(responseAcc);
+            setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+            setStorageItem(STORAGE_KEYS.STARKEY_ACCOUNTS, responseAcc[0]);
+            window.dispatchEvent(
+              new CustomEvent(WALLET_EVENTS.PRESIGNED_STATE, {
+                detail: {
+                  timestamp: Date.now(),
+                  account: responseAcc[0]
+                }
+              })
+            );
+            window.dispatchEvent(
+              new CustomEvent(WALLET_EVENTS.CONNECTED, {
+                detail: {
+                  timestamp: Date.now(),
+                  account: responseAcc[0],
+                  wallet: "starkey"
+                }
+              })
+            );
+            try {
+              const message = "To verify your account, please sign this message.";
+              const nonce = generateNonce();
+              const hexMessage = "0x" + Buffer.from(message, "utf8").toString("hex");
+              logger.debug("Signature request initiated", { account: responseAcc[0] });
+              const signatureResponse = await provider.signMessage({
+                message: hexMessage,
+                nonce
+              });
+              if (signatureResponse) {
+                logger.info("Signature approved", { account: responseAcc[0] });
+                window.dispatchEvent(
+                  new CustomEvent(WALLET_EVENTS.POSTSIGNED_STATE, {
+                    detail: {
+                      timestamp: Date.now(),
+                      account: responseAcc[0]
+                    }
+                  })
+                );
+              }
+            } catch (signError) {
+              const error = new SignMessageError(ERROR_MESSAGES.SIGNING_FAILED, signError);
+              logger.error("Signing failed", error, { account: responseAcc[0] });
+              window.dispatchEvent(
+                new CustomEvent(WALLET_EVENTS.ERROR, {
+                  detail: {
+                    timestamp: Date.now(),
+                    error
+                  }
+                })
+              );
+              throw error;
+            }
+          }
+          break;
+        }
+        case "ribbit": {
+          const dappMetadata = {
+            name: "multiwallet",
+            description: "NFT Marketplace and Lootbox Platform",
+            logo: window.location.origin + "/favicon.ico",
+            url: window.location.origin
+          };
+          const response = await provider.connectToWallet(
+            dappMetadata
+          );
+          if (response == null ? void 0 : response.connected) {
+            logger.info("Ribbit wallet connection approved");
+          }
+          if (response.walletAddress == null) {
+            throw new WalletConnectionError(ERROR_MESSAGES.NO_ACCOUNT_FOUND);
+          }
+          if (response == null ? void 0 : response.connected) {
+            await updateAccounts();
+            if (response.walletAddress) {
+              setAccounts([response.walletAddress]);
+              setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+              window.dispatchEvent(
+                new CustomEvent(WALLET_EVENTS.PRESIGNED_STATE, {
+                  detail: {
+                    timestamp: Date.now(),
+                    account: response.walletAddress
+                  }
+                })
+              );
+              window.dispatchEvent(
+                new CustomEvent(WALLET_EVENTS.CONNECTED, {
+                  detail: {
+                    timestamp: Date.now(),
+                    account: response.walletAddress,
+                    wallet: "ribbit"
+                  }
+                })
+              );
+              try {
+                const message = "To verify your account, please sign this message.";
+                const nonce = generateNonce();
+                const hexMessage = "0x" + Buffer.from(message, "utf8").toString("hex");
+                logger.debug("Signature request initiated", { account: response.walletAddress });
+                const signatureResponse = await provider.signMessage({
+                  message: hexMessage,
+                  nonce: parseInt(nonce),
+                  chainId: parseInt(getChainId())
+                });
+                if (signatureResponse && signatureResponse.approved) {
+                  logger.info("Signature approved", { account: response.walletAddress });
+                  window.dispatchEvent(
+                    new CustomEvent(WALLET_EVENTS.POSTSIGNED_STATE, {
+                      detail: {
+                        timestamp: Date.now(),
+                        account: response.walletAddress
+                      }
+                    })
+                  );
+                } else {
+                  throw new SignMessageError(signatureResponse.error || ERROR_MESSAGES.SIGNING_REJECTED);
+                }
+              } catch (signError) {
+                const error = new SignMessageError(ERROR_MESSAGES.SIGNING_FAILED, signError);
+                logger.error("Signing failed", error, { account: response.walletAddress });
+                window.dispatchEvent(
+                  new CustomEvent(WALLET_EVENTS.ERROR, {
+                    detail: {
+                      timestamp: Date.now(),
+                      error
+                    }
+                  })
+                );
+                throw error;
+              }
+            }
+          } else {
+            throw new WalletConnectionError(ERROR_MESSAGES.CONNECTION_REJECTED);
+          }
+          break;
+        }
+        default: {
+          throw new WalletConnectionError(
+            `${ERROR_MESSAGES.UNSUPPORTED_WALLET}: ${walletType || selectedWallet}`
+          );
+        }
+      }
+      return true;
+    } catch (error) {
+      const walletError = error instanceof WalletConnectionError ? error : new WalletConnectionError(ERROR_MESSAGES.CONNECTION_FAILED, error);
+      logger.error("Wallet connection failed", walletError, {
+        walletType: walletType || selectedWallet
+      });
+      window.dispatchEvent(
+        new CustomEvent(WALLET_EVENTS.ERROR, {
+          detail: {
+            timestamp: Date.now(),
+            error: walletError
+          }
+        })
+      );
+      return false;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const disconnectWallet = async () => {
+    const provider = getCurrentProvider();
+    if (!provider) return;
+    try {
+      switch (selectedWallet) {
+        case "starkey": {
+          await provider.disconnect();
+          break;
+        }
+        case "ribbit": {
+          await provider.disconnect();
+          break;
+        }
+      }
+      resetWalletData();
+      clearStoredWalletType();
+      router.push("/");
+    } catch (error) {
+      logger.error("Wallet disconnect failed", error, { walletType: selectedWallet });
+      resetWalletData();
+      clearStoredWalletType();
+    }
+  };
+  const resetWalletData = () => {
+    setAccounts([]);
+    setBalance("");
+    setNetworkData({});
+    switch (selectedWallet) {
+      case "starkey": {
+        setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+        removeStorageItem(STORAGE_KEYS.STARKEY_ACCOUNTS);
+        break;
+      }
+      case "ribbit": {
+        break;
+      }
+    }
+  };
+  const getSequenceNumber = async (address) => {
+    const rpcUrl = getRpcUrl();
+    const data = await fetch(`${rpcUrl}/rpc/v1/accounts/${address}`);
+    if (!data.ok) {
+      throw new NetworkError(`Failed to fetch sequence number for ${address}`);
+    }
+    const accountData = await data.json();
+    return accountData.sequence_number;
+  };
+  const sendRawTransaction = async (moduleAddress, moduleName, functionName, params, runTimeParams = [], txExpiryTime = Math.ceil(Date.now() / 1e3) + 3e3) => {
+    const provider = getCurrentProvider();
+    if (!provider || !accounts.length || !moduleAddress || !moduleName || !functionName)
+      return;
+    try {
+      switch (selectedWallet) {
+        case "starkey": {
+          if (!walletCapabilities.rawTransactions) {
+            throw new TransactionError("Raw transactions not supported by current wallet");
+          }
+          let networkData2 = await getNetworkData();
+          const currentChainId = getChainId();
+          if (networkData2.chainId !== currentChainId) {
+            setSelectedChainId(currentChainId);
+            await provider.changeNetwork({
+              chainId: currentChainId
+            });
+          }
+          const rawTxPayload = [
+            accounts[0],
+            0,
+            // sequence number
+            moduleAddress,
+            moduleName,
+            functionName,
+            runTimeParams,
+            params,
+            {}
+          ];
+          const data = await provider.createRawTransactionData(rawTxPayload);
+          const txHash = await provider.sendTransaction({
+            data,
+            from: accounts[0],
+            to: moduleAddress,
+            chainId: currentChainId,
+            value: ""
+          });
+          addTransactions(txHash || "failed");
+          logger.info("Transaction sent successfully", { txHash, walletType: "starkey" });
+          return txHash;
+        }
+        case "ribbit": {
+          if (!walletCapabilities.rawTransactions) {
+            throw new TransactionError("Raw transactions not supported by current wallet");
+          }
+          const currentChainId = getChainId();
+          let chainId = SupraChainId.TESTNET;
+          if (currentChainId === DEFAULT_CHAIN_IDS.TESTNET) {
+            chainId = SupraChainId.TESTNET;
+          } else if (currentChainId === DEFAULT_CHAIN_IDS.MAINNET) {
+            chainId = SupraChainId.MAINNET;
+          }
+          const rawTxnRequest = {
+            sender: accounts[0],
+            // Use actual sender address
+            moduleAddress,
+            // Use provided module address
+            moduleName,
+            // Use provided module name
+            functionName,
+            // Use provided function name
+            typeArgs: runTimeParams,
+            // Use converted runtime parameters
+            args: params || [],
+            // Use provided parameters
+            chainId
+          };
+          const rawTxnBase64 = await provider.createRawTransactionBuffer(rawTxnRequest);
+          const response = await provider.signAndSendRawTransaction({
+            rawTxn: rawTxnBase64,
+            chainId,
+            meta: {
+              description: `Call ${moduleName}::${functionName}`
+              // Dynamic description
+            }
+          });
+          if (response.approved) {
+            const txHash = response.txHash || response.result || "success";
+            addTransactions(txHash);
+            logger.info("Transaction sent successfully", { txHash, walletType: "ribbit" });
+            return txHash;
+          } else {
+            throw new TransactionError(response.error || ERROR_MESSAGES.TRANSACTION_REJECTED);
+          }
+        }
+        default: {
+          throw new TransactionError(
+            `Raw transactions not supported for wallet: ${selectedWallet}`
+          );
+        }
+      }
+    } catch (error) {
+      const txError = error instanceof TransactionError ? error : new TransactionError(ERROR_MESSAGES.TRANSACTION_FAILED, void 0, error);
+      logger.error("Transaction failed", txError, {
+        walletType: selectedWallet,
+        moduleAddress,
+        moduleName,
+        functionName
+      });
+      throw txError;
+    }
+  };
+  const signMessage = async (message, nonce, account, forceSign = false) => {
+    const provider = getCurrentProvider();
+    if (!provider) return;
+    const secureNonce = nonce || generateNonce();
+    switch (selectedWallet) {
+      case "starkey": {
+        if (!walletCapabilities.signMessage) {
+          throw new SignMessageError("Message signing not supported by current wallet");
+        }
+        if (!accounts.length && !account) return;
+        if (!accounts.length && account) {
+          accounts[0] = account;
+        }
+        if (getStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET) === "true" && !forceSign) {
+          return;
+        }
+        setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "true");
+        try {
+          const hexMessage = "0x" + Buffer.from(message, "utf8").toString("hex");
+          const response = await provider.signMessage({
+            message: hexMessage,
+            nonce: secureNonce
+          });
+          const { publicKey, signature } = response;
+          const verified = nacl.sign.detached.verify(
+            new TextEncoder().encode(message),
+            Uint8Array.from(Buffer.from(signature.slice(2), "hex")),
+            Uint8Array.from(Buffer.from(publicKey.slice(2), "hex"))
+          );
+          setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+          logger.info("Message signed successfully", { walletType: "starkey" });
+          return __spreadProps(__spreadValues({}, response), { verified });
+        } catch (error) {
+          setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+          throw new SignMessageError(ERROR_MESSAGES.SIGNING_FAILED, error);
+        }
+      }
+      case "ribbit": {
+        if (!walletCapabilities.signMessage) {
+          throw new SignMessageError("Message signing not supported by current wallet");
+        }
+        if (!accounts.length && !account) return;
+        if (!accounts.length && account) {
+          accounts[0] = account;
+        }
+        if (getStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET) === "true" && !forceSign) {
+          return;
+        }
+        setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "true");
+        try {
+          const hexMessage = "0x" + Buffer.from(message, "utf8").toString("hex");
+          const response = await provider.signMessage({
+            message: hexMessage,
+            nonce: parseInt(secureNonce),
+            chainId: parseInt(getChainId())
+          });
+          if (response.approved && response.publicKey && response.signature) {
+            const { publicKey, signature } = response;
+            const verified = nacl.sign.detached.verify(
+              new TextEncoder().encode(message),
+              Uint8Array.from(Buffer.from(signature.slice(2), "hex")),
+              Uint8Array.from(Buffer.from(publicKey.slice(2), "hex"))
+            );
+            setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+            logger.info("Message signed successfully", { walletType: "ribbit" });
+            return __spreadProps(__spreadValues({}, response), { verified });
+          } else {
+            setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+            throw new SignMessageError(response.error || ERROR_MESSAGES.SIGNING_REJECTED);
+          }
+        } catch (error) {
+          setStorageItem(STORAGE_KEYS.IS_SIGNING_WALLET, "false");
+          throw new SignMessageError(ERROR_MESSAGES.SIGNING_FAILED, error);
+        }
+      }
+      default: {
+        throw new SignMessageError(
+          `Message signing not supported for wallet: ${selectedWallet}`
+        );
+      }
+    }
+  };
+  useEffect(() => {
+    if (selectedWallet === "starkey" && walletCapabilities.eventListeners) {
+      const handleExtensionEvents = (event) => {
+        var _a, _b, _c;
+        if ((_b = (_a = event == null ? void 0 : event.data) == null ? void 0 : _a.name) == null ? void 0 : _b.startsWith("starkey-")) {
+          switch ((_c = event == null ? void 0 : event.data) == null ? void 0 : _c.name) {
+            case "starkey-extension-installed": {
+              checkIsExtensionInstalled();
+              break;
+            }
+            case "starkey-wallet-updated": {
+              (async () => {
+                const responseAcc = await supraProvider.account();
+                if (responseAcc.length) {
+                  setAccounts(responseAcc);
+                  window.dispatchEvent(
+                    new CustomEvent(WALLET_EVENTS.CONNECTED, {
+                      detail: {
+                        timestamp: Date.now(),
+                        account: responseAcc[0]
+                      }
+                    })
+                  );
+                  await updateBalance();
+                  await getNetworkData();
+                } else {
+                  logger.debug("Starkey wallet updated: No accounts found - Resetting");
+                  resetWalletData();
+                }
+                setLoading(false);
+              })();
+              break;
+            }
+            case "starkey-wallet-disconnected": {
+              resetWalletData();
+              router.push("/");
+              setLoading(false);
+              break;
+            }
+            case "starkey-window-removed": {
+              setLoading(false);
+              break;
+            }
+          }
+        }
+      };
+      checkIsExtensionInstalled();
+      window.addEventListener("message", handleExtensionEvents);
+      return () => window.removeEventListener("message", handleExtensionEvents);
+    }
+  }, [selectedWallet, walletCapabilities, supraProvider]);
+  const getAvailableWallets = useCallback(() => {
+    const allWallets = [];
+    Object.entries(WALLET_CONFIGS).forEach(([walletType, config2]) => {
+      if (enabledWallets && !enabledWallets.includes(walletType)) {
+        return;
+      }
+      const provider = config2.provider();
+      const isInstalled = !!provider;
+      switch (walletType) {
+        case "starkey": {
+          allWallets.push({
+            type: "starkey",
+            name: "Starkey Wallet",
+            isInstalled,
+            capabilities: config2.capabilities
+          });
+          break;
+        }
+        case "ribbit": {
+          allWallets.push({
+            type: "ribbit",
+            name: "Ribbit Wallet",
+            isInstalled,
+            capabilities: config2.capabilities
+          });
+          break;
+        }
+      }
+    });
+    return allWallets;
+  }, [enabledWallets]);
+  const updateSelectedWallet = (walletType) => {
+    setSelectedWallet(walletType);
+    setWalletCapabilities(WALLET_CONFIGS[walletType].capabilities);
+    setStoredWalletType(walletType);
+  };
+  return {
+    // New wallet selection functionality
+    selectedWallet,
+    walletCapabilities,
+    getAvailableWallets,
+    // Add this new function
+    // Existing interface (unchanged)
+    getCurrentProvider,
+    isExtensionInstalled,
+    accounts,
+    networkData,
+    balance,
+    transactions,
+    selectedChainId,
+    connectWallet,
+    // Now accepts optional walletType parameter
+    disconnectWallet,
+    sendRawTransaction,
+    signMessage,
+    setSelectedChainId,
+    // switchToChain,
+    loading
+    // authFetch,
+    // checkAndRevalidateToken,
+    // signIn,
+  };
+};
+var useSupraMultiWallet_default = useSupraMultiWallet;
+
+// components/ConnectWalletHandler.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var starkeyIcon = "/walletIcons/Starkey.png";
+var ribbitIcon = "/walletIcons/Ribbit.jpg";
+var PROFILE_CACHE_KEY = STORAGE_KEYS.USER_PROFILE_CACHE;
+var PROFILE_CACHE_TIMESTAMP_KEY = STORAGE_KEYS.USER_PROFILE_CACHE_TIMESTAMP;
+var WALLET_INFO = {
+  starkey: {
+    name: "Starkey Wallet",
+    icon: /* @__PURE__ */ jsx3(
+      "img",
+      {
+        src: starkeyIcon,
+        alt: "Starkey Wallet",
+        className: "w-10 h-10 rounded-full"
+      }
+    ),
+    downloadUrl: WALLET_DOWNLOAD_URLS.starkey
+  },
+  ribbit: {
+    name: "Ribbit Wallet",
+    icon: /* @__PURE__ */ jsx3(
+      "img",
+      {
+        src: ribbitIcon,
+        alt: "Ribbit Wallet",
+        className: "w-10 h-10 rounded-full"
+      }
+    ),
+    downloadUrl: WALLET_DOWNLOAD_URLS.ribbit
+  }
+};
+var ConnectWalletHandler = ({
+  onConnect,
+  onDisconnect,
+  enabledWallets,
+  // Destructure the new prop
+  children
+}) => {
+  const starKeyWalletHook = useSupraMultiWallet_default(enabledWallets);
+  const getAvailableWallets = starKeyWalletHook.getAvailableWallets;
+  const [loading, setLoading] = useState2(false);
+  const [showWalletModal, setShowWalletModal] = useState2(false);
+  const [userProfile, setUserProfile] = useState2(null);
+  const [walletBalance, setWalletBalance] = useState2("0.00");
+  const [availableWallets, setAvailableWallets] = useState2([]);
+  const [recentWallet, setRecentWallet] = useState2(null);
+  const [selectedWallet, setSelectedWallet] = useState2(null);
+  const [hoveredWallet, setHoveredWallet] = useState2(null);
+  const [connectionStage, setConnectionStage] = useState2("idle");
+  const [connectionStageStartTime, setConnectionStageStartTime] = useState2(null);
+  const [canClickOutside, setCanClickOutside] = useState2(false);
+  const getProfileFromCache = useCallback2(() => {
+    try {
+      if (typeof window === "undefined") return null;
+      const cachedData = getStorageItem(PROFILE_CACHE_KEY);
+      const timestamp = getStorageItem(PROFILE_CACHE_TIMESTAMP_KEY);
+      if (!cachedData || !timestamp) return null;
+      const now = Date.now();
+      const cacheTime = parseInt(timestamp);
+      if (now - cacheTime > CACHE_TTL.PROFILE) {
+        return null;
+      }
+      return JSON.parse(cachedData);
+    } catch (error) {
+      logger.error("Failed to read profile from cache", error);
+      return null;
+    }
+  }, []);
+  const updateWalletBalance = useCallback2(async () => {
+    const provider = starKeyWalletHook.getCurrentProvider();
+    if (!provider) return;
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 1));
+      switch (starKeyWalletHook.selectedWallet) {
+        case "starkey": {
+          const balance = await provider.balance();
+          if (balance && balance.formattedBalance) {
+            setWalletBalance(balance.formattedBalance);
+          }
+          break;
+        }
+        case "ribbit": {
+          const walletBalanceRequest = {
+            chainId: parseInt(process.env.NEXT_PUBLIC_SUPRA_CHAIN_ID || "6"),
+            resourceType: "0x1::supra_coin::SupraCoin",
+            decimals: 8
+          };
+          try {
+            const balance = await provider.getWalletBalance(walletBalanceRequest);
+            const balanceStr = balance.balance;
+            logger.debug("Ribbit balance fetched", { balance: balanceStr });
+            if (balanceStr) {
+              setWalletBalance(balanceStr);
+            }
+          } catch (error) {
+            logger.error("Failed to fetch Ribbit balance", error);
+          }
+          break;
+        }
+      }
+    } catch (error) {
+      logger.error("Failed to update wallet balance", error);
+    }
+  }, [starKeyWalletHook.selectedWallet, starKeyWalletHook.getCurrentProvider]);
+  const connectWallet = useCallback2(async (walletType) => {
+    if (walletType) {
+      setLoading(true);
+      setSelectedWallet(walletType);
+      setConnectionStage("connecting");
+      try {
+        const success = await starKeyWalletHook.connectWallet(walletType);
+        if (success) {
+          setStorageItem(STORAGE_KEYS.RECENT_WALLET, walletType);
+          setRecentWallet(walletType);
+          if (starKeyWalletHook.accounts.length > 0) {
+            onConnect == null ? void 0 : onConnect(starKeyWalletHook.accounts[0]);
+          }
+        }
+      } catch (error) {
+        logger.error("Failed to connect wallet", error, { walletType });
+        toast2.error(`Connection failed: ${error.message || "Unknown error"}`);
+        setConnectionStage("idle");
+      } finally {
+        setLoading(false);
+      }
+    } else {
+      handleConnectClick();
+    }
+  }, [starKeyWalletHook, onConnect]);
+  const handleConnectClick = () => {
+    const installedWallets = availableWallets.filter((w) => w.isInstalled);
+    if (installedWallets.length === 0) {
+      setShowWalletModal(true);
+    } else if (installedWallets.length === 1) {
+      setShowWalletModal(true);
+    } else {
+      setShowWalletModal(true);
+    }
+  };
+  const handleDisconnectWallet = useCallback2(async () => {
+    setLoading(true);
+    try {
+      await starKeyWalletHook.disconnectWallet();
+      setUserProfile(null);
+      setWalletBalance("0.00");
+      onDisconnect == null ? void 0 : onDisconnect();
+    } catch (error) {
+      logger.error("Failed to disconnect wallet", error);
+    } finally {
+      setLoading(false);
+    }
+  }, [starKeyWalletHook, onDisconnect]);
+  const getConnectionStageInfo = useCallback2(() => {
+    const wallet = selectedWallet ? WALLET_INFO[selectedWallet] : null;
+    switch (connectionStage) {
+      case "connecting":
+        return {
+          title: `Waiting for ${(wallet == null ? void 0 : wallet.name) || "Wallet"}`,
+          subtitle: CONNECTION_MESSAGES.CONNECTING,
+          buttonText: "Connecting"
+        };
+      case "signing":
+        return {
+          title: "Sign to verify",
+          subtitle: CONNECTION_MESSAGES.SIGNING,
+          buttonText: "Signing"
+        };
+      case "success":
+        return {
+          title: `Connected to ${(wallet == null ? void 0 : wallet.name.replace(" Wallet", "")) || "Wallet"}`,
+          subtitle: CONNECTION_MESSAGES.SUCCESS,
+          buttonText: "Connected"
+        };
+      case "error":
+        return {
+          title: "Error",
+          subtitle: CONNECTION_MESSAGES.ERROR,
+          buttonText: "Close"
+        };
+      case "connected-not-signed":
+        return {
+          title: `Connected to ${(wallet == null ? void 0 : wallet.name.replace(" Wallet", "")) || "Wallet"}`,
+          subtitle: CONNECTION_MESSAGES.CONNECTED_NOT_SIGNED,
+          buttonText: "Connected"
+        };
+      default:
+        return null;
+    }
+  }, [connectionStage, selectedWallet]);
+  useEffect2(() => {
+    const recent = getStorageItem(STORAGE_KEYS.RECENT_WALLET);
+    if (recent && ["starkey", "ribbit"].includes(recent)) {
+      setRecentWallet(recent);
+    }
+  }, []);
+  useEffect2(() => {
+    const checkWallets = () => {
+      const wallets = getAvailableWallets();
+      setAvailableWallets(wallets);
+    };
+    checkWallets();
+    const interval = setInterval(checkWallets, TIMEOUTS.WALLET_CHECK_INTERVAL);
+    const timeout = setTimeout(() => clearInterval(interval), TIMEOUTS.WALLET_CHECK_MAX_DURATION);
+    return () => {
+      clearInterval(interval);
+      clearTimeout(timeout);
+    };
+  }, [getAvailableWallets]);
+  useEffect2(() => {
+    if (starKeyWalletHook.accounts.length > 0) {
+      updateWalletBalance();
+    }
+  }, [starKeyWalletHook.accounts, starKeyWalletHook.selectedWallet]);
+  useEffect2(() => {
+    const handlePresignedState = () => {
+      setConnectionStage(() => "signing");
+    };
+    const handlePostsignedState = () => {
+      setConnectionStage("success");
+      setTimeout(() => {
+        setConnectionStage("idle");
+        setShowWalletModal(false);
+        updateWalletBalance();
+      }, TIMEOUTS.MODAL_CLOSE_DELAY);
+    };
+    const handleWalletError = () => {
+      if (connectionStage == "signing") {
+        setConnectionStage(() => "connected-not-signed");
+      } else {
+        setConnectionStage(() => "error");
+      }
+      setTimeout(() => {
+        setShowWalletModal(false);
+        setSelectedWallet(null);
+        setConnectionStage("idle");
+        setLoading(false);
+      }, TIMEOUTS.MODAL_CLOSE_DELAY);
+    };
+    const handleStarkeyEvents = (event) => {
+      var _a, _b, _c;
+      if ((_b = (_a = event == null ? void 0 : event.data) == null ? void 0 : _a.name) == null ? void 0 : _b.startsWith("starkey-")) {
+        switch ((_c = event == null ? void 0 : event.data) == null ? void 0 : _c.name) {
+          case "starkey-wallet-updated":
+          case "starkey-wallet-connected":
+            setTimeout(updateWalletBalance, 1);
+            break;
+          case "starkey-wallet-disconnected":
+            setWalletBalance("0.00");
+            break;
+        }
+      }
+    };
+    window.addEventListener("presigned-state", handlePresignedState);
+    window.addEventListener("postsigned-state", handlePostsignedState);
+    window.addEventListener("wallet-error", handleWalletError);
+    window.addEventListener("message", handleStarkeyEvents);
+    return () => {
+      window.removeEventListener("presigned-state", handlePresignedState);
+      window.removeEventListener("postsigned-state", handlePostsignedState);
+      window.removeEventListener("wallet-error", handleWalletError);
+      window.removeEventListener("message", handleStarkeyEvents);
+    };
+  }, [connectionStage]);
+  useEffect2(() => {
+    const handleProfileUpdated = (event) => {
+      const { address, username, profileImage } = event.detail;
+      if (starKeyWalletHook.accounts[0] === address) {
+        setUserProfile({ address, username, profileImage });
+      }
+    };
+    window.addEventListener("profile-updated", handleProfileUpdated);
+    return () => {
+      window.removeEventListener("profile-updated", handleProfileUpdated);
+    };
+  }, [starKeyWalletHook.accounts]);
+  useEffect2(() => {
+    if (starKeyWalletHook.accounts.length > 0) {
+      const handleVisibilityChange = () => {
+        if (!document.hidden) {
+          updateWalletBalance();
+        }
+      };
+      document.addEventListener("visibilitychange", handleVisibilityChange);
+      const balanceInterval = setInterval(() => {
+        if (!document.hidden) {
+          updateWalletBalance();
+        }
+      }, TIMEOUTS.BALANCE_POLL_INTERVAL);
+      return () => {
+        clearInterval(balanceInterval);
+        document.removeEventListener("visibilitychange", handleVisibilityChange);
+      };
+    }
+  }, [starKeyWalletHook.accounts, updateWalletBalance]);
+  useEffect2(() => {
+    if (connectionStage === "connecting" || connectionStage === "signing") {
+      setConnectionStageStartTime(Date.now());
+      setCanClickOutside(false);
+      const timer = setTimeout(() => {
+        setCanClickOutside(true);
+      }, TIMEOUTS.CLICK_OUTSIDE_DELAY);
+      return () => clearTimeout(timer);
+    } else {
+      setConnectionStageStartTime(null);
+      setCanClickOutside(false);
+    }
+  }, [connectionStage]);
+  const handleModalClose = useCallback2((open) => {
+    if (!open) {
+      if (connectionStage === "idle" || connectionStage === "success" || connectionStage === "connected-not-signed" || connectionStage === "error" || canClickOutside && (connectionStage === "connecting" || connectionStage === "signing")) {
+        setShowWalletModal(false);
+        setSelectedWallet(null);
+        setLoading(false);
+        setCanClickOutside(false);
+        setConnectionStageStartTime(null);
+        setTimeout(() => {
+          setConnectionStage("idle");
+        }, 100);
+      }
+    }
+  }, [connectionStage, canClickOutside]);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    children({
+      isConnected: starKeyWalletHook.accounts.length > 0,
+      accounts: starKeyWalletHook.accounts,
+      loading: loading || starKeyWalletHook.loading,
+      balance: walletBalance,
+      userProfile,
+      handleConnect: handleConnectClick,
+      handleDisconnect: handleDisconnectWallet
+    }),
+    /* @__PURE__ */ jsxs2(
+      Dialog,
+      {
+        open: showWalletModal,
+        onOpenChange: handleModalClose,
+        children: [
+          /* @__PURE__ */ jsx3(VisuallyHidden, { asChild: true, children: /* @__PURE__ */ jsx3(DialogTitle, { children: "Select a wallet" }) }),
+          /* @__PURE__ */ jsx3(VisuallyHidden, { asChild: true, children: /* @__PURE__ */ jsx3(DialogDescription, { children: "Select a wallet to connect to MyDApp" }) }),
+          /* @__PURE__ */ jsxs2(
+            DialogContent,
+            {
+              className: "z-[100] px-4 py-6 w-[90%] mx-auto max-w-sm bg-gradient-to-br from-brand-dark via-gray-900 to-brand-dark border border-brand-dark sm:rounded-3xl rounded-3xl",
+              children: [
+                canClickOutside && (connectionStage === "connecting" || connectionStage === "signing") && /* @__PURE__ */ jsx3("div", { className: "absolute top-4 right-4", children: /* @__PURE__ */ jsx3(X2, { className: "h-5 w-5" }) }),
+                /* @__PURE__ */ jsx3("div", { className: "", children: connectionStage === "idle" ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+                  /* @__PURE__ */ jsx3("p", { className: "text-center text-sm text-brand-light/75 mb-6 text-white", children: "Select Wallet" }),
+                  /* @__PURE__ */ jsx3("div", { className: "space-y-3", children: availableWallets.map((wallet) => {
+                    return /* @__PURE__ */ jsx3("div", { className: "w-full relative", children: /* @__PURE__ */ jsxs2(
+                      motion.button,
+                      {
+                        initial: { opacity: 0, y: 20 },
+                        animate: { opacity: 1, y: 0 },
+                        transition: { duration: 0.05, ease: "easeInOut" },
+                        onClick: () => {
+                          wallet.isInstalled ? connectWallet(wallet.type) : window.open(WALLET_INFO[wallet.type].downloadUrl, "_blank");
+                        },
+                        type: "button",
+                        disabled: loading && wallet.isInstalled,
+                        onMouseEnter: () => setHoveredWallet(wallet.type),
+                        onMouseLeave: () => setHoveredWallet(null),
+                        className: "w-full px-4 py-2 rounded-2xl border border-gray-950/60 hover:border-gray-800/80 bg-gray-950/20 hover:bg-gray-900/40 transition-all duration-300 flex items-center gap-4 group",
+                        children: [
+                          /* @__PURE__ */ jsx3("div", { className: "flex-shrink-0", children: WALLET_INFO[wallet.type].icon }),
+                          /* @__PURE__ */ jsxs2("div", { className: "flex-1 text-left", children: [
+                            /* @__PURE__ */ jsx3("h3", { className: "font-medium text-white", children: WALLET_INFO[wallet.type].name }),
+                            !wallet.isInstalled && /* @__PURE__ */ jsx3("p", { className: "text-sm text-gray-400", children: "Not installed - Click to download" })
+                          ] }),
+                          /* @__PURE__ */ jsx3("div", { className: "flex-shrink-0", children: recentWallet === wallet.type && wallet.isInstalled ? /* @__PURE__ */ jsx3("span", { className: "bg-gray-800/60 text-gray-300 text-xs px-3 py-1 rounded-full border border-gray-700/40", children: "Recent" }) : wallet.isInstalled ? loading && wallet.type === selectedWallet ? /* @__PURE__ */ jsx3(Loader2, { className: "h-4 w-4 animate-spin text-gray-400" }) : hoveredWallet === wallet.type && /* @__PURE__ */ jsx3("span", { className: "text-gray-400 text-sm font-medium", children: "Connect" }) : /* @__PURE__ */ jsx3(ExternalLink, { className: "h-4 w-4 text-gray-500" }) })
+                        ]
+                      }
+                    ) }, wallet.type);
+                  }) })
+                ] }) : /* @__PURE__ */ jsx3("div", { className: "w-full text-center py-8", children: (() => {
+                  const stageInfo = getConnectionStageInfo();
+                  const wallet = selectedWallet ? WALLET_INFO[selectedWallet] : null;
+                  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+                    /* @__PURE__ */ jsx3("div", { className: "relative flex justify-center mb-6", children: connectionStage === "success" || connectionStage === "connected-not-signed" ? /* @__PURE__ */ jsx3("div", { className: "w-20 h-20 rounded-full border-4 border-green-500 flex items-center justify-center", children: wallet && /* @__PURE__ */ jsx3("div", { className: "w-12 h-12 flex items-center justify-center", children: wallet.icon }) }) : connectionStage === "error" ? /* @__PURE__ */ jsx3("div", { className: "w-20 h-20 rounded-full border-4 border-red-500 flex items-center justify-center", children: wallet && /* @__PURE__ */ jsx3("div", { className: "w-12 h-12 flex items-center justify-center", children: wallet.icon }) }) : /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
+                      /* @__PURE__ */ jsx3("div", { className: "w-20 h-20 rounded-full border-4 border-gray-600 border-t-gray-400 animate-spin" }),
+                      /* @__PURE__ */ jsx3("div", { className: "absolute inset-0 flex items-center justify-center", children: wallet && /* @__PURE__ */ jsx3("div", { className: "w-12 h-12 flex items-center justify-center", children: wallet.icon }) })
+                    ] }) }),
+                    /* @__PURE__ */ jsx3("h3", { className: "text-lg font-semibold text-white mb-2", children: stageInfo == null ? void 0 : stageInfo.title }),
+                    /* @__PURE__ */ jsx3("p", { className: "text-sm text-gray-400 mb-6", children: stageInfo == null ? void 0 : stageInfo.subtitle }),
+                    /* @__PURE__ */ jsx3(
+                      Button,
+                      {
+                        disabled: true,
+                        className: "w-full bg-gray-700 text-gray-400 cursor-not-allowed rounded-2xl py-3",
+                        children: stageInfo == null ? void 0 : stageInfo.buttonText
+                      }
+                    )
+                  ] });
+                })() }) })
+              ]
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+// src/hooks/useConversionUtils.ts
+import { useCallback as useCallback3 } from "react";
+import { BCS as BCS2, TxnBuilderTypes } from "supra-l1-sdk-core";
+
+// src/lib/abis/supra_account.ts
+var supraAccountABI = {
+  address: "0x1",
+  name: "supra_account",
+  friends: [
+    "0x1::genesis",
+    "0x1::resource_account",
+    "0x1::transaction_fee",
+    "0x1::transaction_validation"
+  ],
+  exposed_functions: [
+    {
+      name: "assert_account_exists",
+      visibility: "public",
+      is_entry: false,
+      is_view: false,
+      generic_type_params: [],
+      params: ["address"],
+      return: []
+    },
+    {
+      name: "assert_account_is_registered_for_apt",
+      visibility: "public",
+      is_entry: false,
+      is_view: false,
+      generic_type_params: [],
+      params: ["address"],
+      return: []
+    },
+    {
+      name: "assert_account_is_registered_for_supra",
+      visibility: "public",
+      is_entry: false,
+      is_view: false,
+      generic_type_params: [],
+      params: ["address"],
+      return: []
+    },
+    {
+      name: "batch_transfer",
+      visibility: "public",
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [],
+      params: ["&signer", "vector<address>", "vector<u64>"],
+      return: []
+    },
+    {
+      name: "batch_transfer_coins",
+      visibility: "public",
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [{ constraints: [] }],
+      params: ["&signer", "vector<address>", "vector<u64>"],
+      return: []
+    },
+    {
+      name: "burn_from_fungible_store",
+      visibility: "friend",
+      is_entry: false,
+      is_view: false,
+      generic_type_params: [],
+      params: ["&0x1::fungible_asset::BurnRef", "address", "u64"],
+      return: []
+    },
+    {
+      name: "can_receive_direct_coin_transfers",
+      visibility: "public",
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ["address"],
+      return: ["bool"]
+    },
+    {
+      name: "create_account",
+      visibility: "public",
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [],
+      params: ["address"],
+      return: []
+    },
+    {
+      name: "deposit_coins",
+      visibility: "public",
+      is_entry: false,
+      is_view: false,
+      generic_type_params: [{ constraints: [] }],
+      params: ["address", "0x1::coin::Coin<T0>"],
+      return: []
+    },
+    {
+      name: "is_fungible_balance_at_least",
+      visibility: "friend",
+      is_entry: false,
+      is_view: false,
+      generic_type_params: [],
+      params: ["address", "u64"],
+      return: ["bool"]
+    },
+    {
+      name: "register_supra",
+      visibility: "friend",
+      is_entry: false,
+      is_view: false,
+      generic_type_params: [],
+      params: ["&signer"],
+      return: []
+    },
+    {
+      name: "set_allow_direct_coin_transfers",
+      visibility: "public",
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [],
+      params: ["&signer", "bool"],
+      return: []
+    },
+    {
+      name: "transfer",
+      visibility: "public",
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [],
+      params: ["&signer", "address", "u64"],
+      return: []
+    },
+    {
+      name: "transfer_coins",
+      visibility: "public",
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [{ constraints: [] }],
+      params: ["&signer", "address", "u64"],
+      return: []
+    }
+  ],
+  structs: [
+    {
+      name: "DirectCoinTransferConfigUpdated",
+      is_native: false,
+      abilities: ["drop", "store"],
+      generic_type_params: [],
+      fields: [
+        { name: "account", type: "address" },
+        { name: "new_allow_direct_transfers", type: "bool" }
+      ]
+    },
+    {
+      name: "DirectCoinTransferConfigUpdatedEvent",
+      is_native: false,
+      abilities: ["drop", "store"],
+      generic_type_params: [],
+      fields: [{ name: "new_allow_direct_transfers", type: "bool" }]
+    },
+    {
+      name: "DirectTransferConfig",
+      is_native: false,
+      abilities: ["key"],
+      generic_type_params: [],
+      fields: [
+        { name: "allow_arbitrary_coin_transfers", type: "bool" },
+        {
+          name: "update_coin_transfer_events",
+          type: "0x1::event::EventHandle<0x1::supra_account::DirectCoinTransferConfigUpdatedEvent>"
+        }
+      ]
+    }
+  ]
+};
+
+// src/lib/utils.ts
+import { clsx as clsx2 } from "clsx";
+import { twMerge as twMerge2 } from "tailwind-merge";
+function cn2(...inputs) {
+  return twMerge2(clsx2(inputs));
+}
+function standardizeAddress(address) {
+  let cleanAddress = address.replace(/^0x/, "");
+  if (cleanAddress.length < 64) {
+    cleanAddress = cleanAddress.padStart(64, "0");
+  }
+  if (cleanAddress.length > 64) {
+    throw new Error(`Address ${address} is not a valid address`);
+  }
+  return `0x${cleanAddress}`;
+}
+
+// src/lib/abiStorage.ts
+var abiStorage = {
+  [standardizeAddress("0x1")]: {
+    supra_account: supraAccountABI
+  }
+};
+function getStoredABI(moduleAddress, moduleName) {
+  var _a;
+  const standardizedAddress = standardizeAddress(moduleAddress);
+  const normalizedName = moduleName;
+  if ((_a = abiStorage[standardizedAddress]) == null ? void 0 : _a[normalizedName]) {
+    return abiStorage[standardizedAddress][normalizedName];
+  }
+  return null;
+}
+
+// src/hooks/useConversionUtils.ts
+var useConversionUtils = () => {
+  const stringToUint8Array = useCallback3((humanReadableStr) => {
+    return BCS2.bcsToBytes(new TxnBuilderTypes.Identifier(humanReadableStr));
+  }, []);
+  const serializeString = useCallback3((humanReadableStr) => {
+    return BCS2.bcsSerializeStr(humanReadableStr);
+  }, []);
+  const addressToUint8Array = useCallback3((cryptoAddress) => {
+    return BCS2.bcsToBytes(TxnBuilderTypes.AccountAddress.fromHex(cryptoAddress));
+  }, []);
+  const deserializeString = (uint8Array) => {
+    return BCS2.bcsSerializeStr(uint8Array);
+  };
+  const deserializeVector = (uint8Array) => {
+    const deserializer = new BCS2.Deserializer(uint8Array);
+    return BCS2.deserializeVector(deserializer, BCS2.bcsSerializeU8);
+  };
+  const serializeUint8 = useCallback3((value) => {
+    const num = typeof value === "string" ? parseInt(value, 10) : value;
+    if (num < 0 || num > 255) {
+      throw new Error(`u8 value out of range: ${num}`);
+    }
+    return BCS2.bcsSerializeU8(num);
+  }, []);
+  const serializeUint16 = useCallback3((value) => {
+    let num;
+    if (typeof value === "string") {
+      num = parseInt(value, 10);
+    } else if (typeof value === "bigint") {
+      num = Number(value);
+    } else {
+      num = value;
+    }
+    if (num < 0 || num > 65535) {
+      throw new Error(`u16 value out of range: ${num}`);
+    }
+    return BCS2.bcsSerializeU16(num);
+  }, []);
+  const serializeUint32 = useCallback3((value) => {
+    let num;
+    if (typeof value === "string") {
+      num = parseInt(value, 10);
+    } else if (typeof value === "bigint") {
+      num = Number(value);
+    } else {
+      num = value;
+    }
+    if (num < 0 || num > 4294967295) {
+      throw new Error(`u32 value out of range: ${num}`);
+    }
+    return BCS2.bcsSerializeU32(num);
+  }, []);
+  const serializeUint64 = useCallback3((value) => {
+    let num;
+    if (typeof value === "string") {
+      num = BigInt(value);
+    } else if (typeof value === "number") {
+      num = BigInt(value);
+    } else {
+      num = value;
+    }
+    if (num < 0) {
+      throw new Error(`u64 value cannot be negative: ${num}`);
+    }
+    return BCS2.bcsSerializeUint64(num);
+  }, []);
+  const serializeUint128 = useCallback3((value) => {
+    let num;
+    if (typeof value === "string") {
+      num = BigInt(value);
+    } else if (typeof value === "number") {
+      num = BigInt(value);
+    } else {
+      num = value;
+    }
+    if (num < 0) {
+      throw new Error(`u128 value cannot be negative: ${num}`);
+    }
+    return BCS2.bcsSerializeU128(num);
+  }, []);
+  const serializeU256 = useCallback3((value) => {
+    return BCS2.bcsSerializeU256(value);
+  }, []);
+  const serializeBool = useCallback3((value) => {
+    return BCS2.bcsSerializeBool(value);
+  }, []);
+  const serializeVector = useCallback3((values, type) => {
+    const serializer = new BCS2.Serializer();
+    serializer.serializeU32AsUleb128(values.length);
+    values.forEach((value) => {
+      if (type === "u64") {
+        serializer.serializeU64(value);
+      } else if (type === "bool") {
+        serializer.serializeBool(value);
+      } else if (type === "string") {
+        serializer.serializeStr(value);
+      } else if (type === "address") {
+        const accountAddress = TxnBuilderTypes.AccountAddress.fromHex(value);
+        serializer.serializeFixedBytes(accountAddress.address);
+      } else {
+        serializer.serializeStr(value);
+      }
+    });
+    return serializer.getBytes();
+  }, []);
+  const hexToString = (hex, type) => {
+    if (!hex) {
+      return "";
+    }
+    if (type !== "String") {
+      try {
+        return BigInt(hex).toString();
+      } catch (error) {
+        console.error("Error converting hex to string:", error);
+        return hex;
+      }
+    }
+    try {
+      const cleanHex = hex.slice(2);
+      return Buffer.from(cleanHex, "hex").toString().slice(1);
+    } catch (error) {
+      console.error("Error converting hex to string:", error);
+      return hex;
+    }
+  };
+  const stringToHex = (str) => {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(str);
+    let hexString = "";
+    for (let i = 0; i < bytes.length; i++) {
+      const hex = bytes[i].toString(16).padStart(2, "0");
+      hexString += hex;
+    }
+    return hexString;
+  };
+  const serializeValueByType = useCallback3(
+    (value, type, serializer) => {
+      var _a;
+      const ser = serializer || new BCS2.Serializer();
+      const shouldReturnBytes = !serializer;
+      if (type.startsWith("0x1::option::Option<")) {
+        if (value === null || value === void 0) {
+          ser.serializeU8(0);
+        } else {
+          ser.serializeU8(1);
+          const innerType = type.slice(21, -1);
+          serializeValueByType(value, innerType, ser);
+        }
+        return shouldReturnBytes ? ser.getBytes() : new Uint8Array(0);
+      }
+      if (type.startsWith("vector<")) {
+        const vectorMatch = type.match(/vector<(.+)>$/);
+        if (!vectorMatch) {
+          throw new Error(`Invalid vector type format: ${type}`);
+        }
+        const innerType = vectorMatch[1];
+        if (innerType === "u8") {
+          let bytes;
+          if (typeof value === "string") {
+            const cleanHex = value.startsWith("0x") ? value.slice(2) : value;
+            bytes = new Uint8Array(
+              ((_a = cleanHex.match(/.{1,2}/g)) == null ? void 0 : _a.map((byte) => parseInt(byte, 16))) || []
+            );
+          } else if (value instanceof Uint8Array) {
+            bytes = value;
+          } else if (Array.isArray(value)) {
+            bytes = new Uint8Array(
+              value.map((item) => {
+                const u8 = typeof item === "string" ? parseInt(item, 10) : item;
+                if (u8 < 0 || u8 > 255) {
+                  throw new Error(`u8 value out of range in vector: ${u8}`);
+                }
+                return u8;
+              })
+            );
+          } else {
+            throw new Error(
+              `Expected string, Uint8Array, or number[] for vector<u8>, got ${typeof value}`
+            );
+          }
+          ser.serializeU32AsUleb128(bytes.length);
+          for (let i = 0; i < bytes.length; i++) {
+            ser.serializeU8(bytes[i]);
+          }
+        } else {
+          if (!Array.isArray(value)) {
+            throw new Error(
+              `Expected array for vector<${innerType}>, got ${typeof value}`
+            );
+          }
+          ser.serializeU32AsUleb128(value.length);
+          for (const item of value) {
+            serializeValueByType(item, innerType, ser);
+          }
+        }
+        return shouldReturnBytes ? ser.getBytes() : new Uint8Array(0);
+      }
+      if (type.startsWith("0x1::object::Object")) {
+        if (typeof value !== "string") {
+          throw new Error(`Expected string for Object, got ${typeof value}`);
+        }
+        const objectAddress = TxnBuilderTypes.AccountAddress.fromHex(value);
+        ser.serializeFixedBytes(objectAddress.address);
+        return shouldReturnBytes ? ser.getBytes() : new Uint8Array(0);
+      }
+      switch (type) {
+        case "address":
+          if (typeof value !== "string") {
+            throw new Error(`Expected string for address, got ${typeof value}`);
+          }
+          const accountAddress = TxnBuilderTypes.AccountAddress.fromHex(value);
+          ser.serializeFixedBytes(accountAddress.address);
+          break;
+        case "u8":
+          const u8 = typeof value === "string" ? parseInt(value, 10) : value;
+          if (u8 < 0 || u8 > 255) {
+            throw new Error(`u8 value out of range: ${u8}`);
+          }
+          ser.serializeU8(u8);
+          break;
+        case "u16":
+          const u16 = typeof value === "string" ? parseInt(value, 10) : typeof value === "bigint" ? Number(value) : value;
+          if (u16 < 0 || u16 > 65535) {
+            throw new Error(`u16 value out of range: ${u16}`);
+          }
+          ser.serializeU16(u16);
+          break;
+        case "u32":
+          const u32 = typeof value === "string" ? parseInt(value, 10) : typeof value === "bigint" ? Number(value) : value;
+          if (u32 < 0 || u32 > 4294967295) {
+            throw new Error(`u32 value out of range: ${u32}`);
+          }
+          ser.serializeU32(u32);
+          break;
+        case "u64":
+          const u64 = typeof value === "string" ? BigInt(value) : typeof value === "number" ? BigInt(value) : value;
+          if (u64 < 0) {
+            throw new Error(`u64 value cannot be negative: ${u64}`);
+          }
+          ser.serializeU64(u64);
+          break;
+        case "u128":
+          const u128 = typeof value === "string" ? BigInt(value) : typeof value === "number" ? BigInt(value) : value;
+          if (u128 < 0) {
+            throw new Error(`u128 value cannot be negative: ${u128}`);
+          }
+          ser.serializeU128(u128);
+          break;
+        case "u256":
+          if (typeof value !== "bigint") {
+            throw new Error(`Expected bigint for u256, got ${typeof value}`);
+          }
+          ser.serializeU256(value);
+          break;
+        case "bool":
+          if (typeof value !== "boolean") {
+            throw new Error(`Expected boolean, got ${typeof value}`);
+          }
+          ser.serializeBool(value);
+          break;
+        case "0x1::string::String":
+          if (typeof value !== "string") {
+            throw new Error(`Expected string, got ${typeof value}`);
+          }
+          ser.serializeStr(value);
+          break;
+        default:
+          throw new Error(`Unsupported type: ${type}`);
+      }
+      return shouldReturnBytes ? ser.getBytes() : new Uint8Array(0);
+    },
+    []
+  );
+  const serializeArgsFromTypes = useCallback3(
+    (args, paramTypes) => {
+      if (args.length !== paramTypes.length) {
+        throw new Error(
+          `Argument count mismatch: expected ${paramTypes.length}, got ${args.length}`
+        );
+      }
+      return args.map((arg, index) => {
+        try {
+          const paramType = paramTypes[index].replace("&signer", "").trim();
+          return serializeValueByType(arg, paramType);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          throw new Error(
+            `Failed to serialize argument ${index} (${paramTypes[index]}): ${errorMessage}`
+          );
+        }
+      });
+    },
+    [serializeValueByType]
+  );
+  const fetchModuleABI = useCallback3(
+    async (moduleAddress, moduleName, rpcUrl) => {
+      const storedABI = getStoredABI(moduleAddress, moduleName);
+      if (storedABI) {
+        return storedABI;
+      }
+      const baseUrl = rpcUrl || (process.env.NEXT_PUBLIC_SUPRA_CHAIN_ID === "8" ? "https://rpc-mainnet.supra.com" : "https://rpc-testnet.supra.com");
+      const url = `${baseUrl}/rpc/v3/accounts/${moduleAddress}/modules/${moduleName}`;
+      try {
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch ABI: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.abi;
+      } catch (error) {
+        console.error("Error fetching module ABI:", error);
+        throw new Error(
+          `Failed to fetch module ABI: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    []
+  );
+  const getFunctionParamTypes = useCallback3(
+    async (moduleAddress, moduleName, functionName, rpcUrl) => {
+      const moduleABI = await fetchModuleABI(moduleAddress, moduleName, rpcUrl);
+      if (!moduleABI.exposed_functions) {
+        throw new Error("Invalid module ABI response");
+      }
+      const functionDef = moduleABI.exposed_functions.find(
+        (func) => func.name === functionName
+      );
+      if (!functionDef) {
+        throw new Error(`Function ${functionName} not found in module ${moduleName}`);
+      }
+      return functionDef.params.filter((param) => {
+        const trimmed = param.trim();
+        return trimmed !== "signer" && trimmed !== "&signer";
+      });
+    },
+    [fetchModuleABI]
+  );
+  const serializeTransactionArgs = useCallback3(
+    async (args, moduleAddress, moduleName, functionName, rpcUrl) => {
+      const paramTypes = await getFunctionParamTypes(
+        moduleAddress,
+        moduleName,
+        functionName,
+        rpcUrl
+      );
+      return serializeArgsFromTypes(args, paramTypes);
+    },
+    [getFunctionParamTypes, serializeArgsFromTypes]
+  );
+  return {
+    stringToUint8Array,
+    addressToUint8Array,
+    serializeString,
+    serializeUint8,
+    serializeUint16,
+    serializeUint32,
+    serializeUint64,
+    serializeUint128,
+    serializeU256,
+    serializeBool,
+    serializeVector,
+    deserializeString,
+    deserializeVector,
+    hexToString,
+    stringToHex,
+    // ABI-based serialization
+    serializeValueByType,
+    serializeArgsFromTypes,
+    fetchModuleABI,
+    getFunctionParamTypes,
+    serializeTransactionArgs
+    // Main function to use
+  };
+};
+var useConversionUtils_default = useConversionUtils;
+
+// components/ui/sonner.tsx
+import { useTheme } from "next-themes";
+import { Toaster as Sonner } from "sonner";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var Toaster = (_a) => {
+  var props = __objRest(_a, []);
+  const { theme = "system" } = useTheme();
+  return /* @__PURE__ */ jsx4(
+    Sonner,
+    __spreadValues({
+      theme,
+      className: "toaster group",
+      toastOptions: {
+        classNames: {
+          toast: "group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg",
+          description: "group-[.toast]:text-muted-foreground",
+          actionButton: "group-[.toast]:bg-primary group-[.toast]:text-primary-foreground",
+          cancelButton: "group-[.toast]:bg-muted group-[.toast]:text-muted-foreground"
+        }
+      }
+    }, props)
+  );
+};
+
+// src/assets/walletIcons/Starkey.png
+var Starkey_default = "data:image/png;base64,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";
+
+// src/assets/walletIcons/Ribbit.jpg
+var Ribbit_default = "data:image/jpeg;base64,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";
+
+// src/assets/walletIcons/index.ts
+var WALLET_ICONS = {
+  starkey: Starkey_default,
+  ribbit: Ribbit_default
+};
+export {
+  Button,
+  ConnectWalletHandler,
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  Toaster,
+  WALLET_EVENTS,
+  WALLET_ICONS,
+  buttonVariants,
+  cn2 as cn,
+  getStoredABI,
+  Ribbit_default as ribbitIcon,
+  standardizeAddress,
+  Starkey_default as starkeyIcon,
+  useConversionUtils_default as useConversionUtils,
+  useSupraMultiWallet_default as useSupraMultiWallet
+};
+//# sourceMappingURL=index.mjs.map