@waaskey/sdk 0.2.1 → 0.3.1

package/dist/node-mpc-worker.d.ts

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

package/dist/node-mpc-worker.js

@@ -0,0 +1,142 @@
+import { readFile } from 'fs/promises';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { parentPort, workerData } from 'worker_threads';
+
+// src/mpc/node/worker.ts
+if (!parentPort) {
+  throw new Error("waaskey mpc worker must be spawned as a worker_threads Worker");
+}
+var port = parentPort;
+function post(message) {
+  port.postMessage(message);
+}
+var CEREMONY_EXPORTS = ["keygen", "sign", "pregeneratePrimes", "reshareAssemble", "completeReshare", "keygenMember", "signMember", "keygenEddsa", "signEddsa"];
+var nextWsId = 1;
+var sockets = /* @__PURE__ */ new Map();
+var BridgedWebSocket = class _BridgedWebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  url;
+  readyState = _BridgedWebSocket.CONNECTING;
+  binaryType = "blob";
+  protocol = "";
+  onopen = null;
+  onmessage = null;
+  onclose = null;
+  onerror = null;
+  wsId;
+  listeners = /* @__PURE__ */ new Map();
+  constructor(url, protocols) {
+    this.url = String(url);
+    this.wsId = nextWsId++;
+    sockets.set(this.wsId, this);
+    const list = protocols === void 0 ? [] : Array.isArray(protocols) ? protocols : [protocols];
+    post({ type: "ws-open", wsId: this.wsId, url: this.url, protocols: list });
+  }
+  send(data) {
+    if (typeof data === "string") {
+      post({ type: "ws-send", wsId: this.wsId, data });
+      return;
+    }
+    const bytes = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)) : new Uint8Array(data.slice(0));
+    post({ type: "ws-send", wsId: this.wsId, data: bytes });
+  }
+  close(code, reason) {
+    if (this.readyState === _BridgedWebSocket.CLOSING || this.readyState === _BridgedWebSocket.CLOSED) return;
+    this.readyState = _BridgedWebSocket.CLOSING;
+    post({ type: "ws-close", wsId: this.wsId, code, reason });
+  }
+  addEventListener(type, listener) {
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(listener);
+  }
+  removeEventListener(type, listener) {
+    this.listeners.get(type)?.delete(listener);
+  }
+  deliver(event) {
+    if (event.event === "open") {
+      this.readyState = _BridgedWebSocket.OPEN;
+      this.protocol = event.protocol;
+      this.dispatch("open", { type: "open", target: this });
+      return;
+    }
+    if (event.event === "message") {
+      const data = event.data instanceof Uint8Array ? toArrayBuffer(event.data) : event.data;
+      this.dispatch("message", { type: "message", data, target: this });
+      return;
+    }
+    if (event.event === "close") {
+      this.readyState = _BridgedWebSocket.CLOSED;
+      sockets.delete(this.wsId);
+      this.dispatch("close", { type: "close", code: event.code, reason: event.reason, wasClean: event.wasClean, target: this });
+      return;
+    }
+    this.dispatch("error", { type: "error", message: event.message, target: this });
+  }
+  dispatch(type, event) {
+    const handler = this[`on${type}`];
+    if (typeof handler === "function") handler.call(this, event);
+    for (const listener of this.listeners.get(type) ?? []) listener.call(this, event);
+  }
+};
+function toArrayBuffer(bytes) {
+  if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength && bytes.buffer instanceof ArrayBuffer) {
+    return bytes.buffer;
+  }
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+globalThis.WebSocket = BridgedWebSocket;
+function resolveAsset(spec) {
+  for (const base of [import.meta.url, pathToFileURL(`${process.cwd()}/`).href]) {
+    try {
+      return createRequire(base).resolve(spec);
+    } catch {
+    }
+  }
+  return void 0;
+}
+var { wasmPackage } = workerData;
+var moduleExports;
+try {
+  const mod = await import(wasmPackage);
+  if (typeof mod.default === "function") {
+    const wasmPath = resolveAsset(`${wasmPackage}/client_wasm_bg.wasm`);
+    if (!wasmPath) {
+      throw new Error(`cannot resolve ${wasmPackage}/client_wasm_bg.wasm \u2014 is ${wasmPackage} installed?`);
+    }
+    await mod.default({ module_or_path: await WebAssembly.compile(await readFile(wasmPath)) });
+  }
+  moduleExports = mod;
+  post({ type: "ready", exports: CEREMONY_EXPORTS.filter((name) => typeof mod[name] === "function") });
+} catch (err) {
+  post({ type: "fatal", error: err instanceof Error ? err.message : String(err) });
+  throw err;
+}
+port.on("message", (message) => {
+  if (message.type === "ws-event") {
+    sockets.get(message.wsId)?.deliver(message);
+    return;
+  }
+  const { id, method, paramsJson } = message;
+  void (async () => {
+    try {
+      const fn = moduleExports[method];
+      if (typeof fn !== "function") {
+        throw new Error(`client-wasm does not expose ${method}`);
+      }
+      const result = await fn(paramsJson);
+      post({ type: "call-result", id, ok: true, resultJson: JSON.stringify(result) });
+    } catch (err) {
+      post({ type: "call-result", id, ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  })();
+});
+//# sourceMappingURL=node-mpc-worker.js.map
+//# sourceMappingURL=node-mpc-worker.js.map

package/dist/node-mpc-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mpc/node/worker.ts"],"names":[],"mappings":"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","file":"node-mpc-worker.js","sourcesContent":["/**\n * The Node MPC worker (waas-sdk#82): loads the client-wasm module OFF the main thread so\n * the zk-proof computation (minutes of single-threaded WASM during `aux_info_gen`) cannot\n * starve the relay WebSocket. The wasm still believes it owns a `WebSocket` — this file\n * installs a bridged shim whose frames are forwarded over the thread boundary to the real\n * socket on the main thread (see `worker-core.ts`), which stays responsive and pings.\n *\n * Runs as a `worker_threads` ESM worker; `workerData.wasmPackage` names the wasm package\n * (or a file URL to a module with the same export shape, used by tests).\n */\nimport { readFile } from 'node:fs/promises';\nimport { createRequire } from 'node:module';\nimport { pathToFileURL } from 'node:url';\nimport { parentPort, workerData } from 'node:worker_threads';\n\nimport type { MainToWorker, WorkerToMain, WsEvent } from './bridge-protocol';\n\nif (!parentPort) {\n  throw new Error('waaskey mpc worker must be spawned as a worker_threads Worker');\n}\nconst port = parentPort;\n\nfunction post(message: WorkerToMain): void {\n  port.postMessage(message);\n}\n\n/** The `ClientWasmModule` surface worth reporting to the main thread. */\nconst CEREMONY_EXPORTS = ['keygen', 'sign', 'pregeneratePrimes', 'reshareAssemble', 'completeReshare', 'keygenMember', 'signMember', 'keygenEddsa', 'signEddsa'];\n\nlet nextWsId = 1;\nconst sockets = new Map<number, BridgedWebSocket>();\n\ntype Listener = (event: unknown) => void;\n\n/**\n * The `WebSocket` shim the wasm drives (via `ws_stream_wasm` / web_sys): same surface as\n * the DOM API — `on*` properties + `addEventListener`, `binaryType`, `readyState`,\n * `send`, `close` — but every frame crosses the thread boundary instead of a network\n * stack. Events queue on this worker's loop while the wasm computes and are delivered\n * when it yields, exactly as they would on a blocked single-thread setup; the difference\n * is the REAL socket on the main thread never stops reading or answering pings.\n */\nclass BridgedWebSocket {\n  static readonly CONNECTING = 0;\n  static readonly OPEN = 1;\n  static readonly CLOSING = 2;\n  static readonly CLOSED = 3;\n\n  readonly url: string;\n  readyState = BridgedWebSocket.CONNECTING;\n  binaryType = 'blob';\n  protocol = '';\n  onopen: Listener | null = null;\n  onmessage: Listener | null = null;\n  onclose: Listener | null = null;\n  onerror: Listener | null = null;\n\n  private readonly wsId: number;\n  private readonly listeners = new Map<string, Set<Listener>>();\n\n  constructor(url: string | URL, protocols?: string | string[]) {\n    this.url = String(url);\n    this.wsId = nextWsId++;\n    sockets.set(this.wsId, this);\n    const list = protocols === undefined ? [] : Array.isArray(protocols) ? protocols : [protocols];\n    post({ type: 'ws-open', wsId: this.wsId, url: this.url, protocols: list });\n  }\n\n  send(data: string | ArrayBuffer | ArrayBufferView): void {\n    if (typeof data === 'string') {\n      post({ type: 'ws-send', wsId: this.wsId, data });\n      return;\n    }\n    const bytes = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer) : new Uint8Array(data.slice(0));\n    post({ type: 'ws-send', wsId: this.wsId, data: bytes });\n  }\n\n  close(code?: number, reason?: string): void {\n    if (this.readyState === BridgedWebSocket.CLOSING || this.readyState === BridgedWebSocket.CLOSED) return;\n    this.readyState = BridgedWebSocket.CLOSING;\n    post({ type: 'ws-close', wsId: this.wsId, code, reason });\n  }\n\n  addEventListener(type: string, listener: Listener): void {\n    let set = this.listeners.get(type);\n    if (!set) {\n      set = new Set();\n      this.listeners.set(type, set);\n    }\n    set.add(listener);\n  }\n\n  removeEventListener(type: string, listener: Listener): void {\n    this.listeners.get(type)?.delete(listener);\n  }\n\n  deliver(event: WsEvent): void {\n    if (event.event === 'open') {\n      this.readyState = BridgedWebSocket.OPEN;\n      this.protocol = event.protocol;\n      this.dispatch('open', { type: 'open', target: this });\n      return;\n    }\n    if (event.event === 'message') {\n      // Binary frames always surface as ArrayBuffer (there is no DOM Blob here; the wasm\n      // sets binaryType='arraybuffer' anyway).\n      const data: unknown = event.data instanceof Uint8Array ? toArrayBuffer(event.data) : event.data;\n      this.dispatch('message', { type: 'message', data, target: this });\n      return;\n    }\n    if (event.event === 'close') {\n      this.readyState = BridgedWebSocket.CLOSED;\n      sockets.delete(this.wsId);\n      this.dispatch('close', { type: 'close', code: event.code, reason: event.reason, wasClean: event.wasClean, target: this });\n      return;\n    }\n    this.dispatch('error', { type: 'error', message: event.message, target: this });\n  }\n\n  private dispatch(type: 'open' | 'message' | 'close' | 'error', event: unknown): void {\n    const handler = this[`on${type}`];\n    if (typeof handler === 'function') handler.call(this, event);\n    for (const listener of this.listeners.get(type) ?? []) listener.call(this, event);\n  }\n}\n\n/** Re-view a (structured-clone-owned) Uint8Array as a standalone ArrayBuffer. */\nfunction toArrayBuffer(bytes: Uint8Array): ArrayBuffer {\n  if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength && bytes.buffer instanceof ArrayBuffer) {\n    return bytes.buffer;\n  }\n  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;\n}\n\n// The wasm (and any test fixture) resolves `WebSocket` from the global scope — install\n// the shim BEFORE the module loads so every ceremony socket is bridged.\n(globalThis as Record<string, unknown>).WebSocket = BridgedWebSocket;\n\n/** Resolve a package subpath from this worker's location, falling back to the app cwd. */\nfunction resolveAsset(spec: string): string | undefined {\n  for (const base of [import.meta.url, pathToFileURL(`${process.cwd()}/`).href]) {\n    try {\n      return createRequire(base).resolve(spec);\n    } catch {\n      // try the next base\n    }\n  }\n  return undefined;\n}\n\ntype WasmExport = (paramsJson: string) => unknown;\n\nconst { wasmPackage } = workerData as { wasmPackage: string };\n\nlet moduleExports: Record<string, WasmExport>;\ntry {\n  const mod = (await import(wasmPackage)) as Record<string, unknown>;\n  // wasm-pack `--target web` modules need explicit init with the engine bytes (Node's\n  // fetch cannot read file paths). Test fixtures are plain JS modules without a default init.\n  if (typeof mod.default === 'function') {\n    const wasmPath = resolveAsset(`${wasmPackage}/client_wasm_bg.wasm`);\n    if (!wasmPath) {\n      throw new Error(`cannot resolve ${wasmPackage}/client_wasm_bg.wasm — is ${wasmPackage} installed?`);\n    }\n    await (mod.default as (init: unknown) => Promise<unknown>)({ module_or_path: await WebAssembly.compile(await readFile(wasmPath)) });\n  }\n  moduleExports = mod as Record<string, WasmExport>;\n  post({ type: 'ready', exports: CEREMONY_EXPORTS.filter((name) => typeof mod[name] === 'function') });\n} catch (err) {\n  post({ type: 'fatal', error: err instanceof Error ? err.message : String(err) });\n  throw err;\n}\n\nport.on('message', (message: MainToWorker) => {\n  if (message.type === 'ws-event') {\n    sockets.get(message.wsId)?.deliver(message);\n    return;\n  }\n  const { id, method, paramsJson } = message;\n  void (async () => {\n    try {\n      const fn = moduleExports[method];\n      if (typeof fn !== 'function') {\n        throw new Error(`client-wasm does not expose ${method}`);\n      }\n      const result = await fn(paramsJson);\n      post({ type: 'call-result', id, ok: true, resultJson: JSON.stringify(result) });\n    } catch (err) {\n      post({ type: 'call-result', id, ok: false, error: err instanceof Error ? err.message : String(err) });\n    }\n  })();\n});\n"]}

package/dist/node.d.ts

@@ -0,0 +1,426 @@
+/**
+ * Device-party MPC contract.
+ *
+ * Waaskey wallets are 2-of-3: the user's **device** holds one key share and runs
+ * its half of the cggmp24 ceremony locally (in WASM), talking to the Waaskey
+ * `signer` (the server party) over the relay. The private key never exists whole
+ * anywhere. This is the device side of that ceremony.
+ *
+ * The wire shapes mirror the waas-core `client-wasm` exports (`keygen` / `sign`),
+ * which mirror the server `party-runner`. The backend tells the SDK the per-party
+ * routing (relay url, session id, indices, roles) in the create-wallet response.
+ */
+/** Curves the device party can run a ceremony on. */
+type MpcCurve = 'secp256k1';
+/** Relay routing + party identity shared by keygen and sign. */
+interface CeremonyParams {
+    curve: MpcCurve;
+    /** Relay websocket URL both parties connect to. */
+    relayUrl: string;
+    /** Ceremony id shared by all parties; derives the execution ids. */
+    sessionId: string;
+    /** This party's relay routing id. Defaults to `"device"`. */
+    role?: string;
+    /** The peer (server) party's relay routing id. Defaults to `"server"`. */
+    peerRole?: string;
+    /** This party's keygen index. */
+    partyIndex: number;
+    /** The peer (server) party's keygen index. */
+    peerPartyIndex: number;
+    /**
+     * Short-lived relay token (JWT) the device presents to the relay to join this session as
+     * `role`. Returned by the backend on the ceremony / sign-session response; present only when
+     * relay authentication is enabled. Absent ⇒ the relay accepts an unauthenticated join.
+     */
+    relayToken?: string;
+}
+/** Parameters for the device half of a keygen ceremony. */
+interface DeviceKeygenParams extends CeremonyParams {
+    /** Total parties `n`. */
+    parties: number;
+    /** Signing threshold `t` (`2 <= t <= n`). */
+    threshold: number;
+    /**
+     * Pre-generated Paillier safe-primes (JSON) for this device, produced ahead of time off the
+     * hot path (see {@link MpcCore.pregeneratePrimes} / `PrimePool`). When omitted the core
+     * generates them inline — correct, but slow in single-threaded browser WASM. The primes are
+     * this device's private aux material and are NEVER sent to the server.
+     */
+    pregeneratedPrimes?: string;
+    /**
+     * The FULL party roster (`roles[i]` = relay role of protocol index `i`), when the backend
+     * provides it (waas-core#131). Required to route a `parties > 2` ceremony — the plain 2-party
+     * transport cannot attribute messages from more than one peer.
+     */
+    roles?: string[];
+}
+/** Result of the device half of keygen — the device's share never leaves the device. */
+interface DeviceKeygenResult {
+    /** The device's KeyShare (JSON). Seal + store on the device; never send to the server. */
+    keyShare: string;
+    /** The ceremony's aux info (JSON). */
+    auxInfo: string;
+    /** The wallet's shared public key (hex), derived from the share — safe to publish. */
+    sharedPublicKey: string;
+}
+/** Parameters for the device half of a sign ceremony. */
+interface DeviceSignParams extends CeremonyParams {
+    /**
+     * The device's KeyShare as its JSON **string** — the bare crypto material from a prior keygen
+     * ({@link DeviceKeygenResult.keyShare}), NOT the on-device storage blob. It rides the sign wire as
+     * a parsed JSON OBJECT (the wasm deserializes it with `serde_json::from_value::<KeyShare>`).
+     */
+    share: string;
+    /** Keygen indices signing together (any `t` of `n`). */
+    participants: number[];
+    /** This party's 0-based position within `participants`. */
+    signerPosition: number;
+    /** 32-byte hex digest to sign (`0x` prefix optional). */
+    digest: string;
+}
+/** Result of the device half of sign. */
+interface DeviceSignResult {
+    /** The cggmp24 signature (JSON). */
+    signature: string;
+}
+/**
+ * Parameters for the device's reshare **assemble** stage ({@link MpcCore.runReshareAssemble}).
+ * A structural mirror of the backend `DeviceReshareMaterial` plus the wallet's curve — pure
+ * and local, so no relay routing is needed. The fields are opaque JSON produced by the backend
+ * reshare; the device only routes them into the core.
+ */
+interface DeviceReshareAssembleParams {
+    curve: MpcCurve;
+    /** This device's 0-based slot within {@link newPreimages}. */
+    newPosition: number;
+    /** New share preimages `I'` (32-byte big-endian hex scalars), new-holder order. */
+    newPreimages: string[];
+    /** The new signing threshold `t'`. */
+    newThreshold: number;
+    /** The unchanged wallet public info (`WalletPublicInfo` JSON, opaque). */
+    wallet: unknown;
+    /** One Feldman-commitments object per dealer (the broadcast set), opaque JSON. */
+    commitments: unknown[];
+    /** This device's private sub-share from each dealer, one per dealer, opaque JSON. */
+    subShares: unknown[];
+}
+/**
+ * Result of the device reshare **assemble** — the bare NEW-epoch core. It cannot sign yet
+ * (aux material is generated in {@link MpcCore.runCompleteReshare}), and it is secret: seal it,
+ * never log it.
+ */
+interface DeviceReshareAssembleResult {
+    /** The device's NEW-epoch bare core (`IncompleteKeyShare` JSON). Secret. */
+    core: string;
+    /** The assembled shared public key (hex) — must equal the wallet's (unchanged across a reshare). */
+    sharedPublicKey: string;
+}
+/**
+ * Parameters for the device's **complete-reshare** stage ({@link MpcCore.runCompleteReshare}) —
+ * the interactive aux-info ceremony over the NEW committee that turns the bare core into a
+ * signable share. Relay routing mirrors keygen/sign ({@link CeremonyParams}); the backend uses
+ * `<sessionId>/reshare-aux` (kind `reshare-aux`) and drives the server + recovery parties.
+ */
+interface DeviceCompleteReshareParams extends CeremonyParams {
+    /** The device's bare NEW-epoch core (JSON) from {@link MpcCore.runReshareAssemble}. */
+    core: string;
+    /** Total parties `n'` in the NEW committee. */
+    parties: number;
+    /**
+     * This device's OWN pre-generated Paillier safe-primes (JSON) for the aux ceremony, off the hot
+     * path (see {@link MpcCore.pregeneratePrimes} / `PrimePool`). When omitted the core generates
+     * them inline. The primes are the device's private material and are NEVER server-provided — a
+     * server-supplied prime pool would collapse the threshold to custodial.
+     */
+    pregeneratedPrimes?: string;
+}
+/** Result of the device **complete-reshare** — the COMPLETE, signable share. Seal it, never log it. */
+interface DeviceCompleteReshareResult {
+    /** The device's complete KeyShare (JSON). Seal + store on the device; never send to the server. */
+    keyShare: string;
+    /** The wallet's shared public key (hex), preserved across the reshare — verify it is unchanged. */
+    sharedPublicKey: string;
+}
+/** Relay connection info shared by an n-party (member-bound) keygen/sign ceremony (#349). */
+interface MemberCeremonyParams {
+    curve: MpcCurve;
+    /** Relay websocket URL every party connects to. */
+    relayUrl: string;
+    /** Ceremony id shared by every party; derives the execution ids. */
+    sessionId: string;
+    /**
+     * Short-lived relay token (JWT) this party presents to join the session as its own role in
+     * {@link MemberKeygenParams.roles} / {@link MemberSignParams.roles}. Present only when relay
+     * authentication is enabled. Absent ⇒ the relay accepts an unauthenticated join.
+     */
+    relayToken?: string;
+}
+/** Parameters for this party's half of an n-party keygen ceremony (member-bound wallets, #349). */
+interface MemberKeygenParams extends MemberCeremonyParams {
+    /** Every party's relay role, in protocol index order — the FULL n-party roster (`roles[i]` is party `i`'s role). */
+    roles: string[];
+    /** This party's own 0-based index into {@link roles} (its keygen index). */
+    partyIndex: number;
+    /** Signing threshold `t` (`2 <= t <= roles.length`). */
+    threshold: number;
+    /**
+     * Pre-generated Paillier safe-primes (JSON) for this party, produced ahead of time off the hot
+     * path (see {@link MpcCore.pregeneratePrimes}). When omitted the core generates them inline.
+     */
+    pregeneratedPrimes?: string;
+}
+/** Parameters for this party's half of an n-party sign ceremony (member-bound wallets, #349). */
+interface MemberSignParams extends MemberCeremonyParams {
+    /** The FIXED t-of-n quorum's relay roles, in signing order (this ceremony's `PartyRouting`). */
+    roles: string[];
+    /**
+     * This party's KeyShare as its JSON **string** — the bare crypto material from a prior
+     * {@link MpcCore.runMemberKeygen} ({@link DeviceKeygenResult.keyShare}), NOT the on-device storage
+     * blob. It rides the sign wire as a parsed JSON OBJECT (`serde_json::from_value::<KeyShare>`).
+     */
+    share: string;
+    /** Keygen indices of the parties signing together, parallel to {@link roles}. */
+    participants: number[];
+    /** This party's 0-based position within {@link roles} / {@link participants}. */
+    signerPosition: number;
+    /** 32-byte hex digest to sign (`0x` prefix optional). */
+    digest: string;
+}
+/** Relay connection info shared by an ed25519 (FROST) keygen/sign ceremony (#110). */
+interface EddsaCeremonyParams {
+    /** Relay websocket URL every party connects to. */
+    relayUrl: string;
+    /** Ceremony id shared by every party; derives the FROST execution ids. */
+    sessionId: string;
+    /**
+     * Short-lived relay token (JWT) this party presents to join the session as its own role in
+     * {@link roles}. Present only when relay authentication is enabled; absent ⇒ unauthenticated join.
+     */
+    relayToken?: string;
+    /**
+     * Every party's relay role, in protocol-index order (`roles[i]` is party `i`'s role) — for keygen
+     * the FULL n-party roster; for sign the FIXED t-of-n quorum in {@link EddsaSignParams.participants}
+     * order. MUST match the platform/party-runner order (role ↔ FROST identifier).
+     */
+    roles: string[];
+    /** This party's own 0-based index into {@link roles} (its slot in the ceremony). */
+    partyIndex: number;
+}
+/** Parameters for this device's half of an ed25519 (FROST) DKG keygen ceremony (#110). */
+interface EddsaKeygenParams extends EddsaCeremonyParams {
+    /** Signing threshold `t` (`2 <= t <= roles.length`, validated by the FROST DKG). */
+    threshold: number;
+    /**
+     * The FROST DKG round-2 encryption roster (#114): one X25519 encryption PUBLIC key (32-byte hex) per
+     * party, in `roles`/protocol-index order (`encPubkeys[i]` ↔ FROST identifier `i + 1`). Every party
+     * seals its round-2 packages to these keys so no secret share crosses the relay in the clear — the
+     * device needs the whole ordered roster (chiefly the server's key). Maps to the wasm `enc_pubkeys`.
+     */
+    encPubkeys: string[];
+    /**
+     * This device's OWN X25519 encryption SECRET key (32-byte hex) — opens the round-2 packages sealed to
+     * it (the counterpart of this device's entry in {@link encPubkeys}). SECRET: never logged, never sent
+     * to the server. Maps to the wasm `enc_secret`.
+     */
+    encSecret: string;
+}
+/**
+ * Result of the device half of an ed25519 keygen — the device's FROST share. The `keyPackage` is
+ * **secret** (the device's signing share): seal + store it, never send it to the server. The
+ * `publicKeyPackage` is the wallet's group verifying key package (safe to publish). Both are opaque
+ * FROST JSON objects (the exact shapes `signEddsa` feeds back), not the cggmp24 KeyShare blob.
+ */
+interface EddsaKeygenResult {
+    /** The device's FROST `key_package` (JSON object). Secret — seal + store on the device. */
+    keyPackage: unknown;
+    /** The wallet's shared `public_key_package` (JSON object). Group key — safe to publish. */
+    publicKeyPackage: unknown;
+}
+/** Parameters for this device's half of an ed25519 (FROST) two-round sign ceremony (#110). */
+interface EddsaSignParams extends EddsaCeremonyParams {
+    /** This device's FROST `key_package` — the secret share from {@link EddsaKeygenResult.keyPackage}, as a JSON object (or its JSON string). */
+    keyPackage: unknown;
+    /** The wallet's shared `public_key_package` from {@link EddsaKeygenResult.publicKeyPackage}, as a JSON object (or its JSON string). */
+    publicKeyPackage: unknown;
+    /** The 1-based FROST identifiers of the signing quorum, parallel to {@link EddsaCeremonyParams.roles}. */
+    participants: number[];
+    /** Hex-encoded raw message bytes to sign (`0x` prefix optional) — the chain adapter's serialized tx message. */
+    message: string;
+}
+/** Result of the device half of an ed25519 sign — the RFC 8032 signature. */
+interface EddsaSignResult {
+    /** The 64-byte ed25519 signature, hex. */
+    signature: string;
+}
+/**
+ * The device-party crypto core. Implemented by {@link WasmMpcCore} (web) and, in
+ * future, a native core on mobile — the SDK depends on this port, not the engine.
+ */
+interface MpcCore {
+    runKeygen(params: DeviceKeygenParams): Promise<DeviceKeygenResult>;
+    runSign(params: DeviceSignParams): Promise<DeviceSignResult>;
+    /**
+     * Pre-generate this device's Paillier safe-primes for `curve`, off the keygen hot path
+     * (e.g. in a Web Worker during onboarding/idle). Returns opaque serialized primes (JSON) to
+     * cache and later pass as {@link DeviceKeygenParams.pregeneratedPrimes}. Optional: a native
+     * mobile core generates primes fast inline and need not implement it.
+     */
+    pregeneratePrimes?(curve: MpcCurve): Promise<string>;
+    /**
+     * Assemble this device's NEW-epoch bare core from a device-retaining reshare's material (#318).
+     * Pure and local — no relay. Optional: only a core built with the reshare capability implements
+     * it (the web wasm needs a `--features reshare` build).
+     */
+    runReshareAssemble?(params: DeviceReshareAssembleParams): Promise<DeviceReshareAssembleResult>;
+    /**
+     * Complete a reshared bare core into a signable share by running the aux-info ceremony over the
+     * NEW committee (#318 / #95). Relay-driven, mirroring keygen's aux phase. Optional: only a core
+     * built with the reshare capability implements it (the web wasm needs a `--features reshare` build).
+     */
+    runCompleteReshare?(params: DeviceCompleteReshareParams): Promise<DeviceCompleteReshareResult>;
+    /**
+     * Run this party's half of an n-party (member-bound wallet) keygen ceremony (#349) — every
+     * member device + the platform join the SAME relay session, addressed by the full
+     * {@link MemberKeygenParams.roles} roster rather than a single peer. Optional: only a core built
+     * with n-party (member-ceremony) support implements it.
+     */
+    runMemberKeygen?(params: MemberKeygenParams): Promise<DeviceKeygenResult>;
+    /**
+     * Run this party's half of an n-party (member-bound wallet) sign ceremony (#349) over the FIXED
+     * t-of-n quorum in {@link MemberSignParams.roles}. Optional: only a core built with n-party
+     * (member-ceremony) support implements it.
+     */
+    runMemberSign?(params: MemberSignParams): Promise<DeviceSignResult>;
+    /**
+     * Run this device's half of an ed25519 (FROST) DKG keygen ceremony (#110) — the device holds one
+     * FROST share in a real 2-of-3 wallet, co-generating the group key with the server (+ recovery)
+     * parties on the same relay session. Optional: only a core with the ed25519 (FROST) exports
+     * (`keygenEddsa`) implements it.
+     */
+    runEddsaKeygen?(params: EddsaKeygenParams): Promise<EddsaKeygenResult>;
+    /**
+     * Run this device's half of an ed25519 (FROST) two-round sign ceremony (#110) over the fixed
+     * quorum in {@link EddsaSignParams.roles} — co-signing the raw message with the server party.
+     * Optional: only a core with the ed25519 (FROST) exports (`signEddsa`) implements it.
+     */
+    runEddsaSign?(params: EddsaSignParams): Promise<EddsaSignResult>;
+}
+
+/** The subset of the client-wasm module the SDK drives. Each export takes one JSON string. */
+interface ClientWasmModule {
+    /** Device half of keygen; resolves with `{ aux_info_json, keyshare_json, shared_public_key_json }`. */
+    keygen(paramsJson: string): Promise<unknown>;
+    /** Device half of sign; resolves with `{ signature_json }`. */
+    sign(paramsJson: string): Promise<unknown>;
+    /** Pre-generate Paillier safe-primes off the hot path; resolves with `{ primes_json }`. Optional. */
+    pregeneratePrimes?(paramsJson: string): Promise<unknown>;
+    /**
+     * Device reshare **assemble** — compute the NEW-epoch bare core locally; returns
+     * `{ core_json, shared_public_key_json }`. Present only in a `--features reshare` wasm build.
+     * Synchronous in the core (no relay); the SDK awaits it uniformly.
+     */
+    reshareAssemble?(paramsJson: string): unknown | Promise<unknown>;
+    /**
+     * Device **complete-reshare** — run the aux ceremony over the new committee and return the
+     * signable share as `{ keyshare_json, shared_public_key_json }`. Present only in a
+     * `--features reshare` wasm build.
+     */
+    completeReshare?(paramsJson: string): Promise<unknown>;
+    /**
+     * This party's half of an n-party (member-bound wallet) keygen ceremony (#349); resolves with
+     * `{ aux_info_json, keyshare_json, shared_public_key_json }`. Present only in a client-wasm
+     * build with n-party (member-ceremony) support.
+     */
+    keygenMember?(paramsJson: string): Promise<unknown>;
+    /**
+     * This party's half of an n-party (member-bound wallet) sign ceremony over a fixed t-of-n
+     * quorum (#349); resolves with `{ signature_json }`. Present only in a client-wasm build with
+     * n-party (member-ceremony) support.
+     */
+    signMember?(paramsJson: string): Promise<unknown>;
+    /**
+     * This device's half of an ed25519 (FROST) DKG keygen ceremony (#110); resolves with
+     * `{ key_package, public_key_package }` (JSON objects). Present only in a client-wasm build with
+     * the ed25519 (FROST) exports.
+     */
+    keygenEddsa?(paramsJson: string): Promise<unknown>;
+    /**
+     * This device's half of an ed25519 (FROST) two-round sign ceremony (#110); resolves with
+     * `{ signature }` (64-byte hex). Present only in a client-wasm build with the ed25519 (FROST) exports.
+     */
+    signEddsa?(paramsJson: string): Promise<unknown>;
+}
+/** Lazily loads + initializes the client-wasm module (e.g. dynamic `import()` of the wasm-pack pkg). */
+type ClientWasmLoader = () => Promise<ClientWasmModule>;
+/**
+ * {@link MpcCore} backed by the waas-core `client-wasm` module (`keygen` / `sign`).
+ *
+ * The wasm engine is injected via a loader so the SDK stays runtime-agnostic and
+ * the core is unit-testable without a real ceremony. The device key share returned
+ * by keygen must be sealed and stored on the device — it is never sent to the server.
+ */
+declare class WasmMpcCore implements MpcCore {
+    private readonly load;
+    private modulePromise?;
+    constructor(load: ClientWasmLoader);
+    private init;
+    runKeygen(params: DeviceKeygenParams): Promise<DeviceKeygenResult>;
+    runSign(params: DeviceSignParams): Promise<DeviceSignResult>;
+    pregeneratePrimes(curve: MpcCurve): Promise<string>;
+    runReshareAssemble(params: DeviceReshareAssembleParams): Promise<DeviceReshareAssembleResult>;
+    runCompleteReshare(params: DeviceCompleteReshareParams): Promise<DeviceCompleteReshareResult>;
+    runMemberKeygen(params: MemberKeygenParams): Promise<DeviceKeygenResult>;
+    runMemberSign(params: MemberSignParams): Promise<DeviceSignResult>;
+    runEddsaKeygen(params: EddsaKeygenParams): Promise<EddsaKeygenResult>;
+    runEddsaSign(params: EddsaSignParams): Promise<EddsaSignResult>;
+    /** Build the snake_case params JSON the wasm exports expect from the common routing + extras. */
+    private encode;
+    /**
+     * Build the snake_case params JSON for an n-party (member-bound, #349) member ceremony — the
+     * roster-based routing shape (`roles` + `party_index`), not the 2-party `role`/`peer_role` shape
+     * {@link encode} builds. The `roles` roster and `party_index` are passed through in `extra` by
+     * the caller and land on the wire under those exact keys — what `keygenMember` / `signMember`
+     * deserialize.
+     */
+    private encodeMember;
+    /**
+     * Build the snake_case params JSON for an ed25519 (FROST, #110) ceremony — the roster-based routing
+     * shape (`roles` + `party_index`) the `keygenEddsa` / `signEddsa` exports deserialize. Unlike
+     * {@link encodeMember} there is NO `curve` (ed25519-only) and no Paillier primes; the caller passes
+     * the ceremony-specific extras (keygen: `threshold`; sign: the FROST packages + participants + message).
+     */
+    private encodeEddsa;
+}
+
+interface NodeWorkerMpcOptions {
+    /**
+     * The wasm engine package the worker imports (a bare specifier or file URL).
+     * Defaults to `@waaskey/client-wasm`.
+     */
+    wasmPackage?: string;
+    /**
+     * Protocol-level ping cadence on each open relay socket, keeping the connection alive
+     * through proxies while the worker computes. Default 15s; `0` disables.
+     */
+    pingIntervalMs?: number;
+}
+/**
+ * A drop-in {@link WasmMpcCore} for Node ≥ 22 that runs the wasm ceremony in a worker
+ * thread and keeps the relay WebSocket responsive on the main thread (waas-sdk#82).
+ *
+ * ```ts
+ * import { NodeWorkerMpcCore } from '@waaskey/sdk/node';
+ * const mpc = new NodeWorkerMpcCore();
+ * const waaskey = new Waaskey({ apiKey, mpc, ... });
+ * // …create / sign…
+ * await mpc.terminate(); // the worker keeps the process alive until terminated
+ * ```
+ */
+declare class NodeWorkerMpcCore extends WasmMpcCore {
+    private readonly bridge;
+    constructor(options?: NodeWorkerMpcOptions);
+    /** Close every bridged socket and terminate the worker; the core is unusable afterwards. */
+    terminate(): Promise<void>;
+}
+
+export { NodeWorkerMpcCore, type NodeWorkerMpcOptions };