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

package/dist/vanilla.cjs

@@ -0,0 +1,828 @@
+'use strict';
+
+var SignClient = require('@walletconnect/sign-client');
+var QRCode = require('qrcode');
+
+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 };
+  }
+};
+
+// 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/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
+      }
+    );
+    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 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/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.copyToClipboard = copyToClipboard;
+exports.createMultiChainNamespaces = createMultiChainNamespaces;
+exports.createSiweConfigFromSession = createSiweConfigFromSession;
+exports.createSiweMessage = createSiweMessage;
+exports.extractAddressFromAccount = extractAddressFromAccount;
+exports.extractChainIdFromAccount = extractChainIdFromAccount;
+exports.formatAddress = formatAddress;
+exports.formatError = formatError;
+exports.formatTimestamp = formatTimestamp;
+exports.generateDeepLink = generateDeepLink;
+exports.getAllWallets = getAllWallets;
+exports.getBrowserWallets = getBrowserWallets;
+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.verifySiweSignature = verifySiweSignature;