@bitgo-beta/sdk-lib-mpc 8.2.0-beta.1685 → 8.2.0-beta.1687

package/dist/src/tss/ecdsa-dkls/commsLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commsLayer.d.ts","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/commsLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGxG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2BAA2B,QAAsB,CAAC;AAE/D;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAkB7F;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,cAAc,CAAC,CA6BzB;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,yBAAyB,EAAE,cAAc,EACzC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAcxG;AAED;;;;;GAKG;AACH,wBAAsB,gCAAgC,CACpD,QAAQ,EAAE,eAAe,EACzB,sBAAsB,EAAE,WAAW,EAAE,EACrC,oBAAoB,EAAE,WAAW,EAAE,GAClC,OAAO,CAAC,kBAAkB,CAAC,CAoC7B;AAED;;;;;GAKG;AACH,wBAAsB,8BAA8B,CAClD,QAAQ,EAAE,kBAAkB,EAC5B,oBAAoB,EAAE,WAAW,EAAE,EACnC,wBAAwB,EAAE,WAAW,EAAE,GACtC,OAAO,CAAC,eAAe,CAAC,CAuC1B"}
+{"version":3,"file":"commsLayer.d.ts","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/commsLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGxG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2BAA2B,QAAsB,CAAC;AAE/D;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAkB7F;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,cAAc,CAAC,CA6BzB;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,yBAAyB,EAAE,cAAc,EACzC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAcxG;AAED;;;;;GAKG;AACH,wBAAsB,gCAAgC,CACpD,QAAQ,EAAE,eAAe,EACzB,sBAAsB,EAAE,WAAW,EAAE,EACrC,oBAAoB,EAAE,WAAW,EAAE,GAClC,OAAO,CAAC,kBAAkB,CAAC,CA0C7B;AAED;;;;;GAKG;AACH,wBAAsB,8BAA8B,CAClD,QAAQ,EAAE,kBAAkB,EAC5B,oBAAoB,EAAE,WAAW,EAAE,EACnC,wBAAwB,EAAE,WAAW,EAAE,GACtC,OAAO,CAAC,eAAe,CAAC,CAwC1B"}

package/dist/src/tss/ecdsa-dkls/commsLayer.js

@@ -209,9 +209,15 @@ async function decryptAndVerifyIncomingMessages(messages, pubVerificationGpgKeys
             if (!(await verifySignedData(m.payload, pubGpgKey.gpgKey))) {
                 throw Error(`Failed to authenticate broadcast message from party: ${m.from}`);
             }
+            if (m.signatureR !== undefined) {
+                if (!(await verifySignedData(m.signatureR, pubGpgKey.gpgKey))) {
+                    throw Error(`Failed to authenticate signatureR in broadcast message from party: ${m.from}`);
+                }
+            }
             return {
                 from: m.from,
                 payload: m.payload.message,
+                signatureR: m.signatureR?.message,
             };
         })),
     };
@@ -245,17 +251,18 @@ async function encryptAndAuthOutgoingMessages(messages, pubEncryptionGpgKeys, pr
             if (!prvGpgKey) {
                 throw Error(`No private key provided for sender with ID: ${m.from}`);
             }
+            const [signedPayload, signedSignatureR] = await Promise.all([
+                detachSignData(Buffer.from(m.payload, 'base64'), prvGpgKey.gpgKey),
+                m.signatureR
+                    ? detachSignData(Buffer.from(m.signatureR, 'base64'), prvGpgKey.gpgKey)
+                    : Promise.resolve(undefined),
+            ]);
             return {
                 from: m.from,
-                payload: await detachSignData(Buffer.from(m.payload, 'base64'), prvGpgKey.gpgKey),
-                signatureR: m.signatureR
-                    ? {
-                        message: m.signatureR,
-                        signature: '',
-                    }
-                    : undefined,
+                payload: signedPayload,
+                signatureR: signedSignatureR,
             };
         })),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commsLayer.js","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/commsLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,wCAkBC;AAQD,4DAiCC;AAQD,gEAyBC;AAOD,4CAcC;AAQD,4EAwCC;AAQD,wEA2CC;AAvPD,6CAA+B;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACU,QAAA,2BAA2B,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE/D;;;;GAIG;AACI,KAAK,UAAU,cAAc,CAAC,IAAY,EAAE,YAAoB;IACrE,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1E,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC;QAC/B,OAAO;QACP,WAAW,EAAE,UAAU;QACvB,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;KACF,CAAC,CAAC;IACH,OAAO;QACL,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAChC,SAAS,EAAE,SAAS;KACrB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,wBAAwB,CAC5C,IAAY,EACZ,WAAmB,EACnB,YAAoB;IAEpB,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1E,MAAM,gBAAgB,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC;QACzC,OAAO;QACP,cAAc,EAAE,SAAS;QACzB,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;KACF,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC;QAC/B,OAAO;QACP,WAAW,EAAE,UAAU;QACvB,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;KACF,CAAC,CAAC;IACH,OAAO;QACL,gBAAgB,EAAE,gBAAgB;QAClC,SAAS,EAAE,SAAS;KACrB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,0BAA0B,CAC9C,yBAAyC,EACzC,WAAmB,EACnB,YAAoB;IAEpB,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1E,MAAM,gBAAgB,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC;QACzC,OAAO,EAAE,MAAM,GAAG,CAAC,WAAW,CAAC,EAAE,cAAc,EAAE,yBAAyB,CAAC,gBAAgB,EAAE,CAAC;QAC9F,cAAc,EAAE,CAAC,UAAU,CAAC;QAC5B,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;QACD,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAC;IACH,MAAM,kBAAkB,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC;QAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,IAAI,EAAE,CAAC;QACnE,SAAS,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,gBAAgB,EAAE,yBAAyB,CAAC,SAAS,EAAE,CAAC;QAC7F,gBAAgB,EAAE,SAAS;QAC3B,IAAI,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,mCAA2B,CAAC;KACzD,CAAC,CAAC;IACH,MAAM,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAChD,OAAO,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAC/D,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,gBAAgB,CAAC,aAA0B,EAAE,WAAmB;IACpF,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IACjE,MAAM,kBAAkB,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC;QAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;QAC1F,SAAS,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,gBAAgB,EAAE,aAAa,CAAC,SAAS,EAAE,CAAC;QACjF,gBAAgB,EAAE,SAAS;QAC3B,IAAI,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,mCAA2B,CAAC;KACzD,CAAC,CAAC;IACH,IAAI,CAAC;QACH,MAAM,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAChD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,gCAAgC,CACpD,QAAyB,EACzB,sBAAqC,EACrC,oBAAmC;IAEnC,OAAO;QACL,WAAW,EAAE,MAAM,OAAO,CAAC,GAAG,CAC5B,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC3E,MAAM,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;YACvE,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,kDAAkD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACxE,CAAC;YACD,OAAO;gBACL,EAAE,EAAE,CAAC,CAAC,EAAE;gBACR,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,MAAM,0BAA0B,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC;gBACxF,UAAU,EAAE,CAAC,CAAC,UAAU;aACzB,CAAC;QACJ,CAAC,CAAC,CACH;QACD,iBAAiB,EAAE,MAAM,OAAO,CAAC,GAAG,CAClC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACzC,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC3E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,CAAC,CAAC,MAAM,gBAAgB,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;gBAC3D,MAAM,KAAK,CAAC,wDAAwD,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAChF,CAAC;YACD,OAAO;gBACL,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO;aAC3B,CAAC;QACJ,CAAC,CAAC,CACH;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,8BAA8B,CAClD,QAA4B,EAC5B,oBAAmC,EACnC,wBAAuC;IAEvC,OAAO;QACL,WAAW,EAAE,MAAM,OAAO,CAAC,GAAG,CAC5B,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;YACvE,MAAM,SAAS,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC7E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,iDAAiD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,OAAO;gBACL,EAAE,EAAE,CAAC,CAAC,EAAE;gBACR,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,MAAM,wBAAwB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC;gBAC7G,UAAU,EAAE,CAAC,CAAC,UAAU;aACzB,CAAC;QACJ,CAAC,CAAC,CACH;QACD,iBAAiB,EAAE,MAAM,OAAO,CAAC,GAAG,CAClC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACzC,MAAM,SAAS,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC7E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,OAAO;gBACL,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,MAAM,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC;gBACjF,UAAU,EAAE,CAAC,CAAC,UAAU;oBACtB,CAAC,CAAC;wBACE,OAAO,EAAE,CAAC,CAAC,UAAU;wBACrB,SAAS,EAAE,EAAE;qBACd;oBACH,CAAC,CAAC,SAAS;aACd,CAAC;QACJ,CAAC,CAAC,CACH;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { SerializedMessages, AuthEncMessage, AuthEncMessages, PartyGpgKey, AuthMessage } from './types';\nimport * as pgp from 'openpgp';\n\n/**\n * Tolerance window for OpenPGP date-based key validity checks (24 hours).\n *\n * Background: OpenPGP.js uses the `date` parameter to check key expiry at a\n * given point in time. We previously passed `date: null` to disable this check\n * entirely (see HSM-706) because OVC cold-signing flows for trust and SMC\n * clients can involve significant clock skew between the signing device and the\n * server — the device may be air-gapped and its clock can drift by hours.\n *\n * Note: this GPG expiry check is not strictly required for replay protection.\n * The DKLS protocol has its own mechanism for preventing replay attacks\n * (session-bound commitments and round-specific message validation), so the\n * OpenPGP date check is a defense-in-depth measure rather than the primary\n * replay mitigation.\n *\n * OpenPGP's `date` parameter shifts the reference time for ALL temporal\n * checks simultaneously (key expiry, self-signature validity, signature\n * freshness). This means a single shifted date cannot independently relax\n * key-expiry checks without breaking self-signature validation on fresh keys.\n *\n * Therefore:\n * - encrypt/decrypt omit `date` (use default = current time) for normal key\n *   expiry checking and self-signature validation.\n * - verify uses `now + tolerance` so that signatures from OVC devices whose\n *   clocks are up to 24 hours ahead are not rejected as \"from the future\".\n */\nexport const SIGNATURE_DATE_TOLERANCE_MS = 24 * 60 * 60 * 1000;\n\n/**\n * Detach signs a binary and encodes it in base64\n * @param data binary to encode in base64 and sign\n * @param privateArmor private key to sign with\n */\nexport async function detachSignData(data: Buffer, privateArmor: string): Promise<AuthMessage> {\n  const message = await pgp.createMessage({ binary: data });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const signature = await pgp.sign({\n    message,\n    signingKeys: privateKey,\n    format: 'armored',\n    detached: true,\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  return {\n    message: data.toString('base64'),\n    signature: signature,\n  };\n}\n\n/**\n * Encrypts and detach signs a binary\n * @param data binary to encrypt and sign\n * @param publicArmor public key to encrypt with\n * @param privateArmor private key to sign with\n */\nexport async function encryptAndDetachSignData(\n  data: Buffer,\n  publicArmor: string,\n  privateArmor: string\n): Promise<AuthEncMessage> {\n  const message = await pgp.createMessage({ binary: data });\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const encryptedMessage = await pgp.encrypt({\n    message,\n    encryptionKeys: publicKey,\n    format: 'armored',\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  const signature = await pgp.sign({\n    message,\n    signingKeys: privateKey,\n    format: 'armored',\n    detached: true,\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  return {\n    encryptedMessage: encryptedMessage,\n    signature: signature,\n  };\n}\n\n/**\n * Decrypts and verifies signature on a binary\n * @param encryptedAndSignedMessage message to decrypt and verify\n * @param publicArmor public key to verify signature with\n * @param privateArmor private key to decrypt with\n */\nexport async function decryptAndVerifySignedData(\n  encryptedAndSignedMessage: AuthEncMessage,\n  publicArmor: string,\n  privateArmor: string\n): Promise<string> {\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const decryptedMessage = await pgp.decrypt({\n    message: await pgp.readMessage({ armoredMessage: encryptedAndSignedMessage.encryptedMessage }),\n    decryptionKeys: [privateKey],\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n    format: 'binary',\n  });\n  const verificationResult = await pgp.verify({\n    message: await pgp.createMessage({ binary: decryptedMessage.data }),\n    signature: await pgp.readSignature({ armoredSignature: encryptedAndSignedMessage.signature }),\n    verificationKeys: publicKey,\n    date: new Date(Date.now() + SIGNATURE_DATE_TOLERANCE_MS),\n  });\n  await verificationResult.signatures[0].verified;\n  return Buffer.from(decryptedMessage.data).toString('base64');\n}\n\n/**\n * Verifies signature on a binary (message passed should be encoded in base64).\n * @param signedMessage message to verify\n * @param publicArmor public key to verify signature with\n */\nexport async function verifySignedData(signedMessage: AuthMessage, publicArmor: string): Promise<boolean> {\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const verificationResult = await pgp.verify({\n    message: await pgp.createMessage({ binary: Buffer.from(signedMessage.message, 'base64') }),\n    signature: await pgp.readSignature({ armoredSignature: signedMessage.signature }),\n    verificationKeys: publicKey,\n    date: new Date(Date.now() + SIGNATURE_DATE_TOLERANCE_MS),\n  });\n  try {\n    await verificationResult.signatures[0].verified;\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Decrypts and verifies p2p messages + verifies broadcast messages\n * @param messages message to decrypt and verify\n * @param pubVerificationGpgKeys public keys to verify signatures with\n * @param prvDecryptionGpgKeys private keys to decrypt with\n */\nexport async function decryptAndVerifyIncomingMessages(\n  messages: AuthEncMessages,\n  pubVerificationGpgKeys: PartyGpgKey[],\n  prvDecryptionGpgKeys: PartyGpgKey[]\n): Promise<SerializedMessages> {\n  return {\n    p2pMessages: await Promise.all(\n      messages.p2pMessages.map(async (m) => {\n        const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);\n        const prvGpgKey = prvDecryptionGpgKeys.find((k) => k.partyId === m.to);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for sender with ID: ${m.from}`);\n        }\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for recepient with ID: ${m.to}`);\n        }\n        return {\n          to: m.to,\n          from: m.from,\n          payload: await decryptAndVerifySignedData(m.payload, pubGpgKey.gpgKey, prvGpgKey.gpgKey),\n          commitment: m.commitment,\n        };\n      })\n    ),\n    broadcastMessages: await Promise.all(\n      messages.broadcastMessages.map(async (m) => {\n        const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for sender with ID: ${m.from}`);\n        }\n        if (!(await verifySignedData(m.payload, pubGpgKey.gpgKey))) {\n          throw Error(`Failed to authenticate broadcast message from party: ${m.from}`);\n        }\n        return {\n          from: m.from,\n          payload: m.payload.message,\n        };\n      })\n    ),\n  };\n}\n\n/**\n * Encrypts and signs p2p messages + signs broadcast messages\n * @param messages messages to encrypt and sign\n * @param pubEncryptionGpgKey public keys to encrypt data to\n * @param prvAuthenticationGpgKey private keys to sign with\n */\nexport async function encryptAndAuthOutgoingMessages(\n  messages: SerializedMessages,\n  pubEncryptionGpgKeys: PartyGpgKey[],\n  prvAuthenticationGpgKeys: PartyGpgKey[]\n): Promise<AuthEncMessages> {\n  return {\n    p2pMessages: await Promise.all(\n      messages.p2pMessages.map(async (m) => {\n        const pubGpgKey = pubEncryptionGpgKeys.find((k) => k.partyId === m.to);\n        const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for recipient with ID: ${m.to}`);\n        }\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for sender with ID: ${m.from}`);\n        }\n        return {\n          to: m.to,\n          from: m.from,\n          payload: await encryptAndDetachSignData(Buffer.from(m.payload, 'base64'), pubGpgKey.gpgKey, prvGpgKey.gpgKey),\n          commitment: m.commitment,\n        };\n      })\n    ),\n    broadcastMessages: await Promise.all(\n      messages.broadcastMessages.map(async (m) => {\n        const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for sender with ID: ${m.from}`);\n        }\n        return {\n          from: m.from,\n          payload: await detachSignData(Buffer.from(m.payload, 'base64'), prvGpgKey.gpgKey),\n          signatureR: m.signatureR\n            ? {\n                message: m.signatureR,\n                signature: '',\n              }\n            : undefined,\n        };\n      })\n    ),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commsLayer.js","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/commsLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,wCAkBC;AAQD,4DAiCC;AAQD,gEAyBC;AAOD,4CAcC;AAQD,4EA8CC;AAQD,wEA4CC;AA9PD,6CAA+B;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACU,QAAA,2BAA2B,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE/D;;;;GAIG;AACI,KAAK,UAAU,cAAc,CAAC,IAAY,EAAE,YAAoB;IACrE,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1E,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC;QAC/B,OAAO;QACP,WAAW,EAAE,UAAU;QACvB,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;KACF,CAAC,CAAC;IACH,OAAO;QACL,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAChC,SAAS,EAAE,SAAS;KACrB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,wBAAwB,CAC5C,IAAY,EACZ,WAAmB,EACnB,YAAoB;IAEpB,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1E,MAAM,gBAAgB,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC;QACzC,OAAO;QACP,cAAc,EAAE,SAAS;QACzB,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;KACF,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC;QAC/B,OAAO;QACP,WAAW,EAAE,UAAU;QACvB,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;KACF,CAAC,CAAC;IACH,OAAO;QACL,gBAAgB,EAAE,gBAAgB;QAClC,SAAS,EAAE,SAAS;KACrB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,0BAA0B,CAC9C,yBAAyC,EACzC,WAAmB,EACnB,YAAoB;IAEpB,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1E,MAAM,gBAAgB,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC;QACzC,OAAO,EAAE,MAAM,GAAG,CAAC,WAAW,CAAC,EAAE,cAAc,EAAE,yBAAyB,CAAC,gBAAgB,EAAE,CAAC;QAC9F,cAAc,EAAE,CAAC,UAAU,CAAC;QAC5B,MAAM,EAAE;YACN,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;SACnB;QACD,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAC;IACH,MAAM,kBAAkB,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC;QAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,IAAI,EAAE,CAAC;QACnE,SAAS,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,gBAAgB,EAAE,yBAAyB,CAAC,SAAS,EAAE,CAAC;QAC7F,gBAAgB,EAAE,SAAS;QAC3B,IAAI,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,mCAA2B,CAAC;KACzD,CAAC,CAAC;IACH,MAAM,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAChD,OAAO,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAC/D,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,gBAAgB,CAAC,aAA0B,EAAE,WAAmB;IACpF,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC;IACjE,MAAM,kBAAkB,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC;QAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;QAC1F,SAAS,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC,EAAE,gBAAgB,EAAE,aAAa,CAAC,SAAS,EAAE,CAAC;QACjF,gBAAgB,EAAE,SAAS;QAC3B,IAAI,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,mCAA2B,CAAC;KACzD,CAAC,CAAC;IACH,IAAI,CAAC;QACH,MAAM,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAChD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,gCAAgC,CACpD,QAAyB,EACzB,sBAAqC,EACrC,oBAAmC;IAEnC,OAAO;QACL,WAAW,EAAE,MAAM,OAAO,CAAC,GAAG,CAC5B,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC3E,MAAM,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;YACvE,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,kDAAkD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACxE,CAAC;YACD,OAAO;gBACL,EAAE,EAAE,CAAC,CAAC,EAAE;gBACR,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,MAAM,0BAA0B,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC;gBACxF,UAAU,EAAE,CAAC,CAAC,UAAU;aACzB,CAAC;QACJ,CAAC,CAAC,CACH;QACD,iBAAiB,EAAE,MAAM,OAAO,CAAC,GAAG,CAClC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACzC,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC3E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,CAAC,CAAC,MAAM,gBAAgB,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;gBAC3D,MAAM,KAAK,CAAC,wDAAwD,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAChF,CAAC;YACD,IAAI,CAAC,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;gBAC/B,IAAI,CAAC,CAAC,MAAM,gBAAgB,CAAC,CAAC,CAAC,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;oBAC9D,MAAM,KAAK,CAAC,sEAAsE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;gBAC9F,CAAC;YACH,CAAC;YACD,OAAO;gBACL,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO;gBAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,OAAO;aAClC,CAAC;QACJ,CAAC,CAAC,CACH;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,8BAA8B,CAClD,QAA4B,EAC5B,oBAAmC,EACnC,wBAAuC;IAEvC,OAAO;QACL,WAAW,EAAE,MAAM,OAAO,CAAC,GAAG,CAC5B,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;YACvE,MAAM,SAAS,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC7E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,iDAAiD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,OAAO;gBACL,EAAE,EAAE,CAAC,CAAC,EAAE;gBACR,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,MAAM,wBAAwB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC;gBAC7G,UAAU,EAAE,CAAC,CAAC,UAAU;aACzB,CAAC;QACJ,CAAC,CAAC,CACH;QACD,iBAAiB,EAAE,MAAM,OAAO,CAAC,GAAG,CAClC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACzC,MAAM,SAAS,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC7E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,MAAM,CAAC,aAAa,EAAE,gBAAgB,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;gBAC1D,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC;gBAClE,CAAC,CAAC,UAAU;oBACV,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC;oBACvE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;aAC/B,CAAC,CAAC;YACH,OAAO;gBACL,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,OAAO,EAAE,aAAa;gBACtB,UAAU,EAAE,gBAAgB;aAC7B,CAAC;QACJ,CAAC,CAAC,CACH;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { SerializedMessages, AuthEncMessage, AuthEncMessages, PartyGpgKey, AuthMessage } from './types';\nimport * as pgp from 'openpgp';\n\n/**\n * Tolerance window for OpenPGP date-based key validity checks (24 hours).\n *\n * Background: OpenPGP.js uses the `date` parameter to check key expiry at a\n * given point in time. We previously passed `date: null` to disable this check\n * entirely (see HSM-706) because OVC cold-signing flows for trust and SMC\n * clients can involve significant clock skew between the signing device and the\n * server — the device may be air-gapped and its clock can drift by hours.\n *\n * Note: this GPG expiry check is not strictly required for replay protection.\n * The DKLS protocol has its own mechanism for preventing replay attacks\n * (session-bound commitments and round-specific message validation), so the\n * OpenPGP date check is a defense-in-depth measure rather than the primary\n * replay mitigation.\n *\n * OpenPGP's `date` parameter shifts the reference time for ALL temporal\n * checks simultaneously (key expiry, self-signature validity, signature\n * freshness). This means a single shifted date cannot independently relax\n * key-expiry checks without breaking self-signature validation on fresh keys.\n *\n * Therefore:\n * - encrypt/decrypt omit `date` (use default = current time) for normal key\n *   expiry checking and self-signature validation.\n * - verify uses `now + tolerance` so that signatures from OVC devices whose\n *   clocks are up to 24 hours ahead are not rejected as \"from the future\".\n */\nexport const SIGNATURE_DATE_TOLERANCE_MS = 24 * 60 * 60 * 1000;\n\n/**\n * Detach signs a binary and encodes it in base64\n * @param data binary to encode in base64 and sign\n * @param privateArmor private key to sign with\n */\nexport async function detachSignData(data: Buffer, privateArmor: string): Promise<AuthMessage> {\n  const message = await pgp.createMessage({ binary: data });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const signature = await pgp.sign({\n    message,\n    signingKeys: privateKey,\n    format: 'armored',\n    detached: true,\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  return {\n    message: data.toString('base64'),\n    signature: signature,\n  };\n}\n\n/**\n * Encrypts and detach signs a binary\n * @param data binary to encrypt and sign\n * @param publicArmor public key to encrypt with\n * @param privateArmor private key to sign with\n */\nexport async function encryptAndDetachSignData(\n  data: Buffer,\n  publicArmor: string,\n  privateArmor: string\n): Promise<AuthEncMessage> {\n  const message = await pgp.createMessage({ binary: data });\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const encryptedMessage = await pgp.encrypt({\n    message,\n    encryptionKeys: publicKey,\n    format: 'armored',\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  const signature = await pgp.sign({\n    message,\n    signingKeys: privateKey,\n    format: 'armored',\n    detached: true,\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  return {\n    encryptedMessage: encryptedMessage,\n    signature: signature,\n  };\n}\n\n/**\n * Decrypts and verifies signature on a binary\n * @param encryptedAndSignedMessage message to decrypt and verify\n * @param publicArmor public key to verify signature with\n * @param privateArmor private key to decrypt with\n */\nexport async function decryptAndVerifySignedData(\n  encryptedAndSignedMessage: AuthEncMessage,\n  publicArmor: string,\n  privateArmor: string\n): Promise<string> {\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const decryptedMessage = await pgp.decrypt({\n    message: await pgp.readMessage({ armoredMessage: encryptedAndSignedMessage.encryptedMessage }),\n    decryptionKeys: [privateKey],\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n    format: 'binary',\n  });\n  const verificationResult = await pgp.verify({\n    message: await pgp.createMessage({ binary: decryptedMessage.data }),\n    signature: await pgp.readSignature({ armoredSignature: encryptedAndSignedMessage.signature }),\n    verificationKeys: publicKey,\n    date: new Date(Date.now() + SIGNATURE_DATE_TOLERANCE_MS),\n  });\n  await verificationResult.signatures[0].verified;\n  return Buffer.from(decryptedMessage.data).toString('base64');\n}\n\n/**\n * Verifies signature on a binary (message passed should be encoded in base64).\n * @param signedMessage message to verify\n * @param publicArmor public key to verify signature with\n */\nexport async function verifySignedData(signedMessage: AuthMessage, publicArmor: string): Promise<boolean> {\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const verificationResult = await pgp.verify({\n    message: await pgp.createMessage({ binary: Buffer.from(signedMessage.message, 'base64') }),\n    signature: await pgp.readSignature({ armoredSignature: signedMessage.signature }),\n    verificationKeys: publicKey,\n    date: new Date(Date.now() + SIGNATURE_DATE_TOLERANCE_MS),\n  });\n  try {\n    await verificationResult.signatures[0].verified;\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Decrypts and verifies p2p messages + verifies broadcast messages\n * @param messages message to decrypt and verify\n * @param pubVerificationGpgKeys public keys to verify signatures with\n * @param prvDecryptionGpgKeys private keys to decrypt with\n */\nexport async function decryptAndVerifyIncomingMessages(\n  messages: AuthEncMessages,\n  pubVerificationGpgKeys: PartyGpgKey[],\n  prvDecryptionGpgKeys: PartyGpgKey[]\n): Promise<SerializedMessages> {\n  return {\n    p2pMessages: await Promise.all(\n      messages.p2pMessages.map(async (m) => {\n        const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);\n        const prvGpgKey = prvDecryptionGpgKeys.find((k) => k.partyId === m.to);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for sender with ID: ${m.from}`);\n        }\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for recepient with ID: ${m.to}`);\n        }\n        return {\n          to: m.to,\n          from: m.from,\n          payload: await decryptAndVerifySignedData(m.payload, pubGpgKey.gpgKey, prvGpgKey.gpgKey),\n          commitment: m.commitment,\n        };\n      })\n    ),\n    broadcastMessages: await Promise.all(\n      messages.broadcastMessages.map(async (m) => {\n        const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for sender with ID: ${m.from}`);\n        }\n        if (!(await verifySignedData(m.payload, pubGpgKey.gpgKey))) {\n          throw Error(`Failed to authenticate broadcast message from party: ${m.from}`);\n        }\n        if (m.signatureR !== undefined) {\n          if (!(await verifySignedData(m.signatureR, pubGpgKey.gpgKey))) {\n            throw Error(`Failed to authenticate signatureR in broadcast message from party: ${m.from}`);\n          }\n        }\n        return {\n          from: m.from,\n          payload: m.payload.message,\n          signatureR: m.signatureR?.message,\n        };\n      })\n    ),\n  };\n}\n\n/**\n * Encrypts and signs p2p messages + signs broadcast messages\n * @param messages messages to encrypt and sign\n * @param pubEncryptionGpgKey public keys to encrypt data to\n * @param prvAuthenticationGpgKey private keys to sign with\n */\nexport async function encryptAndAuthOutgoingMessages(\n  messages: SerializedMessages,\n  pubEncryptionGpgKeys: PartyGpgKey[],\n  prvAuthenticationGpgKeys: PartyGpgKey[]\n): Promise<AuthEncMessages> {\n  return {\n    p2pMessages: await Promise.all(\n      messages.p2pMessages.map(async (m) => {\n        const pubGpgKey = pubEncryptionGpgKeys.find((k) => k.partyId === m.to);\n        const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for recipient with ID: ${m.to}`);\n        }\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for sender with ID: ${m.from}`);\n        }\n        return {\n          to: m.to,\n          from: m.from,\n          payload: await encryptAndDetachSignData(Buffer.from(m.payload, 'base64'), pubGpgKey.gpgKey, prvGpgKey.gpgKey),\n          commitment: m.commitment,\n        };\n      })\n    ),\n    broadcastMessages: await Promise.all(\n      messages.broadcastMessages.map(async (m) => {\n        const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for sender with ID: ${m.from}`);\n        }\n        const [signedPayload, signedSignatureR] = await Promise.all([\n          detachSignData(Buffer.from(m.payload, 'base64'), prvGpgKey.gpgKey),\n          m.signatureR\n            ? detachSignData(Buffer.from(m.signatureR, 'base64'), prvGpgKey.gpgKey)\n            : Promise.resolve(undefined),\n        ]);\n        return {\n          from: m.from,\n          payload: signedPayload,\n          signatureR: signedSignatureR,\n        };\n      })\n    ),\n  };\n}\n"]}

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

@@ -0,0 +1,93 @@
+import { DeserializedMessage, DeserializedMessages, DkgState } from './types';
+/**
+ * EdDSA Distributed Key Generation (DKG) implementation using @bitgo/wasm-mps.
+ *
+ * State is explicit: each round function returns `{ msg, state }` bytes.
+ * The state bytes are stored between rounds and passed to the next round function,
+ * mirroring the server-side persistence pattern (state would be serialised to DB).
+ *
+ * @example
+ * ```typescript
+ * const dkg = new DKG(3, 2, 0);
+ * // X25519 keys come from GPG encryption subkeys (extracted by the orchestrator)
+ * dkg.initDkg(myX25519PrivKey, [otherParty1X25519PubKey, otherParty2X25519PubKey]);
+ * const msg1 = dkg.getFirstMessage();
+ * const msg2s = dkg.handleIncomingMessages(allThreeMsg1s);
+ * dkg.handleIncomingMessages(allThreeMsg2s);  // completes DKG
+ * const keyShare = dkg.getKeyShare();
+ * ```
+ */
+export declare class DKG {
+    protected n: number;
+    protected t: number;
+    protected partyIdx: number;
+    /** Private X25519 key (from GPG encryption subkey) */
+    private decryptionKey;
+    /** Other parties' X25519 public keys (from their GPG encryption subkeys), sorted by party index */
+    private otherPubKeys;
+    /** Serialised round state bytes returned by the previous round function */
+    private dkgStateBytes;
+    /** Opaque bincode-serialised keyshare from round2 */
+    private keyShare;
+    /** 32-byte Ed25519 public key from round2 */
+    private sharePk;
+    protected dkgState: DkgState;
+    constructor(n: number, t: number, partyIdx: number);
+    getState(): DkgState;
+    /**
+     * Initialises the DKG session with this party's X25519 private key and the other parties'
+     * X25519 public keys. Keys are extracted from GPG encryption subkeys by the orchestrator.
+     *
+     * @param decryptionKey - This party's 32-byte X25519 private key (GPG enc subkey private part).
+     * @param otherEncPublicKeys - Other parties' 32-byte X25519 public keys, sorted by ascending
+     *   party index (excluding own). For a 3-party setup, this is [party_A_pub, party_B_pub].
+     */
+    initDkg(decryptionKey: Buffer, otherEncPublicKeys: Buffer[]): void;
+    /**
+     * Runs round0 of the DKG protocol. Returns this party's broadcast message.
+     * Stores the round state bytes internally for the next round.
+     *
+     * @param dkgSeed - Optional 32-byte seed for deterministic DKG output (testing only).
+     */
+    getFirstMessage(dkgSeed?: Buffer): DeserializedMessage;
+    /**
+     * Handles incoming messages from all parties and advances the protocol.
+     *
+     * - In WaitMsg1: runs round1, returns this party's round1 broadcast message.
+     * - In WaitMsg2: runs round2, completes DKG, returns [].
+     *
+     * The caller passes all n messages (including own); own message is filtered
+     * out internally. Other parties' messages are sorted by ascending party index,
+     * matching the ordering expected by @bitgo/wasm-mps.
+     *
+     * @param messagesForIthRound - All n messages for this round (including own).
+     */
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
+    /**
+     * Returns the opaque bincode-serialised keyshare produced by round2.
+     * This is used as input to the signing protocol.
+     */
+    getKeyShare(): Buffer;
+    /**
+     * Returns the 32-byte Ed25519 public key agreed by all parties during DKG.
+     */
+    getSharePublicKey(): Buffer;
+    /**
+     * Returns a CBOR-encoded reduced representation containing the public key.
+     * Note: private key material and chain code are not separately accessible
+     * from @bitgo/wasm-mps; the full keyshare is available via getKeyShare().
+     */
+    getReducedKeyShare(): Buffer;
+    /**
+     * Exports the current session state as a JSON string for persistence.
+     * Includes: round state bytes, current DKG round, decryption key, other parties' pub keys.
+     * This mirrors what a server would store in a database between API rounds.
+     */
+    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=dkg.d.ts.map

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

@@ -0,0 +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;AAEpG;;;;;;;;;;;;;;;;;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;IAEtC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAA0B;gBAE1C,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAMlD,QAAQ,IAAI,QAAQ;IAIpB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,IAAI;IAgBlE;;;;;OAKG;IACH,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,mBAAmB;IAkBtD;;;;;;;;;;;OAWG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IAoDvF;;;OAGG;IACH,WAAW,IAAI,MAAM;IAOrB;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAO3B;;;;OAIG;IACH,kBAAkB,IAAI,MAAM;IAU5B;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAepB;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAOtC"}

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

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DKG = void 0;
+const wasm_mps_1 = require("@bitgo/wasm-mps");
+const cbor_x_1 = require("cbor-x");
+const crypto_1 = __importDefault(require("crypto"));
+const types_1 = require("./types");
+/**
+ * EdDSA Distributed Key Generation (DKG) implementation using @bitgo/wasm-mps.
+ *
+ * State is explicit: each round function returns `{ msg, state }` bytes.
+ * The state bytes are stored between rounds and passed to the next round function,
+ * mirroring the server-side persistence pattern (state would be serialised to DB).
+ *
+ * @example
+ * ```typescript
+ * const dkg = new DKG(3, 2, 0);
+ * // X25519 keys come from GPG encryption subkeys (extracted by the orchestrator)
+ * dkg.initDkg(myX25519PrivKey, [otherParty1X25519PubKey, otherParty2X25519PubKey]);
+ * const msg1 = dkg.getFirstMessage();
+ * const msg2s = dkg.handleIncomingMessages(allThreeMsg1s);
+ * dkg.handleIncomingMessages(allThreeMsg2s);  // completes DKG
+ * const keyShare = dkg.getKeyShare();
+ * ```
+ */
+class DKG {
+    constructor(n, t, partyIdx) {
+        /** Private X25519 key (from GPG encryption subkey) */
+        this.decryptionKey = null;
+        /** Other parties' X25519 public keys (from their GPG encryption subkeys), sorted by party index */
+        this.otherPubKeys = null;
+        /** Serialised round state bytes returned by the previous round function */
+        this.dkgStateBytes = null;
+        /** Opaque bincode-serialised keyshare from round2 */
+        this.keyShare = null;
+        /** 32-byte Ed25519 public key from round2 */
+        this.sharePk = null;
+        this.dkgState = types_1.DkgState.Uninitialized;
+        this.n = n;
+        this.t = t;
+        this.partyIdx = partyIdx;
+    }
+    getState() {
+        return this.dkgState;
+    }
+    /**
+     * Initialises the DKG session with this party's X25519 private key and the other parties'
+     * X25519 public keys. Keys are extracted from GPG encryption subkeys by the orchestrator.
+     *
+     * @param decryptionKey - This party's 32-byte X25519 private key (GPG enc subkey private part).
+     * @param otherEncPublicKeys - Other parties' 32-byte X25519 public keys, sorted by ascending
+     *   party index (excluding own). For a 3-party setup, this is [party_A_pub, party_B_pub].
+     */
+    initDkg(decryptionKey, otherEncPublicKeys) {
+        if (!decryptionKey || decryptionKey.length !== 32) {
+            throw Error('Missing or invalid decryption key: must be 32 bytes');
+        }
+        if (!otherEncPublicKeys || otherEncPublicKeys.length !== this.n - 1) {
+            throw Error(`Expected ${this.n - 1} other parties' public keys`);
+        }
+        if (this.t > this.n || this.partyIdx >= this.n) {
+            throw Error('Invalid parameters for DKG');
+        }
+        this.decryptionKey = decryptionKey;
+        this.otherPubKeys = otherEncPublicKeys;
+        this.dkgState = types_1.DkgState.Init;
+    }
+    /**
+     * Runs round0 of the DKG protocol. Returns this party's broadcast message.
+     * Stores the round state bytes internally for the next round.
+     *
+     * @param dkgSeed - Optional 32-byte seed for deterministic DKG output (testing only).
+     */
+    getFirstMessage(dkgSeed) {
+        if (this.dkgState !== types_1.DkgState.Init) {
+            throw Error('DKG session not initialized');
+        }
+        const seed = dkgSeed ?? crypto_1.default.randomBytes(32);
+        let result;
+        try {
+            result = (0, wasm_mps_1.ed25519_dkg_round0_process)(this.partyIdx, this.decryptionKey, this.otherPubKeys, seed);
+        }
+        catch (err) {
+            throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);
+        }
+        this.dkgStateBytes = Buffer.from(result.state);
+        this.dkgState = types_1.DkgState.WaitMsg1;
+        return { payload: new Uint8Array(result.msg), from: this.partyIdx };
+    }
+    /**
+     * Handles incoming messages from all parties and advances the protocol.
+     *
+     * - In WaitMsg1: runs round1, returns this party's round1 broadcast message.
+     * - In WaitMsg2: runs round2, completes DKG, returns [].
+     *
+     * The caller passes all n messages (including own); own message is filtered
+     * out internally. Other parties' messages are sorted by ascending party index,
+     * matching the ordering expected by @bitgo/wasm-mps.
+     *
+     * @param messagesForIthRound - All n messages for this round (including own).
+     */
+    handleIncomingMessages(messagesForIthRound) {
+        if (this.dkgState === types_1.DkgState.Complete) {
+            throw Error('DKG session already completed');
+        }
+        if (this.dkgState === types_1.DkgState.Uninitialized) {
+            throw Error('DKG session not initialized');
+        }
+        if (this.dkgState === types_1.DkgState.Init) {
+            throw Error('DKG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.');
+        }
+        if (messagesForIthRound.length !== this.n) {
+            throw Error('Invalid number of messages for the round. Number of messages should be equal to N');
+        }
+        // Extract other parties' messages, sorted by party index (ascending)
+        const otherMsgs = messagesForIthRound
+            .filter((m) => m.from !== this.partyIdx)
+            .sort((a, b) => a.from - b.from)
+            .map((m) => m.payload);
+        if (this.dkgState === types_1.DkgState.WaitMsg1) {
+            let result;
+            try {
+                result = (0, wasm_mps_1.ed25519_dkg_round1_process)(otherMsgs, this.dkgStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);
+            }
+            // Store new state; this is what would be persisted to DB between API rounds
+            this.dkgStateBytes = Buffer.from(result.state);
+            this.dkgState = types_1.DkgState.WaitMsg2;
+            return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];
+        }
+        if (this.dkgState === types_1.DkgState.WaitMsg2) {
+            let share;
+            try {
+                share = (0, wasm_mps_1.ed25519_dkg_round2_process)(otherMsgs, this.dkgStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);
+            }
+            this.keyShare = Buffer.from(share.share);
+            this.sharePk = Buffer.from(share.pk);
+            this.dkgStateBytes = null;
+            this.dkgState = types_1.DkgState.Complete;
+            return [];
+        }
+        throw Error('Unexpected DKG state');
+    }
+    /**
+     * Returns the opaque bincode-serialised keyshare produced by round2.
+     * This is used as input to the signing protocol.
+     */
+    getKeyShare() {
+        if (!this.keyShare) {
+            throw Error('DKG session not initialized');
+        }
+        return this.keyShare;
+    }
+    /**
+     * Returns the 32-byte Ed25519 public key agreed by all parties during DKG.
+     */
+    getSharePublicKey() {
+        if (!this.sharePk) {
+            throw Error('DKG session not initialized');
+        }
+        return this.sharePk;
+    }
+    /**
+     * Returns a CBOR-encoded reduced representation containing the public key.
+     * Note: private key material and chain code are not separately accessible
+     * from @bitgo/wasm-mps; the full keyshare is available via getKeyShare().
+     */
+    getReducedKeyShare() {
+        if (!this.sharePk) {
+            throw Error('DKG session not initialized');
+        }
+        const reducedKeyShare = {
+            pub: Array.from(this.sharePk),
+        };
+        return Buffer.from((0, cbor_x_1.encode)(reducedKeyShare));
+    }
+    /**
+     * Exports the current session state as a JSON string for persistence.
+     * Includes: round state bytes, current DKG round, decryption key, other parties' pub keys.
+     * This mirrors what a server would store in a database between API rounds.
+     */
+    getSession() {
+        if (this.dkgState === types_1.DkgState.Complete) {
+            throw Error('DKG session is complete. Exporting the session is not allowed.');
+        }
+        if (this.dkgState === types_1.DkgState.Uninitialized) {
+            throw Error('DKG session not initialized');
+        }
+        return JSON.stringify({
+            dkgStateBytes: this.dkgStateBytes?.toString('base64') ?? null,
+            dkgRound: this.dkgState,
+            decryptionKey: this.decryptionKey?.toString('base64') ?? null,
+            otherPubKeys: this.otherPubKeys?.map((k) => k.toString('base64')) ?? null,
+        });
+    }
+    /**
+     * 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);
+        this.dkgStateBytes = data.dkgStateBytes ? Buffer.from(data.dkgStateBytes, 'base64') : null;
+        this.dkgState = data.dkgRound;
+        this.decryptionKey = data.decryptionKey ? Buffer.from(data.decryptionKey, 'base64') : null;
+        this.otherPubKeys = data.otherPubKeys ? data.otherPubKeys.map((k) => Buffer.from(k, 'base64')) : null;
+    }
+}
+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 { ed25519_dkg_round0_process, ed25519_dkg_round1_process, ed25519_dkg_round2_process } from '@bitgo/wasm-mps';\nimport { encode } from 'cbor-x';\nimport crypto from 'crypto';\nimport { DeserializedMessage, DeserializedMessages, DkgState, EddsaReducedKeyShare } from './types';\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 * 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\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  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  initDkg(decryptionKey: Buffer, otherEncPublicKeys: Buffer[]): void {\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    let result;\n    try {\n      result = 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    if (this.dkgState === DkgState.WaitMsg1) {\n      let result;\n      try {\n        result = 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;\n      try {\n        share = 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.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 a CBOR-encoded reduced representation containing the public key.\n   * Note: private key material and chain code are not separately accessible\n   * from @bitgo/wasm-mps; the full keyshare is available via getKeyShare().\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"]}

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

@@ -0,0 +1,4 @@
+export * as EddsaMPSDkg from './dkg';
+export * as MPSUtil from './util';
+export * as MPSTypes from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MPSTypes = exports.MPSUtil = exports.EddsaMPSDkg = void 0;
+exports.EddsaMPSDkg = __importStar(require("./dkg"));
+exports.MPSUtil = __importStar(require("./util"));
+exports.MPSTypes = __importStar(require("./types"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHNzL2VkZHNhLW1wcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxREFBcUM7QUFDckMsa0RBQWtDO0FBQ2xDLG9EQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGFzIEVkZHNhTVBTRGtnIGZyb20gJy4vZGtnJztcbmV4cG9ydCAqIGFzIE1QU1V0aWwgZnJvbSAnLi91dGlsJztcbmV4cG9ydCAqIGFzIE1QU1R5cGVzIGZyb20gJy4vdHlwZXMnO1xuIl19

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

@@ -0,0 +1,36 @@
+import * as t from 'io-ts';
+export declare const ReducedKeyShareType: t.TypeC<{
+    pub: t.ArrayC<t.NumberC>;
+}>;
+export type EddsaReducedKeyShare = t.TypeOf<typeof ReducedKeyShareType>;
+/**
+ * Represents the state of a DKG (Distributed Key Generation) session
+ */
+export declare enum DkgState {
+    /** DKG session has not been initialized */
+    Uninitialized = "Uninitialized",
+    /** DKG session has been initialized (Init state in WASM) */
+    Init = "Init",
+    /** DKG session is waiting for first message (WaitMsg1 state in WASM) */
+    WaitMsg1 = "WaitMsg1",
+    /** DKG session is waiting for second message (WaitMsg2 state in WASM) */
+    WaitMsg2 = "WaitMsg2",
+    /** DKG session has generated key shares (Share state in WASM) */
+    Share = "Share",
+    /** DKG session has completed successfully and key shares are available */
+    Complete = "Complete"
+}
+export interface Message<T> {
+    payload: T;
+    from: number;
+}
+export type SerializedMessage = Message<string>;
+export type SerializedMessages = Message<string>[];
+export type DeserializedMessage = Message<Uint8Array>;
+export type DeserializedMessages = Message<Uint8Array>[];
+export declare function serializeMessage(msg: DeserializedMessage): SerializedMessage;
+export declare function deserializeMessage(msg: SerializedMessage): DeserializedMessage;
+export declare function serializeMessages(msgs: DeserializedMessages): SerializedMessages;
+export declare function deserializeMessages(msgs: SerializedMessages): DeserializedMessages;
+export declare function getDecodedReducedKeyShare(reducedKeyShare: Buffer | Uint8Array): EddsaReducedKeyShare;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tss/eddsa-mps/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAE3B,eAAO,MAAM,mBAAmB;;EAE9B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAExE;;GAEG;AACH,oBAAY,QAAQ;IAClB,2CAA2C;IAC3C,aAAa,kBAAkB;IAC/B,4DAA4D;IAC5D,IAAI,SAAS;IACb,wEAAwE;IACxE,QAAQ,aAAa;IACrB,yEAAyE;IACzE,QAAQ,aAAa;IACrB,iEAAiE;IACjE,KAAK,UAAU;IACf,0EAA0E;IAC1E,QAAQ,aAAa;CACtB;AAED,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAEhD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;AAEnD,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAEtD,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;AAEzD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,CAE5E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,iBAAiB,GAAG,mBAAmB,CAE9E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,oBAAoB,GAAG,kBAAkB,CAEhF;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,GAAG,oBAAoB,CAElF;AAED,wBAAgB,yBAAyB,CAAC,eAAe,EAAE,MAAM,GAAG,UAAU,GAAG,oBAAoB,CAMpG"}