@bitgo-beta/sdk-lib-mpc 8.2.1-alpha.6 → 8.2.1-alpha.61

package/dist/src/tss/ecdsa/zkVProof.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { BaseCurve as Curve } from '../../curves';
+import { ZkVProof } from './types';
+/**
+ * Create a ZK Proof of knowledge of the s and l that are behind the public value V = sR + lG.
+ * @param V The curve point V.
+ * @param s The s that multiplies R.
+ * @param l The l that multiplies the curve genreator G.
+ * @param R The curve point R shared by all participants.
+ * @param curve The elliptic curve.
+ * @param additionalCtx Additional contextual information to associate with the proof.
+ * @returns The created proof.
+ */
+export declare function createZkVProof(V: bigint, s: bigint, l: bigint, R: bigint, curve: Curve, additionalCtx?: Buffer): ZkVProof;
+/**
+ * Verify a ZK Proof of knowledge of the s and l that are behind the public value V = sR + lG.
+ * @param V The curve point V.
+ * @param proof The ZK proof.
+ * @param R The curve point R shared by all participants.
+ * @param curve The elliptic curve.
+ * @param additionalCtx Additional contextual information that is supposed to associate with the proof.
+ * @returns True if the proof checks out.
+ */
+export declare function verifyZkVProof(V: bigint, proof: ZkVProof, R: bigint, curve: Curve, additionalCtx?: Buffer): boolean;
+//# sourceMappingURL=zkVProof.d.ts.map

package/dist/src/tss/ecdsa/zkVProof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zkVProof.d.ts","sourceRoot":"","sources":["../../../../src/tss/ecdsa/zkVProof.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,SAAS,IAAI,KAAK,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,KAAK,EACZ,aAAa,GAAE,MAAwB,GACtC,QAAQ,CAeV;AAyBD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,QAAQ,EACf,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,KAAK,EACZ,aAAa,GAAE,MAAwB,GACtC,OAAO,CAOT"}

package/dist/src/tss/ecdsa/zkVProof.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyZkVProof = exports.createZkVProof = void 0;
+/**
+ * Zero Knowledge Proof of knowledge of the s and l that are behind the public value V = sR + lG.
+ * The V value is calculated in step 5A and the proof is created in step 5B of the GG18 signing protocol.
+ * @see {@link https://eprint.iacr.org/2019/114.pdf} section 4.3 for reference.
+ */
+const crypto_1 = require("crypto");
+const util_1 = require("../../util");
+/**
+ * Create a ZK Proof of knowledge of the s and l that are behind the public value V = sR + lG.
+ * @param V The curve point V.
+ * @param s The s that multiplies R.
+ * @param l The l that multiplies the curve genreator G.
+ * @param R The curve point R shared by all participants.
+ * @param curve The elliptic curve.
+ * @param additionalCtx Additional contextual information to associate with the proof.
+ * @returns The created proof.
+ */
+function createZkVProof(V, s, l, R, curve, additionalCtx = Buffer.from('')) {
+    const a = curve.scalarRandom();
+    const b = curve.scalarRandom();
+    const Alpha = curve.pointAdd(curve.pointMultiply(R, a), curve.basePointMult(b));
+    const c = nonInteractiveChallenge(V, R, Alpha, curve, additionalCtx);
+    const t = curve.scalarAdd(a, curve.scalarMult(c, s));
+    const u = curve.scalarAdd(b, curve.scalarMult(c, l));
+    return {
+        Alpha: Alpha,
+        t: t,
+        u: u,
+    };
+}
+exports.createZkVProof = createZkVProof;
+/**
+ * Calculate challenge for NIZK proof of V using Fiat-Shamir transform.
+ *
+ * @param V The point to be proven.
+ * @param R The point R shared by all participants in the ECDSA signing protocol.
+ * @param Alpha The point/public value corresponding to the random scalar values a and b chosen by the prover.
+ * @param curve The elliptic curve.
+ * @param additionalCtx Additional contextual information to associate with the proof.
+ * @returns The calculated challenge.
+ */
+function nonInteractiveChallenge(V, R, Alpha, curve, additionalCtx) {
+    const G = curve.basePointMult(BigInt(1));
+    const hash = crypto_1.createHash('sha256');
+    hash.update(util_1.bigIntToBufferBE(G, curve.pointBytes));
+    hash.update(util_1.bigIntToBufferBE(R, curve.pointBytes));
+    hash.update(util_1.bigIntToBufferBE(V, curve.pointBytes));
+    hash.update(util_1.bigIntToBufferBE(Alpha, curve.pointBytes));
+    hash.update(additionalCtx);
+    return util_1.bigIntFromBufferBE(hash.digest());
+}
+/**
+ * Verify a ZK Proof of knowledge of the s and l that are behind the public value V = sR + lG.
+ * @param V The curve point V.
+ * @param proof The ZK proof.
+ * @param R The curve point R shared by all participants.
+ * @param curve The elliptic curve.
+ * @param additionalCtx Additional contextual information that is supposed to associate with the proof.
+ * @returns True if the proof checks out.
+ */
+function verifyZkVProof(V, proof, R, curve, additionalCtx = Buffer.from('')) {
+    const c = nonInteractiveChallenge(V, R, proof.Alpha, curve, additionalCtx);
+    const lhs = curve.pointAdd(curve.pointMultiply(R, proof.t), curve.basePointMult(proof.u));
+    const rhs = curve.pointAdd(proof.Alpha, curve.pointMultiply(V, curve.scalarReduce(c)));
+    return lhs === rhs;
+}
+exports.verifyZkVProof = verifyZkVProof;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { SerializedMessages, AuthEncMessage, AuthEncMessages, PartyGpgKey, AuthMessage } from './types';
+/**
+ * Detach signs a binary and encodes it in base64
+ * @param data binary to encode in base64 and sign
+ * @param privateArmor private key to sign with
+ */
+export declare function detachSignData(data: Buffer, privateArmor: string): Promise<AuthMessage>;
+/**
+ * Encrypts and detach signs a binary
+ * @param data binary to encrypt and sign
+ * @param publicArmor public key to encrypt with
+ * @param privateArmor private key to sign with
+ */
+export declare function encryptAndDetachSignData(data: Buffer, publicArmor: string, privateArmor: string): Promise<AuthEncMessage>;
+/**
+ * Decrypts and verifies signature on a binary
+ * @param encryptedAndSignedMessage message to decrypt and verify
+ * @param publicArmor public key to verify signature with
+ * @param privateArmor private key to decrypt with
+ */
+export declare function decryptAndVerifySignedData(encryptedAndSignedMessage: AuthEncMessage, publicArmor: string, privateArmor: string): Promise<string>;
+/**
+ * Verifies signature on a binary (message passed should be encoded in base64).
+ * @param signedMessage message to verify
+ * @param publicArmor public key to verify signature with
+ */
+export declare function verifySignedData(signedMessage: AuthMessage, publicArmor: string): Promise<boolean>;
+/**
+ * Decrypts and verifies p2p messages + verifies broadcast messages
+ * @param messages message to decrypt and verify
+ * @param pubVerificationGpgKeys public keys to verify signatures with
+ * @param prvDecryptionGpgKeys private keys to decrypt with
+ */
+export declare function decryptAndVerifyIncomingMessages(messages: AuthEncMessages, pubVerificationGpgKeys: PartyGpgKey[], prvDecryptionGpgKeys: PartyGpgKey[]): Promise<SerializedMessages>;
+/**
+ * Encrypts and signs p2p messages + signs broadcast messages
+ * @param messages messages to encrypt and sign
+ * @param pubEncryptionGpgKey public keys to encrypt data to
+ * @param prvAuthenticationGpgKey private keys to sign with
+ */
+export declare function encryptAndAuthOutgoingMessages(messages: SerializedMessages, pubEncryptionGpgKeys: PartyGpgKey[], prvAuthenticationGpgKeys: PartyGpgKey[]): Promise<AuthEncMessages>;
+//# sourceMappingURL=commsLayer.d.ts.map

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

@@ -0,0 +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;;;;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,CAoBjB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAaxG;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,CAiC1B"}

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

@@ -0,0 +1,212 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptAndAuthOutgoingMessages = exports.decryptAndVerifyIncomingMessages = exports.verifySignedData = exports.decryptAndVerifySignedData = exports.encryptAndDetachSignData = exports.detachSignData = void 0;
+const pgp = __importStar(require("openpgp"));
+/**
+ * Detach signs a binary and encodes it in base64
+ * @param data binary to encode in base64 and sign
+ * @param privateArmor private key to sign with
+ */
+async function detachSignData(data, privateArmor) {
+    const message = await pgp.createMessage({ binary: data });
+    const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });
+    const signature = await pgp.sign({
+        message,
+        signingKeys: privateKey,
+        format: 'armored',
+        detached: true,
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+    return {
+        message: data.toString('base64'),
+        signature: signature,
+    };
+}
+exports.detachSignData = detachSignData;
+/**
+ * Encrypts and detach signs a binary
+ * @param data binary to encrypt and sign
+ * @param publicArmor public key to encrypt with
+ * @param privateArmor private key to sign with
+ */
+async function encryptAndDetachSignData(data, publicArmor, privateArmor) {
+    const message = await pgp.createMessage({ binary: data });
+    const publicKey = await pgp.readKey({ armoredKey: publicArmor });
+    const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });
+    const encryptedMessage = await pgp.encrypt({
+        message,
+        encryptionKeys: publicKey,
+        format: 'armored',
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+    const signature = await pgp.sign({
+        message,
+        signingKeys: privateKey,
+        format: 'armored',
+        detached: true,
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+    return {
+        encryptedMessage: encryptedMessage,
+        signature: signature,
+    };
+}
+exports.encryptAndDetachSignData = encryptAndDetachSignData;
+/**
+ * Decrypts and verifies signature on a binary
+ * @param encryptedAndSignedMessage message to decrypt and verify
+ * @param publicArmor public key to verify signature with
+ * @param privateArmor private key to decrypt with
+ */
+async function decryptAndVerifySignedData(encryptedAndSignedMessage, publicArmor, privateArmor) {
+    const publicKey = await pgp.readKey({ armoredKey: publicArmor });
+    const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });
+    const decryptedMessage = await pgp.decrypt({
+        message: await pgp.readMessage({ armoredMessage: encryptedAndSignedMessage.encryptedMessage }),
+        decryptionKeys: [privateKey],
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+        format: 'binary',
+    });
+    const verificationResult = await pgp.verify({
+        message: await pgp.createMessage({ binary: decryptedMessage.data }),
+        signature: await pgp.readSignature({ armoredSignature: encryptedAndSignedMessage.signature }),
+        verificationKeys: publicKey,
+    });
+    await verificationResult.signatures[0].verified;
+    return Buffer.from(decryptedMessage.data).toString('base64');
+}
+exports.decryptAndVerifySignedData = decryptAndVerifySignedData;
+/**
+ * Verifies signature on a binary (message passed should be encoded in base64).
+ * @param signedMessage message to verify
+ * @param publicArmor public key to verify signature with
+ */
+async function verifySignedData(signedMessage, publicArmor) {
+    const publicKey = await pgp.readKey({ armoredKey: publicArmor });
+    const verificationResult = await pgp.verify({
+        message: await pgp.createMessage({ binary: Buffer.from(signedMessage.message, 'base64') }),
+        signature: await pgp.readSignature({ armoredSignature: signedMessage.signature }),
+        verificationKeys: publicKey,
+    });
+    try {
+        await verificationResult.signatures[0].verified;
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.verifySignedData = verifySignedData;
+/**
+ * Decrypts and verifies p2p messages + verifies broadcast messages
+ * @param messages message to decrypt and verify
+ * @param pubVerificationGpgKeys public keys to verify signatures with
+ * @param prvDecryptionGpgKeys private keys to decrypt with
+ */
+async function decryptAndVerifyIncomingMessages(messages, pubVerificationGpgKeys, prvDecryptionGpgKeys) {
+    return {
+        p2pMessages: await Promise.all(messages.p2pMessages.map(async (m) => {
+            const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);
+            const prvGpgKey = prvDecryptionGpgKeys.find((k) => k.partyId === m.to);
+            if (!pubGpgKey) {
+                throw Error(`No public key provided for sender with ID: ${m.from}`);
+            }
+            if (!prvGpgKey) {
+                throw Error(`No private key provided for recepient with ID: ${m.to}`);
+            }
+            return {
+                to: m.to,
+                from: m.from,
+                payload: await decryptAndVerifySignedData(m.payload, pubGpgKey.gpgKey, prvGpgKey.gpgKey),
+                commitment: m.commitment,
+            };
+        })),
+        broadcastMessages: await Promise.all(messages.broadcastMessages.map(async (m) => {
+            const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);
+            if (!pubGpgKey) {
+                throw Error(`No public key provided for sender with ID: ${m.from}`);
+            }
+            if (!(await verifySignedData(m.payload, pubGpgKey.gpgKey))) {
+                throw Error(`Failed to authenticate broadcast message from party: ${m.from}`);
+            }
+            return {
+                from: m.from,
+                payload: m.payload.message,
+            };
+        })),
+    };
+}
+exports.decryptAndVerifyIncomingMessages = decryptAndVerifyIncomingMessages;
+/**
+ * Encrypts and signs p2p messages + signs broadcast messages
+ * @param messages messages to encrypt and sign
+ * @param pubEncryptionGpgKey public keys to encrypt data to
+ * @param prvAuthenticationGpgKey private keys to sign with
+ */
+async function encryptAndAuthOutgoingMessages(messages, pubEncryptionGpgKeys, prvAuthenticationGpgKeys) {
+    return {
+        p2pMessages: await Promise.all(messages.p2pMessages.map(async (m) => {
+            const pubGpgKey = pubEncryptionGpgKeys.find((k) => k.partyId === m.to);
+            const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);
+            if (!pubGpgKey) {
+                throw Error(`No public key provided for recipient with ID: ${m.to}`);
+            }
+            if (!prvGpgKey) {
+                throw Error(`No private key provided for sender with ID: ${m.from}`);
+            }
+            return {
+                to: m.to,
+                from: m.from,
+                payload: await encryptAndDetachSignData(Buffer.from(m.payload, 'base64'), pubGpgKey.gpgKey, prvGpgKey.gpgKey),
+                commitment: m.commitment,
+            };
+        })),
+        broadcastMessages: await Promise.all(messages.broadcastMessages.map(async (m) => {
+            const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);
+            if (!prvGpgKey) {
+                throw Error(`No private key provided for sender with ID: ${m.from}`);
+            }
+            return {
+                from: m.from,
+                payload: await detachSignData(Buffer.from(m.payload, 'base64'), prvGpgKey.gpgKey),
+            };
+        })),
+    };
+}
+exports.encryptAndAuthOutgoingMessages = encryptAndAuthOutgoingMessages;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commsLayer.js","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/commsLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AACA,6CAA+B;AAE/B;;;;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;AAlBD,wCAkBC;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;AAjCD,4DAiCC;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;KAC5B,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;AAxBD,gEAwBC;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;KAC5B,CAAC,CAAC;IACH,IAAI;QACF,MAAM,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAChD,OAAO,IAAI,CAAC;KACb;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAbD,4CAaC;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;gBACd,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;aACrE;YACD,IAAI,CAAC,SAAS,EAAE;gBACd,MAAM,KAAK,CAAC,kDAAkD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;aACvE;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;gBACd,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;aACrE;YACD,IAAI,CAAC,CAAC,MAAM,gBAAgB,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE;gBAC1D,MAAM,KAAK,CAAC,wDAAwD,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;aAC/E;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;AAxCD,4EAwCC;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;gBACd,MAAM,KAAK,CAAC,iDAAiD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;aACtE;YACD,IAAI,CAAC,SAAS,EAAE;gBACd,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;aACtE;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;gBACd,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;aACtE;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;aAClF,CAAC;QACJ,CAAC,CAAC,CACH;KACF,CAAC;AACJ,CAAC;AArCD,wEAqCC","sourcesContent":["import { SerializedMessages, AuthEncMessage, AuthEncMessages, PartyGpgKey, AuthMessage } from './types';\nimport * as pgp from 'openpgp';\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  });\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  });\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        };\n      })\n    ),\n  };\n}\n"]}

package/dist/src/tss/ecdsa-dkls/dkg.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { KeygenSession, Keyshare } from '@silencelaboratories/dkls-wasm-ll-node';
+import { DeserializedBroadcastMessage, DeserializedMessages, DkgState } from './types';
+export declare class Dkg {
+    protected dkgSession: KeygenSession | undefined;
+    protected dkgSessionBytes: Uint8Array;
+    protected dkgKeyShare: Keyshare;
+    protected n: number;
+    protected t: number;
+    protected chainCodeCommitment: Uint8Array | undefined;
+    protected partyIdx: number;
+    protected dkgState: DkgState;
+    constructor(n: number, t: number, partyIdx: number);
+    private _restoreSession;
+    private _deserializeState;
+    initDkg(): Promise<DeserializedBroadcastMessage>;
+    getKeyShare(): Buffer;
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
+}
+//# sourceMappingURL=dkg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dkg.d.ts","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/dkg.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAW,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAE,4BAA4B,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGvF,qBAAa,GAAG;IACd,SAAS,CAAC,UAAU,EAAE,aAAa,GAAG,SAAS,CAAC;IAChD,SAAS,CAAC,eAAe,EAAE,UAAU,CAAC;IACtC,SAAS,CAAC,WAAW,EAAE,QAAQ,CAAC;IAChC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,mBAAmB,EAAE,UAAU,GAAG,SAAS,CAAC;IACtD,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAA0B;gBAE1C,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAOlD,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,iBAAiB;IA2BnB,OAAO,IAAI,OAAO,CAAC,4BAA4B,CAAC;IAwBtD,WAAW,IAAI,MAAM;IAMrB,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;CA8ExF"}

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

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dkg = void 0;
+const dkls_wasm_ll_node_1 = require("@silencelaboratories/dkls-wasm-ll-node");
+const types_1 = require("./types");
+const cbor_1 = require("cbor");
+class Dkg {
+    constructor(n, t, partyIdx) {
+        this.dkgState = types_1.DkgState.Uninitialized;
+        this.n = n;
+        this.t = t;
+        this.partyIdx = partyIdx;
+        this.chainCodeCommitment = undefined;
+    }
+    _restoreSession() {
+        if (!this.dkgSession) {
+            this.dkgSession = dkls_wasm_ll_node_1.KeygenSession.fromBytes(this.dkgSessionBytes);
+        }
+    }
+    _deserializeState() {
+        if (!this.dkgSession) {
+            throw Error('Session not intialized');
+        }
+        const round = cbor_1.decode(this.dkgSession.toBytes()).round;
+        switch (round) {
+            case 'WaitMsg1':
+                this.dkgState = types_1.DkgState.Round1;
+                break;
+            case 'WaitMsg2':
+                this.dkgState = types_1.DkgState.Round2;
+                break;
+            case 'WaitMsg3':
+                this.dkgState = types_1.DkgState.Round3;
+                break;
+            case 'WaitMsg4':
+                this.dkgState = types_1.DkgState.Round4;
+                break;
+            case 'Ended':
+                this.dkgState = types_1.DkgState.Complete;
+                break;
+            default:
+                this.dkgState = types_1.DkgState.InvalidState;
+                throw `Invalid State: ${round}`;
+        }
+    }
+    async initDkg() {
+        if (this.t > this.n || this.partyIdx >= this.n) {
+            throw 'Invalid parameters for DKG';
+        }
+        if (this.dkgState != types_1.DkgState.Uninitialized) {
+            throw 'DKG session already initialized';
+        }
+        if (typeof window !== 'undefined') {
+            const initDkls = require('@silencelaboratories/dkls-wasm-ll-web');
+            await initDkls();
+        }
+        this.dkgSession = new dkls_wasm_ll_node_1.KeygenSession(this.n, this.t, this.partyIdx);
+        try {
+            const payload = this.dkgSession.createFirstMessage().payload;
+            this._deserializeState();
+            return {
+                payload: payload,
+                from: this.partyIdx,
+            };
+        }
+        catch (e) {
+            throw `Error while creating the first message from party ${this.partyIdx}: ${e}`;
+        }
+    }
+    getKeyShare() {
+        const keyShareBuff = Buffer.from(this.dkgKeyShare.toBytes());
+        this.dkgKeyShare.free();
+        return keyShareBuff;
+    }
+    handleIncomingMessages(messagesForIthRound) {
+        let nextRoundMessages = [];
+        let nextRoundDeserializedMessages = { broadcastMessages: [], p2pMessages: [] };
+        this._restoreSession();
+        if (!this.dkgSession) {
+            throw Error('Session not initialized');
+        }
+        try {
+            if (this.dkgState == types_1.DkgState.Round3) {
+                const commitmentsUnsorted = messagesForIthRound.p2pMessages
+                    .map((m) => {
+                    return { from: m.from, commitment: m.commitment };
+                })
+                    .concat([{ from: this.partyIdx, commitment: this.chainCodeCommitment }]);
+                const commitmentsSorted = commitmentsUnsorted
+                    .sort((a, b) => {
+                    return a.from - b.from;
+                })
+                    .map((c) => c.commitment);
+                nextRoundMessages = this.dkgSession.handleMessages(messagesForIthRound.broadcastMessages
+                    .map((m) => new dkls_wasm_ll_node_1.Message(m.payload, m.from, undefined))
+                    .concat(messagesForIthRound.p2pMessages.map((m) => new dkls_wasm_ll_node_1.Message(m.payload, m.from, m.to))), commitmentsSorted);
+            }
+            else {
+                nextRoundMessages = this.dkgSession.handleMessages(messagesForIthRound.broadcastMessages
+                    .map((m) => new dkls_wasm_ll_node_1.Message(m.payload, m.from, undefined))
+                    .concat(messagesForIthRound.p2pMessages.map((m) => new dkls_wasm_ll_node_1.Message(m.payload, m.from, m.to))), undefined);
+            }
+            if (this.dkgState == types_1.DkgState.Round4) {
+                this.dkgKeyShare = this.dkgSession.keyshare();
+                this.dkgState = types_1.DkgState.Complete;
+                return { broadcastMessages: [], p2pMessages: [] };
+            }
+            else {
+                // Update ronud data.
+                this._deserializeState();
+            }
+            if (this.dkgState == types_1.DkgState.Round2) {
+                this.chainCodeCommitment = this.dkgSession.calculateChainCodeCommitment();
+            }
+            nextRoundDeserializedMessages = {
+                p2pMessages: nextRoundMessages
+                    .filter((m) => m.to_id !== undefined)
+                    .map((m) => {
+                    const p2pReturn = {
+                        payload: m.payload,
+                        from: m.from_id,
+                        to: m.to_id,
+                        commitment: this.chainCodeCommitment,
+                    };
+                    return p2pReturn;
+                }),
+                broadcastMessages: nextRoundMessages
+                    .filter((m) => m.to_id === undefined)
+                    .map((m) => {
+                    const broadcastReturn = {
+                        payload: m.payload,
+                        from: m.from_id,
+                    };
+                    return broadcastReturn;
+                }),
+            };
+        }
+        catch (e) {
+            throw `Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${e}`;
+        }
+        finally {
+            nextRoundMessages.forEach((m) => m.free());
+            // Session is freed when keyshare is called.
+            if (this.dkgState !== types_1.DkgState.Complete) {
+                this.dkgSessionBytes = this.dkgSession.toBytes();
+                this.dkgSession = undefined;
+            }
+        }
+        return nextRoundDeserializedMessages;
+    }
+}
+exports.Dkg = Dkg;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dkg.js","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/dkg.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeygenSession, Keyshare, Message } from '@silencelaboratories/dkls-wasm-ll-node';\nimport { DeserializedBroadcastMessage, DeserializedMessages, DkgState } from './types';\nimport { decode } from 'cbor';\n\nexport class Dkg {\n  protected dkgSession: KeygenSession | undefined;\n  protected dkgSessionBytes: Uint8Array;\n  protected dkgKeyShare: Keyshare;\n  protected n: number;\n  protected t: number;\n  protected chainCodeCommitment: Uint8Array | undefined;\n  protected partyIdx: number;\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    this.chainCodeCommitment = undefined;\n  }\n\n  private _restoreSession() {\n    if (!this.dkgSession) {\n      this.dkgSession = KeygenSession.fromBytes(this.dkgSessionBytes);\n    }\n  }\n\n  private _deserializeState() {\n    if (!this.dkgSession) {\n      throw Error('Session not intialized');\n    }\n    const round = decode(this.dkgSession.toBytes()).round;\n    switch (round) {\n      case 'WaitMsg1':\n        this.dkgState = DkgState.Round1;\n        break;\n      case 'WaitMsg2':\n        this.dkgState = DkgState.Round2;\n        break;\n      case 'WaitMsg3':\n        this.dkgState = DkgState.Round3;\n        break;\n      case 'WaitMsg4':\n        this.dkgState = DkgState.Round4;\n        break;\n      case 'Ended':\n        this.dkgState = DkgState.Complete;\n        break;\n      default:\n        this.dkgState = DkgState.InvalidState;\n        throw `Invalid State: ${round}`;\n    }\n  }\n\n  async initDkg(): Promise<DeserializedBroadcastMessage> {\n    if (this.t > this.n || this.partyIdx >= this.n) {\n      throw 'Invalid parameters for DKG';\n    }\n    if (this.dkgState != DkgState.Uninitialized) {\n      throw 'DKG session already initialized';\n    }\n    if (typeof window !== 'undefined') {\n      const initDkls = require('@silencelaboratories/dkls-wasm-ll-web');\n      await initDkls();\n    }\n    this.dkgSession = new KeygenSession(this.n, this.t, this.partyIdx);\n    try {\n      const payload = this.dkgSession.createFirstMessage().payload;\n      this._deserializeState();\n      return {\n        payload: payload,\n        from: this.partyIdx,\n      };\n    } catch (e) {\n      throw `Error while creating the first message from party ${this.partyIdx}: ${e}`;\n    }\n  }\n\n  getKeyShare(): Buffer {\n    const keyShareBuff = Buffer.from(this.dkgKeyShare.toBytes());\n    this.dkgKeyShare.free();\n    return keyShareBuff;\n  }\n\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    let nextRoundMessages: Message[] = [];\n    let nextRoundDeserializedMessages: DeserializedMessages = { broadcastMessages: [], p2pMessages: [] };\n    this._restoreSession();\n    if (!this.dkgSession) {\n      throw Error('Session not initialized');\n    }\n    try {\n      if (this.dkgState == DkgState.Round3) {\n        const commitmentsUnsorted = messagesForIthRound.p2pMessages\n          .map((m) => {\n            return { from: m.from, commitment: m.commitment };\n          })\n          .concat([{ from: this.partyIdx, commitment: this.chainCodeCommitment }]);\n        const commitmentsSorted = commitmentsUnsorted\n          .sort((a, b) => {\n            return a.from - b.from;\n          })\n          .map((c) => c.commitment);\n        nextRoundMessages = this.dkgSession.handleMessages(\n          messagesForIthRound.broadcastMessages\n            .map((m) => new Message(m.payload, m.from, undefined))\n            .concat(messagesForIthRound.p2pMessages.map((m) => new Message(m.payload, m.from, m.to))),\n          commitmentsSorted\n        );\n      } else {\n        nextRoundMessages = this.dkgSession.handleMessages(\n          messagesForIthRound.broadcastMessages\n            .map((m) => new Message(m.payload, m.from, undefined))\n            .concat(messagesForIthRound.p2pMessages.map((m) => new Message(m.payload, m.from, m.to))),\n          undefined\n        );\n      }\n      if (this.dkgState == DkgState.Round4) {\n        this.dkgKeyShare = this.dkgSession.keyshare();\n        this.dkgState = DkgState.Complete;\n        return { broadcastMessages: [], p2pMessages: [] };\n      } else {\n        // Update ronud data.\n        this._deserializeState();\n      }\n      if (this.dkgState == DkgState.Round2) {\n        this.chainCodeCommitment = this.dkgSession.calculateChainCodeCommitment();\n      }\n      nextRoundDeserializedMessages = {\n        p2pMessages: nextRoundMessages\n          .filter((m) => m.to_id !== undefined)\n          .map((m) => {\n            const p2pReturn = {\n              payload: m.payload,\n              from: m.from_id,\n              to: m.to_id!,\n              commitment: this.chainCodeCommitment,\n            };\n            return p2pReturn;\n          }),\n        broadcastMessages: nextRoundMessages\n          .filter((m) => m.to_id === undefined)\n          .map((m) => {\n            const broadcastReturn = {\n              payload: m.payload,\n              from: m.from_id,\n            };\n            return broadcastReturn;\n          }),\n      };\n    } catch (e) {\n      throw `Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${e}`;\n    } finally {\n      nextRoundMessages.forEach((m) => m.free());\n      // Session is freed when keyshare is called.\n      if (this.dkgState !== DkgState.Complete) {\n        this.dkgSessionBytes = this.dkgSession.toBytes();\n        this.dkgSession = undefined;\n      }\n    }\n    return nextRoundDeserializedMessages;\n  }\n}\n"]}

package/dist/src/tss/ecdsa-dkls/dsg.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { SignSession, Keyshare } from '@silencelaboratories/dkls-wasm-ll-node';
+import { DeserializedBroadcastMessage, DeserializedMessages, DklsSignature, DsgState } from './types';
+export declare class Dsg {
+    protected dsgSession: SignSession | undefined;
+    protected dsgSessionBytes: Uint8Array;
+    private _signature;
+    protected keyShare: Keyshare;
+    protected messageHash: Buffer;
+    protected derivationPath: string;
+    protected partyIdx: number;
+    protected dsgState: DsgState;
+    constructor(keyShare: Buffer, partyIdx: number, derivationPath: string, messageHash: Buffer);
+    private _restoreSession;
+    private _deserializeState;
+    init(): Promise<DeserializedBroadcastMessage>;
+    get signature(): DklsSignature;
+    /**
+     * Ends the DSG session by freeing any heap allocations from wasm. Note that the session is freed if a signature is produced.
+     */
+    endSession(): void;
+    /**
+     * Proccesses incoming messages to this party in the DKLs DSG protocol and
+     * produces messages from this party to other parties for the next round.
+     * @param messagesForIthRound - messages to process the current round
+     * @returns {DeserializedMessages} - messages to send to other parties for the next round
+     */
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
+}
+//# sourceMappingURL=dsg.d.ts.map