@bitgo-beta/account-lib 2.24.1-alpha.49 → 2.24.1-alpha.490

package/dist/test/unit/mpc/tss/ecdsa/ecdsa.js

@@ -0,0 +1,333 @@
+"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 });
+/**
+ * @prettier
+ */
+const assert_1 = __importDefault(require("assert"));
+const crypto_1 = require("crypto");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const sinon = __importStar(require("sinon"));
+const keccak_1 = __importDefault(require("keccak"));
+const ecdsa_1 = require("../fixtures/ecdsa");
+// Need to import and then monkey-patch to make stubbing work with ESM
+const paillierBigintModule = require('paillier-bigint');
+const paillierBigint = paillierBigintModule;
+const schnorrModule = require('@bitgo-beta/sdk-lib-mpc');
+const Schnorr = schnorrModule.Schnorr;
+describe('TSS ECDSA TESTS', function () {
+    const MPC = new sdk_core_1.Ecdsa();
+    const base = BigInt('0x010000000000000000000000000000000000000000000000000000000000000000'); // 2^256
+    let keyShares;
+    let commonPublicKey;
+    const seed = Buffer.from('c4d1583a0b7b88626b56f0c83ee6df4d95d99cca73893ffb57c5e4411fa1b2b9c87456080e8d3f03462f065688abc28be2d4af3164d593c50b55269b435ea48d', 'hex');
+    let A, B, C;
+    before(async () => {
+        // Direct monkey patching of the module for ESM compatibility
+        const originalGenerateRandomKeys = paillierBigint.generateRandomKeys;
+        const paillierMock = sinon.stub();
+        paillierMock
+            .onCall(0)
+            .resolves(ecdsa_1.paillerKeys[0])
+            .onCall(1)
+            .resolves(ecdsa_1.paillerKeys[1])
+            .onCall(2)
+            .resolves(ecdsa_1.paillerKeys[2])
+            .onCall(3)
+            .resolves(ecdsa_1.paillerKeys[0])
+            .onCall(4)
+            .resolves(ecdsa_1.paillerKeys[1])
+            .onCall(5)
+            .resolves(ecdsa_1.paillerKeys[2]);
+        // Replace the function directly on the module
+        paillierBigint.generateRandomKeys = paillierMock;
+        // Save references to restore later
+        paillierMock.originalFn = originalGenerateRandomKeys;
+        // Apply the same monkey-patching approach for Schnorr
+        const originalCreateSchnorrProof = Schnorr.createSchnorrProof;
+        const schnorrProofMock = sinon.stub();
+        schnorrProofMock
+            .onCall(0)
+            .returns(ecdsa_1.schnorrProofs[0])
+            .onCall(1)
+            .returns(ecdsa_1.schnorrProofs[1])
+            .onCall(2)
+            .returns(ecdsa_1.schnorrProofs[2])
+            .onCall(3)
+            .returns(ecdsa_1.schnorrProofs[3])
+            .onCall(4)
+            .returns(ecdsa_1.schnorrProofs[4])
+            .onCall(5)
+            .returns(ecdsa_1.schnorrProofs[5]);
+        // Replace the function directly on the module
+        Schnorr.createSchnorrProof = schnorrProofMock;
+        // Save references to restore later
+        schnorrProofMock.originalFn = originalCreateSchnorrProof;
+        [A, B, C] = await Promise.all([MPC.keyShare(1, 2, 3), MPC.keyShare(2, 2, 3), MPC.keyShare(3, 2, 3)]);
+        // Needs to run this serially for testing deterministic key generation
+        // to get specific paillier keys to be assigned
+        const D = await MPC.keyShare(1, 2, 3, seed);
+        const E = await MPC.keyShare(2, 2, 3, seed);
+        const F = await MPC.keyShare(3, 2, 3, seed);
+        const aKeyCombine = MPC.keyCombine(A.pShare, [B.nShares[1], C.nShares[1]]);
+        const bKeyCombine = MPC.keyCombine(B.pShare, [A.nShares[2], C.nShares[2]]);
+        const cKeyCombine = MPC.keyCombine(C.pShare, [A.nShares[3], B.nShares[3]]);
+        // Shares with specific seeds
+        const dKeyCombine = MPC.keyCombine(D.pShare, [E.nShares[1], F.nShares[1]]);
+        const eKeyCombine = MPC.keyCombine(E.pShare, [D.nShares[2], F.nShares[2]]);
+        const fKeyCombine = MPC.keyCombine(F.pShare, [D.nShares[3], E.nShares[3]]);
+        // Shares for derived keys.
+        const path = 'm/0/1';
+        const aKeyDerive = MPC.keyDerive(A.pShare, [B.nShares[1], C.nShares[1]], path);
+        const gKeyCombine = {
+            xShare: aKeyDerive.xShare,
+            yShares: aKeyCombine.yShares,
+        };
+        const hKeyCombine = MPC.keyCombine(B.pShare, [aKeyDerive.nShares[2], C.nShares[2]]);
+        keyShares = [
+            aKeyCombine,
+            bKeyCombine,
+            cKeyCombine,
+            dKeyCombine,
+            eKeyCombine,
+            fKeyCombine,
+            gKeyCombine,
+            hKeyCombine,
+        ];
+        commonPublicKey = aKeyCombine.xShare.y;
+        // Adding an explicit assertion to check if the stub was used
+        paillierMock.callCount.should.equal(6, 'paillierMock should be called 6 times');
+        schnorrProofMock.callCount.should.equal(8, 'schnorrProofMock should be called 6 times');
+        // Restore original functions
+        paillierBigint.generateRandomKeys = paillierMock.originalFn;
+        Schnorr.createSchnorrProof = schnorrProofMock.originalFn;
+    });
+    describe('Ecdsa Key Generation Test', function () {
+        it('should generate keys with correct threshold and share number', async function () {
+            for (let index = 0; index < 3; index++) {
+                const participantOne = (index % 3) + 1;
+                const participantTwo = ((index + 1) % 3) + 1;
+                const participantThree = ((index + 2) % 3) + 1;
+                keyShares[index].xShare.i.should.equal(participantOne);
+                keyShares[index].xShare.y.should.equal(commonPublicKey);
+                keyShares[index].xShare.m.should.not.be.Null;
+                keyShares[index].xShare.l.should.not.be.Null;
+                keyShares[index].xShare.n.should.not.be.Null;
+                const chaincode = BigInt('0x' + keyShares[index].xShare.chaincode);
+                const isChainCodeValid = chaincode > BigInt(0) && chaincode <= base;
+                isChainCodeValid.should.equal(true);
+                keyShares[index].yShares[participantTwo].i.should.equal(participantOne);
+                keyShares[index].yShares[participantThree].i.should.equal(participantOne);
+                keyShares[index].yShares[participantTwo].j.should.equal(participantTwo);
+                keyShares[index].yShares[participantThree].j.should.equal(participantThree);
+                keyShares[index].yShares[participantTwo].n.should.not.be.Null;
+                keyShares[index].yShares[participantThree].n.should.not.be.Null;
+                const publicKeyPrefix = keyShares[index].xShare.y.slice(0, 2);
+                const isRightPrefix = publicKeyPrefix === '03' || publicKeyPrefix === '02';
+                isRightPrefix.should.equal(true);
+            }
+        });
+        it('should generate keyshares with specific seed', async function () {
+            // Keys should be deterministic when using seed
+            const [, , , D, E, F] = keyShares;
+            assert_1.default.deepEqual(D, ecdsa_1.mockDKeyShare);
+            assert_1.default.deepEqual(E, ecdsa_1.mockEKeyShare);
+            assert_1.default.deepEqual(F, ecdsa_1.mockFKeyShare);
+        });
+        it('should fail if seed is length less than 64 bytes', async function () {
+            await MPC.keyShare(1, 2, 3, (0, crypto_1.randomBytes)(16)).should.be.rejectedWith('Seed must have a length of at least 64 bytes');
+            await MPC.keyShare(1, 2, 3, (0, crypto_1.randomBytes)(32)).should.be.rejectedWith('Seed must have a length of at least 64 bytes');
+        });
+        it('should pass if seed length is greater than 64', async function () {
+            const paillierMock = sinon.stub(paillierBigint, 'generateRandomKeys').onCall(0).resolves(ecdsa_1.paillerKeys[0]);
+            const seed72Bytes = Buffer.from('4f7e914dc9ec696398675d1544aab61cb7a67662ffcbdb4079ec5d682be565d87c1b2de75c943dec14c96586984860268779498e6732473aed9ed9c2538f50bea0af926bdccc0134', 'hex');
+            (await MPC.keyShare(1, 2, 3, seed72Bytes)).pShare.u.length.should.equal(64);
+            paillierMock.restore();
+        });
+        it('should calculate correct chaincode while combining', async function () {
+            const keyCombine = MPC.keyCombine(ecdsa_1.mockPShare, ecdsa_1.mockNShares);
+            keyCombine.xShare.chaincode.should.equal('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc32');
+        });
+        it('should fail to generate keys with invalid threshold and share number', async function () {
+            const invalidConfigs = [
+                { index: 1, threshold: 5, numShares: 3 },
+                { index: -1, threshold: 2, numShares: 3 },
+                { index: 1, threshold: 2, numShares: 1 },
+            ];
+            for (let index = 0; index < invalidConfigs.length; index++) {
+                try {
+                    await MPC.keyShare(invalidConfigs[index].index, invalidConfigs[index].threshold, invalidConfigs[index].numShares);
+                }
+                catch (e) {
+                    e.should.equal('Invalid KeyShare Config');
+                }
+            }
+        });
+        it('should derive unhardened child keys', async function () {
+            // parent key
+            const aKeyCombine = keyShares[0];
+            const commonKeychain = aKeyCombine.xShare.y + aKeyCombine.xShare.chaincode;
+            for (let index = 0; index < 10; index++) {
+                const path = `m/0/0/${index}`;
+                const subkey = MPC.keyDerive(A.pShare, [B.nShares[1], C.nShares[1]], path);
+                const derive1 = MPC.deriveUnhardened(commonKeychain, path);
+                const derive2 = MPC.deriveUnhardened(commonKeychain, path);
+                derive1.should.equal(derive2, 'derivation should be deterministic');
+                (subkey.xShare.y + subkey.xShare.chaincode).should.equal(derive1, 'subkey common keychain should match derived keychain');
+            }
+        });
+    });
+    describe('ECDSA Signing', async function () {
+        let config;
+        before(() => {
+            const [A, B, C, D, E, F, G, H] = keyShares;
+            config = [
+                { signerOne: A, signerTwo: B },
+                { signerOne: A, signerTwo: C },
+                { signerOne: B, signerTwo: A },
+                { signerOne: B, signerTwo: C },
+                { signerOne: C, signerTwo: A },
+                { signerOne: C, signerTwo: B },
+                // Checks signing with specific seed
+                { signerOne: D, signerTwo: E },
+                { signerOne: E, signerTwo: F },
+                { signerOne: F, signerTwo: D },
+                // Checks with specific hashing algorithm
+                { signerOne: A, signerTwo: B, hash: 'keccak256' },
+                // checks with no hashing
+                { signerOne: A, signerTwo: B, shouldHash: false },
+                // Checks with derived subkey
+                { signerOne: G, signerTwo: H },
+            ];
+        });
+        for (let index = 0; index < 9; index++) {
+            it(`should properly sign the message case ${index}`, async function () {
+                // Step One
+                // signerOne, signerTwo have decided to sign the message
+                const signerOne = config[index].signerOne;
+                const signerOneIndex = signerOne.xShare.i;
+                const signerTwo = config[index].signerTwo;
+                const signerTwoIndex = signerTwo.xShare.i;
+                const [signerOneToTwoPaillierChallenge, signerTwoToOnePaillierChallenge] = await Promise.all([
+                    sdk_lib_mpc_1.EcdsaPaillierProof.generateP((0, sdk_core_1.hexToBigInt)(signerOne.yShares[signerTwoIndex].n)),
+                    sdk_lib_mpc_1.EcdsaPaillierProof.generateP((0, sdk_core_1.hexToBigInt)(signerTwo.yShares[signerOneIndex].n)),
+                ]);
+                // Step Two
+                // First signer generates their range proof challenge.
+                const signerOneXShare = MPC.appendChallenge(signerOne.xShare, sdk_lib_mpc_1.EcdsaTypes.serializeNtilde(ecdsa_1.ntildes[index]), sdk_lib_mpc_1.EcdsaTypes.serializePaillierChallenge({ p: signerOneToTwoPaillierChallenge }));
+                // Step Three
+                //  Second signer generates their range proof challenge.
+                const signerTwoXShare = MPC.appendChallenge(signerTwo.xShare, sdk_lib_mpc_1.EcdsaTypes.serializeNtilde(ecdsa_1.ntildes[index + 1]), sdk_lib_mpc_1.EcdsaTypes.serializePaillierChallenge({ p: signerTwoToOnePaillierChallenge }));
+                const signerTwoChallenge = { ntilde: signerTwoXShare.ntilde, h1: signerTwoXShare.h1, h2: signerTwoXShare.h2 };
+                // Step Four
+                // First signer receives the challenge from the second signer and appends it to their YShare
+                const signerTwoYShare = MPC.appendChallenge(signerOne.yShares[signerTwoIndex], signerTwoChallenge, sdk_lib_mpc_1.EcdsaTypes.serializePaillierChallenge({ p: signerTwoToOnePaillierChallenge }));
+                // Step Five
+                // Sign Shares are created by one of the participants (signerOne)
+                // with its private XShare and YShare corresponding to the other participant (signerTwo)
+                // This step produces a private WShare which signerOne saves and KShare which signerOne sends to signerTwo
+                const signShares = await MPC.signShare(signerOneXShare, signerTwoYShare);
+                // Step Six
+                // signerTwo receives the KShare from signerOne and uses it produce private
+                // BShare (Beta Share) which signerTwo saves and AShare (Alpha Share)
+                // which is sent to signerOne
+                const signConvertS21 = await MPC.signConvertStep1({
+                    xShare: signerTwoXShare,
+                    yShare: signerTwo.yShares[signerOneIndex], // YShare corresponding to the other participant signerOne
+                    kShare: signShares.kShare,
+                });
+                // Step Seven
+                // signerOne receives the AShare from signerTwo and signerOne using the private WShare from step two
+                // uses it produce private GShare (Gamma Share) and MUShare (Mu Share) which
+                // is sent to signerTwo to produce its Gamma Share
+                const signConvertS12 = await MPC.signConvertStep2({
+                    aShare: signConvertS21.aShare,
+                    wShare: signShares.wShare,
+                });
+                // Step Eight
+                // signerTwo receives the MUShare from signerOne and signerOne using the private BShare from step three
+                // uses it produce private GShare (Gamma Share)
+                const signConvertS21_2 = await MPC.signConvertStep3({
+                    muShare: signConvertS12.muShare,
+                    bShare: signConvertS21.bShare,
+                });
+                // Step Nine
+                // signerOne and signerTwo both have successfully generated GShares and they use
+                // the sign combine function to generate their private omicron shares and
+                // delta shares which they share to each other
+                const [signCombineOne, signCombineTwo] = [
+                    MPC.signCombine({
+                        gShare: signConvertS12.gShare,
+                        signIndex: {
+                            i: signConvertS12.muShare.i,
+                            j: signConvertS12.muShare.j,
+                        },
+                    }),
+                    MPC.signCombine({
+                        gShare: signConvertS21_2.gShare,
+                        signIndex: {
+                            i: signConvertS21_2.signIndex.i,
+                            j: signConvertS21_2.signIndex.j,
+                        },
+                    }),
+                ];
+                const MESSAGE = Buffer.from('TOO MANY SECRETS');
+                // Step Ten
+                // signerOne and signerTwo shares the delta share from each other
+                // and finally signs the message using their private OShare
+                // and delta share received from the other signer
+                const hashGenerator = (hashType) => {
+                    return hashType === 'keccak256' ? (0, keccak_1.default)('keccak256') : undefined;
+                };
+                const [signA, signB] = [
+                    MPC.sign(MESSAGE, signCombineOne.oShare, signCombineTwo.dShare, hashGenerator(config[index].hash), config[index].shouldHash),
+                    MPC.sign(MESSAGE, signCombineTwo.oShare, signCombineOne.dShare, hashGenerator(config[index].hash), config[index].shouldHash),
+                ];
+                // Step Eleven
+                // Construct the final signature
+                const signature = MPC.constructSignature([signA, signB]);
+                // Step Twelve
+                // Verify signature
+                const isValid = MPC.verify(MESSAGE, signature, hashGenerator(config[index].hash), config[index].shouldHash);
+                isValid.should.equal(true);
+            });
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecdsa.js","sourceRoot":"","sources":["../../../../../../test/unit/mpc/tss/ecdsa/ecdsa.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport assert from 'assert';\nimport { Hash, randomBytes } from 'crypto';\nimport { Ecdsa, ECDSA, hexToBigInt } from '@bitgo-beta/sdk-core';\nimport { EcdsaPaillierProof, EcdsaTypes, SchnorrProof } from '@bitgo-beta/sdk-lib-mpc';\nimport * as sinon from 'sinon';\nimport createKeccakHash from 'keccak';\nimport {\n  schnorrProofs,\n  ntildes,\n  paillerKeys,\n  mockNShares,\n  mockPShare,\n  mockDKeyShare,\n  mockEKeyShare,\n  mockFKeyShare,\n} from '../fixtures/ecdsa';\n\n// Need to import and then monkey-patch to make stubbing work with ESM\nconst paillierBigintModule = require('paillier-bigint');\nconst paillierBigint = paillierBigintModule;\nconst schnorrModule = require('@bitgo-beta/sdk-lib-mpc');\nconst Schnorr = schnorrModule.Schnorr;\n\ndescribe('TSS ECDSA TESTS', function () {\n  const MPC = new Ecdsa();\n  const base = BigInt('0x010000000000000000000000000000000000000000000000000000000000000000'); // 2^256\n  let keyShares: ECDSA.KeyCombined[];\n  let commonPublicKey: string;\n  const seed = Buffer.from(\n    'c4d1583a0b7b88626b56f0c83ee6df4d95d99cca73893ffb57c5e4411fa1b2b9c87456080e8d3f03462f065688abc28be2d4af3164d593c50b55269b435ea48d',\n    'hex',\n  );\n  let A: ECDSA.KeyShare, B: ECDSA.KeyShare, C: ECDSA.KeyShare;\n  before(async () => {\n    // Direct monkey patching of the module for ESM compatibility\n    const originalGenerateRandomKeys = paillierBigint.generateRandomKeys;\n\n    const paillierMock = sinon.stub();\n    paillierMock\n      .onCall(0)\n      .resolves(paillerKeys[0])\n      .onCall(1)\n      .resolves(paillerKeys[1])\n      .onCall(2)\n      .resolves(paillerKeys[2])\n      .onCall(3)\n      .resolves(paillerKeys[0])\n      .onCall(4)\n      .resolves(paillerKeys[1])\n      .onCall(5)\n      .resolves(paillerKeys[2]);\n\n    // Replace the function directly on the module\n    paillierBigint.generateRandomKeys = paillierMock;\n\n    // Save references to restore later\n    (paillierMock as any).originalFn = originalGenerateRandomKeys;\n\n    // Apply the same monkey-patching approach for Schnorr\n    const originalCreateSchnorrProof = Schnorr.createSchnorrProof;\n\n    const schnorrProofMock = sinon.stub();\n    schnorrProofMock\n      .onCall(0)\n      .returns(schnorrProofs[0] as unknown as SchnorrProof)\n      .onCall(1)\n      .returns(schnorrProofs[1] as unknown as SchnorrProof)\n      .onCall(2)\n      .returns(schnorrProofs[2] as unknown as SchnorrProof)\n      .onCall(3)\n      .returns(schnorrProofs[3] as unknown as SchnorrProof)\n      .onCall(4)\n      .returns(schnorrProofs[4] as unknown as SchnorrProof)\n      .onCall(5)\n      .returns(schnorrProofs[5] as unknown as SchnorrProof);\n\n    // Replace the function directly on the module\n    Schnorr.createSchnorrProof = schnorrProofMock;\n\n    // Save references to restore later\n    (schnorrProofMock as any).originalFn = originalCreateSchnorrProof;\n\n    [A, B, C] = await Promise.all([MPC.keyShare(1, 2, 3), MPC.keyShare(2, 2, 3), MPC.keyShare(3, 2, 3)]);\n\n    // Needs to run this serially for testing deterministic key generation\n    // to get specific paillier keys to be assigned\n    const D = await MPC.keyShare(1, 2, 3, seed);\n    const E = await MPC.keyShare(2, 2, 3, seed);\n    const F = await MPC.keyShare(3, 2, 3, seed);\n\n    const aKeyCombine = MPC.keyCombine(A.pShare, [B.nShares[1], C.nShares[1]]);\n    const bKeyCombine = MPC.keyCombine(B.pShare, [A.nShares[2], C.nShares[2]]);\n    const cKeyCombine = MPC.keyCombine(C.pShare, [A.nShares[3], B.nShares[3]]);\n\n    // Shares with specific seeds\n    const dKeyCombine = MPC.keyCombine(D.pShare, [E.nShares[1], F.nShares[1]]);\n    const eKeyCombine = MPC.keyCombine(E.pShare, [D.nShares[2], F.nShares[2]]);\n    const fKeyCombine = MPC.keyCombine(F.pShare, [D.nShares[3], E.nShares[3]]);\n\n    // Shares for derived keys.\n    const path = 'm/0/1';\n    const aKeyDerive = MPC.keyDerive(A.pShare, [B.nShares[1], C.nShares[1]], path);\n    const gKeyCombine: ECDSA.KeyCombined = {\n      xShare: aKeyDerive.xShare,\n      yShares: aKeyCombine.yShares,\n    };\n    const hKeyCombine = MPC.keyCombine(B.pShare, [aKeyDerive.nShares[2], C.nShares[2]]);\n    keyShares = [\n      aKeyCombine,\n      bKeyCombine,\n      cKeyCombine,\n      dKeyCombine,\n      eKeyCombine,\n      fKeyCombine,\n      gKeyCombine,\n      hKeyCombine,\n    ];\n    commonPublicKey = aKeyCombine.xShare.y;\n    // Adding an explicit assertion to check if the stub was used\n    paillierMock.callCount.should.equal(6, 'paillierMock should be called 6 times');\n    schnorrProofMock.callCount.should.equal(8, 'schnorrProofMock should be called 6 times');\n\n    // Restore original functions\n    paillierBigint.generateRandomKeys = (paillierMock as any).originalFn;\n    Schnorr.createSchnorrProof = (schnorrProofMock as any).originalFn;\n  });\n\n  describe('Ecdsa Key Generation Test', function () {\n    it('should generate keys with correct threshold and share number', async function () {\n      for (let index = 0; index < 3; index++) {\n        const participantOne = (index % 3) + 1;\n        const participantTwo = ((index + 1) % 3) + 1;\n        const participantThree = ((index + 2) % 3) + 1;\n        keyShares[index].xShare.i.should.equal(participantOne);\n        keyShares[index].xShare.y.should.equal(commonPublicKey);\n        keyShares[index].xShare.m.should.not.be.Null;\n        keyShares[index].xShare.l.should.not.be.Null;\n        keyShares[index].xShare.n.should.not.be.Null;\n\n        const chaincode = BigInt('0x' + keyShares[index].xShare.chaincode);\n        const isChainCodeValid = chaincode > BigInt(0) && chaincode <= base;\n        isChainCodeValid.should.equal(true);\n\n        keyShares[index].yShares[participantTwo].i.should.equal(participantOne);\n        keyShares[index].yShares[participantThree].i.should.equal(participantOne);\n        keyShares[index].yShares[participantTwo].j.should.equal(participantTwo);\n        keyShares[index].yShares[participantThree].j.should.equal(participantThree);\n        keyShares[index].yShares[participantTwo].n.should.not.be.Null;\n        keyShares[index].yShares[participantThree].n.should.not.be.Null;\n\n        const publicKeyPrefix = keyShares[index].xShare.y.slice(0, 2);\n        const isRightPrefix = publicKeyPrefix === '03' || publicKeyPrefix === '02';\n        isRightPrefix.should.equal(true);\n      }\n    });\n\n    it('should generate keyshares with specific seed', async function () {\n      // Keys should be deterministic when using seed\n      const [, , , D, E, F] = keyShares;\n      assert.deepEqual(D, mockDKeyShare);\n      assert.deepEqual(E, mockEKeyShare);\n      assert.deepEqual(F, mockFKeyShare);\n    });\n\n    it('should fail if seed is length less than 64 bytes', async function () {\n      await MPC.keyShare(1, 2, 3, randomBytes(16)).should.be.rejectedWith(\n        'Seed must have a length of at least 64 bytes',\n      );\n      await MPC.keyShare(1, 2, 3, randomBytes(32)).should.be.rejectedWith(\n        'Seed must have a length of at least 64 bytes',\n      );\n    });\n\n    it('should pass if seed length is greater than 64', async function () {\n      const paillierMock = sinon.stub(paillierBigint, 'generateRandomKeys').onCall(0).resolves(paillerKeys[0]);\n      const seed72Bytes = Buffer.from(\n        '4f7e914dc9ec696398675d1544aab61cb7a67662ffcbdb4079ec5d682be565d87c1b2de75c943dec14c96586984860268779498e6732473aed9ed9c2538f50bea0af926bdccc0134',\n        'hex',\n      );\n      (await MPC.keyShare(1, 2, 3, seed72Bytes)).pShare.u.length.should.equal(64);\n      paillierMock.restore();\n    });\n\n    it('should calculate correct chaincode while combining', async function () {\n      const keyCombine = MPC.keyCombine(mockPShare, mockNShares);\n      keyCombine.xShare.chaincode.should.equal('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc32');\n    });\n\n    it('should fail to generate keys with invalid threshold and share number', async function () {\n      const invalidConfigs = [\n        { index: 1, threshold: 5, numShares: 3 },\n        { index: -1, threshold: 2, numShares: 3 },\n        { index: 1, threshold: 2, numShares: 1 },\n      ];\n      for (let index = 0; index < invalidConfigs.length; index++) {\n        try {\n          await MPC.keyShare(\n            invalidConfigs[index].index,\n            invalidConfigs[index].threshold,\n            invalidConfigs[index].numShares,\n          );\n        } catch (e) {\n          e.should.equal('Invalid KeyShare Config');\n        }\n      }\n    });\n\n    it('should derive unhardened child keys', async function () {\n      // parent key\n      const aKeyCombine = keyShares[0];\n      const commonKeychain = aKeyCombine.xShare.y + aKeyCombine.xShare.chaincode;\n\n      for (let index = 0; index < 10; index++) {\n        const path = `m/0/0/${index}`;\n\n        const subkey = MPC.keyDerive(A.pShare, [B.nShares[1], C.nShares[1]], path);\n\n        const derive1: string = MPC.deriveUnhardened(commonKeychain, path);\n        const derive2: string = MPC.deriveUnhardened(commonKeychain, path);\n\n        derive1.should.equal(derive2, 'derivation should be deterministic');\n\n        (subkey.xShare.y + subkey.xShare.chaincode).should.equal(\n          derive1,\n          'subkey common keychain should match derived keychain',\n        );\n      }\n    });\n  });\n\n  describe('ECDSA Signing', async function () {\n    let config: { signerOne: ECDSA.KeyCombined; signerTwo: ECDSA.KeyCombined; hash?: string; shouldHash?: boolean }[];\n\n    before(() => {\n      const [A, B, C, D, E, F, G, H] = keyShares;\n\n      config = [\n        { signerOne: A, signerTwo: B },\n        { signerOne: A, signerTwo: C },\n        { signerOne: B, signerTwo: A },\n        { signerOne: B, signerTwo: C },\n        { signerOne: C, signerTwo: A },\n        { signerOne: C, signerTwo: B },\n\n        // Checks signing with specific seed\n        { signerOne: D, signerTwo: E },\n        { signerOne: E, signerTwo: F },\n        { signerOne: F, signerTwo: D },\n\n        // Checks with specific hashing algorithm\n        { signerOne: A, signerTwo: B, hash: 'keccak256' },\n\n        // checks with no hashing\n        { signerOne: A, signerTwo: B, shouldHash: false },\n\n        // Checks with derived subkey\n        { signerOne: G, signerTwo: H },\n      ];\n    });\n\n    for (let index = 0; index < 9; index++) {\n      it(`should properly sign the message case ${index}`, async function () {\n        // Step One\n        // signerOne, signerTwo have decided to sign the message\n        const signerOne = config[index].signerOne;\n        const signerOneIndex = signerOne.xShare.i;\n        const signerTwo = config[index].signerTwo;\n        const signerTwoIndex = signerTwo.xShare.i;\n\n        const [signerOneToTwoPaillierChallenge, signerTwoToOnePaillierChallenge] = await Promise.all([\n          EcdsaPaillierProof.generateP(hexToBigInt(signerOne.yShares[signerTwoIndex].n)),\n          EcdsaPaillierProof.generateP(hexToBigInt(signerTwo.yShares[signerOneIndex].n)),\n        ]);\n        // Step Two\n        // First signer generates their range proof challenge.\n        const signerOneXShare: ECDSA.XShareWithChallenges = MPC.appendChallenge(\n          signerOne.xShare,\n          EcdsaTypes.serializeNtilde(ntildes[index]),\n          EcdsaTypes.serializePaillierChallenge({ p: signerOneToTwoPaillierChallenge }),\n        );\n\n        // Step Three\n        //  Second signer generates their range proof challenge.\n        const signerTwoXShare: ECDSA.XShareWithChallenges = MPC.appendChallenge(\n          signerTwo.xShare,\n          EcdsaTypes.serializeNtilde(ntildes[index + 1]),\n          EcdsaTypes.serializePaillierChallenge({ p: signerTwoToOnePaillierChallenge }),\n        );\n        const signerTwoChallenge = { ntilde: signerTwoXShare.ntilde, h1: signerTwoXShare.h1, h2: signerTwoXShare.h2 };\n\n        // Step Four\n        // First signer receives the challenge from the second signer and appends it to their YShare\n        const signerTwoYShare: ECDSA.YShareWithChallenges = MPC.appendChallenge(\n          signerOne.yShares[signerTwoIndex],\n          signerTwoChallenge,\n          EcdsaTypes.serializePaillierChallenge({ p: signerTwoToOnePaillierChallenge }),\n        );\n\n        // Step Five\n        // Sign Shares are created by one of the participants (signerOne)\n        // with its private XShare and YShare corresponding to the other participant (signerTwo)\n        // This step produces a private WShare which signerOne saves and KShare which signerOne sends to signerTwo\n        const signShares = await MPC.signShare(signerOneXShare, signerTwoYShare);\n\n        // Step Six\n        // signerTwo receives the KShare from signerOne and uses it produce private\n        // BShare (Beta Share) which signerTwo saves and AShare (Alpha Share)\n        // which is sent to signerOne\n\n        const signConvertS21 = await MPC.signConvertStep1({\n          xShare: signerTwoXShare,\n          yShare: signerTwo.yShares[signerOneIndex], // YShare corresponding to the other participant signerOne\n          kShare: signShares.kShare,\n        });\n\n        // Step Seven\n        // signerOne receives the AShare from signerTwo and signerOne using the private WShare from step two\n        // uses it produce private GShare (Gamma Share) and MUShare (Mu Share) which\n        // is sent to signerTwo to produce its Gamma Share\n        const signConvertS12 = await MPC.signConvertStep2({\n          aShare: signConvertS21.aShare,\n          wShare: signShares.wShare,\n        });\n\n        // Step Eight\n        // signerTwo receives the MUShare from signerOne and signerOne using the private BShare from step three\n        // uses it produce private GShare (Gamma Share)\n        const signConvertS21_2 = await MPC.signConvertStep3({\n          muShare: signConvertS12.muShare,\n          bShare: signConvertS21.bShare,\n        });\n\n        // Step Nine\n        // signerOne and signerTwo both have successfully generated GShares and they use\n        // the sign combine function to generate their private omicron shares and\n        // delta shares which they share to each other\n\n        const [signCombineOne, signCombineTwo] = [\n          MPC.signCombine({\n            gShare: signConvertS12.gShare,\n            signIndex: {\n              i: signConvertS12.muShare.i,\n              j: signConvertS12.muShare.j,\n            },\n          }),\n          MPC.signCombine({\n            gShare: signConvertS21_2.gShare,\n            signIndex: {\n              i: signConvertS21_2.signIndex.i,\n              j: signConvertS21_2.signIndex.j,\n            },\n          }),\n        ];\n\n        const MESSAGE = Buffer.from('TOO MANY SECRETS');\n\n        // Step Ten\n        // signerOne and signerTwo shares the delta share from each other\n        // and finally signs the message using their private OShare\n        // and delta share received from the other signer\n\n        const hashGenerator = (hashType?: string): Hash | undefined => {\n          return hashType === 'keccak256' ? (createKeccakHash('keccak256') as Hash) : undefined;\n        };\n        const [signA, signB] = [\n          MPC.sign(\n            MESSAGE,\n            signCombineOne.oShare,\n            signCombineTwo.dShare,\n            hashGenerator(config[index].hash),\n            config[index].shouldHash,\n          ),\n          MPC.sign(\n            MESSAGE,\n            signCombineTwo.oShare,\n            signCombineOne.dShare,\n            hashGenerator(config[index].hash),\n            config[index].shouldHash,\n          ),\n        ];\n\n        // Step Eleven\n        // Construct the final signature\n\n        const signature = MPC.constructSignature([signA, signB]);\n\n        // Step Twelve\n        // Verify signature\n\n        const isValid = MPC.verify(MESSAGE, signature, hashGenerator(config[index].hash), config[index].shouldHash);\n        isValid.should.equal(true);\n      });\n    }\n  });\n});\n"]}

package/dist/test/unit/mpc/tss/eddsa/eddsa.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @prettier
+ */
+import 'should';
+//# sourceMappingURL=eddsa.d.ts.map

package/dist/test/unit/mpc/tss/eddsa/eddsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../../../../test/unit/mpc/tss/eddsa/eddsa.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,QAAQ,CAAC"}