@bitgo/sdk-core 37.10.0 → 37.11.0

package/dist/test/unit/bitgo/utils/tss/eddsa/eddsaExternalSigner.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=eddsaExternalSigner.d.ts.map

package/dist/test/unit/bitgo/utils/tss/eddsa/eddsaExternalSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eddsaExternalSigner.d.ts","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/eddsa/eddsaExternalSigner.ts"],"names":[],"mappings":""}

package/dist/test/unit/bitgo/utils/tss/eddsa/eddsaExternalSigner.js

@@ -0,0 +1,158 @@
+"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 });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+const src_1 = require("../../../../../../src");
+const gpgKeys_1 = require("../ecdsa/gpgKeys");
+describe('EddsaUtils.createKeychainsWithExternalSigner', function () {
+    let utils;
+    let callbacks;
+    let mockCoin;
+    const enterprise = 'enterprise-id';
+    const commonKeychain = 'eddsa-common-keychain';
+    const keyShare = (pub, prv, proof) => ({
+        publicShare: pub,
+        privateShare: prv,
+        privateShareProof: proof,
+        vssProof: `${proof}-vss`,
+        gpgKey: `${pub}-gpg`,
+    });
+    const userToBitgoKeyShare = keyShare('upub', 'uprv-enc', 'uproof');
+    const backupToBitgoKeyShare = keyShare('bpub', 'bprv-enc', 'bproof');
+    const backupToUserCounterPartyKeyShare = keyShare('ucp-pub', 'ucp-prv', 'ucp-proof');
+    const userState = { encryptedData: 'u-data', encryptedDataKey: 'u-data-key' };
+    const backupState = { encryptedData: 'b-data', encryptedDataKey: 'b-data-key' };
+    const bitgoKeychain = { id: 'bitgo-key-id', commonKeychain, source: 'bitgo', type: 'tss' };
+    const initResult = {
+        userGpgPublicKey: 'user-gpg-pub',
+        backupGpgPublicKey: 'backup-gpg-pub',
+        userToBitgoKeyShare,
+        backupToBitgoKeyShare,
+        userState,
+        backupState,
+        backupToUserCounterPartyKeyShare,
+    };
+    beforeEach(function () {
+        callbacks = {
+            initializeCallback: sinon.stub().resolves(initResult),
+            finalizeCallback: sinon.stub().callsFake(async ({ source }) => ({
+                commonKeychain,
+                counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,
+            })),
+        };
+        const mockKeychains = {
+            add: sinon.stub().callsFake((params) => {
+                if (params.source === 'bitgo')
+                    return Promise.resolve(bitgoKeychain);
+                return Promise.resolve({ id: `${params.source}-key-id`, commonKeychain, source: params.source, type: 'tss' });
+            }),
+        };
+        const mockBitGo = {
+            getEnv: sinon.stub().returns('dev'),
+            fetchConstants: sinon.stub().resolves({
+                mpc: { bitgoPublicKey: gpgKeys_1.bitgoGpgKey.public },
+            }),
+        };
+        mockCoin = {
+            getChain: sinon.stub().returns('tsol'),
+            keychains: sinon.stub().returns(mockKeychains),
+        };
+        utils = new src_1.EddsaUtils(mockBitGo, mockCoin);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('should call initialize before finalize, and finalize user before backup (sequential)', async function () {
+        const callOrder = [];
+        callbacks.initializeCallback.callsFake(async () => {
+            callOrder.push('initialize');
+            return initResult;
+        });
+        callbacks.finalizeCallback.callsFake(async ({ source }) => {
+            callOrder.push(`finalize-${source}`);
+            return {
+                commonKeychain,
+                counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,
+            };
+        });
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        assert.deepStrictEqual(callOrder, ['initialize', 'finalize-user', 'finalize-backup']);
+    });
+    it('should return user, backup, and bitgo keychains', async function () {
+        const result = await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        assert.ok(result.userKeychain);
+        assert.ok(result.backupKeychain);
+        assert.ok(result.bitgoKeychain);
+        assert.strictEqual(result.bitgoKeychain.commonKeychain, commonKeychain);
+    });
+    it('should pass bitgoKeychain and counterparty context to finalizeCallback for both sources', async function () {
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        const userCall = callbacks.finalizeCallback.getCall(0).args[0];
+        const backupCall = callbacks.finalizeCallback.getCall(1).args[0];
+        assert.strictEqual(userCall.source, 'user');
+        assert.strictEqual(userCall.coin, 'tsol');
+        assert.deepStrictEqual(userCall.bitgoKeychain, bitgoKeychain);
+        assert.strictEqual(userCall.counterPartyGPGKey, 'backup-gpg-pub');
+        assert.deepStrictEqual(userCall.counterPartyKeyShare, backupToUserCounterPartyKeyShare);
+        assert.deepStrictEqual(userCall.state, userState);
+        assert.strictEqual(backupCall.source, 'backup');
+        assert.strictEqual(backupCall.coin, 'tsol');
+        assert.deepStrictEqual(backupCall.bitgoKeychain, bitgoKeychain);
+        assert.strictEqual(backupCall.counterPartyGPGKey, 'user-gpg-pub');
+        // backup receives the counterparty share produced by user finalize
+        assert.ok(backupCall.counterPartyKeyShare);
+        assert.deepStrictEqual(backupCall.state, backupState);
+    });
+    it('should reject when user finalize does not produce a counterparty key share', async function () {
+        callbacks.finalizeCallback.callsFake(async () => ({ commonKeychain }));
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /User finalize did not produce a counterparty key share/);
+    });
+    it('should reject when user finalizeCallback returns mismatched commonKeychain', async function () {
+        callbacks.finalizeCallback.callsFake(async ({ source }) => ({
+            commonKeychain: source === 'user' ? 'wrong-keychain' : commonKeychain,
+            counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,
+        }));
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /User common keychain does not match BitGo/);
+    });
+    it('should reject when backup finalizeCallback returns mismatched commonKeychain', async function () {
+        callbacks.finalizeCallback.callsFake(async ({ source }) => ({
+            commonKeychain: source === 'backup' ? 'wrong-keychain' : commonKeychain,
+            counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,
+        }));
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /Backup common keychain does not match BitGo/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eddsaExternalSigner.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/eddsa/eddsaExternalSigner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { EddsaUtils, EddsaKeyGenCallbacks } from '../../../../../../src';\nimport { bitgoGpgKey } from '../ecdsa/gpgKeys';\n\ndescribe('EddsaUtils.createKeychainsWithExternalSigner', function () {\n  let utils: EddsaUtils;\n  let callbacks: EddsaKeyGenCallbacks;\n  let mockCoin: any;\n  const enterprise = 'enterprise-id';\n  const commonKeychain = 'eddsa-common-keychain';\n\n  const keyShare = (pub: string, prv: string, proof: string) => ({\n    publicShare: pub,\n    privateShare: prv,\n    privateShareProof: proof,\n    vssProof: `${proof}-vss`,\n    gpgKey: `${pub}-gpg`,\n  });\n  const userToBitgoKeyShare = keyShare('upub', 'uprv-enc', 'uproof');\n  const backupToBitgoKeyShare = keyShare('bpub', 'bprv-enc', 'bproof');\n  const backupToUserCounterPartyKeyShare = keyShare('ucp-pub', 'ucp-prv', 'ucp-proof');\n  const userState = { encryptedData: 'u-data', encryptedDataKey: 'u-data-key' };\n  const backupState = { encryptedData: 'b-data', encryptedDataKey: 'b-data-key' };\n  const bitgoKeychain = { id: 'bitgo-key-id', commonKeychain, source: 'bitgo', type: 'tss' };\n\n  const initResult = {\n    userGpgPublicKey: 'user-gpg-pub',\n    backupGpgPublicKey: 'backup-gpg-pub',\n    userToBitgoKeyShare,\n    backupToBitgoKeyShare,\n    userState,\n    backupState,\n    backupToUserCounterPartyKeyShare,\n  };\n\n  beforeEach(function () {\n    callbacks = {\n      initializeCallback: sinon.stub().resolves(initResult),\n      finalizeCallback: sinon.stub().callsFake(async ({ source }: { source: 'user' | 'backup' }) => ({\n        commonKeychain,\n        counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,\n      })),\n    };\n\n    const mockKeychains = {\n      add: sinon.stub().callsFake((params: any) => {\n        if (params.source === 'bitgo') return Promise.resolve(bitgoKeychain);\n        return Promise.resolve({ id: `${params.source}-key-id`, commonKeychain, source: params.source, type: 'tss' });\n      }),\n    };\n\n    const mockBitGo = {\n      getEnv: sinon.stub().returns('dev'),\n      fetchConstants: sinon.stub().resolves({\n        mpc: { bitgoPublicKey: bitgoGpgKey.public },\n      }),\n    } as any;\n\n    mockCoin = {\n      getChain: sinon.stub().returns('tsol'),\n      keychains: sinon.stub().returns(mockKeychains),\n    } as any;\n\n    utils = new EddsaUtils(mockBitGo, mockCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('should call initialize before finalize, and finalize user before backup (sequential)', async function () {\n    const callOrder: string[] = [];\n    (callbacks.initializeCallback as sinon.SinonStub).callsFake(async () => {\n      callOrder.push('initialize');\n      return initResult;\n    });\n    (callbacks.finalizeCallback as sinon.SinonStub).callsFake(async ({ source }: { source: 'user' | 'backup' }) => {\n      callOrder.push(`finalize-${source}`);\n      return {\n        commonKeychain,\n        counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,\n      };\n    });\n\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    assert.deepStrictEqual(callOrder, ['initialize', 'finalize-user', 'finalize-backup']);\n  });\n\n  it('should return user, backup, and bitgo keychains', async function () {\n    const result = await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    assert.ok(result.userKeychain);\n    assert.ok(result.backupKeychain);\n    assert.ok(result.bitgoKeychain);\n    assert.strictEqual(result.bitgoKeychain.commonKeychain, commonKeychain);\n  });\n\n  it('should pass bitgoKeychain and counterparty context to finalizeCallback for both sources', async function () {\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    const userCall = (callbacks.finalizeCallback as sinon.SinonStub).getCall(0).args[0];\n    const backupCall = (callbacks.finalizeCallback as sinon.SinonStub).getCall(1).args[0];\n\n    assert.strictEqual(userCall.source, 'user');\n    assert.strictEqual(userCall.coin, 'tsol');\n    assert.deepStrictEqual(userCall.bitgoKeychain, bitgoKeychain);\n    assert.strictEqual(userCall.counterPartyGPGKey, 'backup-gpg-pub');\n    assert.deepStrictEqual(userCall.counterPartyKeyShare, backupToUserCounterPartyKeyShare);\n    assert.deepStrictEqual(userCall.state, userState);\n\n    assert.strictEqual(backupCall.source, 'backup');\n    assert.strictEqual(backupCall.coin, 'tsol');\n    assert.deepStrictEqual(backupCall.bitgoKeychain, bitgoKeychain);\n    assert.strictEqual(backupCall.counterPartyGPGKey, 'user-gpg-pub');\n    // backup receives the counterparty share produced by user finalize\n    assert.ok(backupCall.counterPartyKeyShare);\n    assert.deepStrictEqual(backupCall.state, backupState);\n  });\n\n  it('should reject when user finalize does not produce a counterparty key share', async function () {\n    (callbacks.finalizeCallback as sinon.SinonStub).callsFake(async () => ({ commonKeychain }));\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /User finalize did not produce a counterparty key share/\n    );\n  });\n\n  it('should reject when user finalizeCallback returns mismatched commonKeychain', async function () {\n    (callbacks.finalizeCallback as sinon.SinonStub).callsFake(async ({ source }: { source: 'user' | 'backup' }) => ({\n      commonKeychain: source === 'user' ? 'wrong-keychain' : commonKeychain,\n      counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,\n    }));\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /User common keychain does not match BitGo/\n    );\n  });\n\n  it('should reject when backup finalizeCallback returns mismatched commonKeychain', async function () {\n    (callbacks.finalizeCallback as sinon.SinonStub).callsFake(async ({ source }: { source: 'user' | 'backup' }) => ({\n      commonKeychain: source === 'backup' ? 'wrong-keychain' : commonKeychain,\n      counterpartyKeyShare: source === 'user' ? keyShare('bcp-pub', 'bcp-prv', 'bcp-proof') : undefined,\n    }));\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /Backup common keychain does not match BitGo/\n    );\n  });\n});\n"]}