windkit 0.2.1 → 0.2.3

package/src/WalletSession.js

@@ -0,0 +1,375 @@
+// windkit/WalletSession.js
+// Ultra Clean++ (single replace)
+// ✅ fixes peerID case bug in ACTIVE_ACCOUNT_CHANGED
+// ✅ bounded ping heartbeat (jitter) for low-end
+// ✅ strict request mapping + timeout cleanup
+// ✅ minimal surface: transact/signRequest/signMessage/sharedSecret
+
+import { Base64u, IdentityProof, SigningRequest } from "@wharfkit/signing-request";
+import {
+  Checksum512,
+  Name,
+  PermissionLevel,
+  PublicKey,
+  Serializer,
+  Signature,
+  SignedTransaction,
+} from "@wharfkit/antelope";
+
+import zlib from "pako";
+import { loadSession, saveSession } from "./StoreSession.js";
+
+const DEFAULT_TIMEOUT_MS = 90_000;
+const PING_MS = 15_000;
+const PING_JITTER_MS = 2_000;
+
+function uuid() {
+  try {
+    if (globalThis?.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+  } catch {}
+  return `id-${Math.random().toString(16).slice(2)}-${Date.now().toString(16)}`;
+}
+
+function setTimer(fn, ms) {
+  try {
+    return globalThis.setTimeout(fn, ms);
+  } catch {
+    return setTimeout(fn, ms);
+  }
+}
+
+function clearTimer(id) {
+  try {
+    globalThis.clearTimeout(id);
+  } catch {
+    clearTimeout(id);
+  }
+}
+
+function normalizeTimeoutMs(v, fallback = DEFAULT_TIMEOUT_MS) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(1000, Math.trunc(n));
+}
+
+function errorFromReply(reply, fallback) {
+  const err = reply?.error;
+  if (typeof err === "string") return new Error(err);
+  if (err?.message) return new Error(err.message);
+  return new Error(fallback || "Request rejected.");
+}
+
+/**
+ * WalletSession
+ * - Wraps a PeerJS DataConnection (DApp->Wallet)
+ * - Sends requests to wallet and maps replies by id
+ */
+export class WalletSession {
+  static ChainID = "f9f432b1851b5c179d2091a96f593aaed50ec7466b74f89301f957a83e56ce1f";
+
+  /** @type {import("peerjs").DataConnection} */
+  #connection;
+
+  /** @type {Map<string, {resolve:Function, reject:Function, timeout:any}>} */
+  #pending = new Map();
+
+  /** @type {{zlib:any, abiProvider?:any} | undefined} */
+  #encodingOptions;
+
+  /** @type {PermissionLevel | undefined} */
+  #permissionLevel;
+
+  /** @type {(permission: PermissionLevel) => void | undefined} */
+  #accountChangeListener;
+
+  /** @type {() => void | undefined} */
+  #closeListener;
+
+  /** @type {(error: Error) => void | undefined} */
+  #errorListener;
+
+  /** @type {any} */
+  #pingTimer = null;
+
+  /**
+   * @param {import("peerjs").DataConnection} connection
+   */
+  constructor(connection) {
+    this.#connection = connection;
+
+    connection.on("data", (msg) => this.#onDataReceived(msg));
+
+    connection.on("close", () => {
+      this.#stopPing();
+
+      for (const [id, p] of this.#pending.entries()) {
+        try {
+          clearTimer(p.timeout);
+        } catch {}
+        try {
+          p.reject(new Error("Wallet connection closed."));
+        } catch {}
+        this.#pending.delete(id);
+      }
+
+      if (this.#closeListener) this.#closeListener();
+    });
+
+    connection.on("error", (error) => {
+      if (this.#errorListener) this.#errorListener(error);
+    });
+
+    this.#startPing();
+  }
+
+  /**
+   * Optional ABI cache provider (recommended when creating requests).
+   * @param {import("@wharfkit/abicache").ABICache} cache
+   */
+  setABICache(cache) {
+    this.#encodingOptions = { zlib, abiProvider: cache };
+  }
+
+  onAccountChange(listener) {
+    this.#accountChangeListener = listener;
+  }
+
+  onClose(listener) {
+    this.#closeListener = listener;
+  }
+
+  onError(listener) {
+    this.#errorListener = listener;
+  }
+
+  isOpen() {
+    return Boolean(this.#connection?.open);
+  }
+
+  close() {
+    this.#stopPing();
+    try {
+      this.#connection.close();
+    } catch {}
+  }
+
+  metadata() {
+    return this.#connection.metadata;
+  }
+
+  get permissionLevel() {
+    return this.#permissionLevel;
+  }
+
+  set permissionLevel(value) {
+    this.#permissionLevel = value;
+  }
+
+  get actor() {
+    return this.#permissionLevel?.actor ?? Name.from("");
+  }
+
+  get permission() {
+    return this.#permissionLevel?.permission ?? Name.from("");
+  }
+
+  /**
+   * @typedef {Object} TransactArguments
+   * @property {import("@wharfkit/antelope").Action=} action
+   * @property {Array<import("@wharfkit/antelope").Action>=} actions
+   * @property {import("@wharfkit/antelope").Transaction=} transaction
+   */
+
+  /**
+   * @typedef {Object} TransactOptions
+   * @property {boolean=} broadcast True to broadcast, false for sign-only.
+   * @property {number=} timeoutMs Per-request timeout (default 90s).
+   */
+
+  /**
+   * Create a VSR signing request for a transaction and send to wallet.
+   * @param {TransactArguments} args
+   * @param {TransactOptions=} options
+   * @returns {Promise<SignedTransaction|any>} SignedTransaction (sign-only) OR wallet push result (broadcast)
+   */
+  async transact(args, options) {
+    const willBroadcast = typeof options?.broadcast === "boolean" ? options.broadcast : true;
+
+    const requestArgs = { ...args, chainId: WalletSession.ChainID };
+    const req = await SigningRequest.create(requestArgs, this.#encodingOptions);
+    req.setBroadcast(willBroadcast);
+
+    const vsr = req.encode(true, false, "vsr:");
+    return this.signRequest(vsr, options?.timeoutMs);
+  }
+
+  /**
+   * Send a signing request string to the wallet.
+   * @param {string} vsr
+   * @param {number=} timeoutMs
+   * @returns {Promise<any|SignedTransaction>}
+   */
+  signRequest(vsr, timeoutMs) {
+    return this.#request("signRequest", { vsr }, timeoutMs, (reply) => {
+      if (reply?.code === "SENT") return reply.result;
+      if (reply?.code === "SIGNED") return SignedTransaction.from(reply.result);
+      throw errorFromReply(reply, "Signing request rejected.");
+    });
+  }
+
+  /**
+   * Ask wallet to sign an arbitrary message.
+   * @param {string} message
+   * @param {number=} timeoutMs
+   * @returns {Promise<Signature>}
+   */
+  signMessage(message, timeoutMs) {
+    return this.#request("signMessage", { message }, timeoutMs, (reply) => {
+      if (reply?.code === "SIGNED") return Signature.from(reply.result.signature);
+      throw errorFromReply(reply, "Message signing rejected.");
+    });
+  }
+
+  /**
+   * Ask wallet to derive a shared secret from a public key.
+   * @param {PublicKey} publicKey
+   * @param {number=} timeoutMs
+   * @returns {Promise<Checksum512>}
+   */
+  sharedSecret(publicKey, timeoutMs) {
+    return this.#request("sharedSecret", { key: publicKey.toString() }, timeoutMs, (reply) => {
+      if (reply?.code === "CREATED") return Checksum512.from(reply.result.secret);
+      throw errorFromReply(reply, "Shared secret creation failed.");
+    });
+  }
+
+  /**
+   * Internal: handle ACTIVE_ACCOUNT_CHANGED.
+   * @param {string} auth
+   */
+  #onChangeAccount(auth) {
+    const proof = Serializer.decode({ data: Base64u.decode(auth), type: IdentityProof });
+    this.permissionLevel = proof.signer;
+
+    const session = loadSession();
+    if (session) {
+      // ✅ FIX: property is peerID (case-sensitive)
+      saveSession({
+        peerID: session.peerID,
+        permission: proof.signer.toString(),
+        expiration: proof.expiration,
+        auth,
+      });
+    }
+
+    if (this.#accountChangeListener) this.#accountChangeListener(proof.signer);
+  }
+
+  #startPing() {
+    if (this.#pingTimer) return;
+
+    const loop = () => {
+      if (!this.isOpen()) return;
+
+      const jitter = Math.floor(Math.random() * PING_JITTER_MS);
+      this.#pingTimer = setTimer(() => {
+        this.#ping().catch(() => {});
+        loop();
+      }, PING_MS + jitter);
+    };
+
+    loop();
+  }
+
+  #stopPing() {
+    if (this.#pingTimer != null) {
+      clearTimer(this.#pingTimer);
+      this.#pingTimer = null;
+    }
+  }
+
+  async #ping() {
+    if (!this.isOpen()) return;
+    try {
+      this.#connection.send({ method: "ping", id: uuid(), params: { time: Date.now() } });
+    } catch {
+      // best-effort only
+    }
+  }
+
+  /**
+   * Core request helper with timeout + reply mapping.
+   * @template T
+   * @param {string} method
+   * @param {any} params
+   * @param {number=} timeoutMs
+   * @param {(reply:any)=>T} mapper
+   * @returns {Promise<T>}
+   */
+  #request(method, params, timeoutMs, mapper) {
+    if (!this.isOpen()) return Promise.reject(new Error("Wallet connection is not open."));
+
+    const id = uuid();
+    const ms = normalizeTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS);
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimer(() => {
+        this.#pending.delete(id);
+        reject(new Error(`${method} timed out.`));
+      }, ms);
+
+      this.#pending.set(id, {
+        timeout,
+        resolve: (reply) => {
+          try {
+            const out = mapper(reply);
+            clearTimer(timeout);
+            this.#pending.delete(id);
+            resolve(out);
+          } catch (e) {
+            clearTimer(timeout);
+            this.#pending.delete(id);
+            reject(e);
+          }
+        },
+        reject: (e) => {
+          clearTimer(timeout);
+          this.#pending.delete(id);
+          reject(e);
+        },
+      });
+
+      try {
+        this.#connection.send({ method, id, params });
+      } catch (e) {
+        clearTimer(timeout);
+        this.#pending.delete(id);
+        reject(e);
+      }
+    });
+  }
+
+  /**
+   * Handle incoming messages from wallet.
+   * @param {any} data
+   */
+  #onDataReceived(data) {
+    if (!data || typeof data !== "object") return;
+
+    // Reply to pending request
+    if (data.id && this.#pending.has(data.id)) {
+      const p = this.#pending.get(data.id);
+      try {
+        p.resolve(data);
+      } catch (e) {
+        p.reject(e);
+      }
+      return;
+    }
+
+    // Wallet push notifications
+    if (data.code === "ACTIVE_ACCOUNT_CHANGED" && data?.result?.auth) {
+      this.#onChangeAccount(data.result.auth);
+    }
+  }
+}

package/src/WindConnector.js

@@ -0,0 +1,294 @@
+// windkit/WindConnector.js
+// Ultra Clean++ (single replace)
+// ✅ PeerID embedded into VSR (infoKey "pi")
+// ✅ connect() reuses stored peerID (stable pairing)
+// ✅ LOGIN_OK → decode IdentityProof → yield WalletSession
+// ✅ low-end friendly: minimal work, no polling loops
+
+import { Base64u, IdentityProof, SigningRequest } from "@wharfkit/signing-request";
+import { Serializer } from "@wharfkit/antelope";
+import Peer from "peerjs";
+import zlib from "pako";
+
+import { WalletSession } from "./WalletSession.js";
+import { loadSession, saveSession, clearSession } from "./StoreSession.js";
+
+function uuid() {
+  try {
+    if (globalThis?.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+  } catch {}
+  return `id-${Math.random().toString(16).slice(2)}-${Date.now().toString(16)}`;
+}
+
+function originSafe() {
+  try {
+    return globalThis?.location?.origin || "";
+  } catch {
+    return "";
+  }
+}
+
+function defaultPeerConfig() {
+  return {
+    iceServers: [
+      { urls: "stun:stun.l.google.com:19302" },
+      { urls: "stun:stun1.l.google.com:3478" },
+      { urls: "stun:stun.relay.metered.ca:80" },
+      {
+        urls: "turn:asia.relay.metered.ca:80",
+        username: "b66cd40a117bddb5cde924ab",
+        credential: "4jRmuTehVCZ2a/S+",
+      },
+    ],
+    sdpSemantics: "unified-plan",
+  };
+}
+
+function mergePeerOptions(userOptions) {
+  const opts = userOptions ? { ...userOptions } : {};
+  const base = defaultPeerConfig();
+
+  // Keep base config but allow user overrides
+  if (!opts.config) {
+    opts.config = base;
+    return opts;
+  }
+
+  const userCfg = { ...opts.config };
+  const userIce = Array.isArray(userCfg.iceServers) ? userCfg.iceServers : null;
+
+  opts.config = {
+    ...base,
+    ...userCfg,
+    iceServers: userIce ? [...base.iceServers, ...userIce] : base.iceServers,
+  };
+
+  return opts;
+}
+
+/**
+ * WindConnector (DApp-side)
+ * - Owns PeerJS instance (DApp is server peer)
+ * - Creates VSR identity login request
+ * - Waits for wallet connection + LOGIN_OK, then yields WalletSession
+ */
+export class WindConnector {
+  /** @type {Peer | null} */
+  #peer = null;
+
+  /** @type {import("peerjs").PeerJSOption} */
+  #peerOptions;
+
+  /** @type {string | null} */
+  #peerId = null;
+
+  /** @type {Map<string, Function>} */
+  #listeners = new Map();
+
+  /** @type {any} */
+  #identityArgs;
+
+  /**
+   * @param {import("peerjs").PeerJSOption=} options Optional PeerJS options.
+   */
+  constructor(options) {
+    this.#peerOptions = mergePeerOptions(options);
+
+    this.#identityArgs = {
+      scope: "vexanium",
+      chainId: WalletSession.ChainID,
+      callback: originSafe(),
+    };
+  }
+
+  /**
+   * Add extra STUN/TURN server.
+   * @param {RTCIceServer} server
+   */
+  addIceServer(server) {
+    if (!this.#peerOptions.config) this.#peerOptions.config = { iceServers: [] };
+    if (!Array.isArray(this.#peerOptions.config.iceServers)) this.#peerOptions.config.iceServers = [];
+    this.#peerOptions.config.iceServers.push(server);
+  }
+
+  /**
+   * Set PeerJS signaling server (optional).
+   * @param {string} host
+   * @param {number=} port
+   * @param {string=} path
+   * @param {boolean=} secure
+   */
+  setServer(host, port, path, secure) {
+    this.#peerOptions.host = host;
+    if (typeof port === "number") this.#peerOptions.port = port;
+    if (typeof path === "string") this.#peerOptions.path = path;
+    if (typeof secure === "boolean") this.#peerOptions.secure = secure;
+  }
+
+  /**
+   * Subscribe to events.
+   * Supported: "open", "close", "disconnected", "error", "connection", "session"
+   * @param {string} event
+   * @param {Function} func
+   */
+  on(event, func) {
+    this.#listeners.set(String(event || ""), func);
+  }
+
+  /**
+   * Unsubscribe.
+   * @param {string} event
+   */
+  off(event) {
+    this.#listeners.delete(String(event || ""));
+  }
+
+  /**
+   * Connect to signaling server. Resolves when Peer is "open".
+   * @returns {Promise<string>} peerId
+   */
+  async connect() {
+    if (this.#peer && !this.#peer.destroyed) return this.#peer.id;
+
+    const stored = loadSession();
+    this.#peerId = stored?.peerID || this.#peerId || `VEX-${uuid()}`;
+
+    const peer = new Peer(this.#peerId, this.#peerOptions);
+    this.#peer = peer;
+
+    peer.on("connection", (conn) => this.#onConnection(conn));
+
+    // Bridge PeerJS events to our listeners (except "session" which is internal)
+    for (const [key, fn] of this.#listeners.entries()) {
+      if (key === "session") continue;
+      try {
+        peer.on(key, fn);
+      } catch {}
+    }
+
+    return await new Promise((resolve, reject) => {
+      const onOpen = (id) => {
+        try {
+          peer.off("error", onError);
+        } catch {}
+        resolve(id);
+      };
+      const onError = (err) => {
+        try {
+          peer.off("open", onOpen);
+        } catch {}
+        reject(err);
+      };
+      peer.once("open", onOpen);
+      peer.once("error", onError);
+    });
+  }
+
+  disconnect() {
+    try {
+      this.#peer?.disconnect();
+    } catch {}
+  }
+
+  destroy() {
+    try {
+      this.#peer?.destroy();
+    } catch {}
+    this.#peer = null;
+  }
+
+  reconnect() {
+    try {
+      this.#peer?.reconnect();
+    } catch {}
+  }
+
+  isDisconnected() {
+    return this.#peer ? this.#peer.disconnected : true;
+  }
+
+  isDestroyed() {
+    return this.#peer ? this.#peer.destroyed : true;
+  }
+
+  /**
+   * Create VSR identity request for login.
+   * Put this string into:
+   *  - QR payload, or
+   *  - wallet login URL query (?vsr=...)
+   *
+   * @param {string} name App name
+   * @param {string=} icon App icon URL
+   * @returns {string} "vsr:...."
+   */
+  createLoginRequest(name, icon) {
+    const session = loadSession();
+
+    if (session) {
+      // reuse peer id + identity hints
+      this.#peerId = session.peerID;
+
+      const [actor, perm] = String(session.permission).split("@");
+      this.#identityArgs.account = actor;
+      this.#identityArgs.permission = perm;
+    } else {
+      clearSession();
+      this.#peerId = `VEX-${uuid()}`;
+      delete this.#identityArgs.account;
+      delete this.#identityArgs.permission;
+    }
+
+    const req = SigningRequest.identity(this.#identityArgs, { zlib });
+
+    // Compact app info keys
+    req.setInfoKey("pi", this.#peerId); // peer id
+    req.setInfoKey("na", String(name || "")); // app name
+    if (icon) req.setInfoKey("ic", String(icon)); // icon
+    req.setInfoKey("do", originSafe()); // dapp origin
+
+    // If a stored auth proof exists, pass it (wallet may optimize)
+    if (session?.auth) req.setInfoKey("auth", session.auth);
+
+    return req.encode(true, false, "vsr:");
+  }
+
+  /**
+   * @param {import("peerjs").DataConnection} conn
+   */
+  #onConnection(conn) {
+    const onConn = this.#listeners.get("connection");
+    if (onConn) onConn(conn);
+
+    // Expect LOGIN_OK first (one-shot)
+    conn.once("data", (payload) => {
+      if (!payload || typeof payload !== "object") return;
+      if (payload.code !== "LOGIN_OK") return;
+
+      try {
+        const auth = payload?.result?.auth;
+        if (!auth || typeof auth !== "string") return;
+
+        const proof = Serializer.decode({
+          data: Base64u.decode(auth),
+          type: IdentityProof,
+        });
+
+        const session = new WalletSession(conn);
+        session.permissionLevel = proof.signer;
+
+        saveSession({
+          peerID: this.#peerId || conn.peer,
+          permission: proof.signer.toString(),
+          expiration: proof.expiration,
+          auth,
+        });
+
+        const onSession = this.#listeners.get("session");
+        if (onSession) onSession(session, proof);
+      } catch (e) {
+        const onError = this.#listeners.get("error");
+        if (onError) onError(e);
+      }
+    });
+  }
+}