@tomo-inc/wallet-connect-protocol 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -0,0 +1,1245 @@
+'use strict';
+
+var SignClient = require('@walletconnect/sign-client');
+var QRCode = require('qrcode');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var SignClient__default = /*#__PURE__*/_interopDefault(SignClient);
+var QRCode__default = /*#__PURE__*/_interopDefault(QRCode);
+
+// 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 {
+      this.signClient = await SignClient__default.default.init({
+        projectId: this.config.projectId,
+        metadata: this.config.metadata,
+        relayUrl: this.config.relayUrl
+      });
+      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__default.default.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"
+        }
+      };
+      await QRCode__default.default.toCanvas(canvas, uri, qrOptions);
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * 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");
+    }
+    try {
+      await this.signClient.disconnect({
+        topic,
+        reason: {
+          code: 6e3,
+          message: "User disconnected"
+        }
+      });
+    } catch (error) {
+      throw 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());
+    }
+    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 };
+  }
+};
+var WalletConnectContext = react.createContext(void 0);
+function WalletConnectProvider({ config, children, autoInit = true }) {
+  const [client, setClient] = react.useState(null);
+  const [initialized, setInitialized] = react.useState(false);
+  const [connecting, setConnecting] = react.useState(false);
+  const [uri, setUri] = react.useState(null);
+  const [sessions, setSessions] = react.useState([]);
+  const refreshSessions = react.useCallback(() => {
+    if (client) {
+      const activeSessions = client.getActiveSessions();
+      setSessions(activeSessions);
+    }
+  }, [client]);
+  const initialize = react.useCallback(async () => {
+    if (initialized) {
+      return;
+    }
+    try {
+      const newClient = new WalletConnectClient(config);
+      newClient.on("display_uri", ({ uri: uri2 }) => {
+        setUri(uri2);
+      });
+      const handleSessionUpdate = () => {
+        const activeSessions2 = newClient.getActiveSessions();
+        setSessions(activeSessions2);
+      };
+      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);
+    } catch (error) {
+      throw error;
+    }
+  }, [config, initialized]);
+  const connect = react.useCallback(async () => {
+    if (!client) {
+      throw new Error("WalletConnect client not initialized");
+    }
+    setConnecting(true);
+    try {
+      const connectionUri = await client.connect();
+      setUri(connectionUri);
+      return connectionUri;
+    } catch (error) {
+      throw error;
+    } finally {
+      setConnecting(false);
+    }
+  }, [client]);
+  const generateQRCode = react.useCallback(
+    async (uri2, options) => {
+      if (!client) {
+        throw new Error("WalletConnect client not initialized");
+      }
+      return client.generateQRCode(uri2, options);
+    },
+    [client]
+  );
+  const disconnect = react.useCallback(
+    async (topic) => {
+      if (!client) {
+        throw new Error("WalletConnect client not initialized");
+      }
+      await client.disconnectSession(topic);
+      refreshSessions();
+    },
+    [client]
+  );
+  react.useEffect(() => {
+    if (!client || !initialized) return;
+    const interval = setInterval(() => {
+      refreshSessions();
+    }, 2e3);
+    return () => clearInterval(interval);
+  }, [client, initialized, refreshSessions]);
+  react.useEffect(() => {
+    if (autoInit && !initialized) {
+      initialize().catch(console.error);
+    }
+  }, [autoInit, initialized, initialize]);
+  react.useEffect(() => {
+    return () => {
+      if (client) {
+        client.destroy().catch(console.error);
+      }
+    };
+  }, [client]);
+  const value = {
+    client,
+    initialized,
+    connecting,
+    uri,
+    sessions,
+    initialize,
+    connect,
+    generateQRCode,
+    disconnect,
+    refreshSessions
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(WalletConnectContext.Provider, { value, children });
+}
+function useWalletConnect() {
+  const context = react.useContext(WalletConnectContext);
+  if (!context) {
+    throw new Error("useWalletConnect must be used within WalletConnectProvider");
+  }
+  return context;
+}
+function useQRCode(uri, options) {
+  const { generateQRCode } = useWalletConnect();
+  const [qrCode, setQrCode] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const generate = react.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]
+  );
+  react.useEffect(() => {
+    if (uri) {
+      generate(uri);
+    }
+  }, [uri, generate]);
+  return {
+    qrCode,
+    loading,
+    error,
+    generate
+  };
+}
+
+// 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
+    };
+  } catch {
+    return null;
+  }
+}
+function formatAddress(address, startLength = 6, endLength = 4) {
+  if (!address || address.length < startLength + endLength) {
+    return address;
+  }
+  return `${address.slice(0, startLength)}...${address.slice(-endLength)}`;
+}
+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}`;
+    }
+  }
+  return `wc://wc?uri=${encodedUri}`;
+}
+async function copyToClipboard(text) {
+  try {
+    if (navigator.clipboard) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } else {
+      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;
+    }
+  } catch {
+    return false;
+  }
+}
+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/hooks/useSession.ts
+function useSession(topic) {
+  const { sessions, disconnect, refreshSessions, client } = useWalletConnect();
+  const [currentSession, setCurrentSession] = react.useState(null);
+  react.useEffect(() => {
+    if (topic) {
+      const session = sessions.find((s) => s.topic === topic);
+      setCurrentSession(session || null);
+    } else {
+      setCurrentSession(sessions[0] || null);
+    }
+  }, [topic, sessions]);
+  const disconnectSession = react.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 = react.useCallback((session) => {
+    return isSessionExpired(session.expiry);
+  }, []);
+  const getAccounts = react.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 = react.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
+  };
+}
+function useConnect(options) {
+  const { connect, generateQRCode, connecting } = useWalletConnect();
+  const [uri, setUri] = react.useState(null);
+  const [qrCode, setQrCode] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const handleConnect = react.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);
+      }
+      return connectionUri;
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      options?.onError?.(error2);
+      throw error2;
+    }
+  }, [connect, generateQRCode, options]);
+  const reset = react.useCallback(() => {
+    setUri(null);
+    setQrCode(null);
+    setError(null);
+  }, []);
+  return {
+    connect: handleConnect,
+    uri,
+    qrCode,
+    connecting,
+    error,
+    reset
+  };
+}
+
+// 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
+      }
+    );
+    if (result.success) {
+      return {
+        success: true,
+        data: result.data
+      };
+    } else {
+      return {
+        success: false,
+        error: result.error?.type || "Verification failed"
+      };
+    }
+  } 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 extractChainIdNumber(account) {
+  const parts = account.split(":");
+  if (parts.length > 2) {
+    return parseInt(parts[1], 10);
+  }
+  return 1;
+}
+function createSiweConfigFromSession(params) {
+  return {
+    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
+  };
+}
+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/hooks/useSiwe.ts
+function useSiwe(config) {
+  const { client } = useWalletConnect();
+  const [isAuthenticating, setIsAuthenticating] = react.useState(false);
+  const [authResult, setAuthResult] = react.useState(null);
+  const signIn = react.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);
+      }
+    },
+    [client, config]
+  );
+  const signOut = react.useCallback(() => {
+    setAuthResult(null);
+  }, []);
+  return {
+    signIn,
+    signOut,
+    isAuthenticating,
+    authResult,
+    isAuthenticated: authResult?.success || false
+  };
+}
+
+// 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 getChainName(chainId) {
+  const chainNames = {
+    // Ethereum
+    "eip155:1": "Ethereum Mainnet",
+    "eip155:5": "Goerli Testnet",
+    "eip155:11155111": "Sepolia Testnet",
+    // Layer 2
+    "eip155:137": "Polygon",
+    "eip155:80001": "Polygon Mumbai",
+    "eip155:42161": "Arbitrum One",
+    "eip155:421613": "Arbitrum Goerli",
+    "eip155:10": "Optimism",
+    "eip155:420": "Optimism Goerli",
+    // other EVM chains
+    "eip155:56": "BNB Smart Chain",
+    "eip155:97": "BSC Testnet",
+    "eip155:43114": "Avalanche C-Chain",
+    "eip155:43113": "Avalanche Fuji",
+    "eip155:250": "Fantom Opera",
+    "eip155:25": "Cronos",
+    "eip155:100": "Gnosis Chain",
+    "eip155:8453": "Base",
+    "eip155:324": "zkSync Era",
+    "eip155:59144": "Linea",
+    "eip155:534352": "Scroll",
+    // Solana
+    "solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ": "Solana Mainnet",
+    "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1": "Solana Devnet",
+    "solana:8E9rvCKLFQia2Y35HXjjpWzj8weVo44K": "Solana Testnet",
+    // Aptos
+    "aptos:1": "Aptos Mainnet",
+    "aptos:2": "Aptos Testnet",
+    "aptos:3": "Aptos Devnet",
+    // Cosmos
+    "cosmos:cosmoshub-4": "Cosmos Hub",
+    "cosmos:osmosis-1": "Osmosis",
+    // Polkadot
+    "polkadot:91b171bb158e2d3848fa23a9f1c25182": "Polkadot",
+    // Near
+    "near:mainnet": "Near Mainnet"
+  };
+  return chainNames[chainId] || chainId;
+}
+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;
+}
+function getChainType(chainId) {
+  if (chainId.startsWith("eip155:")) return "EVM";
+  if (chainId.startsWith("solana:")) return "Solana";
+  if (chainId.startsWith("aptos:")) return "Aptos";
+  if (chainId.startsWith("cosmos:")) return "Cosmos";
+  if (chainId.startsWith("polkadot:")) return "Polkadot";
+  if (chainId.startsWith("near:")) return "Near";
+  return "Unknown";
+}
+
+// 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;
+      }
+      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
+  );
+}
+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 || {});
+
+exports.APTOS_CHAINS = APTOS_CHAINS;
+exports.APTOS_NAMESPACE = APTOS_NAMESPACE;
+exports.AuthMethod = AuthMethod;
+exports.COSMOS_NAMESPACE = COSMOS_NAMESPACE;
+exports.ChainType = ChainType;
+exports.EIP155_NAMESPACE = EIP155_NAMESPACE;
+exports.EVM_CHAINS = EVM_CHAINS;
+exports.NEAR_NAMESPACE = NEAR_NAMESPACE;
+exports.POLKADOT_NAMESPACE = POLKADOT_NAMESPACE;
+exports.POPULAR_WALLET_IDS = POPULAR_WALLET_IDS;
+exports.SOLANA_CHAINS = SOLANA_CHAINS;
+exports.SOLANA_NAMESPACE = SOLANA_NAMESPACE;
+exports.SiweAuth = SiweAuth;
+exports.WalletConnectClient = WalletConnectClient;
+exports.WalletConnectProvider = WalletConnectProvider;
+exports.copyToClipboard = copyToClipboard;
+exports.createMultiChainNamespaces = createMultiChainNamespaces;
+exports.createSiweConfigFromSession = createSiweConfigFromSession;
+exports.createSiweMessage = createSiweMessage;
+exports.extractAddressFromAccount = extractAddressFromAccount;
+exports.extractChainIdFromAccount = extractChainIdFromAccount;
+exports.extractChainIdNumber = extractChainIdNumber;
+exports.formatAddress = formatAddress;
+exports.formatError = formatError;
+exports.formatTimestamp = formatTimestamp;
+exports.generateDeepLink = generateDeepLink;
+exports.generateNonce = generateNonce;
+exports.getAllWallets = getAllWallets;
+exports.getBrowserWallets = getBrowserWallets;
+exports.getChainName = getChainName;
+exports.getChainType = getChainType;
+exports.getDesktopWallets = getDesktopWallets;
+exports.getMobileWallets = getMobileWallets;
+exports.getRecommendedWallets = getRecommendedWallets;
+exports.getSessionTimeRemaining = getSessionTimeRemaining;
+exports.getWalletById = getWalletById;
+exports.getWalletConnectWallets = getWalletConnectWallets;
+exports.getWalletsByChain = getWalletsByChain;
+exports.isMobile = isMobile;
+exports.isSessionExpired = isSessionExpired;
+exports.isValidChainId = isValidChainId;
+exports.isValidWalletConnectUri = isValidWalletConnectUri;
+exports.parseChainId = parseChainId;
+exports.parseSiweMessage = parseSiweMessage;
+exports.parseWalletConnectUri = parseWalletConnectUri;
+exports.searchWallets = searchWallets;
+exports.useConnect = useConnect;
+exports.useQRCode = useQRCode;
+exports.useSession = useSession;
+exports.useSiwe = useSiwe;
+exports.useWalletConnect = useWalletConnect;
+exports.verifySiweSignature = verifySiweSignature;