@tomo-inc/wallet-connect-protocol 0.0.8 → 0.0.9

package/dist/index.js

@@ -1,349 +1,780 @@
-import { WalletConnectClient, isSessionExpired, extractAddressFromAccount, extractChainIdFromAccount, extractChainIdNumber, createSiweConfigFromSession, SiweAuth } from './chunk-32KOSJUW.js';
-export { APTOS_CHAINS, APTOS_NAMESPACE, AuthMethod, COSMOS_NAMESPACE, ChainType, EIP155_NAMESPACE, EVM_CHAINS, NEAR_NAMESPACE, POLKADOT_NAMESPACE, POPULAR_WALLET_IDS, SOLANA_CHAINS, SOLANA_NAMESPACE, SiweAuth, WalletConnectClient, copyToClipboard, createMultiChainNamespaces, createSiweConfigFromSession, createSiweMessage, extractAddressFromAccount, extractChainIdFromAccount, extractChainIdNumber, formatAddress, formatError, formatTimestamp, generateDeepLink, generateNonce, getAllWallets, getBrowserWallets, getChainName, getChainType, getDesktopWallets, getMobileWallets, getRecommendedWallets, getSessionTimeRemaining, getWalletById, getWalletConnectWallets, getWalletsByChain, isMobile, isSessionExpired, isValidChainId, isValidWalletConnectUri, parseChainId, parseSiweMessage, parseWalletConnectUri, searchWallets, verifySiweSignature } from './chunk-32KOSJUW.js';
-import { createContext, useState, useCallback, useEffect, useContext } from 'react';
-import { jsx } from 'react/jsx-runtime';
+import SignClient from '@walletconnect/sign-client';
+import QRCode from 'qrcode';
 
-var WalletConnectContext = createContext(void 0);
-function WalletConnectProvider({ config, children, autoInit = true }) {
-  const [client, setClient] = useState(null);
-  const [initialized, setInitialized] = useState(false);
-  const [connecting, setConnecting] = useState(false);
-  const [uri, setUri] = useState(null);
-  const [sessions, setSessions] = useState([]);
-  const refreshSessions = useCallback(() => {
-    if (client) {
-      const activeSessions = client.getActiveSessions();
-      setSessions(activeSessions);
-    }
-  }, [client]);
-  const initialize = useCallback(async () => {
-    if (initialized) {
+// src/client.ts
+var WalletConnectClient = class {
+  signClient = null;
+  config;
+  eventHandlers = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * initialize WalletConnect client
+   */
+  async initialize() {
+    if (this.initialized) {
       return;
     }
     try {
-      const newClient = new WalletConnectClient(config);
-      newClient.on("display_uri", ({ uri: uri2 }) => {
-        setUri(uri2);
+      this.signClient = await SignClient.init({
+        projectId: this.config.projectId,
+        metadata: this.config.metadata,
+        relayUrl: this.config.relayUrl
       });
-      const handleSessionUpdate = () => {
-        const activeSessions2 = newClient.getActiveSessions();
-        setSessions(activeSessions2);
+      this.setupEventListeners();
+      this.initialized = true;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * set event listeners
+   */
+  setupEventListeners() {
+    if (!this.signClient) return;
+    this.signClient.on("session_proposal", (proposal) => {
+      this.emit("session_proposal", proposal);
+    });
+    this.signClient.on("session_request", (request) => {
+      this.emit("session_request", request);
+    });
+    this.signClient.on("session_delete", (data) => {
+      this.emit("session_delete", data);
+    });
+    this.signClient.on("session_update", (data) => {
+      this.emit("session_update", data);
+    });
+  }
+  /**
+   * create pairing connection and generate URI
+   * @param params connection parameters
+   * @returns WalletConnect URI
+   */
+  async connect(params) {
+    if (!this.signClient) {
+      throw new Error("WalletConnect client not initialized. Call initialize() first.");
+    }
+    try {
+      const defaultNamespaces = {
+        eip155: {
+          methods: [
+            "eth_sendTransaction",
+            "eth_signTransaction",
+            "eth_sign",
+            "personal_sign",
+            "eth_signTypedData",
+            "eth_signTypedData_v4"
+          ],
+          chains: ["eip155:1"],
+          // Ethereum Mainnet
+          events: ["chainChanged", "accountsChanged"]
+        }
+      };
+      const defaultOptionalNamespaces = {
+        eip155: {
+          methods: [
+            "eth_sendTransaction",
+            "eth_signTransaction",
+            "eth_sign",
+            "personal_sign",
+            "eth_signTypedData",
+            "eth_signTypedData_v4"
+          ],
+          chains: [
+            "eip155:137",
+            // Polygon Mainnet
+            "eip155:56",
+            // BSC Mainnet
+            "eip155:42161",
+            // Arbitrum Mainnet
+            "eip155:10",
+            // Optimism Mainnet
+            "eip155:43114"
+            // Avalanche Mainnet
+          ],
+          events: ["chainChanged", "accountsChanged"]
+        },
+        solana: {
+          methods: ["solana_signTransaction", "solana_signMessage"],
+          chains: ["solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ"],
+          events: ["accountsChanged"]
+        }
+      };
+      const { uri, approval } = await this.signClient.connect({
+        requiredNamespaces: params?.requiredNamespaces || defaultNamespaces,
+        optionalNamespaces: params?.optionalNamespaces || defaultOptionalNamespaces
+      });
+      if (!uri) {
+        throw new Error("Failed to generate WalletConnect URI");
+      }
+      this.emit("display_uri", { uri });
+      approval().then((session) => {
+        this.emit("session_update", session);
+      }).catch((error) => {
+      });
+      return uri;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * generate QR code (Base64 format)
+   * @param uri WalletConnect URI
+   * @param options QR code options
+   * @returns Base64 formatted QR code image
+   */
+  async generateQRCode(uri, options) {
+    try {
+      const qrOptions = {
+        width: options?.width || 300,
+        margin: options?.margin || 4,
+        errorCorrectionLevel: options?.errorCorrectionLevel || "M",
+        color: {
+          dark: options?.color?.dark || "#000000",
+          light: options?.color?.light || "#ffffff"
+        }
+      };
+      const qrCodeDataUrl = await QRCode.toDataURL(uri, qrOptions);
+      return qrCodeDataUrl;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * generate QR code (Canvas format)
+   * @param canvas Canvas element
+   * @param uri WalletConnect URI
+   * @param options QR code options
+   */
+  async generateQRCodeToCanvas(canvas, uri, options) {
+    try {
+      const qrOptions = {
+        width: options?.width || 300,
+        margin: options?.margin || 4,
+        errorCorrectionLevel: options?.errorCorrectionLevel || "M",
+        color: {
+          dark: options?.color?.dark || "#000000",
+          light: options?.color?.light || "#ffffff"
+        }
       };
-      newClient.on("session_proposal", handleSessionUpdate);
-      newClient.on("session_update", handleSessionUpdate);
-      newClient.on("session_delete", handleSessionUpdate);
-      await newClient.initialize();
-      setClient(newClient);
-      setInitialized(true);
-      const activeSessions = newClient.getActiveSessions();
-      setSessions(activeSessions);
+      await QRCode.toCanvas(canvas, uri, qrOptions);
     } catch (error) {
       throw error;
     }
-  }, [config, initialized]);
-  const connect = useCallback(async () => {
-    if (!client) {
+  }
+  /**
+   * get all active sessions
+   * @returns session information array
+   */
+  getActiveSessions() {
+    if (!this.signClient) {
+      return [];
+    }
+    const sessions = this.signClient.session.getAll();
+    return sessions.map((session) => ({
+      topic: session.topic,
+      peer: session.peer,
+      namespaces: session.namespaces,
+      expiry: session.expiry
+    }));
+  }
+  /**
+   * disconnect specified session
+   * @param topic session topic/ID
+   */
+  async disconnectSession(topic) {
+    if (!this.signClient) {
       throw new Error("WalletConnect client not initialized");
     }
-    setConnecting(true);
     try {
-      const connectionUri = await client.connect();
-      setUri(connectionUri);
-      return connectionUri;
+      await this.signClient.disconnect({
+        topic,
+        reason: {
+          code: 6e3,
+          message: "User disconnected"
+        }
+      });
     } catch (error) {
       throw error;
-    } finally {
-      setConnecting(false);
     }
-  }, [client]);
-  const generateQRCode = useCallback(
-    async (uri2, options) => {
-      if (!client) {
-        throw new Error("WalletConnect client not initialized");
-      }
-      return client.generateQRCode(uri2, options);
-    },
-    [client]
-  );
-  const disconnect = useCallback(
-    async (topic) => {
-      if (!client) {
-        throw new Error("WalletConnect client not initialized");
-      }
-      await client.disconnectSession(topic);
-      refreshSessions();
-    },
-    [client]
-  );
-  useEffect(() => {
-    if (!client || !initialized) return;
-    const interval = setInterval(() => {
-      refreshSessions();
-    }, 2e3);
-    return () => clearInterval(interval);
-  }, [client, initialized, refreshSessions]);
-  useEffect(() => {
-    if (autoInit && !initialized) {
-      initialize().catch(console.error);
+  }
+  /**
+   * listen to events
+   * @param event event name
+   * @param handler event handler
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
     }
-  }, [autoInit, initialized, initialize]);
-  useEffect(() => {
-    return () => {
-      if (client) {
-        client.destroy().catch(console.error);
-      }
+    this.eventHandlers.get(event)?.add(handler);
+  }
+  /**
+   * remove event listener
+   * @param event event name
+   * @param handler event handler
+   */
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * trigger event
+   * @param event event name
+   * @param data event data
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+        }
+      });
+    }
+  }
+  /**
+   * send JSON-RPC request to wallet
+   * @param params request parameters
+   * @returns request result
+   */
+  async sendRequest(params) {
+    if (!this.signClient) {
+      throw new Error("WalletConnect client not initialized");
+    }
+    try {
+      const result = await this.signClient.request({
+        topic: params.topic,
+        chainId: params.chainId,
+        request: params.request
+      });
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * destroy client
+   */
+  async destroy() {
+    if (this.signClient) {
+      this.eventHandlers.clear();
+      this.signClient = null;
+      this.initialized = false;
+    }
+  }
+  /**
+   * get if client is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * get configuration information
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/utils.ts
+function isValidWalletConnectUri(uri) {
+  return uri.startsWith("wc:") || uri.startsWith("wc://");
+}
+function parseWalletConnectUri(uri) {
+  try {
+    const cleanUri = uri.replace(/^wc:\/?\/?/, "");
+    const [topicVersion, paramsString] = cleanUri.split("?");
+    const [topic, version] = topicVersion.split("@");
+    const params = new URLSearchParams(paramsString);
+    return {
+      topic,
+      version,
+      symKey: params.get("symKey") || void 0,
+      relay: params.get("relay-protocol") ? {
+        protocol: params.get("relay-protocol"),
+        data: params.get("relay-data") || void 0
+      } : void 0
     };
-  }, [client]);
-  const value = {
-    client,
-    initialized,
-    connecting,
-    uri,
-    sessions,
-    initialize,
-    connect,
-    generateQRCode,
-    disconnect,
-    refreshSessions
-  };
-  return /* @__PURE__ */ jsx(WalletConnectContext.Provider, { value, children });
+  } catch {
+    return null;
+  }
 }
-function useWalletConnect() {
-  const context = useContext(WalletConnectContext);
-  if (!context) {
-    throw new Error("useWalletConnect must be used within WalletConnectProvider");
+function formatAddress(address, startLength = 6, endLength = 4) {
+  if (!address || address.length < startLength + endLength) {
+    return address;
   }
-  return context;
+  return `${address.slice(0, startLength)}...${address.slice(-endLength)}`;
 }
-function useQRCode(uri, options) {
-  const { generateQRCode } = useWalletConnect();
-  const [qrCode, setQrCode] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const generate = useCallback(
-    async (targetUri) => {
-      const uriToUse = targetUri || uri;
-      if (!uriToUse) {
-        setError(new Error("No URI provided"));
-        return;
-      }
-      setLoading(true);
-      setError(null);
-      try {
-        const qr = await generateQRCode(uriToUse, options);
-        setQrCode(qr);
-      } catch (err) {
-        setError(err);
-        setQrCode(null);
-      } finally {
-        setLoading(false);
-      }
-    },
-    [uri, options, generateQRCode]
-  );
-  useEffect(() => {
-    if (uri) {
-      generate(uri);
+function extractAddressFromAccount(account) {
+  const parts = account.split(":");
+  return parts.length > 1 ? parts[parts.length - 1] : account;
+}
+function extractChainIdFromAccount(account) {
+  const parts = account.split(":");
+  return parts.length > 2 ? `${parts[0]}:${parts[1]}` : "";
+}
+function isSessionExpired(expiry) {
+  return Date.now() / 1e3 > expiry;
+}
+function getSessionTimeRemaining(expiry) {
+  const remaining = expiry - Date.now() / 1e3;
+  return Math.max(0, remaining);
+}
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp * 1e3);
+  return date.toLocaleString();
+}
+function isMobile() {
+  if (typeof window === "undefined") return false;
+  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+function generateDeepLink(uri, walletName) {
+  const encodedUri = encodeURIComponent(uri);
+  if (walletName) {
+    switch (walletName.toLowerCase()) {
+      case "metamask":
+        return `https://metamask.app.link/wc?uri=${encodedUri}`;
+      case "trust":
+        return `https://link.trustwallet.com/wc?uri=${encodedUri}`;
+      case "rainbow":
+        return `https://rnbwapp.com/wc?uri=${encodedUri}`;
+      default:
+        return `wc://wc?uri=${encodedUri}`;
     }
-  }, [uri, generate]);
-  return {
-    qrCode,
-    loading,
-    error,
-    generate
-  };
+  }
+  return `wc://wc?uri=${encodedUri}`;
 }
-function useSession(topic) {
-  const { sessions, disconnect, refreshSessions, client } = useWalletConnect();
-  const [currentSession, setCurrentSession] = useState(null);
-  useEffect(() => {
-    if (topic) {
-      const session = sessions.find((s) => s.topic === topic);
-      setCurrentSession(session || null);
+async function copyToClipboard(text) {
+  try {
+    if (navigator.clipboard) {
+      await navigator.clipboard.writeText(text);
+      return true;
     } else {
-      setCurrentSession(sessions[0] || null);
+      const textarea = document.createElement("textarea");
+      textarea.value = text;
+      textarea.style.position = "fixed";
+      textarea.style.opacity = "0";
+      document.body.appendChild(textarea);
+      textarea.select();
+      const success = document.execCommand("copy");
+      document.body.removeChild(textarea);
+      return success;
     }
-  }, [topic, sessions]);
-  const disconnectSession = useCallback(
-    async (sessionTopic) => {
-      const topicToDisconnect = sessionTopic || topic || currentSession?.topic;
-      if (!topicToDisconnect) {
-        throw new Error("No session to disconnect");
-      }
-      await disconnect(topicToDisconnect);
-    },
-    [topic, currentSession, disconnect]
-  );
-  const checkExpired = useCallback((session) => {
-    return isSessionExpired(session.expiry);
-  }, []);
-  const getAccounts = useCallback(
-    (session) => {
-      const targetSession = session || currentSession;
-      if (!targetSession) return [];
-      const allAccounts = [];
-      Object.values(targetSession.namespaces).forEach((namespace) => {
-        if (namespace.accounts) {
-          allAccounts.push(...namespace.accounts);
-        }
-      });
-      return allAccounts;
-    },
-    [currentSession]
-  );
-  const getChains = useCallback(
-    (session) => {
-      const targetSession = session || currentSession;
-      if (!targetSession) return [];
-      const allChains = [];
-      Object.values(targetSession.namespaces).forEach((namespace) => {
-        if (namespace.chains) {
-          allChains.push(...namespace.chains);
-        }
-      });
-      return allChains;
-    },
-    [currentSession]
-  );
-  return {
-    session: currentSession,
-    allSessions: sessions,
-    disconnect: disconnectSession,
-    refresh: refreshSessions,
-    isExpired: currentSession ? checkExpired(currentSession) : false,
-    getAccounts,
-    getChains,
-    hasSession: !!currentSession
-  };
+  } catch {
+    return false;
+  }
 }
-function useConnect(options) {
-  const { connect, generateQRCode, connecting } = useWalletConnect();
-  const [uri, setUri] = useState(null);
-  const [qrCode, setQrCode] = useState(null);
-  const [error, setError] = useState(null);
-  const handleConnect = useCallback(async () => {
-    setError(null);
-    try {
-      const connectionUri = await connect();
-      setUri(connectionUri);
-      if (options?.onConnect) {
-        options.onConnect(connectionUri);
-      }
-      if (options?.autoGenerateQRCode !== false) {
-        const qr = await generateQRCode(connectionUri, options?.qrCodeOptions);
-        setQrCode(qr);
+function formatError(error) {
+  if (typeof error === "string") return error;
+  if (error?.message) return error.message;
+  if (error?.error?.message) return error.error.message;
+  return "Unknown error occurred";
+}
+function isValidChainId(chainId) {
+  return /^[a-z]+:\d+$/.test(chainId);
+}
+function parseChainId(chainId) {
+  if (!isValidChainId(chainId)) return null;
+  const [namespace, reference] = chainId.split(":");
+  return { namespace, reference };
+}
+
+// src/chains.ts
+var EIP155_NAMESPACE = {
+  chains: ["eip155:1"],
+  // Ethereum Mainnet
+  methods: [
+    "eth_sendTransaction",
+    "eth_signTransaction",
+    "eth_sign",
+    "personal_sign",
+    "eth_signTypedData",
+    "eth_signTypedData_v4",
+    "wallet_switchEthereumChain",
+    "wallet_addEthereumChain"
+  ],
+  events: ["chainChanged", "accountsChanged"]
+};
+var SOLANA_NAMESPACE = {
+  chains: ["solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ"],
+  // Solana Mainnet
+  methods: ["solana_signTransaction", "solana_signMessage", "solana_signAndSendTransaction"],
+  events: ["accountsChanged", "chainChanged"]
+};
+var APTOS_NAMESPACE = {
+  chains: ["aptos:1"],
+  // Aptos Mainnet
+  methods: ["aptos_signTransaction", "aptos_signMessage", "aptos_signAndSubmitTransaction"],
+  events: ["accountChanged", "networkChanged"]
+};
+var COSMOS_NAMESPACE = {
+  chains: ["cosmos:cosmoshub-4"],
+  // Cosmos Hub
+  methods: ["cosmos_signDirect", "cosmos_signAmino", "cosmos_getAccounts"],
+  events: ["chainChanged", "accountsChanged"]
+};
+var POLKADOT_NAMESPACE = {
+  chains: ["polkadot:91b171bb158e2d3848fa23a9f1c25182"],
+  // Polkadot Mainnet
+  methods: ["polkadot_signTransaction", "polkadot_signMessage"],
+  events: ["accountsChanged"]
+};
+var NEAR_NAMESPACE = {
+  chains: ["near:mainnet"],
+  methods: ["near_signTransaction", "near_signMessage"],
+  events: ["accountsChanged"]
+};
+var EVM_CHAINS = {
+  // Ethereum
+  ETHEREUM_MAINNET: "eip155:1",
+  ETHEREUM_GOERLI: "eip155:5",
+  ETHEREUM_SEPOLIA: "eip155:11155111",
+  // Layer 2 (L2)
+  POLYGON: "eip155:137",
+  POLYGON_MUMBAI: "eip155:80001",
+  ARBITRUM: "eip155:42161",
+  ARBITRUM_GOERLI: "eip155:421613",
+  OPTIMISM: "eip155:10",
+  OPTIMISM_GOERLI: "eip155:420",
+  // other EVM chains
+  BSC: "eip155:56",
+  BSC_TESTNET: "eip155:97",
+  AVALANCHE: "eip155:43114",
+  AVALANCHE_FUJI: "eip155:43113",
+  FANTOM: "eip155:250",
+  CRONOS: "eip155:25",
+  GNOSIS: "eip155:100",
+  BASE: "eip155:8453",
+  ZKSYNC: "eip155:324",
+  LINEA: "eip155:59144",
+  SCROLL: "eip155:534352"
+};
+var SOLANA_CHAINS = {
+  MAINNET: "solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ",
+  DEVNET: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  TESTNET: "solana:8E9rvCKLFQia2Y35HXjjpWzj8weVo44K"
+};
+var APTOS_CHAINS = {
+  MAINNET: "aptos:1",
+  TESTNET: "aptos:2",
+  DEVNET: "aptos:3"
+};
+function createMultiChainNamespaces(chains) {
+  const namespaces = {};
+  const evmChains = chains.filter((chain) => chain.startsWith("eip155:"));
+  if (evmChains.length > 0) {
+    namespaces.eip155 = {
+      ...EIP155_NAMESPACE,
+      chains: evmChains
+    };
+  }
+  const solanaChains = chains.filter((chain) => chain.startsWith("solana:"));
+  if (solanaChains.length > 0) {
+    namespaces.solana = {
+      ...SOLANA_NAMESPACE,
+      chains: solanaChains
+    };
+  }
+  const aptosChains = chains.filter((chain) => chain.startsWith("aptos:"));
+  if (aptosChains.length > 0) {
+    namespaces.aptos = {
+      ...APTOS_NAMESPACE,
+      chains: aptosChains
+    };
+  }
+  const cosmosChains = chains.filter((chain) => chain.startsWith("cosmos:"));
+  if (cosmosChains.length > 0) {
+    namespaces.cosmos = {
+      ...COSMOS_NAMESPACE,
+      chains: cosmosChains
+    };
+  }
+  return namespaces;
+}
+
+// src/siwe.ts
+async function getChecksumAddress(address) {
+  try {
+    const ethers = await import('ethers');
+    return ethers.getAddress(address);
+  } catch {
+    return address;
+  }
+}
+async function createSiweMessage(config, address) {
+  const siweModule = await import('siwe');
+  const SiweMessage = siweModule.SiweMessage || siweModule.default?.SiweMessage;
+  const checksumAddress = await getChecksumAddress(address);
+  const siweMessage = new SiweMessage({
+    domain: config.domain,
+    address: checksumAddress,
+    statement: config.statement || "Sign in with Ethereum to the app.",
+    uri: config.uri,
+    version: config.version || "1",
+    chainId: config.chainId,
+    nonce: config.nonce || generateNonce(),
+    issuedAt: config.issuedAt || (/* @__PURE__ */ new Date()).toISOString(),
+    expirationTime: config.expirationTime,
+    notBefore: config.notBefore,
+    requestId: config.requestId,
+    resources: config.resources
+  });
+  return siweMessage.prepareMessage();
+}
+async function parseSiweMessage(message) {
+  const siweModule = await import('siwe');
+  const SiweMessage = siweModule.SiweMessage || siweModule.default?.SiweMessage;
+  return new SiweMessage(message);
+}
+async function verifySiweSignature(params) {
+  try {
+    const siweModule = await import('siwe');
+    const SiweMessage = siweModule.SiweMessage || siweModule.default?.SiweMessage;
+    const siweMessage = new SiweMessage(params.message);
+    const result = await siweMessage.verify(
+      {
+        signature: params.signature,
+        nonce: params.nonce,
+        domain: params.domain,
+        time: params.time
+      },
+      {
+        suppressExceptions: true
+        // Suppress exceptions to get error details
       }
-      return connectionUri;
-    } catch (err) {
-      const error2 = err;
-      setError(error2);
-      options?.onError?.(error2);
-      throw error2;
+    );
+    if (result.success) {
+      return {
+        success: true,
+        data: result.data
+      };
+    } else {
+      return {
+        success: false,
+        error: result.error?.type || "Verification failed"
+      };
     }
-  }, [connect, generateQRCode, options]);
-  const reset = useCallback(() => {
-    setUri(null);
-    setQrCode(null);
-    setError(null);
-  }, []);
+  } catch (error) {
+    return {
+      success: false,
+      error: error.type || error.message || "Unknown verification error"
+    };
+  }
+}
+function generateNonce(length = 16) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let nonce = "";
+  const randomValues = new Uint8Array(length);
+  if (typeof window !== "undefined" && window.crypto) {
+    window.crypto.getRandomValues(randomValues);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(randomValues);
+  } else {
+    for (let i = 0; i < length; i++) {
+      randomValues[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  for (let i = 0; i < length; i++) {
+    nonce += chars[randomValues[i] % chars.length];
+  }
+  return nonce;
+}
+function createSiweConfigFromSession(params) {
   return {
-    connect: handleConnect,
-    uri,
-    qrCode,
-    connecting,
-    error,
-    reset
+    domain: params.domain,
+    uri: params.uri,
+    chainId: params.chainId,
+    statement: params.statement || "Sign in with Ethereum to authenticate your wallet.",
+    version: "1",
+    nonce: generateNonce(),
+    issuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    expirationTime: new Date(Date.now() + 5 * 60 * 1e3).toISOString(),
+    // 5 minutes
+    resources: params.resources
   };
 }
-function useSiwe(config) {
-  const { client } = useWalletConnect();
-  const [isAuthenticating, setIsAuthenticating] = useState(false);
-  const [authResult, setAuthResult] = useState(null);
-  const signIn = useCallback(
-    async (sessionTopic) => {
-      if (!client) {
-        throw new Error("WalletConnect client not initialized");
-      }
-      const sessions = client.getActiveSessions();
-      if (sessions.length === 0) {
-        throw new Error("No active sessions. Connect wallet first.");
-      }
-      setIsAuthenticating(true);
-      setAuthResult(null);
-      try {
-        const session = sessionTopic ? sessions.find((s) => s.topic === sessionTopic) : sessions[0];
-        if (!session) {
-          throw new Error("Session not found");
-        }
-        const accounts = Object.values(session.namespaces).flatMap((ns) => ns.accounts || []);
-        const primaryAccount = accounts[0];
-        if (!primaryAccount) {
-          throw new Error("No accounts found in session");
-        }
-        const address = extractAddressFromAccount(primaryAccount);
-        const chainIdStr = extractChainIdFromAccount(primaryAccount);
-        const chainId = extractChainIdNumber(primaryAccount);
-        const siweConfig = createSiweConfigFromSession({
-          domain: config?.domain || window.location.host,
-          uri: config?.uri || window.location.origin,
-          chainId,
-          statement: config?.statement,
-          resources: config?.resources
-        });
-        const siweAuth = new SiweAuth(siweConfig);
-        const message = await siweAuth.createMessage(address);
-        if (!client.signClient) {
-          throw new Error("SignClient not initialized");
-        }
-        const signature = await client.signClient.request({
-          topic: session.topic,
-          chainId: chainIdStr,
-          request: {
-            method: "personal_sign",
-            params: [message, address]
-          }
-        });
-        const verifyResult = await siweAuth.verify(message, signature);
-        if (verifyResult.success) {
-          setAuthResult({
-            success: true,
-            address,
-            message,
-            signature
-          });
-          return {
-            success: true,
-            address,
-            message,
-            signature,
-            siweMessage: verifyResult.data
-          };
-        } else {
-          throw new Error(verifyResult.error || "Signature verification failed");
-        }
-      } catch (error) {
-        const errorMsg = error.message || "Authentication failed";
-        setAuthResult({
-          success: false,
-          error: errorMsg
-        });
-        throw error;
-      } finally {
-        setIsAuthenticating(false);
+var SiweAuth = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      nonce: generateNonce(),
+      issuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Create the message to sign
+   */
+  async createMessage(address) {
+    return createSiweMessage(this.config, address);
+  }
+  /**
+   * Verify the signature
+   */
+  async verify(message, signature) {
+    return verifySiweSignature({
+      message,
+      signature,
+      nonce: this.config.nonce,
+      domain: this.config.domain
+    });
+  }
+  /**
+   * Get the nonce
+   */
+  getNonce() {
+    return this.config.nonce || "";
+  }
+  /**
+   * Refresh nonce (for new sign-in attempts)
+   */
+  refreshNonce() {
+    this.config.nonce = generateNonce();
+    this.config.issuedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+
+// src/wallets.ts
+var EXPLORER_API_URL = "https://explorer-api.walletconnect.com";
+async function getWalletConnectWallets(options = {}) {
+  const { projectId, entries = 100, page = 1, search, chains, include, exclude, recommendedIds } = options;
+  const params = new URLSearchParams();
+  if (projectId) {
+    params.append("projectId", projectId);
+  }
+  params.append("entries", entries.toString());
+  params.append("page", page.toString());
+  if (search) {
+    params.append("search", search);
+  }
+  if (chains) {
+    params.append("chains", chains);
+  }
+  if (include) {
+    params.append("include", include);
+  }
+  if (exclude) {
+    params.append("exclude", exclude);
+  }
+  if (recommendedIds) {
+    params.append("recommendedIds", recommendedIds);
+  }
+  const url = `${EXPLORER_API_URL}/v3/wallets?${params.toString()}`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch wallets: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw error;
+  }
+}
+async function getAllWallets(options = {}) {
+  const allWallets = [];
+  let page = 1;
+  let hasMore = true;
+  while (hasMore) {
+    const response = await getWalletConnectWallets({
+      ...options,
+      page,
+      entries: 100
+    });
+    allWallets.push(...response.data);
+    hasMore = response.data.length === 100;
+    page++;
+  }
+  return allWallets;
+}
+async function getWalletById(walletId, projectId) {
+  const params = new URLSearchParams();
+  if (projectId) {
+    params.append("projectId", projectId);
+  }
+  const url = `${EXPLORER_API_URL}/v3/wallets/${walletId}?${params.toString()}`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      if (response.status === 404) {
+        return null;
       }
-    },
-    [client, config]
+      throw new Error(`Failed to fetch wallet: ${response.statusText}`);
+    }
+    return await response.json();
+  } catch (error) {
+    return null;
+  }
+}
+async function searchWallets(query, options = {}) {
+  const response = await getWalletConnectWallets({
+    ...options,
+    search: query
+  });
+  return response.data;
+}
+async function getWalletsByChain(chainId, options = {}) {
+  const response = await getWalletConnectWallets({
+    ...options,
+    chains: chainId
+  });
+  return response.data;
+}
+async function getRecommendedWallets(walletIds, options = {}) {
+  const response = await getWalletConnectWallets({
+    ...options,
+    recommendedIds: walletIds.join(",")
+  });
+  return response.data;
+}
+async function getMobileWallets(options = {}) {
+  const response = await getWalletConnectWallets(options);
+  return response.data.filter((wallet) => wallet.mobile || wallet.app?.ios || wallet.app?.android);
+}
+async function getDesktopWallets(options = {}) {
+  const response = await getWalletConnectWallets(options);
+  return response.data.filter(
+    (wallet) => wallet.desktop || wallet.app?.mac || wallet.app?.windows || wallet.app?.linux
+  );
+}
+async function getBrowserWallets(options = {}) {
+  const response = await getWalletConnectWallets(options);
+  return response.data.filter(
+    (wallet) => wallet.app?.chrome || wallet.app?.firefox || wallet.app?.safari || wallet.app?.edge
   );
-  const signOut = useCallback(() => {
-    setAuthResult(null);
-  }, []);
-  return {
-    signIn,
-    signOut,
-    isAuthenticating,
-    authResult,
-    isAuthenticated: authResult?.success || false
-  };
 }
+var POPULAR_WALLET_IDS = {
+  METAMASK: "c57ca95b47569778a828d19178114f4db188b89b763c899ba0be274e97267d96",
+  TRUST: "4622a2b2d6af1c9844944291e5e7351a6aa24cd7b23099efac1b2fd875da31a0",
+  RAINBOW: "1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a369",
+  COINBASE: "fd20dc426fb37566d803205b19bbc1d4096b248ac04548e3cfb6b3a38bd033aa",
+  SAFE: "225affb176778569276e484e1b92637ad061b01e13a048b35a9d280c3b58970f",
+  ARGENT: "bc949c5d968ae81310268bf9193f9c9fb7bb4e1283e1284af8f2bd4992535fd6",
+  ZERION: "ecc4036f814562b41a5268adc86270fba1365471402006302e70169465b7ac18",
+  IMTOKEN: "ef333840daf915aafdc4a004525502d6d49d77bd9c65e0642dbaefb3c2893bef",
+  OKX: "971e689d0a5be527bac79629b4ee9b925e82208e5168b733496a09c0faed0709",
+  PHANTOM: "a797aa35c0fadbfc1a53e7f675162ed5226968b44a19ee3d24385c64d1d3c393",
+  TOKENPOCKET: "20459438007b75f4f4acb98bf29aa3b800550309646d375da5fd4aac6c2a2c66",
+  BITGET: "7674bb4e353bf52886768a3ddc2a4562ce2f4191c80831291218ebd90f5f5e26"
+};
+
+// src/types.ts
+var ChainType = /* @__PURE__ */ ((ChainType2) => {
+  ChainType2["EIP155"] = "eip155";
+  ChainType2["SOLANA"] = "solana";
+  ChainType2["APTOS"] = "aptos";
+  ChainType2["COSMOS"] = "cosmos";
+  ChainType2["POLKADOT"] = "polkadot";
+  ChainType2["NEAR"] = "near";
+  return ChainType2;
+})(ChainType || {});
+var AuthMethod = /* @__PURE__ */ ((AuthMethod2) => {
+  AuthMethod2["STANDARD"] = "standard";
+  AuthMethod2["SIWE"] = "siwe";
+  return AuthMethod2;
+})(AuthMethod || {});
 
-export { WalletConnectProvider, useConnect, useQRCode, useSession, useSiwe, useWalletConnect };
+export { APTOS_CHAINS, APTOS_NAMESPACE, AuthMethod, COSMOS_NAMESPACE, ChainType, EIP155_NAMESPACE, EVM_CHAINS, NEAR_NAMESPACE, POLKADOT_NAMESPACE, POPULAR_WALLET_IDS, SOLANA_CHAINS, SOLANA_NAMESPACE, SiweAuth, WalletConnectClient, copyToClipboard, createMultiChainNamespaces, createSiweConfigFromSession, createSiweMessage, extractAddressFromAccount, extractChainIdFromAccount, formatAddress, formatError, formatTimestamp, generateDeepLink, getAllWallets, getBrowserWallets, getDesktopWallets, getMobileWallets, getRecommendedWallets, getSessionTimeRemaining, getWalletById, getWalletConnectWallets, getWalletsByChain, isMobile, isSessionExpired, isValidChainId, isValidWalletConnectUri, parseChainId, parseSiweMessage, parseWalletConnectUri, searchWallets, verifySiweSignature };