@bitgo-beta/sdk-lib-mpc 8.2.0-beta.202 → 8.2.0-beta.2020

package/dist/src/tss/redpallas-mps/types.js

@@ -0,0 +1,112 @@
+"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.RedPallasDsgState = exports.RedPallasDkgState = exports.RedPallasReducedKeyShareType = void 0;
+exports.serializeMessage = serializeMessage;
+exports.deserializeMessage = deserializeMessage;
+exports.serializeMessages = serializeMessages;
+exports.deserializeMessages = deserializeMessages;
+exports.getDecodedReducedKeyShare = getDecodedReducedKeyShare;
+const cbor_x_1 = require("cbor-x");
+const Either_1 = require("fp-ts/Either");
+const t = __importStar(require("io-ts"));
+exports.RedPallasReducedKeyShareType = t.type({
+    keyShare: t.array(t.number),
+    pub: t.array(t.number),
+});
+/**
+ * Represents the state of a RedPallas DKG (Distributed Key Generation) session.
+ *
+ * Unlike the EdDSA MPS `DkgState`, there is no `Share` state: `redpallas_dkg_round2_process`
+ * returns a `MsgDerivationInit` (msg/pk/share/state) directly, completing the DKG session in
+ * one step. Key derivation (ask/nk/rivk/ivks) is a separate, subsequent, platform-side-only
+ * process (`redpallas_derivation_process`) not modelled here.
+ */
+var RedPallasDkgState;
+(function (RedPallasDkgState) {
+    /** DKG session has not been initialized */
+    RedPallasDkgState["Uninitialized"] = "Uninitialized";
+    /** DKG session has been initialized (Init state in WASM) */
+    RedPallasDkgState["Init"] = "Init";
+    /** DKG session is waiting for first message (WaitMsg1 state in WASM) */
+    RedPallasDkgState["WaitMsg1"] = "WaitMsg1";
+    /** DKG session is waiting for second message (WaitMsg2 state in WASM) */
+    RedPallasDkgState["WaitMsg2"] = "WaitMsg2";
+    /** DKG session has completed successfully and key shares are available */
+    RedPallasDkgState["Complete"] = "Complete";
+})(RedPallasDkgState || (exports.RedPallasDkgState = RedPallasDkgState = {}));
+/**
+ * Represents the state of a RedPallas DSG (Distributed Sign Generation) session.
+ *
+ * Mirrors the EdDSA MPS `DsgState`, except `redpallas_dsg_round0_process` does not take a
+ * derivation path: RedPallas key derivation (ask/nk/rivk/ivks) happens separately, upstream,
+ * as part of DKG (see `RedPallasDkgState`); the DSG round functions only ever operate on an
+ * already-derived (or root) `Keyshare`.
+ */
+var RedPallasDsgState;
+(function (RedPallasDsgState) {
+    /** DSG session has not been initialized */
+    RedPallasDsgState["Uninitialized"] = "Uninitialized";
+    /** initDsg() has been called; ready for getFirstMessage() */
+    RedPallasDsgState["Init"] = "Init";
+    /** R0 broadcast emitted; waiting for counterpart's R0 broadcast (SignMsg1) */
+    RedPallasDsgState["WaitMsg1"] = "WaitMsg1";
+    /** R1 broadcast emitted; waiting for counterpart's R1 broadcast (SignMsg2) */
+    RedPallasDsgState["WaitMsg2"] = "WaitMsg2";
+    /** R2 broadcast emitted; waiting for counterpart's R2 broadcast (SignMsg3, the partial sig) */
+    RedPallasDsgState["WaitMsg3"] = "WaitMsg3";
+    /** Final RedPallas signature (signature/rk/alpha) is available via getSignature() */
+    RedPallasDsgState["Complete"] = "Complete";
+})(RedPallasDsgState || (exports.RedPallasDsgState = RedPallasDsgState = {}));
+function serializeMessage(msg) {
+    return { from: msg.from, payload: Buffer.from(msg.payload).toString('base64') };
+}
+function deserializeMessage(msg) {
+    return { from: msg.from, payload: Buffer.from(msg.payload, 'base64') };
+}
+function serializeMessages(msgs) {
+    return msgs.map(serializeMessage);
+}
+function deserializeMessages(msgs) {
+    return msgs.map(deserializeMessage);
+}
+function getDecodedReducedKeyShare(reducedKeyShare) {
+    const decoded = exports.RedPallasReducedKeyShareType.decode((0, cbor_x_1.decode)(reducedKeyShare));
+    if ((0, Either_1.isLeft)(decoded)) {
+        throw new Error(`Unable to parse reducedKeyShare: ${decoded.left}`);
+    }
+    return decoded.right;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6FA,4CAEC;AAED,gDAEC;AAED,8CAEC;AAED,kDAEC;AAED,8DAMC;AAnHD,mCAAgC;AAChC,yCAAsC;AACtC,yCAA2B;AAEd,QAAA,4BAA4B,GAAG,CAAC,CAAC,IAAI,CAAC;IACjD,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;IAC3B,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;CACvB,CAAC,CAAC;AAIH;;;;;;;GAOG;AACH,IAAY,iBAWX;AAXD,WAAY,iBAAiB;IAC3B,2CAA2C;IAC3C,oDAA+B,CAAA;IAC/B,4DAA4D;IAC5D,kCAAa,CAAA;IACb,wEAAwE;IACxE,0CAAqB,CAAA;IACrB,yEAAyE;IACzE,0CAAqB,CAAA;IACrB,0EAA0E;IAC1E,0CAAqB,CAAA;AACvB,CAAC,EAXW,iBAAiB,iCAAjB,iBAAiB,QAW5B;AAED;;;;;;;GAOG;AACH,IAAY,iBAaX;AAbD,WAAY,iBAAiB;IAC3B,2CAA2C;IAC3C,oDAA+B,CAAA;IAC/B,6DAA6D;IAC7D,kCAAa,CAAA;IACb,8EAA8E;IAC9E,0CAAqB,CAAA;IACrB,8EAA8E;IAC9E,0CAAqB,CAAA;IACrB,+FAA+F;IAC/F,0CAAqB,CAAA;IACrB,qFAAqF;IACrF,0CAAqB,CAAA;AACvB,CAAC,EAbW,iBAAiB,iCAAjB,iBAAiB,QAa5B;AAwCD,SAAgB,gBAAgB,CAAC,GAAwB;IACvD,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;AAClF,CAAC;AAED,SAAgB,kBAAkB,CAAC,GAAsB;IACvD,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;AACzE,CAAC;AAED,SAAgB,iBAAiB,CAAC,IAA0B;IAC1D,OAAO,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;AACpC,CAAC;AAED,SAAgB,mBAAmB,CAAC,IAAwB;IAC1D,OAAO,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;AACtC,CAAC;AAED,SAAgB,yBAAyB,CAAC,eAAoC;IAC5E,MAAM,OAAO,GAAG,oCAA4B,CAAC,MAAM,CAAC,IAAA,eAAM,EAAC,eAAe,CAAC,CAAC,CAAC;IAC7E,IAAI,IAAA,eAAM,EAAC,OAAO,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,oCAAoC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,OAAO,CAAC,KAAK,CAAC;AACvB,CAAC","sourcesContent":["import { decode } from 'cbor-x';\nimport { isLeft } from 'fp-ts/Either';\nimport * as t from 'io-ts';\n\nexport const RedPallasReducedKeyShareType = t.type({\n  keyShare: t.array(t.number),\n  pub: t.array(t.number),\n});\n\nexport type RedPallasReducedKeyShare = t.TypeOf<typeof RedPallasReducedKeyShareType>;\n\n/**\n * Represents the state of a RedPallas DKG (Distributed Key Generation) session.\n *\n * Unlike the EdDSA MPS `DkgState`, there is no `Share` state: `redpallas_dkg_round2_process`\n * returns a `MsgDerivationInit` (msg/pk/share/state) directly, completing the DKG session in\n * one step. Key derivation (ask/nk/rivk/ivks) is a separate, subsequent, platform-side-only\n * process (`redpallas_derivation_process`) not modelled here.\n */\nexport enum RedPallasDkgState {\n  /** DKG session has not been initialized */\n  Uninitialized = 'Uninitialized',\n  /** DKG session has been initialized (Init state in WASM) */\n  Init = 'Init',\n  /** DKG session is waiting for first message (WaitMsg1 state in WASM) */\n  WaitMsg1 = 'WaitMsg1',\n  /** DKG session is waiting for second message (WaitMsg2 state in WASM) */\n  WaitMsg2 = 'WaitMsg2',\n  /** DKG session has completed successfully and key shares are available */\n  Complete = 'Complete',\n}\n\n/**\n * Represents the state of a RedPallas DSG (Distributed Sign Generation) session.\n *\n * Mirrors the EdDSA MPS `DsgState`, except `redpallas_dsg_round0_process` does not take a\n * derivation path: RedPallas key derivation (ask/nk/rivk/ivks) happens separately, upstream,\n * as part of DKG (see `RedPallasDkgState`); the DSG round functions only ever operate on an\n * already-derived (or root) `Keyshare`.\n */\nexport enum RedPallasDsgState {\n  /** DSG session has not been initialized */\n  Uninitialized = 'Uninitialized',\n  /** initDsg() has been called; ready for getFirstMessage() */\n  Init = 'Init',\n  /** R0 broadcast emitted; waiting for counterpart's R0 broadcast (SignMsg1) */\n  WaitMsg1 = 'WaitMsg1',\n  /** R1 broadcast emitted; waiting for counterpart's R1 broadcast (SignMsg2) */\n  WaitMsg2 = 'WaitMsg2',\n  /** R2 broadcast emitted; waiting for counterpart's R2 broadcast (SignMsg3, the partial sig) */\n  WaitMsg3 = 'WaitMsg3',\n  /** Final RedPallas signature (signature/rk/alpha) is available via getSignature() */\n  Complete = 'Complete',\n}\n\n/**\n * The final output of a RedPallas DSG session.\n *\n * - `signature` is the 64-byte raw Schnorr (RedPallas) signature.\n * - `rk` is the randomized verification key that the signature must be verified against\n *   (i.e. `redpallas_verify(rk, signature, message)`), not the original DKG public key.\n * - `alpha` is the 32-byte randomizer scalar used to re-randomize the DKG public key into\n *   `rk` (`rk = pk + [alpha]G`). Callers that need to independently re-derive/verify `rk`\n *   from the DKG public key can use `alpha` to do so.\n */\nexport interface RedPallasSignatureResult {\n  signature: Buffer;\n  rk: Buffer;\n  alpha: Buffer;\n}\n\n/** A PGP detached-signed message by a party.\n * `message` is the raw payload encoded as base64.\n * `signature` is an armored PGP detached signature over those bytes.\n */\nexport interface MPSSignedMessage {\n  message: string;\n  signature: string;\n}\n\nexport interface Message<T> {\n  payload: T;\n  from: number;\n}\n\nexport type SerializedMessage = Message<string>;\n\nexport type SerializedMessages = Message<string>[];\n\nexport type DeserializedMessage = Message<Uint8Array>;\n\nexport type DeserializedMessages = Message<Uint8Array>[];\n\nexport function serializeMessage(msg: DeserializedMessage): SerializedMessage {\n  return { from: msg.from, payload: Buffer.from(msg.payload).toString('base64') };\n}\n\nexport function deserializeMessage(msg: SerializedMessage): DeserializedMessage {\n  return { from: msg.from, payload: Buffer.from(msg.payload, 'base64') };\n}\n\nexport function serializeMessages(msgs: DeserializedMessages): SerializedMessages {\n  return msgs.map(serializeMessage);\n}\n\nexport function deserializeMessages(msgs: SerializedMessages): DeserializedMessages {\n  return msgs.map(deserializeMessage);\n}\n\nexport function getDecodedReducedKeyShare(reducedKeyShare: Buffer | Uint8Array): RedPallasReducedKeyShare {\n  const decoded = RedPallasReducedKeyShareType.decode(decode(reducedKeyShare));\n  if (isLeft(decoded)) {\n    throw new Error(`Unable to parse reducedKeyShare: ${decoded.left}`);\n  }\n  return decoded.right;\n}\n"]}

package/dist/src/tss/redpallas-mps/util.d.ts

@@ -0,0 +1,46 @@
+import { RedPallasDKG } from './dkg';
+import { RedPallasDSG } from './dsg';
+import { DeserializedMessages, RedPallasSignatureResult } from './types';
+/**
+ * Per-party deterministic seed material. To use the same seed for both, pass it as both fields.
+ * `encKey` seeds the X25519 encryption key; `dkgSeed` seeds DKG round 0.
+ */
+export interface RedPallasDKGPartySeed {
+    encKey?: Buffer;
+    dkgSeed?: Buffer;
+}
+/**
+ * Runs a full 3-party (2-of-3) RedPallas DKG in-process. See `RedPallasDKGPartySeed`.
+ * Mirrors `generateEdDsaDKGKeyShares` in `../eddsa-mps/util.ts`.
+ *
+ * @param derivationSeed - 32-byte seed consumed by round2 for the (platform-side-only)
+ *   subsequent derivation process. Must be the same value across all three parties.
+ */
+export declare function generateRedPallasDKGKeyShares(derivationSeed: Buffer, seedUser?: RedPallasDKGPartySeed, seedBackup?: RedPallasDKGPartySeed, seedBitgo?: RedPallasDKGPartySeed): Promise<[RedPallasDKG, RedPallasDKG, RedPallasDKG]>;
+/**
+ * Initializes two RedPallas DSG parties and drives them through the protocol until the
+ * specified round. Mirrors `executeTillRound` in `../eddsa-mps/util.ts`, minus the
+ * derivation path (RedPallas DSG operates on an already-(root-or-derived) keyshare; there
+ * is no per-signing-session derivation path).
+ *
+ * @param round - Round to execute until (1–3). Returns intermediate message arrays for 1–2,
+ *   or the final `RedPallasSignatureResult` (signature/rk/alpha) for 3.
+ * @param party1Dsg - First DSG party (`new RedPallasDSG(partyIdx)`), not yet initialized.
+ * @param party2Dsg - Second DSG party (`new RedPallasDSG(partyIdx)`), not yet initialized.
+ * @param keyShare1 - Key share for the first party.
+ * @param keyShare2 - Key share for the second party.
+ * @param message - Raw message bytes to sign.
+ */
+export declare function executeTillRound(round: number, party1Dsg: RedPallasDSG, party2Dsg: RedPallasDSG, keyShare1: Buffer, keyShare2: Buffer, message: Buffer): Promise<DeserializedMessages[] | RedPallasSignatureResult>;
+/**
+ * Verifies a `RedPallasSignatureResult` against the raw message.
+ *
+ * IMPORTANT: unlike EdDSA, RedPallas signatures must be verified against `rk` — the
+ * randomized verification key produced alongside the signature by DSG round3 — and NOT
+ * against the DKG (or derived) public key directly. `rk = pk + [alpha]G`; `alpha` is
+ * included in `RedPallasSignatureResult` for callers that need to independently confirm
+ * the relationship between `rk` and a known `pk`, but is not required to verify the
+ * signature itself.
+ */
+export declare function verifyRedPallasSignature(signatureResult: RedPallasSignatureResult, message: Buffer): Promise<boolean>;
+//# sourceMappingURL=util.d.ts.map

package/dist/src/tss/redpallas-mps/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/util.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAQzE;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAQD;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,qBAAqB,EAChC,UAAU,CAAC,EAAE,qBAAqB,EAClC,SAAS,CAAC,EAAE,qBAAqB,GAChC,OAAO,CAAC,CAAC,YAAY,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAkCrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,YAAY,EACvB,SAAS,EAAE,YAAY,EACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,oBAAoB,EAAE,GAAG,wBAAwB,CAAC,CA0B5D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,eAAe,EAAE,wBAAwB,EACzC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAUlB"}

package/dist/src/tss/redpallas-mps/util.js

@@ -0,0 +1,150 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRedPallasDKGKeyShares = generateRedPallasDKGKeyShares;
+exports.executeTillRound = executeTillRound;
+exports.verifyRedPallasSignature = verifyRedPallasSignature;
+const crypto_1 = __importDefault(require("crypto"));
+const assert_1 = __importDefault(require("assert"));
+const ed25519_1 = require("@noble/curves/ed25519");
+const dkg_1 = require("./dkg");
+function generateX25519Keypair(seed) {
+    const privKey = seed ? seed.subarray(0, 32) : crypto_1.default.randomBytes(32);
+    const pubKey = Buffer.from(ed25519_1.x25519.getPublicKey(privKey));
+    return { privKey: Buffer.from(privKey), pubKey };
+}
+function validateSeed(seed) {
+    (0, assert_1.default)(!seed?.encKey || seed.encKey.length >= 32, 'encKey must be at least 32 bytes');
+    (0, assert_1.default)(!seed?.dkgSeed || seed.dkgSeed.length >= 32, 'dkgSeed must be at least 32 bytes');
+    return seed ?? {};
+}
+/**
+ * Runs a full 3-party (2-of-3) RedPallas DKG in-process. See `RedPallasDKGPartySeed`.
+ * Mirrors `generateEdDsaDKGKeyShares` in `../eddsa-mps/util.ts`.
+ *
+ * @param derivationSeed - 32-byte seed consumed by round2 for the (platform-side-only)
+ *   subsequent derivation process. Must be the same value across all three parties.
+ */
+async function generateRedPallasDKGKeyShares(derivationSeed, seedUser, seedBackup, seedBitgo) {
+    const { encKey: userEncKey, dkgSeed: userDkgSeed } = validateSeed(seedUser);
+    const { encKey: backupEncKey, dkgSeed: backupDkgSeed } = validateSeed(seedBackup);
+    const { encKey: bitgoEncKey, dkgSeed: bitgoDkgSeed } = validateSeed(seedBitgo);
+    const user = new dkg_1.RedPallasDKG(3, 2, 0);
+    const backup = new dkg_1.RedPallasDKG(3, 2, 1);
+    const bitgo = new dkg_1.RedPallasDKG(3, 2, 2);
+    const userKP = generateX25519Keypair(userEncKey);
+    const backupKP = generateX25519Keypair(backupEncKey);
+    const bitgoKP = generateX25519Keypair(bitgoEncKey);
+    await user.initDkg(userKP.privKey, [backupKP.pubKey, bitgoKP.pubKey]);
+    await backup.initDkg(backupKP.privKey, [userKP.pubKey, bitgoKP.pubKey]);
+    await bitgo.initDkg(bitgoKP.privKey, [userKP.pubKey, backupKP.pubKey]);
+    const r1Messages = [
+        user.getFirstMessage(userDkgSeed),
+        backup.getFirstMessage(backupDkgSeed),
+        bitgo.getFirstMessage(bitgoDkgSeed),
+    ];
+    const r2Messages = [
+        ...user.handleIncomingMessages(r1Messages),
+        ...backup.handleIncomingMessages(r1Messages),
+        ...bitgo.handleIncomingMessages(r1Messages),
+    ];
+    user.handleIncomingMessages(r2Messages, derivationSeed);
+    backup.handleIncomingMessages(r2Messages, derivationSeed);
+    bitgo.handleIncomingMessages(r2Messages, derivationSeed);
+    return [user, backup, bitgo];
+}
+/**
+ * Initializes two RedPallas DSG parties and drives them through the protocol until the
+ * specified round. Mirrors `executeTillRound` in `../eddsa-mps/util.ts`, minus the
+ * derivation path (RedPallas DSG operates on an already-(root-or-derived) keyshare; there
+ * is no per-signing-session derivation path).
+ *
+ * @param round - Round to execute until (1–3). Returns intermediate message arrays for 1–2,
+ *   or the final `RedPallasSignatureResult` (signature/rk/alpha) for 3.
+ * @param party1Dsg - First DSG party (`new RedPallasDSG(partyIdx)`), not yet initialized.
+ * @param party2Dsg - Second DSG party (`new RedPallasDSG(partyIdx)`), not yet initialized.
+ * @param keyShare1 - Key share for the first party.
+ * @param keyShare2 - Key share for the second party.
+ * @param message - Raw message bytes to sign.
+ */
+async function executeTillRound(round, party1Dsg, party2Dsg, keyShare1, keyShare2, message) {
+    if (round < 1 || round > 3) {
+        throw Error('Invalid round number');
+    }
+    await party1Dsg.initDsg(keyShare1, message, party2Dsg.getPartyIdx());
+    await party2Dsg.initDsg(keyShare2, message, party1Dsg.getPartyIdx());
+    const party1Round0Message = party1Dsg.getFirstMessage();
+    const party2Round0Message = party2Dsg.getFirstMessage();
+    const [party2Round1Messages] = party2Dsg.handleIncomingMessages([party1Round0Message, party2Round0Message]);
+    const [party1Round1Messages] = party1Dsg.handleIncomingMessages([party1Round0Message, party2Round0Message]);
+    if (round === 1)
+        return [[party1Round1Messages], [party2Round1Messages]];
+    const [party1Round2Messages] = party1Dsg.handleIncomingMessages([party1Round1Messages, party2Round1Messages]);
+    const [party2Round2Messages] = party2Dsg.handleIncomingMessages([party1Round1Messages, party2Round1Messages]);
+    if (round === 2)
+        return [[party1Round2Messages], [party2Round2Messages]];
+    party1Dsg.handleIncomingMessages([party1Round2Messages, party2Round2Messages]);
+    party2Dsg.handleIncomingMessages([party1Round2Messages, party2Round2Messages]);
+    const sig1 = party1Dsg.getSignature();
+    const sig2 = party2Dsg.getSignature();
+    (0, assert_1.default)(sig1.signature.toString('hex') === sig2.signature.toString('hex'));
+    (0, assert_1.default)(sig1.rk.toString('hex') === sig2.rk.toString('hex'));
+    (0, assert_1.default)(sig1.alpha.toString('hex') === sig2.alpha.toString('hex'));
+    return sig1;
+}
+/**
+ * Verifies a `RedPallasSignatureResult` against the raw message.
+ *
+ * IMPORTANT: unlike EdDSA, RedPallas signatures must be verified against `rk` — the
+ * randomized verification key produced alongside the signature by DSG round3 — and NOT
+ * against the DKG (or derived) public key directly. `rk = pk + [alpha]G`; `alpha` is
+ * included in `RedPallasSignatureResult` for callers that need to independently confirm
+ * the relationship between `rk` and a known `pk`, but is not required to verify the
+ * signature itself.
+ */
+async function verifyRedPallasSignature(signatureResult, message) {
+    const wasm = typeof window !== 'undefined' && !window.process && !window.process?.['type']
+        ? // eslint-disable-next-line import/no-internal-modules -- @bitgo/wasm-mps exposes environment-specific subpath exports.
+            await Promise.resolve().then(() => __importStar(require('@bitgo/wasm-mps/web'))).then(async (webWasm) => {
+                await webWasm.default();
+                return webWasm;
+            })
+        : await Promise.resolve().then(() => __importStar(require('@bitgo/wasm-mps')));
+    return wasm.redpallas_verify(signatureResult.rk, signatureResult.signature, message);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/util.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from 'crypto';\nimport assert from 'assert';\nimport { x25519 } from '@noble/curves/ed25519';\nimport { RedPallasDKG } from './dkg';\nimport { RedPallasDSG } from './dsg';\nimport { DeserializedMessages, RedPallasSignatureResult } from './types';\n\nfunction generateX25519Keypair(seed?: Buffer): { privKey: Buffer; pubKey: Buffer } {\n  const privKey = seed ? seed.subarray(0, 32) : crypto.randomBytes(32);\n  const pubKey = Buffer.from(x25519.getPublicKey(privKey));\n  return { privKey: Buffer.from(privKey), pubKey };\n}\n\n/**\n * Per-party deterministic seed material. To use the same seed for both, pass it as both fields.\n * `encKey` seeds the X25519 encryption key; `dkgSeed` seeds DKG round 0.\n */\nexport interface RedPallasDKGPartySeed {\n  encKey?: Buffer;\n  dkgSeed?: Buffer;\n}\n\nfunction validateSeed(seed?: RedPallasDKGPartySeed): RedPallasDKGPartySeed {\n  assert(!seed?.encKey || seed.encKey.length >= 32, 'encKey must be at least 32 bytes');\n  assert(!seed?.dkgSeed || seed.dkgSeed.length >= 32, 'dkgSeed must be at least 32 bytes');\n  return seed ?? {};\n}\n\n/**\n * Runs a full 3-party (2-of-3) RedPallas DKG in-process. See `RedPallasDKGPartySeed`.\n * Mirrors `generateEdDsaDKGKeyShares` in `../eddsa-mps/util.ts`.\n *\n * @param derivationSeed - 32-byte seed consumed by round2 for the (platform-side-only)\n *   subsequent derivation process. Must be the same value across all three parties.\n */\nexport async function generateRedPallasDKGKeyShares(\n  derivationSeed: Buffer,\n  seedUser?: RedPallasDKGPartySeed,\n  seedBackup?: RedPallasDKGPartySeed,\n  seedBitgo?: RedPallasDKGPartySeed\n): Promise<[RedPallasDKG, RedPallasDKG, RedPallasDKG]> {\n  const { encKey: userEncKey, dkgSeed: userDkgSeed } = validateSeed(seedUser);\n  const { encKey: backupEncKey, dkgSeed: backupDkgSeed } = validateSeed(seedBackup);\n  const { encKey: bitgoEncKey, dkgSeed: bitgoDkgSeed } = validateSeed(seedBitgo);\n\n  const user = new RedPallasDKG(3, 2, 0);\n  const backup = new RedPallasDKG(3, 2, 1);\n  const bitgo = new RedPallasDKG(3, 2, 2);\n\n  const userKP = generateX25519Keypair(userEncKey);\n  const backupKP = generateX25519Keypair(backupEncKey);\n  const bitgoKP = generateX25519Keypair(bitgoEncKey);\n\n  await user.initDkg(userKP.privKey, [backupKP.pubKey, bitgoKP.pubKey]);\n  await backup.initDkg(backupKP.privKey, [userKP.pubKey, bitgoKP.pubKey]);\n  await bitgo.initDkg(bitgoKP.privKey, [userKP.pubKey, backupKP.pubKey]);\n\n  const r1Messages = [\n    user.getFirstMessage(userDkgSeed),\n    backup.getFirstMessage(backupDkgSeed),\n    bitgo.getFirstMessage(bitgoDkgSeed),\n  ];\n\n  const r2Messages = [\n    ...user.handleIncomingMessages(r1Messages),\n    ...backup.handleIncomingMessages(r1Messages),\n    ...bitgo.handleIncomingMessages(r1Messages),\n  ];\n\n  user.handleIncomingMessages(r2Messages, derivationSeed);\n  backup.handleIncomingMessages(r2Messages, derivationSeed);\n  bitgo.handleIncomingMessages(r2Messages, derivationSeed);\n\n  return [user, backup, bitgo];\n}\n\n/**\n * Initializes two RedPallas DSG parties and drives them through the protocol until the\n * specified round. Mirrors `executeTillRound` in `../eddsa-mps/util.ts`, minus the\n * derivation path (RedPallas DSG operates on an already-(root-or-derived) keyshare; there\n * is no per-signing-session derivation path).\n *\n * @param round - Round to execute until (1–3). Returns intermediate message arrays for 1–2,\n *   or the final `RedPallasSignatureResult` (signature/rk/alpha) for 3.\n * @param party1Dsg - First DSG party (`new RedPallasDSG(partyIdx)`), not yet initialized.\n * @param party2Dsg - Second DSG party (`new RedPallasDSG(partyIdx)`), not yet initialized.\n * @param keyShare1 - Key share for the first party.\n * @param keyShare2 - Key share for the second party.\n * @param message - Raw message bytes to sign.\n */\nexport async function executeTillRound(\n  round: number,\n  party1Dsg: RedPallasDSG,\n  party2Dsg: RedPallasDSG,\n  keyShare1: Buffer,\n  keyShare2: Buffer,\n  message: Buffer\n): Promise<DeserializedMessages[] | RedPallasSignatureResult> {\n  if (round < 1 || round > 3) {\n    throw Error('Invalid round number');\n  }\n  await party1Dsg.initDsg(keyShare1, message, party2Dsg.getPartyIdx());\n  await party2Dsg.initDsg(keyShare2, message, party1Dsg.getPartyIdx());\n  const party1Round0Message = party1Dsg.getFirstMessage();\n  const party2Round0Message = party2Dsg.getFirstMessage();\n\n  const [party2Round1Messages] = party2Dsg.handleIncomingMessages([party1Round0Message, party2Round0Message]);\n  const [party1Round1Messages] = party1Dsg.handleIncomingMessages([party1Round0Message, party2Round0Message]);\n  if (round === 1) return [[party1Round1Messages], [party2Round1Messages]];\n\n  const [party1Round2Messages] = party1Dsg.handleIncomingMessages([party1Round1Messages, party2Round1Messages]);\n  const [party2Round2Messages] = party2Dsg.handleIncomingMessages([party1Round1Messages, party2Round1Messages]);\n  if (round === 2) return [[party1Round2Messages], [party2Round2Messages]];\n\n  party1Dsg.handleIncomingMessages([party1Round2Messages, party2Round2Messages]);\n  party2Dsg.handleIncomingMessages([party1Round2Messages, party2Round2Messages]);\n\n  const sig1 = party1Dsg.getSignature();\n  const sig2 = party2Dsg.getSignature();\n  assert(sig1.signature.toString('hex') === sig2.signature.toString('hex'));\n  assert(sig1.rk.toString('hex') === sig2.rk.toString('hex'));\n  assert(sig1.alpha.toString('hex') === sig2.alpha.toString('hex'));\n  return sig1;\n}\n\n/**\n * Verifies a `RedPallasSignatureResult` against the raw message.\n *\n * IMPORTANT: unlike EdDSA, RedPallas signatures must be verified against `rk` — the\n * randomized verification key produced alongside the signature by DSG round3 — and NOT\n * against the DKG (or derived) public key directly. `rk = pk + [alpha]G`; `alpha` is\n * included in `RedPallasSignatureResult` for callers that need to independently confirm\n * the relationship between `rk` and a known `pk`, but is not required to verify the\n * signature itself.\n */\nexport async function verifyRedPallasSignature(\n  signatureResult: RedPallasSignatureResult,\n  message: Buffer\n): Promise<boolean> {\n  const wasm =\n    typeof window !== 'undefined' && !window.process && !window.process?.['type']\n      ? // eslint-disable-next-line import/no-internal-modules -- @bitgo/wasm-mps exposes environment-specific subpath exports.\n        await import('@bitgo/wasm-mps/web').then(async (webWasm) => {\n          await webWasm.default();\n          return webWasm;\n        })\n      : await import('@bitgo/wasm-mps');\n  return wasm.redpallas_verify(signatureResult.rk, signatureResult.signature, message);\n}\n"]}

package/dist/src/types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export interface HashCommitDecommit {
     commitment: Buffer;
     decommitment: HashDecommitment;

package/dist/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,gBAAgB,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACX"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,gBAAgB,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACX"}

package/dist/src/util.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { PublicKey } from 'paillier-bigint';
 /**
  * Returns a bigint array from a hex string array

package/dist/src/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAK5C;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAInE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAIvF;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU/C;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtE;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAQrE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAQrE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAEvD;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAEzD;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOxE;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAU9E;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAErE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,MAAM,CAQvE"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAK5C;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAInE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAIvF;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU/C;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtE;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAQrE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAQrE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAEvD;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAEzD;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOxE;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAU9E;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAErE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,UAAO,GAAG,MAAM,CAQvE"}

package/dist/src/util.js

@@ -3,7 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDerivationPath = exports.randomBigInt = exports.randomPositiveCoPrimeLessThan = exports.randomPositiveCoPrimeTo = exports.getPaillierPublicKey = exports.clamp = exports.bigIntFromU8ABE = exports.bigIntFromBufferBE = exports.bigIntToBufferBE = exports.bigIntFromBufferLE = exports.bigIntToBufferLE = exports.bigIntToHex = exports.hexToBigInt = exports.convertBigIntArrToHexArr = exports.convertHexArrToBigIntArr = void 0;
+exports.convertHexArrToBigIntArr = convertHexArrToBigIntArr;
+exports.convertBigIntArrToHexArr = convertBigIntArrToHexArr;
+exports.hexToBigInt = hexToBigInt;
+exports.bigIntToHex = bigIntToHex;
+exports.bigIntToBufferLE = bigIntToBufferLE;
+exports.bigIntFromBufferLE = bigIntFromBufferLE;
+exports.bigIntToBufferBE = bigIntToBufferBE;
+exports.bigIntFromBufferBE = bigIntFromBufferBE;
+exports.bigIntFromU8ABE = bigIntFromU8ABE;
+exports.clamp = clamp;
+exports.getPaillierPublicKey = getPaillierPublicKey;
+exports.randomPositiveCoPrimeTo = randomPositiveCoPrimeTo;
+exports.randomPositiveCoPrimeLessThan = randomPositiveCoPrimeLessThan;
+exports.randomBigInt = randomBigInt;
+exports.getDerivationPath = getDerivationPath;
 const paillier_bigint_1 = require("paillier-bigint");
 const bigint_crypto_utils_1 = require("bigint-crypto-utils");
 const bigint_mod_arith_1 = require("bigint-mod-arith");
@@ -17,7 +31,6 @@ function convertHexArrToBigIntArr(values) {
         return hexToBigInt(value);
     });
 }
-exports.convertHexArrToBigIntArr = convertHexArrToBigIntArr;
 /**
  * Returns a hex string array from a bigint array
  * @param values
@@ -28,7 +41,6 @@ function convertBigIntArrToHexArr(values, hexLength) {
         return bigIntToHex(value, hexLength);
     });
 }
-exports.convertBigIntArrToHexArr = convertBigIntArrToHexArr;
 function hexToBigInt(hex) {
     // Strangely bigint.toString(16) gives a hex string without 0x,
     // but it won't accept the same string without 0x to convert
@@ -40,7 +52,6 @@ function hexToBigInt(hex) {
     }
     return BigInt('0x' + hex);
 }
-exports.hexToBigInt = hexToBigInt;
 /**
  * Returns an hex string of the given bigint
  *
@@ -56,7 +67,6 @@ function bigIntToHex(bigint, hexLength) {
     }
     return hex;
 }
-exports.bigIntToHex = bigIntToHex;
 function bigIntToBufferLE(n, minBytes) {
     let v = n.toString(16);
     v = '0'.slice(0, v.length % 2) + v;
@@ -66,11 +76,9 @@ function bigIntToBufferLE(n, minBytes) {
     }
     return buf;
 }
-exports.bigIntToBufferLE = bigIntToBufferLE;
 function bigIntFromBufferLE(buf) {
     return BigInt('0x' + Buffer.from(buf).reverse().toString('hex'));
 }
-exports.bigIntFromBufferLE = bigIntFromBufferLE;
 function bigIntToBufferBE(n, minBytes) {
     let v = n.toString(16);
     v = '0'.slice(0, v.length % 2) + v;
@@ -80,21 +88,17 @@ function bigIntToBufferBE(n, minBytes) {
     }
     return buf;
 }
-exports.bigIntToBufferBE = bigIntToBufferBE;
 function bigIntFromBufferBE(buf) {
     return BigInt('0x' + buf.toString('hex'));
 }
-exports.bigIntFromBufferBE = bigIntFromBufferBE;
 function bigIntFromU8ABE(buf) {
     return bigIntFromBufferBE(Buffer.from(buf));
 }
-exports.bigIntFromU8ABE = bigIntFromU8ABE;
 function clamp(u) {
     u &= BigInt('0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8');
     u |= BigInt('0x4000000000000000000000000000000000000000000000000000000000000000');
     return u;
 }
-exports.clamp = clamp;
 /**
  * Function get paillier public key simple varient
  * @param {bigint} n
@@ -103,7 +107,6 @@ exports.clamp = clamp;
 function getPaillierPublicKey(n) {
     return new paillier_bigint_1.PublicKey(n, n + BigInt(1));
 }
-exports.getPaillierPublicKey = getPaillierPublicKey;
 /**
  * Generate a random positive integer co-prime to x
  * @param x
@@ -111,13 +114,12 @@ exports.getPaillierPublicKey = getPaillierPublicKey;
  */
 async function randomPositiveCoPrimeTo(x) {
     while (true) {
-        const y = await randomBigInt(bigint_crypto_utils_1.bitLength(x));
-        if (y > BigInt(0) && bigint_mod_arith_1.gcd(x, y) === BigInt(1)) {
+        const y = await randomBigInt((0, bigint_crypto_utils_1.bitLength)(x));
+        if (y > BigInt(0) && (0, bigint_mod_arith_1.gcd)(x, y) === BigInt(1)) {
             return y;
         }
     }
 }
-exports.randomPositiveCoPrimeTo = randomPositiveCoPrimeTo;
 /**
  * Generate a random positive integer coprime less than x with the same bit depth.
  * @param x
@@ -128,22 +130,20 @@ async function randomPositiveCoPrimeLessThan(x) {
         throw new Error('x must be larger than 2');
     }
     while (true) {
-        const y = await randomBigInt(bigint_crypto_utils_1.bitLength(x));
-        if (y > BigInt(0) && y < x && bigint_mod_arith_1.gcd(x, y) === BigInt(1)) {
+        const y = await randomBigInt((0, bigint_crypto_utils_1.bitLength)(x));
+        if (y > BigInt(0) && y < x && (0, bigint_mod_arith_1.gcd)(x, y) === BigInt(1)) {
             return y;
         }
     }
 }
-exports.randomPositiveCoPrimeLessThan = randomPositiveCoPrimeLessThan;
 /**
  * Generate a random number of a given bitlength
  * @param bitlength
  * @returns {Promise<bigint>}
  */
 async function randomBigInt(bitlength) {
-    return bigIntFromBufferBE(Buffer.from(await bigint_crypto_utils_1.randBits(bitlength, true)));
+    return bigIntFromBufferBE(Buffer.from(await (0, bigint_crypto_utils_1.randBits)(bitlength, true)));
 }
-exports.randomBigInt = randomBigInt;
 /**
  * @param seed - used to construct derivation path deterministically
  * @param isMaster - if set, path starts with prefix `m/`
@@ -158,8 +158,7 @@ function getDerivationPath(seed, isMaster = true) {
     const prefix = isMaster ? 'm/' : '';
     return prefix + '999999/' + derivationPathParts.join('/');
 }
-exports.getDerivationPath = getDerivationPath;
 function sha256(input) {
     return crypto_1.default.createHash('sha256').update(input).digest();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { PublicKey } from 'paillier-bigint';\nimport { bitLength, randBits } from 'bigint-crypto-utils';\nimport { gcd } from 'bigint-mod-arith';\nimport crypto from 'crypto';\n\n/**\n * Returns a bigint array from a hex string array\n * @param values\n */\nexport function convertHexArrToBigIntArr(values: string[]): bigint[] {\n  return values.map((value) => {\n    return hexToBigInt(value);\n  });\n}\n\n/**\n * Returns a hex string array from a bigint array\n * @param values\n * @param hexLength - length to pad each big int number too\n */\nexport function convertBigIntArrToHexArr(values: bigint[], hexLength?: number): string[] {\n  return values.map((value) => {\n    return bigIntToHex(value, hexLength);\n  });\n}\n\nexport function hexToBigInt(hex: string): bigint {\n  // Strangely bigint.toString(16) gives a hex string without 0x,\n  // but it won't accept the same string without 0x to convert\n  // to a bigint (BigInt(hex string)). So have to introduce this\n  // check to convert to add 0x in case if hex string\n  // doesn't have it.\n  if (hex.slice(0, 2) === '0x') {\n    return BigInt(hex);\n  }\n  return BigInt('0x' + hex);\n}\n\n/**\n * Returns an hex string of the given bigint\n *\n * @param {bigint} bigint - the bigint to be converted to hex\n * @param hexLength\n * @returns {string} - the hex value\n */\nexport function bigIntToHex(bigint: bigint, hexLength?: number): string {\n  let hex = bigint.toString(16);\n  hex = '0'.slice(0, hex.length % 2) + hex;\n  if (hexLength) {\n    hex = hex.padStart(hexLength, '0');\n  }\n  return hex;\n}\n\nexport function bigIntToBufferLE(n: bigint, minBytes?: number): Buffer {\n  let v = n.toString(16);\n  v = '0'.slice(0, v.length % 2) + v;\n  const buf = Buffer.from(v, 'hex').reverse();\n  if (minBytes && buf.length < minBytes) {\n    return Buffer.concat([buf, Buffer.alloc(minBytes - buf.length)]);\n  }\n  return buf;\n}\n\nexport function bigIntFromBufferLE(buf: Buffer): bigint {\n  return BigInt('0x' + Buffer.from(buf).reverse().toString('hex'));\n}\n\nexport function bigIntToBufferBE(n: bigint, minBytes?: number): Buffer {\n  let v = n.toString(16);\n  v = '0'.slice(0, v.length % 2) + v;\n  const buf = Buffer.from(v, 'hex');\n  if (minBytes && buf.length < minBytes) {\n    return Buffer.concat([Buffer.alloc(minBytes - buf.length), buf]);\n  }\n  return buf;\n}\n\nexport function bigIntFromBufferBE(buf: Buffer): bigint {\n  return BigInt('0x' + buf.toString('hex'));\n}\n\nexport function bigIntFromU8ABE(buf: Uint8Array): bigint {\n  return bigIntFromBufferBE(Buffer.from(buf));\n}\n\nexport function clamp(u: bigint): bigint {\n  u &= BigInt('0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8');\n  u |= BigInt('0x4000000000000000000000000000000000000000000000000000000000000000');\n  return u;\n}\n\n/**\n * Function get paillier public key simple varient\n * @param {bigint} n\n * @returns {bigint}\n */\nexport function getPaillierPublicKey(n: bigint): PublicKey {\n  return new PublicKey(n, n + BigInt(1));\n}\n\n/**\n * Generate a random positive integer co-prime to x\n * @param x\n * @returns {Promise<bigint>}\n */\nexport async function randomPositiveCoPrimeTo(x: bigint): Promise<bigint> {\n  while (true) {\n    const y = await randomBigInt(bitLength(x));\n    if (y > BigInt(0) && gcd(x, y) === BigInt(1)) {\n      return y;\n    }\n  }\n}\n\n/**\n * Generate a random positive integer coprime less than x with the same bit depth.\n * @param x\n * @returns {Promise<bigint>}\n */\nexport async function randomPositiveCoPrimeLessThan(x: bigint): Promise<bigint> {\n  if (x <= BigInt(2)) {\n    throw new Error('x must be larger than 2');\n  }\n  while (true) {\n    const y = await randomBigInt(bitLength(x));\n    if (y > BigInt(0) && y < x && gcd(x, y) === BigInt(1)) {\n      return y;\n    }\n  }\n}\n\n/**\n * Generate a random number of a given bitlength\n * @param bitlength\n * @returns {Promise<bigint>}\n */\nexport async function randomBigInt(bitlength: number): Promise<bigint> {\n  return bigIntFromBufferBE(Buffer.from(await randBits(bitlength, true)));\n}\n\n/**\n * @param seed - used to construct derivation path deterministically\n * @param isMaster - if set, path starts with prefix `m/`\n * @return path `(m/)/999999/a/b` where `a` and `b` are 7-byte pseudorandom numbers based on seed\n */\nexport function getDerivationPath(seed: string, isMaster = true): string {\n  const derivationPathInput = sha256(sha256(`${seed}`)).toString('hex');\n  const derivationPathParts = [\n    parseInt(derivationPathInput.slice(0, 7), 16),\n    parseInt(derivationPathInput.slice(7, 14), 16),\n  ];\n  const prefix = isMaster ? 'm/' : '';\n  return prefix + '999999/' + derivationPathParts.join('/');\n}\n\nfunction sha256(input: crypto.BinaryLike): Buffer {\n  return crypto.createHash('sha256').update(input).digest();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { PublicKey } from 'paillier-bigint';\nimport { bitLength, randBits } from 'bigint-crypto-utils';\nimport { gcd } from 'bigint-mod-arith';\nimport crypto from 'crypto';\n\n/**\n * Returns a bigint array from a hex string array\n * @param values\n */\nexport function convertHexArrToBigIntArr(values: string[]): bigint[] {\n  return values.map((value) => {\n    return hexToBigInt(value);\n  });\n}\n\n/**\n * Returns a hex string array from a bigint array\n * @param values\n * @param hexLength - length to pad each big int number too\n */\nexport function convertBigIntArrToHexArr(values: bigint[], hexLength?: number): string[] {\n  return values.map((value) => {\n    return bigIntToHex(value, hexLength);\n  });\n}\n\nexport function hexToBigInt(hex: string): bigint {\n  // Strangely bigint.toString(16) gives a hex string without 0x,\n  // but it won't accept the same string without 0x to convert\n  // to a bigint (BigInt(hex string)). So have to introduce this\n  // check to convert to add 0x in case if hex string\n  // doesn't have it.\n  if (hex.slice(0, 2) === '0x') {\n    return BigInt(hex);\n  }\n  return BigInt('0x' + hex);\n}\n\n/**\n * Returns an hex string of the given bigint\n *\n * @param {bigint} bigint - the bigint to be converted to hex\n * @param hexLength\n * @returns {string} - the hex value\n */\nexport function bigIntToHex(bigint: bigint, hexLength?: number): string {\n  let hex = bigint.toString(16);\n  hex = '0'.slice(0, hex.length % 2) + hex;\n  if (hexLength) {\n    hex = hex.padStart(hexLength, '0');\n  }\n  return hex;\n}\n\nexport function bigIntToBufferLE(n: bigint, minBytes?: number): Buffer {\n  let v = n.toString(16);\n  v = '0'.slice(0, v.length % 2) + v;\n  const buf = Buffer.from(v, 'hex').reverse();\n  if (minBytes && buf.length < minBytes) {\n    return Buffer.concat([buf, Buffer.alloc(minBytes - buf.length)]);\n  }\n  return buf;\n}\n\nexport function bigIntFromBufferLE(buf: Buffer): bigint {\n  return BigInt('0x' + Buffer.from(buf).reverse().toString('hex'));\n}\n\nexport function bigIntToBufferBE(n: bigint, minBytes?: number): Buffer {\n  let v = n.toString(16);\n  v = '0'.slice(0, v.length % 2) + v;\n  const buf = Buffer.from(v, 'hex');\n  if (minBytes && buf.length < minBytes) {\n    return Buffer.concat([Buffer.alloc(minBytes - buf.length), buf]);\n  }\n  return buf;\n}\n\nexport function bigIntFromBufferBE(buf: Buffer): bigint {\n  return BigInt('0x' + buf.toString('hex'));\n}\n\nexport function bigIntFromU8ABE(buf: Uint8Array): bigint {\n  return bigIntFromBufferBE(Buffer.from(buf));\n}\n\nexport function clamp(u: bigint): bigint {\n  u &= BigInt('0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8');\n  u |= BigInt('0x4000000000000000000000000000000000000000000000000000000000000000');\n  return u;\n}\n\n/**\n * Function get paillier public key simple varient\n * @param {bigint} n\n * @returns {bigint}\n */\nexport function getPaillierPublicKey(n: bigint): PublicKey {\n  return new PublicKey(n, n + BigInt(1));\n}\n\n/**\n * Generate a random positive integer co-prime to x\n * @param x\n * @returns {Promise<bigint>}\n */\nexport async function randomPositiveCoPrimeTo(x: bigint): Promise<bigint> {\n  while (true) {\n    const y = await randomBigInt(bitLength(x));\n    if (y > BigInt(0) && gcd(x, y) === BigInt(1)) {\n      return y;\n    }\n  }\n}\n\n/**\n * Generate a random positive integer coprime less than x with the same bit depth.\n * @param x\n * @returns {Promise<bigint>}\n */\nexport async function randomPositiveCoPrimeLessThan(x: bigint): Promise<bigint> {\n  if (x <= BigInt(2)) {\n    throw new Error('x must be larger than 2');\n  }\n  while (true) {\n    const y = await randomBigInt(bitLength(x));\n    if (y > BigInt(0) && y < x && gcd(x, y) === BigInt(1)) {\n      return y;\n    }\n  }\n}\n\n/**\n * Generate a random number of a given bitlength\n * @param bitlength\n * @returns {Promise<bigint>}\n */\nexport async function randomBigInt(bitlength: number): Promise<bigint> {\n  return bigIntFromBufferBE(Buffer.from(await randBits(bitlength, true)));\n}\n\n/**\n * @param seed - used to construct derivation path deterministically\n * @param isMaster - if set, path starts with prefix `m/`\n * @return path `(m/)/999999/a/b` where `a` and `b` are 7-byte pseudorandom numbers based on seed\n */\nexport function getDerivationPath(seed: string, isMaster = true): string {\n  const derivationPathInput = sha256(sha256(`${seed}`)).toString('hex');\n  const derivationPathParts = [\n    parseInt(derivationPathInput.slice(0, 7), 16),\n    parseInt(derivationPathInput.slice(7, 14), 16),\n  ];\n  const prefix = isMaster ? 'm/' : '';\n  return prefix + '999999/' + derivationPathParts.join('/');\n}\n\nfunction sha256(input: crypto.BinaryLike): Buffer {\n  return crypto.createHash('sha256').update(input).digest();\n}\n"]}