@bitgo/sdk-lib-mpc 10.11.1 → 10.13.0

package/dist/src/tss/eddsa-mps/dkg.d.ts

@@ -84,7 +84,9 @@ export declare class DKG {
      */
     getCommonKeychain(): string;
     /**
-     * Returns a CBOR-encoded reduced representation containing the public key.
+     * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's opaque
+     * signing key share in the `keyShare` field. This buffer is private key material.
+     * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.
      */
     getReducedKeyShare(): Buffer;
     /**

package/dist/src/tss/eddsa-mps/dkg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dkg.d.ts","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/dkg.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,QAAQ,EAAwB,MAAM,SAAS,CAAC;AAIpG;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,GAAG;IACd,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE3B,sDAAsD;IACtD,OAAO,CAAC,aAAa,CAAuB;IAC5C,mGAAmG;IACnG,OAAO,CAAC,YAAY,CAAyB;IAC7C,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAAuB;IAC5C,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAuB;IACvC,6CAA6C;IAC7C,OAAO,CAAC,OAAO,CAAuB;IACtC,qCAAqC;IACrC,OAAO,CAAC,cAAc,CAAuB;IAC7C,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAwB;IAEvC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAA0B;gBAE1C,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;YAMpC,WAAW;IAMzB,OAAO,CAAC,UAAU;IAOlB,QAAQ,IAAI,QAAQ;IAIpB;;;;;;;OAOG;IACG,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjF;;;;;OAKG;IACH,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,mBAAmB;IAmBtD;;;;;;;;;;;OAWG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IAuDvF;;;OAGG;IACH,WAAW,IAAI,MAAM;IAOrB;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAO3B;;;OAGG;IACH,iBAAiB,IAAI,MAAM;IAO3B;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAU5B;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAepB;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAOtC"}
+{"version":3,"file":"dkg.d.ts","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/dkg.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,QAAQ,EAAwB,MAAM,SAAS,CAAC;AAMpG;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,GAAG;IACd,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE3B,sDAAsD;IACtD,OAAO,CAAC,aAAa,CAAuB;IAC5C,mGAAmG;IACnG,OAAO,CAAC,YAAY,CAAyB;IAC7C,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAAuB;IAC5C,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAuB;IACvC,6CAA6C;IAC7C,OAAO,CAAC,OAAO,CAAuB;IACtC,qCAAqC;IACrC,OAAO,CAAC,cAAc,CAAuB;IAC7C,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAwB;IAEvC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAA0B;gBAE1C,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;YAMpC,WAAW;IAoBzB,OAAO,CAAC,UAAU;IAOlB,QAAQ,IAAI,QAAQ;IAIpB;;;;;;;OAOG;IACG,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjF;;;;;OAKG;IACH,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,mBAAmB;IAmBtD;;;;;;;;;;;OAWG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IAuDvF;;;OAGG;IACH,WAAW,IAAI,MAAM;IAOrB;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAO3B;;;OAGG;IACH,iBAAiB,IAAI,MAAM;IAO3B;;;;OAIG;IACH,kBAAkB,IAAI,MAAM;IAY5B;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAepB;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAOtC"}

package/dist/src/tss/eddsa-mps/dkg.js

@@ -81,7 +81,20 @@ class DKG {
     }
     async loadWasmMps() {
         if (!this.wasmMps) {
-            this.wasmMps = await Promise.resolve().then(() => __importStar(require('@bitgo/wasm-mps')));
+            if (typeof window !== 'undefined' &&
+                /* checks for electron processes */
+                !window.process &&
+                !window.process?.['type']) {
+                // Browser: web build has explicit init() — guaranteed ready after await
+                // eslint-disable-next-line import/no-internal-modules -- @bitgo/wasm-mps exposes environment-specific subpath exports.
+                const webWasm = await Promise.resolve().then(() => __importStar(require('@bitgo/wasm-mps/web')));
+                await webWasm.default();
+                this.wasmMps = webWasm;
+            }
+            else {
+                // Node.js: dynamic import() rewritten to require() by tsc → CJS build → readFileSync
+                this.wasmMps = await Promise.resolve().then(() => __importStar(require('@bitgo/wasm-mps')));
+            }
         }
     }
     getWasmMps() {
@@ -230,14 +243,18 @@ class DKG {
         return this.sharePk.toString('hex') + this.shareChaincode.toString('hex');
     }
     /**
-     * Returns a CBOR-encoded reduced representation containing the public key.
+     * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's opaque
+     * signing key share in the `keyShare` field. This buffer is private key material.
+     * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.
      */
     getReducedKeyShare() {
-        if (!this.sharePk) {
+        if (!this.keyShare || !this.sharePk || !this.shareChaincode) {
             throw Error('DKG session not initialized');
         }
         const reducedKeyShare = {
+            keyShare: Array.from(this.keyShare),
             pub: Array.from(this.sharePk),
+            rootChainCode: Array.from(this.shareChaincode),
         };
         return Buffer.from((0, cbor_x_1.encode)(reducedKeyShare));
     }
@@ -273,4 +290,4 @@ class DKG {
     }
 }
 exports.DKG = DKG;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dkg.js","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/dkg.ts"],"names":[],"mappings":"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","sourcesContent":["import type { MsgState, Share } from '@bitgo/wasm-mps';\nimport { encode } from 'cbor-x';\nimport crypto from 'crypto';\nimport { DeserializedMessage, DeserializedMessages, DkgState, EddsaReducedKeyShare } from './types';\n\ntype WasmMps = typeof import('@bitgo/wasm-mps');\n\n/**\n * EdDSA Distributed Key Generation (DKG) implementation using @bitgo/wasm-mps.\n *\n * State is explicit: each round function returns `{ msg, state }` bytes.\n * The state bytes are stored between rounds and passed to the next round function,\n * mirroring the server-side persistence pattern (state would be serialised to DB).\n *\n * @example\n * ```typescript\n * const dkg = new DKG(3, 2, 0);\n * // X25519 keys come from GPG encryption subkeys (extracted by the orchestrator)\n * await dkg.initDkg(myX25519PrivKey, [otherParty1X25519PubKey, otherParty2X25519PubKey]);\n * const msg1 = dkg.getFirstMessage();\n * const msg2s = dkg.handleIncomingMessages(allThreeMsg1s);\n * dkg.handleIncomingMessages(allThreeMsg2s);  // completes DKG\n * const keyShare = dkg.getKeyShare();\n * ```\n */\nexport class DKG {\n  protected n: number;\n  protected t: number;\n  protected partyIdx: number;\n\n  /** Private X25519 key (from GPG encryption subkey) */\n  private decryptionKey: Buffer | null = null;\n  /** Other parties' X25519 public keys (from their GPG encryption subkeys), sorted by party index */\n  private otherPubKeys: Buffer[] | null = null;\n  /** Serialised round state bytes returned by the previous round function */\n  private dkgStateBytes: Buffer | null = null;\n  /** Opaque bincode-serialised keyshare from round2 */\n  private keyShare: Buffer | null = null;\n  /** 32-byte Ed25519 public key from round2 */\n  private sharePk: Buffer | null = null;\n  /** 32-byte chain code from round2 */\n  private shareChaincode: Buffer | null = null;\n  /** Lazily loaded WASM module */\n  private wasmMps: WasmMps | null = null;\n\n  protected dkgState: DkgState = DkgState.Uninitialized;\n\n  constructor(n: number, t: number, partyIdx: number) {\n    this.n = n;\n    this.t = t;\n    this.partyIdx = partyIdx;\n  }\n\n  private async loadWasmMps(): Promise<void> {\n    if (!this.wasmMps) {\n      this.wasmMps = await import('@bitgo/wasm-mps');\n    }\n  }\n\n  private getWasmMps(): WasmMps {\n    if (!this.wasmMps) {\n      throw Error('WASM module not loaded');\n    }\n    return this.wasmMps;\n  }\n\n  getState(): DkgState {\n    return this.dkgState;\n  }\n\n  /**\n   * Initialises the DKG session with this party's X25519 private key and the other parties'\n   * X25519 public keys. Keys are extracted from GPG encryption subkeys by the orchestrator.\n   *\n   * @param decryptionKey - This party's 32-byte X25519 private key (GPG enc subkey private part).\n   * @param otherEncPublicKeys - Other parties' 32-byte X25519 public keys, sorted by ascending\n   *   party index (excluding own). For a 3-party setup, this is [party_A_pub, party_B_pub].\n   */\n  async initDkg(decryptionKey: Buffer, otherEncPublicKeys: Buffer[]): Promise<void> {\n    await this.loadWasmMps();\n    if (!decryptionKey || decryptionKey.length !== 32) {\n      throw Error('Missing or invalid decryption key: must be 32 bytes');\n    }\n    if (!otherEncPublicKeys || otherEncPublicKeys.length !== this.n - 1) {\n      throw Error(`Expected ${this.n - 1} other parties' public keys`);\n    }\n    if (this.t > this.n || this.partyIdx >= this.n) {\n      throw Error('Invalid parameters for DKG');\n    }\n\n    this.decryptionKey = decryptionKey;\n    this.otherPubKeys = otherEncPublicKeys;\n    this.dkgState = DkgState.Init;\n  }\n\n  /**\n   * Runs round0 of the DKG protocol. Returns this party's broadcast message.\n   * Stores the round state bytes internally for the next round.\n   *\n   * @param dkgSeed - Optional 32-byte seed for deterministic DKG output (testing only).\n   */\n  getFirstMessage(dkgSeed?: Buffer): DeserializedMessage {\n    if (this.dkgState !== DkgState.Init) {\n      throw Error('DKG session not initialized');\n    }\n\n    const seed = dkgSeed ?? crypto.randomBytes(32);\n    const wasm = this.getWasmMps();\n    let result: MsgState;\n    try {\n      result = wasm.ed25519_dkg_round0_process(this.partyIdx, this.decryptionKey!, this.otherPubKeys!, seed);\n    } catch (err) {\n      throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);\n    }\n\n    this.dkgStateBytes = Buffer.from(result.state);\n    this.dkgState = DkgState.WaitMsg1;\n    return { payload: new Uint8Array(result.msg), from: this.partyIdx };\n  }\n\n  /**\n   * Handles incoming messages from all parties and advances the protocol.\n   *\n   * - In WaitMsg1: runs round1, returns this party's round1 broadcast message.\n   * - In WaitMsg2: runs round2, completes DKG, returns [].\n   *\n   * The caller passes all n messages (including own); own message is filtered\n   * out internally. Other parties' messages are sorted by ascending party index,\n   * matching the ordering expected by @bitgo/wasm-mps.\n   *\n   * @param messagesForIthRound - All n messages for this round (including own).\n   */\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    if (this.dkgState === DkgState.Complete) {\n      throw Error('DKG session already completed');\n    }\n    if (this.dkgState === DkgState.Uninitialized) {\n      throw Error('DKG session not initialized');\n    }\n    if (this.dkgState === DkgState.Init) {\n      throw Error(\n        'DKG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.'\n      );\n    }\n    if (messagesForIthRound.length !== this.n) {\n      throw Error('Invalid number of messages for the round. Number of messages should be equal to N');\n    }\n\n    // Extract other parties' messages, sorted by party index (ascending)\n    const otherMsgs = messagesForIthRound\n      .filter((m) => m.from !== this.partyIdx)\n      .sort((a, b) => a.from - b.from)\n      .map((m) => m.payload);\n\n    const wasm = this.getWasmMps();\n\n    if (this.dkgState === DkgState.WaitMsg1) {\n      let result: MsgState;\n      try {\n        result = wasm.ed25519_dkg_round1_process(otherMsgs, this.dkgStateBytes!);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);\n      }\n      // Store new state; this is what would be persisted to DB between API rounds\n      this.dkgStateBytes = Buffer.from(result.state);\n      this.dkgState = DkgState.WaitMsg2;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dkgState === DkgState.WaitMsg2) {\n      let share: Share;\n      try {\n        share = wasm.ed25519_dkg_round2_process(otherMsgs, this.dkgStateBytes!);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);\n      }\n      this.keyShare = Buffer.from(share.share);\n      this.sharePk = Buffer.from(share.pk);\n      this.shareChaincode = Buffer.from(share.chaincode);\n      this.dkgStateBytes = null;\n      this.dkgState = DkgState.Complete;\n      return [];\n    }\n\n    throw Error('Unexpected DKG state');\n  }\n\n  /**\n   * Returns the opaque bincode-serialised keyshare produced by round2.\n   * This is used as input to the signing protocol.\n   */\n  getKeyShare(): Buffer {\n    if (!this.keyShare) {\n      throw Error('DKG session not initialized');\n    }\n    return this.keyShare;\n  }\n\n  /**\n   * Returns the 32-byte Ed25519 public key agreed by all parties during DKG.\n   */\n  getSharePublicKey(): Buffer {\n    if (!this.sharePk) {\n      throw Error('DKG session not initialized');\n    }\n    return this.sharePk;\n  }\n\n  /**\n   * Returns the 128-char hex common keychain: 64-char public key + 64-char chain code.\n   * This matches the format expected by address derivation (Eddsa.deriveUnhardened).\n   */\n  getCommonKeychain(): string {\n    if (!this.sharePk || !this.shareChaincode) {\n      throw Error('DKG session not initialized');\n    }\n    return this.sharePk.toString('hex') + this.shareChaincode.toString('hex');\n  }\n\n  /**\n   * Returns a CBOR-encoded reduced representation containing the public key.\n   */\n  getReducedKeyShare(): Buffer {\n    if (!this.sharePk) {\n      throw Error('DKG session not initialized');\n    }\n    const reducedKeyShare: EddsaReducedKeyShare = {\n      pub: Array.from(this.sharePk),\n    };\n    return Buffer.from(encode(reducedKeyShare));\n  }\n\n  /**\n   * Exports the current session state as a JSON string for persistence.\n   * Includes: round state bytes, current DKG round, decryption key, other parties' pub keys.\n   * This mirrors what a server would store in a database between API rounds.\n   */\n  getSession(): string {\n    if (this.dkgState === DkgState.Complete) {\n      throw Error('DKG session is complete. Exporting the session is not allowed.');\n    }\n    if (this.dkgState === DkgState.Uninitialized) {\n      throw Error('DKG session not initialized');\n    }\n    return JSON.stringify({\n      dkgStateBytes: this.dkgStateBytes?.toString('base64') ?? null,\n      dkgRound: this.dkgState,\n      decryptionKey: this.decryptionKey?.toString('base64') ?? null,\n      otherPubKeys: this.otherPubKeys?.map((k) => k.toString('base64')) ?? null,\n    });\n  }\n\n  /**\n   * Restores a previously exported session. Allows the protocol to continue\n   * from where it left off, as if the round state was loaded from a database.\n   */\n  restoreSession(session: string): void {\n    const data = JSON.parse(session);\n    this.dkgStateBytes = data.dkgStateBytes ? Buffer.from(data.dkgStateBytes, 'base64') : null;\n    this.dkgState = data.dkgRound;\n    this.decryptionKey = data.decryptionKey ? Buffer.from(data.decryptionKey, 'base64') : null;\n    this.otherPubKeys = data.otherPubKeys ? (data.otherPubKeys as string[]).map((k) => Buffer.from(k, 'base64')) : null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dkg.js","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/dkg.ts"],"names":[],"mappings":"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","sourcesContent":["import type { MsgState, Share } from '@bitgo/wasm-mps';\nimport { encode } from 'cbor-x';\nimport crypto from 'crypto';\nimport { DeserializedMessage, DeserializedMessages, DkgState, EddsaReducedKeyShare } from './types';\n\ntype NodeWasmer = typeof import('@bitgo/wasm-mps');\ntype WebWasmer = typeof import('@bitgo/wasm-mps/web');\ntype WasmMps = NodeWasmer | WebWasmer;\n\n/**\n * EdDSA Distributed Key Generation (DKG) implementation using @bitgo/wasm-mps.\n *\n * State is explicit: each round function returns `{ msg, state }` bytes.\n * The state bytes are stored between rounds and passed to the next round function,\n * mirroring the server-side persistence pattern (state would be serialised to DB).\n *\n * @example\n * ```typescript\n * const dkg = new DKG(3, 2, 0);\n * // X25519 keys come from GPG encryption subkeys (extracted by the orchestrator)\n * await dkg.initDkg(myX25519PrivKey, [otherParty1X25519PubKey, otherParty2X25519PubKey]);\n * const msg1 = dkg.getFirstMessage();\n * const msg2s = dkg.handleIncomingMessages(allThreeMsg1s);\n * dkg.handleIncomingMessages(allThreeMsg2s);  // completes DKG\n * const keyShare = dkg.getKeyShare();\n * ```\n */\nexport class DKG {\n  protected n: number;\n  protected t: number;\n  protected partyIdx: number;\n\n  /** Private X25519 key (from GPG encryption subkey) */\n  private decryptionKey: Buffer | null = null;\n  /** Other parties' X25519 public keys (from their GPG encryption subkeys), sorted by party index */\n  private otherPubKeys: Buffer[] | null = null;\n  /** Serialised round state bytes returned by the previous round function */\n  private dkgStateBytes: Buffer | null = null;\n  /** Opaque bincode-serialised keyshare from round2 */\n  private keyShare: Buffer | null = null;\n  /** 32-byte Ed25519 public key from round2 */\n  private sharePk: Buffer | null = null;\n  /** 32-byte chain code from round2 */\n  private shareChaincode: Buffer | null = null;\n  /** Lazily loaded WASM module */\n  private wasmMps: WasmMps | null = null;\n\n  protected dkgState: DkgState = DkgState.Uninitialized;\n\n  constructor(n: number, t: number, partyIdx: number) {\n    this.n = n;\n    this.t = t;\n    this.partyIdx = partyIdx;\n  }\n\n  private async loadWasmMps(): Promise<void> {\n    if (!this.wasmMps) {\n      if (\n        typeof window !== 'undefined' &&\n        /* checks for electron processes */\n        !window.process &&\n        !window.process?.['type']\n      ) {\n        // Browser: web build has explicit init() — guaranteed ready after await\n        // eslint-disable-next-line import/no-internal-modules -- @bitgo/wasm-mps exposes environment-specific subpath exports.\n        const webWasm = await import('@bitgo/wasm-mps/web');\n        await webWasm.default();\n        this.wasmMps = webWasm;\n      } else {\n        // Node.js: dynamic import() rewritten to require() by tsc → CJS build → readFileSync\n        this.wasmMps = await import('@bitgo/wasm-mps');\n      }\n    }\n  }\n\n  private getWasmMps(): WasmMps {\n    if (!this.wasmMps) {\n      throw Error('WASM module not loaded');\n    }\n    return this.wasmMps;\n  }\n\n  getState(): DkgState {\n    return this.dkgState;\n  }\n\n  /**\n   * Initialises the DKG session with this party's X25519 private key and the other parties'\n   * X25519 public keys. Keys are extracted from GPG encryption subkeys by the orchestrator.\n   *\n   * @param decryptionKey - This party's 32-byte X25519 private key (GPG enc subkey private part).\n   * @param otherEncPublicKeys - Other parties' 32-byte X25519 public keys, sorted by ascending\n   *   party index (excluding own). For a 3-party setup, this is [party_A_pub, party_B_pub].\n   */\n  async initDkg(decryptionKey: Buffer, otherEncPublicKeys: Buffer[]): Promise<void> {\n    await this.loadWasmMps();\n    if (!decryptionKey || decryptionKey.length !== 32) {\n      throw Error('Missing or invalid decryption key: must be 32 bytes');\n    }\n    if (!otherEncPublicKeys || otherEncPublicKeys.length !== this.n - 1) {\n      throw Error(`Expected ${this.n - 1} other parties' public keys`);\n    }\n    if (this.t > this.n || this.partyIdx >= this.n) {\n      throw Error('Invalid parameters for DKG');\n    }\n\n    this.decryptionKey = decryptionKey;\n    this.otherPubKeys = otherEncPublicKeys;\n    this.dkgState = DkgState.Init;\n  }\n\n  /**\n   * Runs round0 of the DKG protocol. Returns this party's broadcast message.\n   * Stores the round state bytes internally for the next round.\n   *\n   * @param dkgSeed - Optional 32-byte seed for deterministic DKG output (testing only).\n   */\n  getFirstMessage(dkgSeed?: Buffer): DeserializedMessage {\n    if (this.dkgState !== DkgState.Init) {\n      throw Error('DKG session not initialized');\n    }\n\n    const seed = dkgSeed ?? crypto.randomBytes(32);\n    const wasm = this.getWasmMps();\n    let result: MsgState;\n    try {\n      result = wasm.ed25519_dkg_round0_process(this.partyIdx, this.decryptionKey!, this.otherPubKeys!, seed);\n    } catch (err) {\n      throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);\n    }\n\n    this.dkgStateBytes = Buffer.from(result.state);\n    this.dkgState = DkgState.WaitMsg1;\n    return { payload: new Uint8Array(result.msg), from: this.partyIdx };\n  }\n\n  /**\n   * Handles incoming messages from all parties and advances the protocol.\n   *\n   * - In WaitMsg1: runs round1, returns this party's round1 broadcast message.\n   * - In WaitMsg2: runs round2, completes DKG, returns [].\n   *\n   * The caller passes all n messages (including own); own message is filtered\n   * out internally. Other parties' messages are sorted by ascending party index,\n   * matching the ordering expected by @bitgo/wasm-mps.\n   *\n   * @param messagesForIthRound - All n messages for this round (including own).\n   */\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    if (this.dkgState === DkgState.Complete) {\n      throw Error('DKG session already completed');\n    }\n    if (this.dkgState === DkgState.Uninitialized) {\n      throw Error('DKG session not initialized');\n    }\n    if (this.dkgState === DkgState.Init) {\n      throw Error(\n        'DKG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.'\n      );\n    }\n    if (messagesForIthRound.length !== this.n) {\n      throw Error('Invalid number of messages for the round. Number of messages should be equal to N');\n    }\n\n    // Extract other parties' messages, sorted by party index (ascending)\n    const otherMsgs = messagesForIthRound\n      .filter((m) => m.from !== this.partyIdx)\n      .sort((a, b) => a.from - b.from)\n      .map((m) => m.payload);\n\n    const wasm = this.getWasmMps();\n\n    if (this.dkgState === DkgState.WaitMsg1) {\n      let result: MsgState;\n      try {\n        result = wasm.ed25519_dkg_round1_process(otherMsgs, this.dkgStateBytes!);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);\n      }\n      // Store new state; this is what would be persisted to DB between API rounds\n      this.dkgStateBytes = Buffer.from(result.state);\n      this.dkgState = DkgState.WaitMsg2;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dkgState === DkgState.WaitMsg2) {\n      let share: Share;\n      try {\n        share = wasm.ed25519_dkg_round2_process(otherMsgs, this.dkgStateBytes!);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);\n      }\n      this.keyShare = Buffer.from(share.share);\n      this.sharePk = Buffer.from(share.pk);\n      this.shareChaincode = Buffer.from(share.chaincode);\n      this.dkgStateBytes = null;\n      this.dkgState = DkgState.Complete;\n      return [];\n    }\n\n    throw Error('Unexpected DKG state');\n  }\n\n  /**\n   * Returns the opaque bincode-serialised keyshare produced by round2.\n   * This is used as input to the signing protocol.\n   */\n  getKeyShare(): Buffer {\n    if (!this.keyShare) {\n      throw Error('DKG session not initialized');\n    }\n    return this.keyShare;\n  }\n\n  /**\n   * Returns the 32-byte Ed25519 public key agreed by all parties during DKG.\n   */\n  getSharePublicKey(): Buffer {\n    if (!this.sharePk) {\n      throw Error('DKG session not initialized');\n    }\n    return this.sharePk;\n  }\n\n  /**\n   * Returns the 128-char hex common keychain: 64-char public key + 64-char chain code.\n   * This matches the format expected by address derivation (Eddsa.deriveUnhardened).\n   */\n  getCommonKeychain(): string {\n    if (!this.sharePk || !this.shareChaincode) {\n      throw Error('DKG session not initialized');\n    }\n    return this.sharePk.toString('hex') + this.shareChaincode.toString('hex');\n  }\n\n  /**\n   * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's opaque\n   * signing key share in the `keyShare` field. This buffer is private key material.\n   * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.\n   */\n  getReducedKeyShare(): Buffer {\n    if (!this.keyShare || !this.sharePk || !this.shareChaincode) {\n      throw Error('DKG session not initialized');\n    }\n    const reducedKeyShare: EddsaReducedKeyShare = {\n      keyShare: Array.from(this.keyShare),\n      pub: Array.from(this.sharePk),\n      rootChainCode: Array.from(this.shareChaincode),\n    };\n    return Buffer.from(encode(reducedKeyShare));\n  }\n\n  /**\n   * Exports the current session state as a JSON string for persistence.\n   * Includes: round state bytes, current DKG round, decryption key, other parties' pub keys.\n   * This mirrors what a server would store in a database between API rounds.\n   */\n  getSession(): string {\n    if (this.dkgState === DkgState.Complete) {\n      throw Error('DKG session is complete. Exporting the session is not allowed.');\n    }\n    if (this.dkgState === DkgState.Uninitialized) {\n      throw Error('DKG session not initialized');\n    }\n    return JSON.stringify({\n      dkgStateBytes: this.dkgStateBytes?.toString('base64') ?? null,\n      dkgRound: this.dkgState,\n      decryptionKey: this.decryptionKey?.toString('base64') ?? null,\n      otherPubKeys: this.otherPubKeys?.map((k) => k.toString('base64')) ?? null,\n    });\n  }\n\n  /**\n   * Restores a previously exported session. Allows the protocol to continue\n   * from where it left off, as if the round state was loaded from a database.\n   */\n  restoreSession(session: string): void {\n    const data = JSON.parse(session);\n    this.dkgStateBytes = data.dkgStateBytes ? Buffer.from(data.dkgStateBytes, 'base64') : null;\n    this.dkgState = data.dkgRound;\n    this.decryptionKey = data.decryptionKey ? Buffer.from(data.decryptionKey, 'base64') : null;\n    this.otherPubKeys = data.otherPubKeys ? (data.otherPubKeys as string[]).map((k) => Buffer.from(k, 'base64')) : null;\n  }\n}\n"]}

package/dist/src/tss/eddsa-mps/dsg.d.ts

@@ -0,0 +1,92 @@
+import { DeserializedMessage, DeserializedMessages, DsgState } from './types';
+/**
+ * EdDSA Distributed Sign Generation (DSG) implementation using @bitgo/wasm-mps.
+ *
+ * State is explicit: each WASM round function returns
+ * `{ msg, state }` bytes; the state bytes are stored between rounds and passed to the
+ * next round function (this is what a server would persist to a database between API
+ * rounds).
+ *
+ * The protocol is hard-coded 2-of-3: each signing party communicates with exactly one
+ * counterpart. `handleIncomingMessages` accepts both messages (own + counterpart), and
+ * filters own out internally.
+ *
+ * @example
+ * ```typescript
+ * const dsg = new DSG(0);  // partyIdx 0
+ * dsg.initDsg(keyShare, message, 'm', 2);  // counterpart is party 2
+ * const msg1 = dsg.getFirstMessage();
+ * const msg2 = dsg.handleIncomingMessages([msg1, peerMsg1]);  // emits SignMsg2
+ * const msg3 = dsg.handleIncomingMessages([msg2[0], peerMsg2]);  // emits SignMsg3
+ * dsg.handleIncomingMessages([msg3[0], peerMsg3]);  // completes DSG
+ * const signature = dsg.getSignature();  // 64-byte Ed25519 signature
+ * ```
+ */
+export declare class DSG {
+    protected partyIdx: number;
+    protected otherPartyIdx: number | null;
+    /** Opaque bincode-serialised Keyshare from a prior DKG */
+    private keyShare;
+    /** Raw message bytes to sign (Ed25519 hashes internally; no prehashing required) */
+    private message;
+    /** BIP-32-style derivation path, e.g. "m" or "m/0/1". Folded in via Keyshare::derive_with_offset */
+    private derivationPath;
+    /** Serialised round state bytes returned by the previous round function */
+    private dsgStateBytes;
+    /** Final 64-byte Ed25519 signature, available after WaitMsg3 -> Complete */
+    private signature;
+    protected dsgState: DsgState;
+    constructor(partyIdx: number);
+    getState(): DsgState;
+    getPartyIdx(): number;
+    getOtherPartyIdx(): number | null;
+    /**
+     * Initialises the DSG session. The keyshare must come from a prior DKG run, and
+     * `otherPartyIdx` must be the single counterpart who will co-sign with this party.
+     *
+     * @param keyShare - Opaque bincode-serialised Keyshare bytes from `DKG.getKeyShare()`.
+     * @param message - Raw message bytes to sign (no prehashing).
+     * @param derivationPath - BIP-32-style derivation path. Use `"m"` for the root key.
+     * @param otherPartyIdx - Party index of the single counterpart in this signing session.
+     *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.
+     */
+    initDsg(keyShare: Buffer, message: Buffer, derivationPath: string, otherPartyIdx: number): void;
+    /**
+     * Runs round 0 of the DSG protocol. Returns this party's broadcast message
+     * (a `SignMsg1` containing the commitment to `R_i`). Stores the round state
+     * bytes internally for the next round.
+     */
+    getFirstMessage(): DeserializedMessage;
+    /**
+     * Handles incoming messages for the current round and advances the protocol.
+     *
+     * - In `WaitMsg1`: runs round 1, returns this party's `SignMsg2` broadcast.
+     * - In `WaitMsg2`: runs round 2 (which internally fuses two Silence Labs transitions),
+     *   returns this party's `SignMsg3` broadcast (partial signature).
+     * - In `WaitMsg3`: runs round 3, completes DSG, returns `[]`.
+     *
+     * The caller passes both messages (own + counterpart) for symmetry with
+     * `DKG.handleIncomingMessages`. Own message is filtered out internally; only the
+     * counterpart's payload is forwarded to the WASM round function.
+     *
+     * @param messagesForIthRound - Both messages for this round (own + counterpart).
+     */
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
+    /**
+     * Returns the final 64-byte Ed25519 signature produced by round 3.
+     * Only available once the protocol reaches `Complete`.
+     */
+    getSignature(): Buffer;
+    /**
+     * Exports the current session state as a JSON string for persistence.
+     * Includes the opaque round state bytes plus everything needed to re-enter the
+     * protocol after a restart (keyshare, message, derivation path, counterpart).
+     */
+    getSession(): string;
+    /**
+     * Restores a previously exported session. Allows the protocol to continue from
+     * where it left off, as if the round state was loaded from a database.
+     */
+    restoreSession(session: string): void;
+}
+//# sourceMappingURL=dsg.d.ts.map

package/dist/src/tss/eddsa-mps/dsg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsg.d.ts","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/dsg.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,GAAG;IACd,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE9C,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAuB;IACvC,oFAAoF;IACpF,OAAO,CAAC,OAAO,CAAuB;IACtC,oGAAoG;IACpG,OAAO,CAAC,cAAc,CAAuB;IAE7C,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAAuB;IAC5C,4EAA4E;IAC5E,OAAO,CAAC,SAAS,CAAuB;IAExC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAA0B;gBAE1C,QAAQ,EAAE,MAAM;IAI5B,QAAQ,IAAI,QAAQ;IAIpB,WAAW,IAAI,MAAM;IAIrB,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAIjC;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAqB/F;;;;OAIG;IACH,eAAe,IAAI,mBAAmB;IAoBtC;;;;;;;;;;;;;OAaG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IAqEvF;;;OAGG;IACH,YAAY,IAAI,MAAM;IAOtB;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAqBpB;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CA2DtC"}

package/dist/src/tss/eddsa-mps/dsg.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DSG = void 0;
+const assert_1 = __importDefault(require("assert"));
+const wasm_mps_1 = require("@bitgo/wasm-mps");
+const types_1 = require("./types");
+/**
+ * EdDSA Distributed Sign Generation (DSG) implementation using @bitgo/wasm-mps.
+ *
+ * State is explicit: each WASM round function returns
+ * `{ msg, state }` bytes; the state bytes are stored between rounds and passed to the
+ * next round function (this is what a server would persist to a database between API
+ * rounds).
+ *
+ * The protocol is hard-coded 2-of-3: each signing party communicates with exactly one
+ * counterpart. `handleIncomingMessages` accepts both messages (own + counterpart), and
+ * filters own out internally.
+ *
+ * @example
+ * ```typescript
+ * const dsg = new DSG(0);  // partyIdx 0
+ * dsg.initDsg(keyShare, message, 'm', 2);  // counterpart is party 2
+ * const msg1 = dsg.getFirstMessage();
+ * const msg2 = dsg.handleIncomingMessages([msg1, peerMsg1]);  // emits SignMsg2
+ * const msg3 = dsg.handleIncomingMessages([msg2[0], peerMsg2]);  // emits SignMsg3
+ * dsg.handleIncomingMessages([msg3[0], peerMsg3]);  // completes DSG
+ * const signature = dsg.getSignature();  // 64-byte Ed25519 signature
+ * ```
+ */
+class DSG {
+    constructor(partyIdx) {
+        this.otherPartyIdx = null;
+        /** Opaque bincode-serialised Keyshare from a prior DKG */
+        this.keyShare = null;
+        /** Raw message bytes to sign (Ed25519 hashes internally; no prehashing required) */
+        this.message = null;
+        /** BIP-32-style derivation path, e.g. "m" or "m/0/1". Folded in via Keyshare::derive_with_offset */
+        this.derivationPath = null;
+        /** Serialised round state bytes returned by the previous round function */
+        this.dsgStateBytes = null;
+        /** Final 64-byte Ed25519 signature, available after WaitMsg3 -> Complete */
+        this.signature = null;
+        this.dsgState = types_1.DsgState.Uninitialized;
+        this.partyIdx = partyIdx;
+    }
+    getState() {
+        return this.dsgState;
+    }
+    getPartyIdx() {
+        return this.partyIdx;
+    }
+    getOtherPartyIdx() {
+        return this.otherPartyIdx;
+    }
+    /**
+     * Initialises the DSG session. The keyshare must come from a prior DKG run, and
+     * `otherPartyIdx` must be the single counterpart who will co-sign with this party.
+     *
+     * @param keyShare - Opaque bincode-serialised Keyshare bytes from `DKG.getKeyShare()`.
+     * @param message - Raw message bytes to sign (no prehashing).
+     * @param derivationPath - BIP-32-style derivation path. Use `"m"` for the root key.
+     * @param otherPartyIdx - Party index of the single counterpart in this signing session.
+     *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.
+     */
+    initDsg(keyShare, message, derivationPath, otherPartyIdx) {
+        if (!keyShare || keyShare.length === 0) {
+            throw Error('Missing or invalid keyShare');
+        }
+        if (!message || message.length === 0) {
+            throw Error('Missing or invalid message');
+        }
+        if (this.partyIdx < 0 || this.partyIdx > 2) {
+            throw Error(`Invalid partyIdx ${this.partyIdx}: must be in [0, 2]`);
+        }
+        if (otherPartyIdx < 0 || otherPartyIdx > 2 || otherPartyIdx === this.partyIdx) {
+            throw Error(`Invalid otherPartyIdx ${otherPartyIdx}: must be in [0, 2] and != partyIdx`);
+        }
+        this.keyShare = keyShare;
+        this.message = message;
+        this.derivationPath = derivationPath;
+        this.otherPartyIdx = otherPartyIdx;
+        this.dsgState = types_1.DsgState.Init;
+    }
+    /**
+     * Runs round 0 of the DSG protocol. Returns this party's broadcast message
+     * (a `SignMsg1` containing the commitment to `R_i`). Stores the round state
+     * bytes internally for the next round.
+     */
+    getFirstMessage() {
+        if (this.dsgState !== types_1.DsgState.Init) {
+            throw Error('DSG session not initialized');
+        }
+        (0, assert_1.default)(this.keyShare, 'keyShare must be set after initDsg');
+        (0, assert_1.default)(this.derivationPath !== null, 'derivationPath must be set after initDsg');
+        (0, assert_1.default)(this.message, 'message must be set after initDsg');
+        let result;
+        try {
+            result = (0, wasm_mps_1.ed25519_dsg_round0_process)(this.keyShare, this.derivationPath, this.message);
+        }
+        catch (err) {
+            throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);
+        }
+        this.dsgStateBytes = Buffer.from(result.state);
+        this.dsgState = types_1.DsgState.WaitMsg1;
+        return { payload: new Uint8Array(result.msg), from: this.partyIdx };
+    }
+    /**
+     * Handles incoming messages for the current round and advances the protocol.
+     *
+     * - In `WaitMsg1`: runs round 1, returns this party's `SignMsg2` broadcast.
+     * - In `WaitMsg2`: runs round 2 (which internally fuses two Silence Labs transitions),
+     *   returns this party's `SignMsg3` broadcast (partial signature).
+     * - In `WaitMsg3`: runs round 3, completes DSG, returns `[]`.
+     *
+     * The caller passes both messages (own + counterpart) for symmetry with
+     * `DKG.handleIncomingMessages`. Own message is filtered out internally; only the
+     * counterpart's payload is forwarded to the WASM round function.
+     *
+     * @param messagesForIthRound - Both messages for this round (own + counterpart).
+     */
+    handleIncomingMessages(messagesForIthRound) {
+        if (this.dsgState === types_1.DsgState.Complete) {
+            throw Error('DSG session already completed');
+        }
+        if (this.dsgState === types_1.DsgState.Uninitialized) {
+            throw Error('DSG session not initialized');
+        }
+        if (this.dsgState === types_1.DsgState.Init) {
+            throw Error('DSG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.');
+        }
+        if (messagesForIthRound.length !== 2) {
+            throw Error('Invalid number of messages for the round. Expected 2 messages (own + counterpart) for 2-of-3 DSG');
+        }
+        const peerMessages = messagesForIthRound.filter((m) => m.from !== this.partyIdx);
+        if (peerMessages.length !== 1) {
+            throw Error(`Expected exactly 1 counterpart message; got ${peerMessages.length}`);
+        }
+        const peerMsg = peerMessages[0];
+        if (peerMsg.from !== this.otherPartyIdx) {
+            throw Error(`Unexpected counterpart party index: got ${peerMsg.from}, expected ${this.otherPartyIdx}`);
+        }
+        const peerPayload = Buffer.from(peerMsg.payload);
+        if (this.dsgState === types_1.DsgState.WaitMsg1) {
+            (0, assert_1.default)(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg1');
+            let result;
+            try {
+                result = (0, wasm_mps_1.ed25519_dsg_round1_process)(peerPayload, this.dsgStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);
+            }
+            this.dsgStateBytes = Buffer.from(result.state);
+            this.dsgState = types_1.DsgState.WaitMsg2;
+            return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];
+        }
+        if (this.dsgState === types_1.DsgState.WaitMsg2) {
+            (0, assert_1.default)(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg2');
+            let result;
+            try {
+                result = (0, wasm_mps_1.ed25519_dsg_round2_process)(peerPayload, this.dsgStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);
+            }
+            this.dsgStateBytes = Buffer.from(result.state);
+            this.dsgState = types_1.DsgState.WaitMsg3;
+            return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];
+        }
+        if (this.dsgState === types_1.DsgState.WaitMsg3) {
+            (0, assert_1.default)(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg3');
+            let sigBytes;
+            try {
+                sigBytes = (0, wasm_mps_1.ed25519_dsg_round3_process)(peerPayload, this.dsgStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);
+            }
+            this.signature = Buffer.from(sigBytes);
+            this.dsgStateBytes = null;
+            this.dsgState = types_1.DsgState.Complete;
+            return [];
+        }
+        throw Error('Unexpected DSG state');
+    }
+    /**
+     * Returns the final 64-byte Ed25519 signature produced by round 3.
+     * Only available once the protocol reaches `Complete`.
+     */
+    getSignature() {
+        if (!this.signature) {
+            throw Error('DSG session has not produced a signature yet');
+        }
+        return this.signature;
+    }
+    /**
+     * Exports the current session state as a JSON string for persistence.
+     * Includes the opaque round state bytes plus everything needed to re-enter the
+     * protocol after a restart (keyshare, message, derivation path, counterpart).
+     */
+    getSession() {
+        if (this.dsgState === types_1.DsgState.Complete) {
+            throw Error('DSG session is complete. Exporting the session is not allowed.');
+        }
+        if (this.dsgState === types_1.DsgState.Uninitialized) {
+            throw Error('DSG session not initialized');
+        }
+        if (this.dsgState === types_1.DsgState.Init) {
+            throw Error('DSG session must produce its first message before exporting.');
+        }
+        return JSON.stringify({
+            dsgStateBytes: this.dsgStateBytes?.toString('base64') ?? null,
+            dsgRound: this.dsgState,
+            keyShare: this.keyShare?.toString('base64') ?? null,
+            message: this.message?.toString('base64') ?? null,
+            derivationPath: this.derivationPath,
+            partyIdx: this.partyIdx,
+            otherPartyIdx: this.otherPartyIdx,
+        });
+    }
+    /**
+     * Restores a previously exported session. Allows the protocol to continue from
+     * where it left off, as if the round state was loaded from a database.
+     */
+    restoreSession(session) {
+        const data = JSON.parse(session);
+        if (!Object.values(types_1.DsgState).includes(data.dsgRound)) {
+            throw Error(`Invalid dsgRound in session: ${data.dsgRound}`);
+        }
+        if (data.dsgRound === types_1.DsgState.Uninitialized || data.dsgRound === types_1.DsgState.Init) {
+            throw Error(`Cannot restore DSG session in state ${data.dsgRound}`);
+        }
+        if (data.dsgRound === types_1.DsgState.Complete) {
+            throw Error('DSG session is complete. Restoring the session is not allowed.');
+        }
+        if (typeof data.partyIdx !== 'number' || data.partyIdx < 0 || data.partyIdx > 2) {
+            throw Error(`Invalid partyIdx in session: ${data.partyIdx}`);
+        }
+        if (typeof data.otherPartyIdx !== 'number' ||
+            data.otherPartyIdx < 0 ||
+            data.otherPartyIdx > 2 ||
+            data.otherPartyIdx === data.partyIdx) {
+            throw Error(`Invalid otherPartyIdx in session: ${data.otherPartyIdx}`);
+        }
+        if (this.partyIdx !== data.partyIdx) {
+            throw Error(`Session partyIdx ${data.partyIdx} does not match instance ${this.partyIdx}`);
+        }
+        if (typeof data.dsgStateBytes !== 'string' || data.dsgStateBytes.length === 0) {
+            throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);
+        }
+        if (typeof data.keyShare !== 'string' || data.keyShare.length === 0) {
+            throw Error('Restored session missing keyShare');
+        }
+        if (typeof data.message !== 'string' || data.message.length === 0) {
+            throw Error('Restored session missing message');
+        }
+        if (typeof data.derivationPath !== 'string') {
+            throw Error('Restored session missing derivationPath');
+        }
+        const dsgStateBytes = Buffer.from(data.dsgStateBytes, 'base64');
+        const keyShare = Buffer.from(data.keyShare, 'base64');
+        const message = Buffer.from(data.message, 'base64');
+        if (dsgStateBytes.length === 0) {
+            throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);
+        }
+        if (keyShare.length === 0) {
+            throw Error('Restored session missing keyShare');
+        }
+        if (message.length === 0) {
+            throw Error('Restored session missing message');
+        }
+        this.dsgStateBytes = dsgStateBytes;
+        this.dsgState = data.dsgRound;
+        this.keyShare = keyShare;
+        this.message = message;
+        this.derivationPath = data.derivationPath;
+        this.partyIdx = data.partyIdx;
+        this.otherPartyIdx = data.otherPartyIdx;
+    }
+}
+exports.DSG = DSG;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dsg.js","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/dsg.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport {\n  ed25519_dsg_round0_process,\n  ed25519_dsg_round1_process,\n  ed25519_dsg_round2_process,\n  ed25519_dsg_round3_process,\n} from '@bitgo/wasm-mps';\nimport { DeserializedMessage, DeserializedMessages, DsgState } from './types';\n\n/**\n * EdDSA Distributed Sign Generation (DSG) implementation using @bitgo/wasm-mps.\n *\n * State is explicit: each WASM round function returns\n * `{ msg, state }` bytes; the state bytes are stored between rounds and passed to the\n * next round function (this is what a server would persist to a database between API\n * rounds).\n *\n * The protocol is hard-coded 2-of-3: each signing party communicates with exactly one\n * counterpart. `handleIncomingMessages` accepts both messages (own + counterpart), and\n * filters own out internally.\n *\n * @example\n * ```typescript\n * const dsg = new DSG(0);  // partyIdx 0\n * dsg.initDsg(keyShare, message, 'm', 2);  // counterpart is party 2\n * const msg1 = dsg.getFirstMessage();\n * const msg2 = dsg.handleIncomingMessages([msg1, peerMsg1]);  // emits SignMsg2\n * const msg3 = dsg.handleIncomingMessages([msg2[0], peerMsg2]);  // emits SignMsg3\n * dsg.handleIncomingMessages([msg3[0], peerMsg3]);  // completes DSG\n * const signature = dsg.getSignature();  // 64-byte Ed25519 signature\n * ```\n */\nexport class DSG {\n  protected partyIdx: number;\n  protected otherPartyIdx: number | null = null;\n\n  /** Opaque bincode-serialised Keyshare from a prior DKG */\n  private keyShare: Buffer | null = null;\n  /** Raw message bytes to sign (Ed25519 hashes internally; no prehashing required) */\n  private message: Buffer | null = null;\n  /** BIP-32-style derivation path, e.g. \"m\" or \"m/0/1\". Folded in via Keyshare::derive_with_offset */\n  private derivationPath: string | null = null;\n\n  /** Serialised round state bytes returned by the previous round function */\n  private dsgStateBytes: Buffer | null = null;\n  /** Final 64-byte Ed25519 signature, available after WaitMsg3 -> Complete */\n  private signature: Buffer | null = null;\n\n  protected dsgState: DsgState = DsgState.Uninitialized;\n\n  constructor(partyIdx: number) {\n    this.partyIdx = partyIdx;\n  }\n\n  getState(): DsgState {\n    return this.dsgState;\n  }\n\n  getPartyIdx(): number {\n    return this.partyIdx;\n  }\n\n  getOtherPartyIdx(): number | null {\n    return this.otherPartyIdx;\n  }\n\n  /**\n   * Initialises the DSG session. The keyshare must come from a prior DKG run, and\n   * `otherPartyIdx` must be the single counterpart who will co-sign with this party.\n   *\n   * @param keyShare - Opaque bincode-serialised Keyshare bytes from `DKG.getKeyShare()`.\n   * @param message - Raw message bytes to sign (no prehashing).\n   * @param derivationPath - BIP-32-style derivation path. Use `\"m\"` for the root key.\n   * @param otherPartyIdx - Party index of the single counterpart in this signing session.\n   *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.\n   */\n  initDsg(keyShare: Buffer, message: Buffer, derivationPath: string, otherPartyIdx: number): void {\n    if (!keyShare || keyShare.length === 0) {\n      throw Error('Missing or invalid keyShare');\n    }\n    if (!message || message.length === 0) {\n      throw Error('Missing or invalid message');\n    }\n    if (this.partyIdx < 0 || this.partyIdx > 2) {\n      throw Error(`Invalid partyIdx ${this.partyIdx}: must be in [0, 2]`);\n    }\n    if (otherPartyIdx < 0 || otherPartyIdx > 2 || otherPartyIdx === this.partyIdx) {\n      throw Error(`Invalid otherPartyIdx ${otherPartyIdx}: must be in [0, 2] and != partyIdx`);\n    }\n\n    this.keyShare = keyShare;\n    this.message = message;\n    this.derivationPath = derivationPath;\n    this.otherPartyIdx = otherPartyIdx;\n    this.dsgState = DsgState.Init;\n  }\n\n  /**\n   * Runs round 0 of the DSG protocol. Returns this party's broadcast message\n   * (a `SignMsg1` containing the commitment to `R_i`). Stores the round state\n   * bytes internally for the next round.\n   */\n  getFirstMessage(): DeserializedMessage {\n    if (this.dsgState !== DsgState.Init) {\n      throw Error('DSG session not initialized');\n    }\n    assert(this.keyShare, 'keyShare must be set after initDsg');\n    assert(this.derivationPath !== null, 'derivationPath must be set after initDsg');\n    assert(this.message, 'message must be set after initDsg');\n\n    let result;\n    try {\n      result = ed25519_dsg_round0_process(this.keyShare, this.derivationPath, this.message);\n    } catch (err) {\n      throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);\n    }\n\n    this.dsgStateBytes = Buffer.from(result.state);\n    this.dsgState = DsgState.WaitMsg1;\n    return { payload: new Uint8Array(result.msg), from: this.partyIdx };\n  }\n\n  /**\n   * Handles incoming messages for the current round and advances the protocol.\n   *\n   * - In `WaitMsg1`: runs round 1, returns this party's `SignMsg2` broadcast.\n   * - In `WaitMsg2`: runs round 2 (which internally fuses two Silence Labs transitions),\n   *   returns this party's `SignMsg3` broadcast (partial signature).\n   * - In `WaitMsg3`: runs round 3, completes DSG, returns `[]`.\n   *\n   * The caller passes both messages (own + counterpart) for symmetry with\n   * `DKG.handleIncomingMessages`. Own message is filtered out internally; only the\n   * counterpart's payload is forwarded to the WASM round function.\n   *\n   * @param messagesForIthRound - Both messages for this round (own + counterpart).\n   */\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    if (this.dsgState === DsgState.Complete) {\n      throw Error('DSG session already completed');\n    }\n    if (this.dsgState === DsgState.Uninitialized) {\n      throw Error('DSG session not initialized');\n    }\n    if (this.dsgState === DsgState.Init) {\n      throw Error(\n        'DSG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.'\n      );\n    }\n    if (messagesForIthRound.length !== 2) {\n      throw Error('Invalid number of messages for the round. Expected 2 messages (own + counterpart) for 2-of-3 DSG');\n    }\n\n    const peerMessages = messagesForIthRound.filter((m) => m.from !== this.partyIdx);\n    if (peerMessages.length !== 1) {\n      throw Error(`Expected exactly 1 counterpart message; got ${peerMessages.length}`);\n    }\n    const peerMsg = peerMessages[0];\n    if (peerMsg.from !== this.otherPartyIdx) {\n      throw Error(`Unexpected counterpart party index: got ${peerMsg.from}, expected ${this.otherPartyIdx}`);\n    }\n    const peerPayload = Buffer.from(peerMsg.payload);\n\n    if (this.dsgState === DsgState.WaitMsg1) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg1');\n      let result;\n      try {\n        result = ed25519_dsg_round1_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.dsgStateBytes = Buffer.from(result.state);\n      this.dsgState = DsgState.WaitMsg2;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dsgState === DsgState.WaitMsg2) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg2');\n      let result;\n      try {\n        result = ed25519_dsg_round2_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.dsgStateBytes = Buffer.from(result.state);\n      this.dsgState = DsgState.WaitMsg3;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dsgState === DsgState.WaitMsg3) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg3');\n      let sigBytes;\n      try {\n        sigBytes = ed25519_dsg_round3_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.signature = Buffer.from(sigBytes);\n      this.dsgStateBytes = null;\n      this.dsgState = DsgState.Complete;\n      return [];\n    }\n\n    throw Error('Unexpected DSG state');\n  }\n\n  /**\n   * Returns the final 64-byte Ed25519 signature produced by round 3.\n   * Only available once the protocol reaches `Complete`.\n   */\n  getSignature(): Buffer {\n    if (!this.signature) {\n      throw Error('DSG session has not produced a signature yet');\n    }\n    return this.signature;\n  }\n\n  /**\n   * Exports the current session state as a JSON string for persistence.\n   * Includes the opaque round state bytes plus everything needed to re-enter the\n   * protocol after a restart (keyshare, message, derivation path, counterpart).\n   */\n  getSession(): string {\n    if (this.dsgState === DsgState.Complete) {\n      throw Error('DSG session is complete. Exporting the session is not allowed.');\n    }\n    if (this.dsgState === DsgState.Uninitialized) {\n      throw Error('DSG session not initialized');\n    }\n    if (this.dsgState === DsgState.Init) {\n      throw Error('DSG session must produce its first message before exporting.');\n    }\n    return JSON.stringify({\n      dsgStateBytes: this.dsgStateBytes?.toString('base64') ?? null,\n      dsgRound: this.dsgState,\n      keyShare: this.keyShare?.toString('base64') ?? null,\n      message: this.message?.toString('base64') ?? null,\n      derivationPath: this.derivationPath,\n      partyIdx: this.partyIdx,\n      otherPartyIdx: this.otherPartyIdx,\n    });\n  }\n\n  /**\n   * Restores a previously exported session. Allows the protocol to continue from\n   * where it left off, as if the round state was loaded from a database.\n   */\n  restoreSession(session: string): void {\n    const data = JSON.parse(session);\n    if (!Object.values(DsgState).includes(data.dsgRound)) {\n      throw Error(`Invalid dsgRound in session: ${data.dsgRound}`);\n    }\n    if (data.dsgRound === DsgState.Uninitialized || data.dsgRound === DsgState.Init) {\n      throw Error(`Cannot restore DSG session in state ${data.dsgRound}`);\n    }\n    if (data.dsgRound === DsgState.Complete) {\n      throw Error('DSG session is complete. Restoring the session is not allowed.');\n    }\n    if (typeof data.partyIdx !== 'number' || data.partyIdx < 0 || data.partyIdx > 2) {\n      throw Error(`Invalid partyIdx in session: ${data.partyIdx}`);\n    }\n    if (\n      typeof data.otherPartyIdx !== 'number' ||\n      data.otherPartyIdx < 0 ||\n      data.otherPartyIdx > 2 ||\n      data.otherPartyIdx === data.partyIdx\n    ) {\n      throw Error(`Invalid otherPartyIdx in session: ${data.otherPartyIdx}`);\n    }\n    if (this.partyIdx !== data.partyIdx) {\n      throw Error(`Session partyIdx ${data.partyIdx} does not match instance ${this.partyIdx}`);\n    }\n    if (typeof data.dsgStateBytes !== 'string' || data.dsgStateBytes.length === 0) {\n      throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);\n    }\n    if (typeof data.keyShare !== 'string' || data.keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n    if (typeof data.message !== 'string' || data.message.length === 0) {\n      throw Error('Restored session missing message');\n    }\n    if (typeof data.derivationPath !== 'string') {\n      throw Error('Restored session missing derivationPath');\n    }\n\n    const dsgStateBytes = Buffer.from(data.dsgStateBytes, 'base64');\n    const keyShare = Buffer.from(data.keyShare, 'base64');\n    const message = Buffer.from(data.message, 'base64');\n    if (dsgStateBytes.length === 0) {\n      throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);\n    }\n    if (keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n    if (message.length === 0) {\n      throw Error('Restored session missing message');\n    }\n\n    this.dsgStateBytes = dsgStateBytes;\n    this.dsgState = data.dsgRound;\n    this.keyShare = keyShare;\n    this.message = message;\n    this.derivationPath = data.derivationPath;\n    this.partyIdx = data.partyIdx;\n    this.otherPartyIdx = data.otherPartyIdx;\n  }\n}\n"]}

package/dist/src/tss/eddsa-mps/index.d.ts

@@ -1,4 +1,5 @@
 export * as EddsaMPSDkg from './dkg';
+export * as EddsaMPSDsg from './dsg';
 export * as MPSUtil from './util';
 export * as MPSTypes from './types';
 export * as MPSComms from './commsLayer';

package/dist/src/tss/eddsa-mps/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,OAAO,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,QAAQ,MAAM,SAAS,CAAC;AACpC,OAAO,KAAK,QAAQ,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,OAAO,CAAC;AACrC,OAAO,KAAK,WAAW,MAAM,OAAO,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,QAAQ,MAAM,SAAS,CAAC;AACpC,OAAO,KAAK,QAAQ,MAAM,cAAc,CAAC"}