walletkit-web 0.22.0 → 0.22.1

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { InitializeOptions, RecoveryData, RegistrationStatus } from "./protocol";
+export type { InitializeOptions, RecoveryData, RegistrationStatus, } from "./protocol";
+export interface WalletKit {
+    recoveryDataFromSeed(seed: Uint8Array): Promise<RecoveryData>;
+    register(seed: Uint8Array): Promise<void>;
+    pollRegistration(): Promise<RegistrationStatus>;
+    initializeAuthenticator(seed: Uint8Array, now?: bigint): Promise<void>;
+    prepareCredential(issuerSchemaId: bigint): Promise<{
+        blindingFactor: string;
+        sub: string;
+    }>;
+    storeCredential(credential: Uint8Array, blindingFactor: string, now?: bigint): Promise<{
+        credentialId: bigint;
+        issuerSchemaId: bigint;
+    }>;
+    generateProof(requestJson: string, now?: bigint): Promise<string>;
+    close(): Promise<void>;
+    terminate(): void;
+}
+/** Loads WASM and persistent OPFS storage in a package-managed dedicated worker. */
+export declare function initializeWalletKit(options: InitializeOptions): Promise<WalletKit>;

package/dist/index.js

@@ -0,0 +1,134 @@
+// src/index.ts
+var WalletKitClient = class {
+  /** @internal Use initializeWalletKit(). */
+  constructor(worker) {
+    this.worker = worker;
+    worker.onmessage = ({ data }) => this.handleResponse(data);
+    worker.onerror = (event) => this.stop(new Error(event.message || "WalletKit worker failed"));
+    worker.onmessageerror = () => this.stop(new Error("WalletKit worker message could not be decoded"));
+  }
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  stopped = false;
+  closing;
+  /**
+   * Sends a typed RPC request to the worker and returns a promise that is
+   * settled by the response with the matching request ID. Rejects immediately
+   * if the client is closing or closed.
+   *
+   * @internal Public methods provide the consumer-facing API.
+   */
+  call(method, ...args) {
+    if (this.stopped || this.closing && method !== "close")
+      return Promise.reject(new Error("WalletKit is closed"));
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, {
+        resolve,
+        reject
+      });
+      try {
+        this.worker.postMessage({ id, method, args });
+      } catch (error) {
+        this.pending.delete(id);
+        reject(error);
+      }
+    });
+  }
+  recoveryDataFromSeed(seed) {
+    return this.call("recoveryDataFromSeed", seed);
+  }
+  register(seed) {
+    return this.call("register", seed);
+  }
+  pollRegistration() {
+    return this.call("pollRegistration");
+  }
+  initializeAuthenticator(seed, now = BigInt(Math.floor(Date.now() / 1e3))) {
+    return this.call("initializeAuthenticator", seed, now);
+  }
+  prepareCredential(issuerSchemaId) {
+    return this.call("prepareCredential", issuerSchemaId);
+  }
+  storeCredential(credential, blindingFactor, now = BigInt(Math.floor(Date.now() / 1e3))) {
+    return this.call("storeCredential", credential, blindingFactor, now);
+  }
+  generateProof(requestJson, now = BigInt(Math.floor(Date.now() / 1e3))) {
+    return this.call("generateProof", requestJson, now);
+  }
+  /** Finishes queued work, releases Rust objects, then terminates the worker. */
+  close() {
+    if (this.stopped) return Promise.resolve();
+    return this.closing ??= this.call("close").finally(
+      () => this.stop(new Error("WalletKit is closed"))
+    );
+  }
+  /** Immediately stops the worker and rejects pending calls. */
+  terminate() {
+    this.stop(new Error("WalletKit was terminated"));
+  }
+  handleResponse(response) {
+    const pending = this.pending.get(response.id);
+    if (!pending) return;
+    this.pending.delete(response.id);
+    if (response.ok) pending.resolve(response.result);
+    else {
+      const error = new Error(response.error.message);
+      error.name = response.error.name;
+      pending.reject(error);
+    }
+  }
+  stop(error) {
+    this.stopped = true;
+    this.worker.terminate();
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+};
+async function initializeWalletKit(options) {
+  if (options.databaseKey.byteLength !== 32) {
+    throw new Error("Expected a 32-byte database key");
+  }
+  const storageId = options.storageId ?? "default";
+  if (!/^[a-zA-Z0-9_-]{1,128}$/.test(storageId)) {
+    throw new Error(
+      "Invalid storageId: use 1\u2013128 letters, digits, underscores or hyphens"
+    );
+  }
+  options.signal?.throwIfAborted();
+  const worker = options.workerUrl ? new Worker(new URL(options.workerUrl, globalThis.location.href), {
+    type: "module"
+  }) : new Worker(new URL("./walletkit.worker.js", import.meta.url), {
+    type: "module"
+  });
+  const client = new WalletKitClient(worker);
+  const abort = () => client.terminate();
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const databaseKey = new Uint8Array(options.databaseKey);
+  try {
+    const wasmUrl = options.wasmUrl ? new URL(options.wasmUrl, globalThis.location.href).href : new URL(
+      new URL("./generated/walletkit.wasm", import.meta.url).href,
+      globalThis.location.href
+    ).href;
+    const workerOptions = {
+      databaseKey,
+      storageId,
+      environment: options.environment ?? "production",
+      region: options.region ?? "eu",
+      rpcUrl: options.rpcUrl,
+      wasmUrl
+    };
+    await client.call("initialize", workerOptions);
+    return client;
+  } catch (error) {
+    client.terminate();
+    throw error;
+  } finally {
+    databaseKey.fill(0);
+    options.signal?.removeEventListener("abort", abort);
+  }
+}
+export {
+  initializeWalletKit
+};
+export {};

package/dist/protocol.d.ts

@@ -0,0 +1,94 @@
+/** Values crossing the worker boundary are plain structured-clone data. */
+export interface RecoveryData {
+    authenticatorAddress: string;
+    authenticatorPubkey: string;
+    offchainSignerCommitment: string;
+}
+export type RegistrationStatus = {
+    state: "queued" | "batching" | "submitted" | "finalized";
+} | {
+    state: "failed";
+    error: string;
+    errorCode?: string;
+};
+export interface InitializeOptions {
+    /** 32-byte database encryption key. Supply the same databaseKey when reopening storage. */
+    databaseKey: Uint8Array;
+    /** Stable storage namespace, unique per consumer/account. Default: "default". */
+    storageId?: string;
+    environment?: "production" | "staging";
+    region?: "eu" | "us" | "ap";
+    rpcUrl?: string;
+    workerUrl?: string | URL;
+    wasmUrl?: string | URL;
+    /** Abort initialization and release the worker (for example on unmount). */
+    signal?: AbortSignal;
+}
+export type WorkerOptions = Required<Pick<InitializeOptions, "storageId" | "environment" | "region">> & Pick<InitializeOptions, "rpcUrl"> & {
+    databaseKey: Uint8Array;
+    wasmUrl: string;
+};
+export interface Operations {
+    initialize: {
+        args: [WorkerOptions];
+        result: void;
+    };
+    recoveryDataFromSeed: {
+        args: [Uint8Array];
+        result: RecoveryData;
+    };
+    register: {
+        args: [Uint8Array];
+        result: void;
+    };
+    pollRegistration: {
+        args: [];
+        result: RegistrationStatus;
+    };
+    initializeAuthenticator: {
+        args: [Uint8Array, bigint];
+        result: void;
+    };
+    prepareCredential: {
+        args: [bigint];
+        result: {
+            blindingFactor: string;
+            sub: string;
+        };
+    };
+    storeCredential: {
+        args: [Uint8Array, string, bigint];
+        result: {
+            credentialId: bigint;
+            issuerSchemaId: bigint;
+        };
+    };
+    generateProof: {
+        args: [string, bigint];
+        result: string;
+    };
+    close: {
+        args: [];
+        result: void;
+    };
+}
+export type Method = keyof Operations;
+export type Request = {
+    [M in Method]: {
+        id: number;
+        method: M;
+        args: Operations[M]["args"];
+    };
+}[Method];
+export type Response = {
+    id: number;
+} & ({
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: {
+        name: string;
+        message: string;
+    };
+});

package/dist/walletkit.worker.d.ts

@@ -0,0 +1 @@
+export {};