npm - @walletconnect/cli-sdk - Versions diffs - 0.1.0 - Mend

@walletconnect/cli-sdk 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,680 @@
+#!/usr/bin/env node
+// src/client.ts
+import { EventEmitter } from "events";
+import { execFileSync } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+import { KeyValueStorage } from "@walletconnect/keyvaluestorage";
+import { SignClient } from "@walletconnect/sign-client";
+// src/browser-ui/server.ts
+import http from "http";
+var SCRIPT_CLOSE = "</script>";
+function buildHTML(uri) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>WalletConnect \u2014 Connect Wallet</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: #1a1a2e;
+      color: #e0e0e0;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      max-width: 420px;
+    }
+    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; color: #fff; }
+    .subtitle { color: #8888aa; margin-bottom: 2rem; }
+    #qr-container {
+      background: #fff;
+      border-radius: 16px;
+      padding: 24px;
+      display: inline-block;
+      margin-bottom: 1.5rem;
+    }
+    #qr-container canvas { display: block; }
+    .uri-box {
+      background: #16213e;
+      border: 1px solid #333;
+      border-radius: 8px;
+      padding: 12px;
+      word-break: break-all;
+      font-size: 0.75rem;
+      color: #8888aa;
+      margin-bottom: 1.5rem;
+      cursor: pointer;
+      transition: border-color 0.2s;
+    }
+    .uri-box:hover { border-color: #5566ff; }
+    .uri-box:active { border-color: #3344dd; }
+    #status {
+      font-size: 0.9rem;
+      padding: 8px 16px;
+      border-radius: 8px;
+      display: inline-block;
+    }
+    .status-waiting { background: #16213e; color: #8888aa; }
+    .status-connected { background: #0a3d2a; color: #4ade80; }
+    .status-error { background: #3d0a0a; color: #f87171; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Connect Your Wallet</h1>
+    <p class="subtitle">Scan the QR code with your mobile wallet</p>
+    <div id="qr-container"><canvas id="qr"></canvas></div>
+    <div class="uri-box" onclick="navigator.clipboard.writeText('${uri}').then(()=>this.textContent='Copied!').catch(()=>{})">
+      ${uri}
+    </div>
+    <div id="status" class="status-waiting">Waiting for connection...</div>
+  </div>
+  <script src="https://cdn.jsdelivr.net/npm/qrcode@1/build/qrcode.min.js">${SCRIPT_CLOSE}
+  <script>
+    QRCode.toCanvas(document.getElementById("qr"), "${uri}", {
+      width: 280,
+      margin: 0,
+      color: { dark: "#1a1a2e", light: "#ffffff" }
+    });
+    const evtSource = new EventSource("/events");
+    evtSource.onmessage = function(event) {
+      const data = JSON.parse(event.data);
+      const el = document.getElementById("status");
+      el.className = "status-" + data.status;
+      el.textContent = data.message || data.status;
+      if (data.status === "connected") {
+        evtSource.close();
+        setTimeout(() => window.close(), 2000);
+      }
+    };
+  ${SCRIPT_CLOSE}
+</body>
+</html>`;
+}
+function createBrowserUI(preferredPort) {
+  let server = null;
+  const sseClients = [];
+  return {
+    async start(uri) {
+      const html = buildHTML(uri);
+      server = http.createServer((req, res) => {
+        if (req.url === "/events") {
+          res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          });
+          res.write(`data: ${JSON.stringify({ status: "waiting", message: "Waiting for connection..." })}
+`);
+          const client = { res };
+          sseClients.push(client);
+          req.on("close", () => {
+            const idx = sseClients.indexOf(client);
+            if (idx !== -1) sseClients.splice(idx, 1);
+          });
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(html);
+      });
+      const port = await new Promise((resolve, reject) => {
+        server.listen(preferredPort || 0, "127.0.0.1", () => {
+          const addr = server.address();
+          resolve(addr.port);
+        });
+        server.on("error", reject);
+      });
+      const url = `http://127.0.0.1:${port}`;
+      try {
+        const { default: open } = await import("open");
+        await open(url);
+      } catch {
+        console.log(`Open your browser at: ${url}`);
+      }
+      return { port, url };
+    },
+    updateStatus(status, message) {
+      const payload = JSON.stringify({
+        status,
+        message: message || status
+      });
+      for (const client of sseClients) {
+        try {
+          client.res.write(`data: ${payload}
+`);
+        } catch {
+        }
+      }
+    },
+    async stop() {
+      for (const client of sseClients) {
+        try {
+          client.res.end();
+        } catch {
+        }
+      }
+      sseClients.length = 0;
+      if (server) {
+        await new Promise((resolve) => {
+          server.close(() => resolve());
+        });
+        server = null;
+      }
+    }
+  };
+}
+// src/session.ts
+function createSessionManager() {
+  return {
+    getExistingSession(client) {
+      const sessions = client.session.getAll();
+      if (sessions.length === 0) return null;
+      const now = Math.floor(Date.now() / 1e3);
+      const valid = sessions.filter((s) => s.expiry > now).sort((a, b) => b.expiry - a.expiry);
+      return valid.length > 0 ? valid[0] : null;
+    },
+    isSessionValid(session) {
+      const now = Math.floor(Date.now() / 1e3);
+      return session.expiry > now;
+    }
+  };
+}
+// src/terminal-ui.ts
+import qrcodeModule from "qrcode-terminal";
+function createTerminalUI() {
+  return {
+    displayQR(uri) {
+      console.log("\nScan this QR code with your wallet app:\n");
+      qrcodeModule.generate(uri, { small: true });
+      console.log("\nOr copy this URI:", uri);
+      console.log("\nWaiting for wallet connection...\n");
+    },
+    showStatus(message) {
+      console.log(`[WalletConnect] ${message}`);
+    },
+    showError(message) {
+      console.error(`[WalletConnect] Error: ${message}`);
+    },
+    showSuccess(message) {
+      console.log(`[WalletConnect] ${message}`);
+    }
+  };
+}
+// src/client.ts
+var DEFAULT_METHODS = [
+  "eth_sendTransaction",
+  "eth_signTransaction",
+  "personal_sign",
+  "eth_sign",
+  "eth_signTypedData",
+  "eth_signTypedData_v4"
+];
+var DEFAULT_EVENTS = ["chainChanged", "accountsChanged"];
+var DEFAULT_CHAINS = ["eip155:1"];
+var DEFAULT_STORAGE_PATH = join(homedir(), ".walletconnect-cli");
+var WalletConnectCLI = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this.signClient = null;
+    this.currentSession = null;
+    this.browserUI = null;
+    this.sessionManager = createSessionManager();
+    this.options = options;
+  }
+  // ---------- Public API ----------------------------------------------- //
+  async tryRestore() {
+    const client = await this.ensureClient();
+    const existing = this.sessionManager.getExistingSession(client);
+    if (!existing) return null;
+    this.currentSession = existing;
+    return this.buildConnectResult(existing);
+  }
+  async connect(connectOptions) {
+    const client = await this.ensureClient();
+    if (this.options.autoConnect !== false) {
+      const existing = this.sessionManager.getExistingSession(client);
+      if (existing) {
+        this.currentSession = existing;
+        const result2 = this.buildConnectResult(existing);
+        this.emit("connect", result2);
+        return result2;
+      }
+    }
+    const chains = this.options.chains || DEFAULT_CHAINS;
+    const methods = this.options.methods || DEFAULT_METHODS;
+    const events = this.options.events || DEFAULT_EVENTS;
+    const optionalNamespaces = connectOptions?.optionalNamespaces || {
+      eip155: { chains, methods, events }
+    };
+    const { uri, approval } = await client.connect({ optionalNamespaces });
+    if (!uri) {
+      throw new Error("Failed to generate WalletConnect URI");
+    }
+    if (this.options.ui === "browser") {
+      await this.showBrowserUI(uri);
+    } else {
+      const terminalUI = createTerminalUI();
+      terminalUI.displayQR(uri);
+    }
+    const session = await approval();
+    this.currentSession = session;
+    if (this.browserUI) {
+      this.browserUI.updateStatus("connected", `Connected to ${session.peer.metadata.name}`);
+      setTimeout(() => this.browserUI?.stop(), 3e3);
+    }
+    const result = this.buildConnectResult(session);
+    this.emit("connect", result);
+    return result;
+  }
+  async request(options) {
+    const client = await this.ensureClient();
+    const topic = options.topic || this.currentSession?.topic;
+    if (!topic) {
+      throw new Error("No active session. Call connect() first.");
+    }
+    this.logRequestDetails(options);
+    try {
+      return await client.request({
+        topic,
+        chainId: options.chainId,
+        request: options.request
+      });
+    } catch (error) {
+      const message = this.extractErrorMessage(error);
+      if (message.includes("rejected") || message.includes("denied") || message.includes("cancelled")) {
+        throw new Error("Request rejected by user");
+      }
+      if (typeof error === "object" && error !== null) {
+        const errObj = error;
+        if (errObj.code === 0 && !errObj.message) {
+          throw new Error("Request rejected or timed out in wallet");
+        }
+      }
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (!this.currentSession) return;
+    try {
+      const client = await this.ensureClient();
+      const swallow = () => {
+      };
+      client.core.relayer.on("error", swallow);
+      try {
+        await client.disconnect({
+          topic: this.currentSession.topic,
+          reason: { code: 6e3, message: "User disconnected" }
+        });
+      } finally {
+        client.core.relayer.off("error", swallow);
+      }
+    } catch {
+    }
+    this.currentSession = null;
+    this.emit("disconnect");
+  }
+  isConnected() {
+    if (!this.currentSession) return false;
+    return this.sessionManager.isSessionValid(this.currentSession);
+  }
+  getAccounts() {
+    if (!this.currentSession) return [];
+    return Object.values(this.currentSession.namespaces).flatMap((ns) => ns.accounts || []);
+  }
+  getSession() {
+    return this.currentSession;
+  }
+  async destroy() {
+    if (this.browserUI) {
+      await this.browserUI.stop();
+      this.browserUI = null;
+    }
+    this.removeAllListeners();
+    if (this.signClient) {
+      try {
+        await this.signClient.core.relayer.transportClose();
+      } catch {
+      }
+    }
+    this.signClient = null;
+    this.currentSession = null;
+  }
+  // Type-safe event emitter overrides
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  // ---------- Private -------------------------------------------------- //
+  logRequestDetails(options) {
+    const walletName = this.currentSession?.peer.metadata.name;
+    if (walletName) {
+      console.log(`
+Requesting approval on ${walletName}...`);
+    }
+    if (options.request.method === "eth_sendTransaction") {
+      const params = options.request.params;
+      const data = params[0]?.data;
+      if (data && data !== "0x") {
+        try {
+          const decoded = execFileSync("cast", ["4d", data], {
+            encoding: "utf-8",
+            timeout: 5e3,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          if (decoded) {
+            console.log(`
+  Decoded calldata:
+${decoded.split("\n").map((l) => `    ${l}`).join("\n")}
+`);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  async ensureClient() {
+    if (this.signClient) return this.signClient;
+    const storagePath = this.options.storagePath || DEFAULT_STORAGE_PATH;
+    const storage = new KeyValueStorage({ database: storagePath });
+    this.signClient = await SignClient.init({
+      projectId: this.options.projectId,
+      metadata: this.options.metadata,
+      storage,
+      logger: this.options.logger || "silent"
+    });
+    this.signClient.on("session_update", ({ topic }) => {
+      const session = this.signClient?.session.get(topic);
+      if (session) {
+        this.currentSession = session;
+        this.emit("session_update", session);
+      }
+    });
+    this.signClient.on("session_delete", ({ topic }) => {
+      if (this.currentSession?.topic === topic) {
+        this.currentSession = null;
+      }
+      this.emit("session_delete", { topic });
+      this.emit("disconnect");
+    });
+    return this.signClient;
+  }
+  async showBrowserUI(uri) {
+    this.browserUI = createBrowserUI(this.options.port);
+    try {
+      const { url } = await this.browserUI.start(uri);
+      console.log(`
+Connect your wallet at: ${url}
+`);
+    } catch {
+      console.log("Could not open browser, falling back to terminal QR code.");
+      const terminalUI = createTerminalUI();
+      terminalUI.displayQR(uri);
+      this.browserUI = null;
+    }
+  }
+  buildConnectResult(session) {
+    const accounts = Object.values(session.namespaces).flatMap((ns) => ns.accounts || []);
+    return {
+      session,
+      accounts,
+      topic: session.topic
+    };
+  }
+  extractErrorMessage(error) {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "object" && error !== null) {
+      const errObj = error;
+      if (errObj.message) return errObj.message;
+      return JSON.stringify(error);
+    }
+    return String(error);
+  }
+};
+// src/config.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+var CONFIG_DIR = join2(homedir2(), ".walletconnect-cli");
+var CONFIG_FILE = join2(CONFIG_DIR, "config.json");
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+}
+function getConfigValue(key) {
+  return readConfig()[key];
+}
+function setConfigValue(key, value) {
+  const config = readConfig();
+  config[key] = value;
+  writeConfig(config);
+}
+function resolveProjectId() {
+  return process.env.WALLETCONNECT_PROJECT_ID || getConfigValue("projectId");
+}
+// src/cli.ts
+var METADATA = {
+  name: "walletconnect",
+  description: "WalletConnect CLI",
+  url: "https://github.com/ARI/walletconnect-cli-sdk",
+  icons: []
+};
+function usage() {
+  console.log(`Usage: walletconnect <command> [options]
+Commands:
+  connect              Connect to a wallet via QR code
+  whoami               Show current session info
+  sign <message>       Sign a message with the connected wallet
+  disconnect           Disconnect the current session
+  config set <k> <v>   Set a config value (e.g. project-id)
+  config get <k>       Get a config value
+Options:
+  --browser        Use browser UI instead of terminal QR code
+  --help           Show this help message
+Config keys:
+  project-id       WalletConnect Cloud project ID
+Environment:
+  WALLETCONNECT_PROJECT_ID   Overrides config project-id when set`);
+}
+function getProjectId() {
+  const id = resolveProjectId();
+  if (!id) {
+    console.error("Error: No project ID found. Set via: walletconnect config set project-id <id>");
+    process.exit(1);
+  }
+  return id;
+}
+function createSDK(options) {
+  return new WalletConnectCLI({
+    projectId: options.projectId || "",
+    metadata: METADATA,
+    ui: options.browser ? "browser" : "terminal"
+  });
+}
+function parseAccount(caip10) {
+  const lastColon = caip10.lastIndexOf(":");
+  return {
+    chain: caip10.slice(0, lastColon),
+    address: caip10.slice(lastColon + 1)
+  };
+}
+async function cmdConnect(browser) {
+  const projectId = getProjectId();
+  const sdk = createSDK({ projectId, browser });
+  try {
+    console.log("Scan this QR code with your wallet app:\n");
+    const result = await sdk.connect();
+    console.log("\nConnected!");
+    for (const account of result.accounts) {
+      const { chain, address } = parseAccount(account);
+      console.log(`  Chain:   ${chain}`);
+      console.log(`  Address: ${address}`);
+    }
+  } finally {
+    await sdk.destroy();
+  }
+}
+async function cmdWhoami() {
+  const sdk = createSDK({});
+  try {
+    const result = await sdk.tryRestore();
+    if (!result) {
+      console.log("Not connected.");
+      process.exit(1);
+    }
+    const walletName = result.session.peer.metadata.name;
+    console.log(`  Wallet:  ${walletName}`);
+    for (const account of result.accounts) {
+      const { chain, address } = parseAccount(account);
+      console.log(`  Chain:   ${chain}`);
+      console.log(`  Address: ${address}`);
+    }
+    const expiry = new Date(result.session.expiry * 1e3);
+    console.log(`  Expires: ${expiry.toLocaleString()}`);
+  } finally {
+    await sdk.destroy();
+  }
+}
+async function cmdSign(message, browser) {
+  const projectId = getProjectId();
+  const sdk = createSDK({ projectId, browser });
+  try {
+    let result = await sdk.tryRestore();
+    if (!result) {
+      console.log("No existing session. Connecting...\n");
+      result = await sdk.connect();
+      console.log();
+    }
+    const { chain, address } = parseAccount(result.accounts[0]);
+    const hexMessage = "0x" + Buffer.from(message, "utf8").toString("hex");
+    const signature = await sdk.request({
+      chainId: chain,
+      request: {
+        method: "personal_sign",
+        params: [hexMessage, address]
+      }
+    });
+    console.log(`  Message:   ${message}`);
+    console.log(`  Signature: ${signature}`);
+  } finally {
+    await sdk.destroy();
+  }
+}
+async function cmdDisconnect() {
+  const sdk = createSDK({});
+  try {
+    const result = await sdk.tryRestore();
+    if (!result) {
+      console.log("Not connected.");
+      return;
+    }
+    await sdk.disconnect();
+    console.log("Disconnected.");
+  } finally {
+    await sdk.destroy();
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const browser = args.includes("--browser");
+  const filtered = args.filter((a) => a !== "--browser");
+  const command = filtered[0];
+  switch (command) {
+    case "connect":
+      await cmdConnect(browser);
+      break;
+    case "whoami":
+      await cmdWhoami();
+      break;
+    case "sign": {
+      const message = filtered[1];
+      if (!message) {
+        console.error("Usage: walletconnect sign <message>");
+        process.exit(1);
+      }
+      await cmdSign(message, browser);
+      break;
+    }
+    case "disconnect":
+      await cmdDisconnect();
+      break;
+    case "config": {
+      const action = filtered[1];
+      const key = filtered[2];
+      if (action === "set") {
+        const value = filtered[3];
+        if (key === "project-id" && value) {
+          setConfigValue("projectId", value);
+          console.log(`Saved project-id to ~/.walletconnect-cli/config.json`);
+        } else {
+          console.error("Usage: walletconnect config set project-id <value>");
+          process.exit(1);
+        }
+      } else if (action === "get") {
+        if (key === "project-id") {
+          const value = getConfigValue("projectId");
+          console.log(value || "(not set)");
+        } else {
+          console.error("Usage: walletconnect config get project-id");
+          process.exit(1);
+        }
+      } else {
+        console.error("Usage: walletconnect config <set|get> <key> [value]");
+        process.exit(1);
+      }
+      break;
+    }
+    case "--help":
+    case "-h":
+    case void 0:
+      usage();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      usage();
+      process.exit(1);
+  }
+}
+main().then(
+  () => process.exit(0),
+  (err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+);