@bitgo-beta/sdk-lib-mpc 8.2.1-alpha.45 → 8.2.1-alpha.451

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

@@ -0,0 +1,334 @@
+"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.Dkg = void 0;
+const cbor_x_1 = require("cbor-x");
+const crypto_1 = require("crypto");
+const curves_1 = require("../../curves");
+const util_1 = require("../../util");
+const types_1 = require("./types");
+class Dkg {
+    constructor(n, t, partyIdx, seed, retrofitData, dklsWasm) {
+        this.dkgState = types_1.DkgState.Uninitialized;
+        this.n = n;
+        this.t = t;
+        this.partyIdx = partyIdx;
+        this.chainCodeCommitment = undefined;
+        this.retrofitData = retrofitData;
+        this.seed = seed;
+        this.dklsWasm = dklsWasm ?? null;
+    }
+    async loadDklsWasm() {
+        if (!this.dklsWasm) {
+            this.dklsWasm = await Promise.resolve().then(() => __importStar(require('@silencelaboratories/dkls-wasm-ll-node')));
+        }
+    }
+    getDklsWasm() {
+        if (!this.dklsWasm) {
+            throw Error('DKLS wasm not loaded');
+        }
+        return this.dklsWasm;
+    }
+    _restoreSession() {
+        if (!this.dkgSession) {
+            this.dkgSession = this.getDklsWasm().KeygenSession.fromBytes(this.dkgSessionBytes);
+        }
+    }
+    _createDKLsRetrofitKeyShare() {
+        if (this.retrofitData) {
+            if (!this.retrofitData.xShare.y || !this.retrofitData.xShare.chaincode || !this.retrofitData.xShare.x) {
+                throw Error('xShare must have a public key, private share value, and a chaincode.');
+            }
+            const xiList = [];
+            for (let i = 0; i < this.n; i++) {
+                xiList.push(Array.from((0, util_1.bigIntToBufferBE)(BigInt(i + 1), 32)));
+            }
+            const secp256k1 = new curves_1.Secp256k1Curve();
+            const dklsKeyShare = {
+                total_parties: this.n,
+                threshold: this.t,
+                rank_list: new Array(this.n).fill(0),
+                party_id: this.partyIdx,
+                public_key: Array.from(Buffer.from(this.retrofitData.xShare.y, 'hex')),
+                root_chain_code: Array.from(Buffer.from(this.retrofitData.xShare.chaincode, 'hex')),
+                final_session_id: Array.from((0, crypto_1.createHash)('sha256')
+                    .update(Buffer.from(this.retrofitData.xShare.y, 'hex'))
+                    .update(Buffer.from(this.retrofitData.xShare.chaincode, 'hex'))
+                    .digest()),
+                seed_ot_receivers: new Array(this.n - 1).fill(Array(32832).fill(0)),
+                seed_ot_senders: new Array(this.n - 1).fill(Array(32768).fill(0)),
+                sent_seed_list: [Array(32).fill(0)],
+                rec_seed_list: [Array(32).fill(0)],
+                s_i: Array.from(Buffer.from(this.retrofitData.xShare.x, 'hex')),
+                // big_s_list is now created internally during the protocol so isn't needed here, however a valid KeyShare object needs to have it.
+                // a dummy public key is used to fill big_s_list.
+                big_s_list: new Array(this.n).fill(Array.from((0, util_1.bigIntToBufferBE)(secp256k1.basePointMult(BigInt('0x' + this.retrofitData.xShare.x))))),
+                x_i_list: this.retrofitData.xiList ? this.retrofitData.xiList : xiList,
+            };
+            this.dklsKeyShareRetrofitObject = this.getDklsWasm().Keyshare.fromBytes((0, cbor_x_1.encode)(dklsKeyShare));
+        }
+    }
+    _deserializeState() {
+        if (!this.dkgSession) {
+            throw Error('Session not intialized');
+        }
+        const round = (0, cbor_x_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':
+                // keyShareBuff present means keyshare() already ran and freed the session; bytes are frozen at WaitMsg4.
+                this.dkgState = this.keyShareBuff ? types_1.DkgState.Complete : types_1.DkgState.Round4;
+                break;
+            case 'Ended':
+                this.dkgState = types_1.DkgState.Complete;
+                break;
+            default:
+                this.dkgState = types_1.DkgState.InvalidState;
+                throw Error(`Invalid State: ${round}`);
+        }
+    }
+    async initDkg() {
+        if (!this.dklsWasm) {
+            await this.loadDklsWasm();
+        }
+        if (this.t > this.n || this.partyIdx >= this.n) {
+            throw Error('Invalid parameters for DKG');
+        }
+        if (this.dkgState != types_1.DkgState.Uninitialized) {
+            throw Error('DKG session already initialized');
+        }
+        if (typeof window !== 'undefined' &&
+            /* checks for electron processes */
+            !window.process &&
+            !window.process?.['type']) {
+            /* This is only needed for browsers/web because it uses fetch to resolve the wasm asset for the web */
+            const initDkls = await Promise.resolve().then(() => __importStar(require('@silencelaboratories/dkls-wasm-ll-web')));
+            await initDkls.default();
+        }
+        this._createDKLsRetrofitKeyShare();
+        if (this.seed && this.seed.length !== 32) {
+            throw Error(`Seed should be 32 bytes, got ${this.seed.length}.`);
+        }
+        const { KeygenSession } = this.getDklsWasm();
+        if (this.dklsKeyShareRetrofitObject) {
+            this.dkgSession = this.seed
+                ? KeygenSession.initKeyRotation(this.dklsKeyShareRetrofitObject, new Uint8Array(this.seed))
+                : KeygenSession.initKeyRotation(this.dklsKeyShareRetrofitObject);
+        }
+        else {
+            this.dkgSession = this.seed
+                ? new KeygenSession(this.n, this.t, this.partyIdx, new Uint8Array(this.seed))
+                : new KeygenSession(this.n, this.t, this.partyIdx);
+        }
+        try {
+            const payload = this.dkgSession.createFirstMessage().payload;
+            this.dkgSessionBytes = this.dkgSession.toBytes();
+            this._deserializeState();
+            return {
+                payload: payload,
+                from: this.partyIdx,
+            };
+        }
+        catch (e) {
+            throw Error(`Error while creating the first message from party ${this.partyIdx}: ${e}`);
+        }
+    }
+    getKeyShare() {
+        if (!this.keyShareBuff) {
+            throw Error('Can not get key share, DKG is not complete yet.');
+        }
+        return this.keyShareBuff;
+    }
+    /**
+     * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's private
+     * scalar (s_i) in the `prv` field. This buffer is private key material.
+     * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.
+     */
+    getReducedKeyShare() {
+        if (!this.keyShareBuff) {
+            throw Error('Can not get key share, DKG is not complete yet.');
+        }
+        const decodedKeyshare = (0, cbor_x_1.decode)(this.keyShareBuff);
+        const reducedKeyShare = {
+            bigSList: decodedKeyshare.big_s_list,
+            xList: decodedKeyshare.x_i_list,
+            rootChainCode: decodedKeyshare.root_chain_code,
+            prv: decodedKeyshare.s_i,
+            pub: decodedKeyshare.public_key,
+        };
+        const encodedKeyShare = (0, cbor_x_1.encode)(reducedKeyShare);
+        return encodedKeyShare;
+    }
+    handleIncomingMessages(messagesForIthRound) {
+        let nextRoundMessages = [];
+        let nextRoundDeserializedMessages = { broadcastMessages: [], p2pMessages: [] };
+        this._restoreSession();
+        if (!this.dkgSession) {
+            throw Error('Session not initialized');
+        }
+        const { Message } = this.getDklsWasm();
+        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 Message(m.payload, m.from, undefined))
+                    .concat(messagesForIthRound.p2pMessages.map((m) => new Message(m.payload, m.from, m.to))), commitmentsSorted);
+            }
+            else {
+                nextRoundMessages = this.dkgSession.handleMessages(messagesForIthRound.broadcastMessages
+                    .map((m) => new Message(m.payload, m.from, undefined))
+                    .concat(messagesForIthRound.p2pMessages.map((m) => new Message(m.payload, m.from, m.to))), undefined);
+            }
+            if (this.dkgState === types_1.DkgState.Round4) {
+                this.dkgKeyShare = this.dkgSession.keyshare();
+                this.keyShareBuff = Buffer.from(this.dkgKeyShare.toBytes());
+                this.dkgKeyShare.free();
+                if (this.dklsKeyShareRetrofitObject) {
+                    this.dklsKeyShareRetrofitObject.free();
+                }
+                this.dkgState = types_1.DkgState.Complete;
+                return { broadcastMessages: [], p2pMessages: [] };
+            }
+            else {
+                // Update round 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(`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;
+    }
+    /**
+     * Get the current session data that can be used to restore the session later
+     * @returns The current session data
+     */
+    getSessionData() {
+        const sessionData = {
+            dkgSessionBytes: this.dkgSessionBytes,
+            dkgState: this.dkgState,
+        };
+        if (this.chainCodeCommitment) {
+            sessionData.chainCodeCommitment = this.chainCodeCommitment;
+        }
+        if (this.keyShareBuff) {
+            sessionData.keyShareBuff = this.keyShareBuff;
+        }
+        return sessionData;
+    }
+    /**
+     * Restore a DKG session from previous session data
+     * Note: This should not be used for Round 1 as that's the initialization phase
+     * @param n Number of parties
+     * @param t Threshold
+     * @param partyIdx Party index
+     * @param sessionData Previous session data
+     * @param seed Optional seed
+     * @param retrofitData Optional retrofit data
+     * @param dklsWasm Optional DKLS wasm instance
+     * @returns A new DKG instance with the restored session
+     */
+    static async restoreSession(n, t, partyIdx, sessionData, seed, retrofitData, dklsWasm) {
+        const dkg = new Dkg(n, t, partyIdx, seed, retrofitData, dklsWasm);
+        if (!dkg.dklsWasm) {
+            await dkg.loadDklsWasm();
+        }
+        dkg.dkgSessionBytes = sessionData.dkgSessionBytes;
+        if (sessionData.chainCodeCommitment) {
+            dkg.chainCodeCommitment = sessionData.chainCodeCommitment;
+        }
+        if (sessionData.keyShareBuff) {
+            dkg.keyShareBuff = sessionData.keyShareBuff;
+        }
+        dkg._restoreSession();
+        // Re-derive state from WASM bytes rather than trusting the caller-supplied dkgState.
+        // This prevents a tampered or corrupted dkgState from causing handleIncomingMessages()
+        // to take the wrong branch (e.g. skipping chain code commitment or calling keyshare() prematurely).
+        dkg._deserializeState();
+        return dkg;
+    }
+}
+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 type { KeygenSession, Keyshare, Message } from '@silencelaboratories/dkls-wasm-ll-node';\nimport { decode, encode } from 'cbor-x';\nimport { createHash } from 'crypto';\nimport { Secp256k1Curve } from '../../curves';\nimport { bigIntToBufferBE } from '../../util';\nimport { DeserializedBroadcastMessage, DeserializedMessages, DkgState, ReducedKeyShare, RetrofitData } from './types';\n\ntype NodeWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-node');\ntype WebWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-web');\ntype BundlerWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-bundler');\n\ntype DklsWasm = NodeWasmer | WebWasmer | BundlerWasmer;\n\nexport interface DkgSessionData {\n  dkgSessionBytes: Uint8Array;\n  dkgState: DkgState;\n  chainCodeCommitment?: Uint8Array;\n  keyShareBuff?: Buffer;\n}\n\nexport class Dkg {\n  protected dkgSession: KeygenSession | undefined;\n  protected dkgSessionBytes: Uint8Array;\n  protected dkgKeyShare: Keyshare;\n  protected keyShareBuff: Buffer;\n  protected n: number;\n  protected t: number;\n  protected seed: Buffer | undefined;\n  protected chainCodeCommitment: Uint8Array | undefined;\n  protected partyIdx: number;\n  protected dkgState: DkgState = DkgState.Uninitialized;\n  protected dklsKeyShareRetrofitObject: Keyshare | undefined;\n  protected retrofitData: RetrofitData | undefined;\n  protected dklsWasm: DklsWasm | null;\n\n  constructor(\n    n: number,\n    t: number,\n    partyIdx: number,\n    seed?: Buffer,\n    retrofitData?: RetrofitData,\n    dklsWasm?: BundlerWasmer\n  ) {\n    this.n = n;\n    this.t = t;\n    this.partyIdx = partyIdx;\n    this.chainCodeCommitment = undefined;\n    this.retrofitData = retrofitData;\n    this.seed = seed;\n    this.dklsWasm = dklsWasm ?? null;\n  }\n\n  private async loadDklsWasm(): Promise<void> {\n    if (!this.dklsWasm) {\n      this.dklsWasm = await import('@silencelaboratories/dkls-wasm-ll-node');\n    }\n  }\n\n  private getDklsWasm() {\n    if (!this.dklsWasm) {\n      throw Error('DKLS wasm not loaded');\n    }\n\n    return this.dklsWasm;\n  }\n\n  private _restoreSession() {\n    if (!this.dkgSession) {\n      this.dkgSession = this.getDklsWasm().KeygenSession.fromBytes(this.dkgSessionBytes);\n    }\n  }\n\n  private _createDKLsRetrofitKeyShare() {\n    if (this.retrofitData) {\n      if (!this.retrofitData.xShare.y || !this.retrofitData.xShare.chaincode || !this.retrofitData.xShare.x) {\n        throw Error('xShare must have a public key, private share value, and a chaincode.');\n      }\n      const xiList: Array<Array<number>> = [];\n      for (let i = 0; i < this.n; i++) {\n        xiList.push(Array.from(bigIntToBufferBE(BigInt(i + 1), 32)));\n      }\n      const secp256k1 = new Secp256k1Curve();\n      const dklsKeyShare = {\n        total_parties: this.n,\n        threshold: this.t,\n        rank_list: new Array(this.n).fill(0),\n        party_id: this.partyIdx,\n        public_key: Array.from(Buffer.from(this.retrofitData.xShare.y, 'hex')),\n        root_chain_code: Array.from(Buffer.from(this.retrofitData.xShare.chaincode, 'hex')),\n        final_session_id: Array.from(\n          createHash('sha256')\n            .update(Buffer.from(this.retrofitData.xShare.y, 'hex'))\n            .update(Buffer.from(this.retrofitData.xShare.chaincode, 'hex'))\n            .digest()\n        ),\n        seed_ot_receivers: new Array(this.n - 1).fill(Array(32832).fill(0)),\n        seed_ot_senders: new Array(this.n - 1).fill(Array(32768).fill(0)),\n        sent_seed_list: [Array(32).fill(0)],\n        rec_seed_list: [Array(32).fill(0)],\n        s_i: Array.from(Buffer.from(this.retrofitData.xShare.x, 'hex')),\n        // big_s_list is now created internally during the protocol so isn't needed here, however a valid KeyShare object needs to have it.\n        // a dummy public key is used to fill big_s_list.\n        big_s_list: new Array(this.n).fill(\n          Array.from(bigIntToBufferBE(secp256k1.basePointMult(BigInt('0x' + this.retrofitData.xShare.x))))\n        ),\n        x_i_list: this.retrofitData.xiList ? this.retrofitData.xiList : xiList,\n      };\n      this.dklsKeyShareRetrofitObject = this.getDklsWasm().Keyshare.fromBytes(encode(dklsKeyShare));\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        // keyShareBuff present means keyshare() already ran and freed the session; bytes are frozen at WaitMsg4.\n        this.dkgState = this.keyShareBuff ? DkgState.Complete : DkgState.Round4;\n        break;\n      case 'Ended':\n        this.dkgState = DkgState.Complete;\n        break;\n      default:\n        this.dkgState = DkgState.InvalidState;\n        throw Error(`Invalid State: ${round}`);\n    }\n  }\n\n  async initDkg(): Promise<DeserializedBroadcastMessage> {\n    if (!this.dklsWasm) {\n      await this.loadDklsWasm();\n    }\n    if (this.t > this.n || this.partyIdx >= this.n) {\n      throw Error('Invalid parameters for DKG');\n    }\n    if (this.dkgState != DkgState.Uninitialized) {\n      throw Error('DKG session already initialized');\n    }\n    if (\n      typeof window !== 'undefined' &&\n      /* checks for electron processes */\n      !window.process &&\n      !window.process?.['type']\n    ) {\n      /* This is only needed for browsers/web because it uses fetch to resolve the wasm asset for the web */\n      const initDkls = await import('@silencelaboratories/dkls-wasm-ll-web');\n      await initDkls.default();\n    }\n    this._createDKLsRetrofitKeyShare();\n    if (this.seed && this.seed.length !== 32) {\n      throw Error(`Seed should be 32 bytes, got ${this.seed.length}.`);\n    }\n    const { KeygenSession } = this.getDklsWasm();\n    if (this.dklsKeyShareRetrofitObject) {\n      this.dkgSession = this.seed\n        ? KeygenSession.initKeyRotation(this.dklsKeyShareRetrofitObject, new Uint8Array(this.seed))\n        : KeygenSession.initKeyRotation(this.dklsKeyShareRetrofitObject);\n    } else {\n      this.dkgSession = this.seed\n        ? new KeygenSession(this.n, this.t, this.partyIdx, new Uint8Array(this.seed))\n        : new KeygenSession(this.n, this.t, this.partyIdx);\n    }\n    try {\n      const payload = this.dkgSession.createFirstMessage().payload;\n      this.dkgSessionBytes = this.dkgSession.toBytes();\n      this._deserializeState();\n      return {\n        payload: payload,\n        from: this.partyIdx,\n      };\n    } catch (e) {\n      throw Error(`Error while creating the first message from party ${this.partyIdx}: ${e}`);\n    }\n  }\n\n  getKeyShare(): Buffer {\n    if (!this.keyShareBuff) {\n      throw Error('Can not get key share, DKG is not complete yet.');\n    }\n    return this.keyShareBuff;\n  }\n\n  /**\n   * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's private\n   * scalar (s_i) in the `prv` field. This buffer is private key material.\n   * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.\n   */\n  getReducedKeyShare(): Buffer {\n    if (!this.keyShareBuff) {\n      throw Error('Can not get key share, DKG is not complete yet.');\n    }\n    const decodedKeyshare = decode(this.keyShareBuff);\n    const reducedKeyShare: ReducedKeyShare = {\n      bigSList: decodedKeyshare.big_s_list,\n      xList: decodedKeyshare.x_i_list,\n      rootChainCode: decodedKeyshare.root_chain_code,\n      prv: decodedKeyshare.s_i,\n      pub: decodedKeyshare.public_key,\n    };\n    const encodedKeyShare = encode(reducedKeyShare);\n    return encodedKeyShare;\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    const { Message } = this.getDklsWasm();\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.keyShareBuff = Buffer.from(this.dkgKeyShare.toBytes());\n        this.dkgKeyShare.free();\n        if (this.dklsKeyShareRetrofitObject) {\n          this.dklsKeyShareRetrofitObject.free();\n        }\n        this.dkgState = DkgState.Complete;\n        return { broadcastMessages: [], p2pMessages: [] };\n      } else {\n        // Update round 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(`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  /**\n   * Get the current session data that can be used to restore the session later\n   * @returns The current session data\n   */\n  getSessionData(): DkgSessionData {\n    const sessionData: DkgSessionData = {\n      dkgSessionBytes: this.dkgSessionBytes,\n      dkgState: this.dkgState,\n    };\n\n    if (this.chainCodeCommitment) {\n      sessionData.chainCodeCommitment = this.chainCodeCommitment;\n    }\n\n    if (this.keyShareBuff) {\n      sessionData.keyShareBuff = this.keyShareBuff;\n    }\n\n    return sessionData;\n  }\n\n  /**\n   * Restore a DKG session from previous session data\n   * Note: This should not be used for Round 1 as that's the initialization phase\n   * @param n Number of parties\n   * @param t Threshold\n   * @param partyIdx Party index\n   * @param sessionData Previous session data\n   * @param seed Optional seed\n   * @param retrofitData Optional retrofit data\n   * @param dklsWasm Optional DKLS wasm instance\n   * @returns A new DKG instance with the restored session\n   */\n  static async restoreSession(\n    n: number,\n    t: number,\n    partyIdx: number,\n    sessionData: DkgSessionData,\n    seed?: Buffer,\n    retrofitData?: RetrofitData,\n    dklsWasm?: BundlerWasmer\n  ): Promise<Dkg> {\n    const dkg = new Dkg(n, t, partyIdx, seed, retrofitData, dklsWasm);\n\n    if (!dkg.dklsWasm) {\n      await dkg.loadDklsWasm();\n    }\n\n    dkg.dkgSessionBytes = sessionData.dkgSessionBytes;\n\n    if (sessionData.chainCodeCommitment) {\n      dkg.chainCodeCommitment = sessionData.chainCodeCommitment;\n    }\n\n    if (sessionData.keyShareBuff) {\n      dkg.keyShareBuff = sessionData.keyShareBuff;\n    }\n\n    dkg._restoreSession();\n    // Re-derive state from WASM bytes rather than trusting the caller-supplied dkgState.\n    // This prevents a tampered or corrupted dkgState from causing handleIncomingMessages()\n    // to take the wrong branch (e.g. skipping chain code commitment or calling keyshare() prematurely).\n    dkg._deserializeState();\n    return dkg;\n  }\n}\n"]}

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

@@ -0,0 +1,47 @@
+import { SignSessionOTVariant } from '@silencelaboratories/dkls-wasm-ll-node';
+import { DeserializedBroadcastMessage, DeserializedDklsSignature, DeserializedMessages, DsgState } from './types';
+type NodeWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-node');
+type WebWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-web');
+type BundlerWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-bundler');
+type DklsWasm = NodeWasmer | WebWasmer | BundlerWasmer;
+export declare class Dsg {
+    protected dsgSession: SignSessionOTVariant | undefined;
+    protected dsgSessionBytes: Uint8Array;
+    private _signature;
+    protected keyShareBytes: Buffer;
+    protected messageHash: Buffer;
+    protected derivationPath: string;
+    protected partyIdx: number;
+    protected dsgState: DsgState;
+    protected dklsWasm: DklsWasm | null;
+    constructor(keyShare: Buffer, partyIdx: number, derivationPath: string, messageHash: Buffer, dklsWasm?: BundlerWasmer);
+    private _restoreSession;
+    private _deserializeState;
+    private loadDklsWasm;
+    private getDklsWasm;
+    /**
+     * Returns the current DSG session as a base64 string.
+     * @returns {string} - base64 string of the current DSG session
+     */
+    getSession(): string;
+    /**
+     * Sets the DSG session from a base64 string.
+     * @param {string} session - base64 string of the DSG session
+     */
+    setSession(session: string): Promise<void>;
+    init(): Promise<DeserializedBroadcastMessage>;
+    get signature(): DeserializedDklsSignature;
+    /**
+     * 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;
+}
+export {};
+//# sourceMappingURL=dsg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dsg.d.ts","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/dsg.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACvF,OAAO,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGlH,KAAK,UAAU,GAAG,cAAc,wCAAwC,CAAC,CAAC;AAC1E,KAAK,SAAS,GAAG,cAAc,uCAAuC,CAAC,CAAC;AACxE,KAAK,aAAa,GAAG,cAAc,2CAA2C,CAAC,CAAC;AAEhF,KAAK,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,aAAa,CAAC;AAEvD,qBAAa,GAAG;IACd,SAAS,CAAC,UAAU,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACvD,SAAS,CAAC,eAAe,EAAE,UAAU,CAAC;IACtC,OAAO,CAAC,UAAU,CAAwC;IAC1D,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,WAAW,EAAE,MAAM,CAAC;IAC9B,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC;IACjC,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAA0B;IACtD,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;gBAGlC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,aAAa;IAS1B,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,iBAAiB;YAqBX,YAAY;IAM1B,OAAO,CAAC,WAAW;IAQnB;;;OAGG;IACH,UAAU,IAAI,MAAM;IAIpB;;;OAGG;IACG,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B1C,IAAI,IAAI,OAAO,CAAC,4BAA4B,CAAC;IAwCnD,IAAI,SAAS,IAAI,yBAAyB,CAKzC;IAED;;OAEG;IACH,UAAU,IAAI,IAAI;IAUlB;;;;;OAKG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;CAoFxF"}