@bitgo-beta/sdk-core 8.2.1-beta.192 → 8.2.1-beta.1921

package/dist/test/unit/bitgo/utils/tss/baseTSSUtils.js

@@ -0,0 +1,399 @@
+"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 });
+const assert = __importStar(require("assert"));
+const crypto_1 = require("crypto");
+const keccak_1 = __importDefault(require("keccak"));
+const openpgp = __importStar(require("openpgp"));
+const sinon = __importStar(require("sinon"));
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const src_1 = require("../../../../../src");
+const baseTSSUtils_1 = __importDefault(require("../../../../../src/bitgo/utils/tss/baseTSSUtils"));
+class TestBaseTssUtils extends baseTSSUtils_1.default {
+    getSignableHexAndDerivationPathForTest(txRequest, missingTransactionsMessage) {
+        return this.getSignableHexAndDerivationPath(txRequest, missingTransactionsMessage);
+    }
+    validateAdataForTest(adata, cyphertext, roundDomainSeparator) {
+        this.validateAdata(adata, cyphertext, roundDomainSeparator);
+    }
+    getBitgoAndUserGpgKeysForTest(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase, adata, userGpgKeyDomainSeparator) {
+        return this.getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase, adata, userGpgKeyDomainSeparator);
+    }
+}
+describe('Base TSS Utils', function () {
+    const walletPassphrase = 'test-password';
+    const signingUserGpgKeyDomainSeparator = 'MPS_DSG_SIGNING_USER_GPG_KEY';
+    const roundOneDomainSeparator = 'MPS_DSG_SIGNING_ROUND1_STATE';
+    let baseTssUtils;
+    let ecdsaMPCv2Utils;
+    let mockBitgo;
+    let decryptAsyncStub;
+    let bitgoGpgKeyPair;
+    let userGpgKeyPair;
+    let userShare;
+    before(async function () {
+        openpgp.config.rejectCurves = new Set();
+        bitgoGpgKeyPair = await openpgp.generateKey({
+            userIDs: [{ name: 'bitgo', email: 'bitgo@test.com' }],
+            curve: 'ed25519',
+            format: 'armored',
+        });
+        userGpgKeyPair = await openpgp.generateKey({
+            userIDs: [{ name: 'user', email: 'user@test.com' }],
+            curve: 'ed25519',
+            format: 'armored',
+        });
+        const [userDkgSession] = await sdk_lib_mpc_1.DklsUtils.generateDKGKeyShares();
+        userShare = userDkgSession.getKeyShare();
+    });
+    beforeEach(function () {
+        decryptAsyncStub = sinon.stub().callsFake(async ({ input, password }) => {
+            try {
+                const parsed = JSON.parse(input);
+                if (parsed.v === 2 && parsed.plaintext !== undefined) {
+                    return parsed.plaintext;
+                }
+            }
+            catch { }
+            return sjcl.decrypt(password ?? '', input);
+        });
+        const mockBg = {};
+        mockBg.getEnv = sinon.stub().returns('test');
+        mockBg.encrypt = sinon
+            .stub()
+            .callsFake((params) => encryptWithSjcl(params.password ?? '', params.input, params.adata));
+        mockBg.encrypt = sinon
+            .stub()
+            .callsFake(async (params) => encryptWithSjcl(params.password ?? '', params.input, params.adata));
+        mockBg.decrypt = sinon.stub().callsFake((params) => sjcl.decrypt(params.password ?? '', params.input));
+        mockBg.decrypt = decryptAsyncStub;
+        mockBitgo = mockBg;
+        const mockCoin = {};
+        mockCoin.getHashFunction = sinon.stub().callsFake(() => (0, keccak_1.default)('keccak256'));
+        baseTssUtils = new TestBaseTssUtils(mockBitgo, mockCoin);
+        ecdsaMPCv2Utils = new src_1.EcdsaMPCv2Utils(mockBitgo, mockCoin);
+    });
+    describe('getSignableHexAndDerivationPath', function () {
+        it('extracts signableHex and derivationPath from a valid txRequest', function () {
+            const txRequest = buildTxRequest({
+                transactions: [
+                    buildTransaction({
+                        unsignedTx: buildUnsignedTransaction({ signableHex: 'deadbeef', derivationPath: 'm/0/0' }),
+                    }),
+                ],
+            });
+            const result = baseTssUtils.getSignableHexAndDerivationPathForTest(txRequest);
+            assert.equal(result.signableHex, 'deadbeef');
+            assert.equal(result.derivationPath, 'm/0/0');
+        });
+        it('throws when transactions field is missing', function () {
+            assert.throws(() => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequestWithoutTransactions()), /createOfflineShare requires exactly one transaction in txRequest/);
+        });
+        it('throws when transactions array is empty', function () {
+            assert.throws(() => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequest({ transactions: [] })), /createOfflineShare requires exactly one transaction in txRequest/);
+        });
+        it('throws when transactions array has more than one element', function () {
+            assert.throws(() => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequest({
+                transactions: [
+                    buildTransaction({
+                        unsignedTx: buildUnsignedTransaction({ signableHex: 'aaa', derivationPath: 'm/0' }),
+                    }),
+                    buildTransaction({
+                        unsignedTx: buildUnsignedTransaction({ signableHex: 'bbb', derivationPath: 'm/1' }),
+                    }),
+                ],
+            })), /createOfflineShare requires exactly one transaction in txRequest/);
+        });
+        it('throws when unsignedTx is missing', function () {
+            // @ts-expect-error Intentionally malformed to exercise the runtime guard.
+            const noUnsignedTx = { state: 'pendingSignature', signatureShares: [] };
+            assert.throws(() => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequest({ transactions: [noUnsignedTx] })), /Missing unsignedTx in transactions/);
+        });
+        it('throws when signableHex is missing', function () {
+            // @ts-expect-error Intentionally malformed to exercise the runtime guard.
+            const noSignableHex = { serializedTxHex: 'aabbccdd', derivationPath: 'm/0' };
+            assert.throws(() => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequest({ transactions: [buildTransaction({ unsignedTx: noSignableHex })] })), /Missing signableHex in unsignedTx/);
+        });
+        it('throws when derivationPath is missing', function () {
+            // @ts-expect-error Intentionally malformed to exercise the runtime guard.
+            const noDerivationPath = { serializedTxHex: 'aabbccdd', signableHex: 'deadbeef' };
+            assert.throws(() => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequest({ transactions: [buildTransaction({ unsignedTx: noDerivationPath })] })), /Missing derivationPath in unsignedTx/);
+        });
+    });
+    describe('validateAdata', function () {
+        it('passes when adata matches with domain separator', async function () {
+            const adata = 'test-value';
+            const cyphertext = await mockBitgo.encrypt({
+                input: 'secret',
+                password: walletPassphrase,
+                adata: `${roundOneDomainSeparator}:${adata}`,
+            });
+            assert.doesNotThrow(() => baseTssUtils.validateAdataForTest(adata, cyphertext, roundOneDomainSeparator));
+        });
+        it('passes when adata matches without domain separator', async function () {
+            const adata = 'test-value';
+            const cyphertext = await mockBitgo.encrypt({ input: 'secret', password: walletPassphrase, adata });
+            assert.doesNotThrow(() => baseTssUtils.validateAdataForTest(adata, cyphertext, roundOneDomainSeparator));
+        });
+        it('throws when adata does not match', async function () {
+            const cyphertext = await mockBitgo.encrypt({
+                input: 'secret',
+                password: walletPassphrase,
+                adata: `${roundOneDomainSeparator}:correct`,
+            });
+            assert.throws(() => baseTssUtils.validateAdataForTest('wrong', cyphertext, roundOneDomainSeparator), /Adata does not match cyphertext adata/);
+        });
+        it('throws when cyphertext is not valid JSON', function () {
+            assert.throws(() => baseTssUtils.validateAdataForTest('adata', 'not-json', roundOneDomainSeparator), /Failed to parse cyphertext to JSON/);
+        });
+    });
+    describe('getBitgoAndUserGpgKeys', function () {
+        it('decrypts v1 SJCL envelope without adata and skips validation', async function () {
+            const encryptedUserGpgPrvKey = await mockBitgo.encrypt({
+                input: userGpgKeyPair.privateKey,
+                password: walletPassphrase,
+            });
+            const result = await baseTssUtils.getBitgoAndUserGpgKeysForTest(bitgoGpgKeyPair.publicKey, encryptedUserGpgPrvKey, walletPassphrase, '', signingUserGpgKeyDomainSeparator);
+            assert.ok(result.bitgoGpgKey);
+            assert.equal(result.userGpgPrvKey.isPrivate(), true);
+        });
+        it('decrypts v1 SJCL envelope with matching adata', async function () {
+            const adata = 'test-adata';
+            const encryptedUserGpgPrvKey = await mockBitgo.encrypt({
+                input: userGpgKeyPair.privateKey,
+                password: walletPassphrase,
+                adata: `${signingUserGpgKeyDomainSeparator}:${adata}`,
+            });
+            const result = await baseTssUtils.getBitgoAndUserGpgKeysForTest(bitgoGpgKeyPair.publicKey, encryptedUserGpgPrvKey, walletPassphrase, adata, signingUserGpgKeyDomainSeparator);
+            assert.ok(result.bitgoGpgKey);
+            assert.equal(result.userGpgPrvKey.isPrivate(), true);
+        });
+        it('decrypts via decrypt and returns GPG keys', async function () {
+            const adata = 'test-adata';
+            // Use a fake v2 envelope (v:2) so isV2Envelope returns true and decrypt is called.
+            // The stub extracts plaintext directly from this fake format.
+            const encryptedUserGpgPrvKey = JSON.stringify({
+                v: 2,
+                adata: `${signingUserGpgKeyDomainSeparator}:${adata}`,
+                plaintext: userGpgKeyPair.privateKey,
+            });
+            const result = await baseTssUtils.getBitgoAndUserGpgKeysForTest(bitgoGpgKeyPair.publicKey, encryptedUserGpgPrvKey, walletPassphrase, adata, signingUserGpgKeyDomainSeparator);
+            sinon.assert.calledOnce(decryptAsyncStub);
+            assert.ok(result.bitgoGpgKey);
+            assert.equal(result.userGpgPrvKey.isPrivate(), true);
+        });
+        it('throws when adata does not match', async function () {
+            const encryptedUserGpgPrvKey = await mockBitgo.encrypt({
+                input: userGpgKeyPair.privateKey,
+                password: walletPassphrase,
+                adata: `${signingUserGpgKeyDomainSeparator}:correct-adata`,
+            });
+            await assert.rejects(baseTssUtils.getBitgoAndUserGpgKeysForTest(bitgoGpgKeyPair.publicKey, encryptedUserGpgPrvKey, walletPassphrase, 'wrong-adata', signingUserGpgKeyDomainSeparator), /Adata does not match cyphertext adata/);
+        });
+        it('throws when cyphertext is not valid JSON', async function () {
+            await assert.rejects(baseTssUtils.getBitgoAndUserGpgKeysForTest(bitgoGpgKeyPair.publicKey, 'not-valid-json', walletPassphrase, 'test-adata', signingUserGpgKeyDomainSeparator), /json decode|Failed to parse cyphertext to JSON/);
+        });
+    });
+    describe('recreateTxRequest', function () {
+        function makeWallet(multisigTypeVersion) {
+            return {
+                id: sinon.stub().returns('wallet-id'),
+                multisigTypeVersion: sinon.stub().returns(multisigTypeVersion),
+            };
+        }
+        function makeCoin(mpcAlgorithm, chain = 'tsol') {
+            const coin = {};
+            coin.getHashFunction = sinon.stub();
+            coin.getMPCAlgorithm = sinon.stub().returns(mpcAlgorithm);
+            coin.getChain = sinon.stub().returns(chain);
+            return coin;
+        }
+        it('derives txParams from intent for EdDSA MPCv2 wallets', async function () {
+            const txRequestId = 'tx-req-id-1';
+            const reqId = new src_1.RequestTracer();
+            const txRequest = buildTxRequest({
+                txRequestId,
+                intent: {
+                    intentType: 'payment',
+                    recipients: [{ address: { address: 'solAddr1' }, amount: { value: '5000000', symbol: 'tsol' } }],
+                },
+            });
+            const utils = new TestBaseTssUtils(mockBitgo, makeCoin('eddsa'), makeWallet('MPCv2'));
+            sinon.stub(utils, 'deleteSignatureShares').resolves();
+            sinon.stub(utils, 'getTxRequest').resolves(txRequest);
+            const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);
+            await utils.recreateTxRequest(txRequestId, 'prv', reqId);
+            // Native SOL: symbol equals the chain name, so tokenName must be omitted
+            assert.deepStrictEqual(signTxRequestStub.firstCall.args[0].txParams, {
+                recipients: [{ address: 'solAddr1', amount: '5000000' }],
+            });
+        });
+        it('sets tokenName for SPL tokens (symbol differs from chain name)', async function () {
+            const txRequestId = 'tx-req-id-spl';
+            const reqId = new src_1.RequestTracer();
+            const txRequest = buildTxRequest({
+                txRequestId,
+                intent: {
+                    intentType: 'payment',
+                    recipients: [{ address: { address: 'splAddr1' }, amount: { value: '1000', symbol: 'tsol:usdc' } }],
+                },
+            });
+            const utils = new TestBaseTssUtils(mockBitgo, makeCoin('eddsa', 'tsol'), makeWallet('MPCv2'));
+            sinon.stub(utils, 'deleteSignatureShares').resolves();
+            sinon.stub(utils, 'getTxRequest').resolves(txRequest);
+            const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);
+            await utils.recreateTxRequest(txRequestId, 'prv', reqId);
+            // SPL token: symbol differs from chain name, so tokenName must be set
+            assert.deepStrictEqual(signTxRequestStub.firstCall.args[0].txParams, {
+                recipients: [{ address: 'splAddr1', amount: '1000', tokenName: 'tsol:usdc' }],
+            });
+        });
+        it('passes undefined txParams for EdDSA MPCv2 when intent has no recipients', async function () {
+            const txRequestId = 'tx-req-id-2';
+            const reqId = new src_1.RequestTracer();
+            const txRequest = buildTxRequest({ txRequestId, intent: { intentType: 'enableToken' } });
+            const utils = new TestBaseTssUtils(mockBitgo, makeCoin('eddsa'), makeWallet('MPCv2'));
+            sinon.stub(utils, 'deleteSignatureShares').resolves();
+            sinon.stub(utils, 'getTxRequest').resolves(txRequest);
+            const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);
+            await utils.recreateTxRequest(txRequestId, 'prv', reqId);
+            assert.strictEqual(signTxRequestStub.firstCall.args[0].txParams, undefined);
+        });
+        it('passes undefined txParams for ECDSA MPCv2 wallets (guard does not apply)', async function () {
+            const txRequestId = 'tx-req-id-3';
+            const reqId = new src_1.RequestTracer();
+            const txRequest = buildTxRequest({
+                txRequestId,
+                intent: {
+                    intentType: 'payment',
+                    recipients: [{ address: { address: 'ethAddr1' }, amount: { value: '1000000', symbol: 'eth' } }],
+                },
+            });
+            const utils = new TestBaseTssUtils(mockBitgo, makeCoin('ecdsa'), makeWallet('MPCv2'));
+            sinon.stub(utils, 'deleteSignatureShares').resolves();
+            sinon.stub(utils, 'getTxRequest').resolves(txRequest);
+            const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);
+            await utils.recreateTxRequest(txRequestId, 'prv', reqId);
+            assert.strictEqual(signTxRequestStub.firstCall.args[0].txParams, undefined);
+        });
+    });
+    describe('ECDSA MPC v2 delegated txRequest parsing', function () {
+        it('getHashStringAndDerivationPath produces the correct hashBuffer and derivationPath', async function () {
+            const signableHex = 'deadbeef';
+            const derivationPath = 'm/0';
+            const txRequest = buildTxRequest({
+                transactions: [buildTransaction({ unsignedTx: buildUnsignedTransaction({ signableHex, derivationPath }) })],
+            });
+            const expectedHashBuffer = (0, keccak_1.default)('keccak256').update(Buffer.from(signableHex, 'hex')).digest();
+            const { encryptedRound1Session } = await ecdsaMPCv2Utils.createOfflineRound1Share({
+                txRequest,
+                prv: userShare.toString('base64'),
+                walletPassphrase,
+            });
+            // The round-1 session is encrypted with adata = "DKLS23_SIGNING_ROUND1_STATE:<hash>:<derivationPath>",
+            // which proves getHashStringAndDerivationPath produced the right values after the delegation refactor.
+            const { adata } = JSON.parse(encryptedRound1Session);
+            assert.equal(adata === undefined ? adata : decodeURIComponent(adata), `DKLS23_SIGNING_ROUND1_STATE:${expectedHashBuffer.toString('hex')}:${derivationPath}`);
+        });
+        it('propagates the base unsignedTx guard through the ECDSA route', async function () {
+            // @ts-expect-error Intentionally malformed to exercise the runtime guard.
+            const noUnsignedTx = { state: 'pendingSignature', signatureShares: [] };
+            await assert.rejects(ecdsaMPCv2Utils.createOfflineRound1Share({
+                txRequest: buildTxRequest({ transactions: [noUnsignedTx] }),
+                prv: 'unused',
+                walletPassphrase,
+            }), /Missing unsignedTx in transactions/);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Fixture builders
+// ---------------------------------------------------------------------------
+function buildTxRequest(overrides = {}) {
+    return {
+        txRequestId: 'tx-request-id',
+        walletId: 'wallet-id',
+        walletType: 'hot',
+        version: 1,
+        state: 'initialized',
+        date: new Date(0).toISOString(),
+        userId: 'user-id',
+        intent: {},
+        policiesChecked: true,
+        unsignedTxs: [],
+        transactions: [buildTransaction()],
+        latest: true,
+        ...overrides,
+    };
+}
+function buildTxRequestWithoutTransactions() {
+    const txRequest = buildTxRequest();
+    delete txRequest.transactions;
+    return txRequest;
+}
+function buildTransaction(overrides = {}) {
+    return { state: 'pendingSignature', unsignedTx: buildUnsignedTransaction(), signatureShares: [], ...overrides };
+}
+function buildUnsignedTransaction(overrides = {}) {
+    return { serializedTxHex: 'aabbccdd', signableHex: 'deadbeef', derivationPath: 'm/0', ...overrides };
+}
+// ---------------------------------------------------------------------------
+// Encryption helpers (mirrors the ecdsaMPCv2 test pattern)
+// ---------------------------------------------------------------------------
+function encryptWithSjcl(password, input, adata) {
+    const salt = (0, crypto_1.randomBytes)(8);
+    const iv = (0, crypto_1.randomBytes)(16);
+    return sjcl.encrypt(password, input, {
+        salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],
+        iv: [
+            bytesToWord(iv.subarray(0, 4)),
+            bytesToWord(iv.subarray(4, 8)),
+            bytesToWord(iv.subarray(8, 12)),
+            bytesToWord(iv.subarray(12, 16)),
+        ],
+        ...(adata !== undefined ? { adata } : {}),
+    });
+}
+function bytesToWord(bytes) {
+    if (bytes.length !== 4) {
+        throw new Error('bytes must have length 4');
+    }
+    return bytes.reduce((num, byte) => num * 0x100 + byte, 0);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"baseTSSUtils.js","sourceRoot":"","sources":["../../../../../../test/unit/bitgo/utils/tss/baseTSSUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport { Hash, randomBytes } from 'crypto';\nimport createKeccakHash from 'keccak';\nimport * as openpgp from 'openpgp';\nimport * as sinon from 'sinon';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport { DklsUtils } from '@bitgo-beta/sdk-lib-mpc';\n\nimport { BitGoBase, EcdsaMPCv2Utils, IBaseCoin, IWallet, RequestTracer, TxRequest } from '../../../../../src';\nimport BaseTssUtils from '../../../../../src/bitgo/utils/tss/baseTSSUtils';\n\ntype BitgoGpgKeyPair = openpgp.SerializedKeyPair<string> & { revocationCertificate: string };\ntype TxRequestTransaction = NonNullable<TxRequest['transactions']>[number];\ntype UnsignedTransaction = TxRequestTransaction['unsignedTx'];\ntype SignableHexAndDerivationPath = {\n  signableHex: string;\n  derivationPath: string;\n  serializedTxHex: string | undefined;\n};\ntype DecryptedGpgKeys = { bitgoGpgKey: openpgp.Key; userGpgPrvKey: openpgp.PrivateKey };\n\nclass TestBaseTssUtils extends BaseTssUtils<Buffer> {\n  getSignableHexAndDerivationPathForTest(\n    txRequest: TxRequest,\n    missingTransactionsMessage?: string\n  ): SignableHexAndDerivationPath {\n    return this.getSignableHexAndDerivationPath(txRequest, missingTransactionsMessage);\n  }\n\n  validateAdataForTest(adata: string, cyphertext: string, roundDomainSeparator: string): void {\n    this.validateAdata(adata, cyphertext, roundDomainSeparator);\n  }\n\n  getBitgoAndUserGpgKeysForTest(\n    bitgoPublicGpgKey: string,\n    encryptedUserGpgPrvKey: string,\n    walletPassphrase: string,\n    adata: string,\n    userGpgKeyDomainSeparator: string\n  ): Promise<DecryptedGpgKeys> {\n    return this.getBitgoAndUserGpgKeys(\n      bitgoPublicGpgKey,\n      encryptedUserGpgPrvKey,\n      walletPassphrase,\n      adata,\n      userGpgKeyDomainSeparator\n    );\n  }\n}\n\ndescribe('Base TSS Utils', function () {\n  const walletPassphrase = 'test-password';\n  const signingUserGpgKeyDomainSeparator = 'MPS_DSG_SIGNING_USER_GPG_KEY';\n  const roundOneDomainSeparator = 'MPS_DSG_SIGNING_ROUND1_STATE';\n\n  let baseTssUtils: TestBaseTssUtils;\n  let ecdsaMPCv2Utils: EcdsaMPCv2Utils;\n  let mockBitgo: BitGoBase;\n  let decryptAsyncStub: sinon.SinonStub;\n  let bitgoGpgKeyPair: BitgoGpgKeyPair;\n  let userGpgKeyPair: BitgoGpgKeyPair;\n  let userShare: Buffer;\n\n  before(async function () {\n    openpgp.config.rejectCurves = new Set();\n    bitgoGpgKeyPair = await openpgp.generateKey({\n      userIDs: [{ name: 'bitgo', email: 'bitgo@test.com' }],\n      curve: 'ed25519',\n      format: 'armored',\n    });\n    userGpgKeyPair = await openpgp.generateKey({\n      userIDs: [{ name: 'user', email: 'user@test.com' }],\n      curve: 'ed25519',\n      format: 'armored',\n    });\n\n    const [userDkgSession] = await DklsUtils.generateDKGKeyShares();\n    userShare = userDkgSession.getKeyShare();\n  });\n\n  beforeEach(function () {\n    decryptAsyncStub = sinon.stub().callsFake(async ({ input, password }: Parameters<BitGoBase['decrypt']>[0]) => {\n      try {\n        const parsed = JSON.parse(input);\n        if (parsed.v === 2 && parsed.plaintext !== undefined) {\n          return parsed.plaintext;\n        }\n      } catch {}\n      return sjcl.decrypt(password ?? '', input);\n    });\n\n    const mockBg = {} as BitGoBase;\n    mockBg.getEnv = sinon.stub().returns('test');\n    mockBg.encrypt = sinon\n      .stub()\n      .callsFake((params) => encryptWithSjcl(params.password ?? '', params.input, params.adata));\n    mockBg.encrypt = sinon\n      .stub()\n      .callsFake(async (params) => encryptWithSjcl(params.password ?? '', params.input, params.adata));\n    mockBg.decrypt = sinon.stub().callsFake((params) => sjcl.decrypt(params.password ?? '', params.input));\n    mockBg.decrypt = decryptAsyncStub;\n    mockBitgo = mockBg;\n\n    const mockCoin = {} as IBaseCoin;\n    mockCoin.getHashFunction = sinon.stub().callsFake(() => createKeccakHash('keccak256') as Hash);\n\n    baseTssUtils = new TestBaseTssUtils(mockBitgo, mockCoin);\n    ecdsaMPCv2Utils = new EcdsaMPCv2Utils(mockBitgo, mockCoin);\n  });\n\n  describe('getSignableHexAndDerivationPath', function () {\n    it('extracts signableHex and derivationPath from a valid txRequest', function () {\n      const txRequest = buildTxRequest({\n        transactions: [\n          buildTransaction({\n            unsignedTx: buildUnsignedTransaction({ signableHex: 'deadbeef', derivationPath: 'm/0/0' }),\n          }),\n        ],\n      });\n\n      const result = baseTssUtils.getSignableHexAndDerivationPathForTest(txRequest);\n      assert.equal(result.signableHex, 'deadbeef');\n      assert.equal(result.derivationPath, 'm/0/0');\n    });\n\n    it('throws when transactions field is missing', function () {\n      assert.throws(\n        () => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequestWithoutTransactions()),\n        /createOfflineShare requires exactly one transaction in txRequest/\n      );\n    });\n\n    it('throws when transactions array is empty', function () {\n      assert.throws(\n        () => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequest({ transactions: [] })),\n        /createOfflineShare requires exactly one transaction in txRequest/\n      );\n    });\n\n    it('throws when transactions array has more than one element', function () {\n      assert.throws(\n        () =>\n          baseTssUtils.getSignableHexAndDerivationPathForTest(\n            buildTxRequest({\n              transactions: [\n                buildTransaction({\n                  unsignedTx: buildUnsignedTransaction({ signableHex: 'aaa', derivationPath: 'm/0' }),\n                }),\n                buildTransaction({\n                  unsignedTx: buildUnsignedTransaction({ signableHex: 'bbb', derivationPath: 'm/1' }),\n                }),\n              ],\n            })\n          ),\n        /createOfflineShare requires exactly one transaction in txRequest/\n      );\n    });\n\n    it('throws when unsignedTx is missing', function () {\n      // @ts-expect-error Intentionally malformed to exercise the runtime guard.\n      const noUnsignedTx: TxRequestTransaction = { state: 'pendingSignature', signatureShares: [] };\n      assert.throws(\n        () => baseTssUtils.getSignableHexAndDerivationPathForTest(buildTxRequest({ transactions: [noUnsignedTx] })),\n        /Missing unsignedTx in transactions/\n      );\n    });\n\n    it('throws when signableHex is missing', function () {\n      // @ts-expect-error Intentionally malformed to exercise the runtime guard.\n      const noSignableHex: UnsignedTransaction = { serializedTxHex: 'aabbccdd', derivationPath: 'm/0' };\n      assert.throws(\n        () =>\n          baseTssUtils.getSignableHexAndDerivationPathForTest(\n            buildTxRequest({ transactions: [buildTransaction({ unsignedTx: noSignableHex })] })\n          ),\n        /Missing signableHex in unsignedTx/\n      );\n    });\n\n    it('throws when derivationPath is missing', function () {\n      // @ts-expect-error Intentionally malformed to exercise the runtime guard.\n      const noDerivationPath: UnsignedTransaction = { serializedTxHex: 'aabbccdd', signableHex: 'deadbeef' };\n      assert.throws(\n        () =>\n          baseTssUtils.getSignableHexAndDerivationPathForTest(\n            buildTxRequest({ transactions: [buildTransaction({ unsignedTx: noDerivationPath })] })\n          ),\n        /Missing derivationPath in unsignedTx/\n      );\n    });\n  });\n\n  describe('validateAdata', function () {\n    it('passes when adata matches with domain separator', async function () {\n      const adata = 'test-value';\n      const cyphertext = await mockBitgo.encrypt({\n        input: 'secret',\n        password: walletPassphrase,\n        adata: `${roundOneDomainSeparator}:${adata}`,\n      });\n      assert.doesNotThrow(() => baseTssUtils.validateAdataForTest(adata, cyphertext, roundOneDomainSeparator));\n    });\n\n    it('passes when adata matches without domain separator', async function () {\n      const adata = 'test-value';\n      const cyphertext = await mockBitgo.encrypt({ input: 'secret', password: walletPassphrase, adata });\n      assert.doesNotThrow(() => baseTssUtils.validateAdataForTest(adata, cyphertext, roundOneDomainSeparator));\n    });\n\n    it('throws when adata does not match', async function () {\n      const cyphertext = await mockBitgo.encrypt({\n        input: 'secret',\n        password: walletPassphrase,\n        adata: `${roundOneDomainSeparator}:correct`,\n      });\n      assert.throws(\n        () => baseTssUtils.validateAdataForTest('wrong', cyphertext, roundOneDomainSeparator),\n        /Adata does not match cyphertext adata/\n      );\n    });\n\n    it('throws when cyphertext is not valid JSON', function () {\n      assert.throws(\n        () => baseTssUtils.validateAdataForTest('adata', 'not-json', roundOneDomainSeparator),\n        /Failed to parse cyphertext to JSON/\n      );\n    });\n  });\n\n  describe('getBitgoAndUserGpgKeys', function () {\n    it('decrypts v1 SJCL envelope without adata and skips validation', async function () {\n      const encryptedUserGpgPrvKey = await mockBitgo.encrypt({\n        input: userGpgKeyPair.privateKey,\n        password: walletPassphrase,\n      });\n\n      const result = await baseTssUtils.getBitgoAndUserGpgKeysForTest(\n        bitgoGpgKeyPair.publicKey,\n        encryptedUserGpgPrvKey,\n        walletPassphrase,\n        '',\n        signingUserGpgKeyDomainSeparator\n      );\n\n      assert.ok(result.bitgoGpgKey);\n      assert.equal(result.userGpgPrvKey.isPrivate(), true);\n    });\n\n    it('decrypts v1 SJCL envelope with matching adata', async function () {\n      const adata = 'test-adata';\n      const encryptedUserGpgPrvKey = await mockBitgo.encrypt({\n        input: userGpgKeyPair.privateKey,\n        password: walletPassphrase,\n        adata: `${signingUserGpgKeyDomainSeparator}:${adata}`,\n      });\n\n      const result = await baseTssUtils.getBitgoAndUserGpgKeysForTest(\n        bitgoGpgKeyPair.publicKey,\n        encryptedUserGpgPrvKey,\n        walletPassphrase,\n        adata,\n        signingUserGpgKeyDomainSeparator\n      );\n\n      assert.ok(result.bitgoGpgKey);\n      assert.equal(result.userGpgPrvKey.isPrivate(), true);\n    });\n\n    it('decrypts via decrypt and returns GPG keys', async function () {\n      const adata = 'test-adata';\n      // Use a fake v2 envelope (v:2) so isV2Envelope returns true and decrypt is called.\n      // The stub extracts plaintext directly from this fake format.\n      const encryptedUserGpgPrvKey = JSON.stringify({\n        v: 2,\n        adata: `${signingUserGpgKeyDomainSeparator}:${adata}`,\n        plaintext: userGpgKeyPair.privateKey,\n      });\n\n      const result = await baseTssUtils.getBitgoAndUserGpgKeysForTest(\n        bitgoGpgKeyPair.publicKey,\n        encryptedUserGpgPrvKey,\n        walletPassphrase,\n        adata,\n        signingUserGpgKeyDomainSeparator\n      );\n\n      sinon.assert.calledOnce(decryptAsyncStub);\n      assert.ok(result.bitgoGpgKey);\n      assert.equal(result.userGpgPrvKey.isPrivate(), true);\n    });\n\n    it('throws when adata does not match', async function () {\n      const encryptedUserGpgPrvKey = await mockBitgo.encrypt({\n        input: userGpgKeyPair.privateKey,\n        password: walletPassphrase,\n        adata: `${signingUserGpgKeyDomainSeparator}:correct-adata`,\n      });\n\n      await assert.rejects(\n        baseTssUtils.getBitgoAndUserGpgKeysForTest(\n          bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey,\n          walletPassphrase,\n          'wrong-adata',\n          signingUserGpgKeyDomainSeparator\n        ),\n        /Adata does not match cyphertext adata/\n      );\n    });\n\n    it('throws when cyphertext is not valid JSON', async function () {\n      await assert.rejects(\n        baseTssUtils.getBitgoAndUserGpgKeysForTest(\n          bitgoGpgKeyPair.publicKey,\n          'not-valid-json',\n          walletPassphrase,\n          'test-adata',\n          signingUserGpgKeyDomainSeparator\n        ),\n        /json decode|Failed to parse cyphertext to JSON/\n      );\n    });\n  });\n\n  describe('recreateTxRequest', function () {\n    function makeWallet(multisigTypeVersion: 'MPCv2' | undefined): IWallet {\n      return {\n        id: sinon.stub().returns('wallet-id'),\n        multisigTypeVersion: sinon.stub().returns(multisigTypeVersion),\n      } as unknown as IWallet;\n    }\n\n    function makeCoin(mpcAlgorithm: 'eddsa' | 'ecdsa', chain = 'tsol'): IBaseCoin {\n      const coin = {} as IBaseCoin;\n      coin.getHashFunction = sinon.stub();\n      coin.getMPCAlgorithm = sinon.stub().returns(mpcAlgorithm);\n      coin.getChain = sinon.stub().returns(chain);\n      return coin;\n    }\n\n    it('derives txParams from intent for EdDSA MPCv2 wallets', async function () {\n      const txRequestId = 'tx-req-id-1';\n      const reqId = new RequestTracer();\n      const txRequest = buildTxRequest({\n        txRequestId,\n        intent: {\n          intentType: 'payment',\n          recipients: [{ address: { address: 'solAddr1' }, amount: { value: '5000000', symbol: 'tsol' } }],\n        },\n      });\n\n      const utils = new TestBaseTssUtils(mockBitgo, makeCoin('eddsa'), makeWallet('MPCv2'));\n      sinon.stub(utils, 'deleteSignatureShares').resolves();\n      sinon.stub(utils, 'getTxRequest').resolves(txRequest);\n      const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);\n\n      await utils.recreateTxRequest(txRequestId, 'prv', reqId);\n\n      // Native SOL: symbol equals the chain name, so tokenName must be omitted\n      assert.deepStrictEqual(signTxRequestStub.firstCall.args[0].txParams, {\n        recipients: [{ address: 'solAddr1', amount: '5000000' }],\n      });\n    });\n\n    it('sets tokenName for SPL tokens (symbol differs from chain name)', async function () {\n      const txRequestId = 'tx-req-id-spl';\n      const reqId = new RequestTracer();\n      const txRequest = buildTxRequest({\n        txRequestId,\n        intent: {\n          intentType: 'payment',\n          recipients: [{ address: { address: 'splAddr1' }, amount: { value: '1000', symbol: 'tsol:usdc' } }],\n        },\n      });\n\n      const utils = new TestBaseTssUtils(mockBitgo, makeCoin('eddsa', 'tsol'), makeWallet('MPCv2'));\n      sinon.stub(utils, 'deleteSignatureShares').resolves();\n      sinon.stub(utils, 'getTxRequest').resolves(txRequest);\n      const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);\n\n      await utils.recreateTxRequest(txRequestId, 'prv', reqId);\n\n      // SPL token: symbol differs from chain name, so tokenName must be set\n      assert.deepStrictEqual(signTxRequestStub.firstCall.args[0].txParams, {\n        recipients: [{ address: 'splAddr1', amount: '1000', tokenName: 'tsol:usdc' }],\n      });\n    });\n\n    it('passes undefined txParams for EdDSA MPCv2 when intent has no recipients', async function () {\n      const txRequestId = 'tx-req-id-2';\n      const reqId = new RequestTracer();\n      const txRequest = buildTxRequest({ txRequestId, intent: { intentType: 'enableToken' } });\n\n      const utils = new TestBaseTssUtils(mockBitgo, makeCoin('eddsa'), makeWallet('MPCv2'));\n      sinon.stub(utils, 'deleteSignatureShares').resolves();\n      sinon.stub(utils, 'getTxRequest').resolves(txRequest);\n      const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);\n\n      await utils.recreateTxRequest(txRequestId, 'prv', reqId);\n\n      assert.strictEqual(signTxRequestStub.firstCall.args[0].txParams, undefined);\n    });\n\n    it('passes undefined txParams for ECDSA MPCv2 wallets (guard does not apply)', async function () {\n      const txRequestId = 'tx-req-id-3';\n      const reqId = new RequestTracer();\n      const txRequest = buildTxRequest({\n        txRequestId,\n        intent: {\n          intentType: 'payment',\n          recipients: [{ address: { address: 'ethAddr1' }, amount: { value: '1000000', symbol: 'eth' } }],\n        },\n      });\n\n      const utils = new TestBaseTssUtils(mockBitgo, makeCoin('ecdsa'), makeWallet('MPCv2'));\n      sinon.stub(utils, 'deleteSignatureShares').resolves();\n      sinon.stub(utils, 'getTxRequest').resolves(txRequest);\n      const signTxRequestStub = sinon.stub(utils, 'signTxRequest').resolves(txRequest);\n\n      await utils.recreateTxRequest(txRequestId, 'prv', reqId);\n\n      assert.strictEqual(signTxRequestStub.firstCall.args[0].txParams, undefined);\n    });\n  });\n\n  describe('ECDSA MPC v2 delegated txRequest parsing', function () {\n    it('getHashStringAndDerivationPath produces the correct hashBuffer and derivationPath', async function () {\n      const signableHex = 'deadbeef';\n      const derivationPath = 'm/0';\n      const txRequest = buildTxRequest({\n        transactions: [buildTransaction({ unsignedTx: buildUnsignedTransaction({ signableHex, derivationPath }) })],\n      });\n      const expectedHashBuffer = createKeccakHash('keccak256').update(Buffer.from(signableHex, 'hex')).digest();\n\n      const { encryptedRound1Session } = await ecdsaMPCv2Utils.createOfflineRound1Share({\n        txRequest,\n        prv: userShare.toString('base64'),\n        walletPassphrase,\n      });\n\n      // The round-1 session is encrypted with adata = \"DKLS23_SIGNING_ROUND1_STATE:<hash>:<derivationPath>\",\n      // which proves getHashStringAndDerivationPath produced the right values after the delegation refactor.\n      const { adata } = JSON.parse(encryptedRound1Session) as { adata?: string };\n      assert.equal(\n        adata === undefined ? adata : decodeURIComponent(adata),\n        `DKLS23_SIGNING_ROUND1_STATE:${expectedHashBuffer.toString('hex')}:${derivationPath}`\n      );\n    });\n\n    it('propagates the base unsignedTx guard through the ECDSA route', async function () {\n      // @ts-expect-error Intentionally malformed to exercise the runtime guard.\n      const noUnsignedTx: TxRequestTransaction = { state: 'pendingSignature', signatureShares: [] };\n      await assert.rejects(\n        ecdsaMPCv2Utils.createOfflineRound1Share({\n          txRequest: buildTxRequest({ transactions: [noUnsignedTx] }),\n          prv: 'unused',\n          walletPassphrase,\n        }),\n        /Missing unsignedTx in transactions/\n      );\n    });\n  });\n});\n\n// ---------------------------------------------------------------------------\n// Fixture builders\n// ---------------------------------------------------------------------------\n\nfunction buildTxRequest(overrides: Partial<TxRequest> = {}): TxRequest {\n  return {\n    txRequestId: 'tx-request-id',\n    walletId: 'wallet-id',\n    walletType: 'hot',\n    version: 1,\n    state: 'initialized',\n    date: new Date(0).toISOString(),\n    userId: 'user-id',\n    intent: {},\n    policiesChecked: true,\n    unsignedTxs: [],\n    transactions: [buildTransaction()],\n    latest: true,\n    ...overrides,\n  };\n}\n\nfunction buildTxRequestWithoutTransactions(): TxRequest {\n  const txRequest = buildTxRequest();\n  delete txRequest.transactions;\n  return txRequest;\n}\n\nfunction buildTransaction(overrides: Partial<TxRequestTransaction> = {}): TxRequestTransaction {\n  return { state: 'pendingSignature', unsignedTx: buildUnsignedTransaction(), signatureShares: [], ...overrides };\n}\n\nfunction buildUnsignedTransaction(overrides: Partial<UnsignedTransaction> = {}): UnsignedTransaction {\n  return { serializedTxHex: 'aabbccdd', signableHex: 'deadbeef', derivationPath: 'm/0', ...overrides };\n}\n\n// ---------------------------------------------------------------------------\n// Encryption helpers (mirrors the ecdsaMPCv2 test pattern)\n// ---------------------------------------------------------------------------\n\nfunction encryptWithSjcl(password: string, input: string, adata?: string): string {\n  const salt = randomBytes(8);\n  const iv = randomBytes(16);\n  return sjcl.encrypt(password, input, {\n    salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],\n    iv: [\n      bytesToWord(iv.subarray(0, 4)),\n      bytesToWord(iv.subarray(4, 8)),\n      bytesToWord(iv.subarray(8, 12)),\n      bytesToWord(iv.subarray(12, 16)),\n    ],\n    ...(adata !== undefined ? { adata } : {}),\n  });\n}\n\nfunction bytesToWord(bytes: Uint8Array): number {\n  if (bytes.length !== 4) {\n    throw new Error('bytes must have length 4');\n  }\n  return bytes.reduce((num, byte) => num * 0x100 + byte, 0);\n}\n"]}

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.d.ts

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

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.d.ts.map

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

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.js

@@ -0,0 +1,94 @@
+"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 ecdsa_1 = require("../../../../../../src/bitgo/utils/tss/ecdsa/ecdsa");
+/**
+ * Regression tests for the ECDSA MPCv1 createKeychains encryptionVersion bug.
+ *
+ * Previously, EcdsaUtils.createKeychains dropped `encryptionVersion` silently —
+ * it was not declared in the params and was never forwarded to createUserKeychain
+ * or createBackupKeychain, causing a version mismatch within a wallet: v2 for
+ * encryptedWalletPassphrase but v1 for the user/backup keychains.
+ */
+describe('EcdsaUtils.createKeychains - encryptionVersion forwarding', function () {
+    let ecdsaUtils;
+    let createUserKeychainStub;
+    let createBackupKeychainStub;
+    const fakeKeychain = { id: 'key-id', pub: 'pub', commonKeychain: 'ckc', type: 'tss' };
+    const fakeGpgKey = { publicKey: 'pub', privateKey: 'prv' };
+    const fakeKeyShare = { userHeldKeyShare: {} };
+    beforeEach(function () {
+        const mockBitgo = { getEnv: sinon.stub().returns('test') };
+        const mockCoin = {};
+        ecdsaUtils = new ecdsa_1.EcdsaUtils(mockBitgo, mockCoin);
+        createUserKeychainStub = sinon.stub(ecdsaUtils, 'createUserKeychain').resolves(fakeKeychain);
+        createBackupKeychainStub = sinon.stub(ecdsaUtils, 'createBackupKeychain').resolves(fakeKeychain);
+        sinon.stub(ecdsaUtils, 'createBitgoKeychain').resolves(fakeKeychain);
+        sinon.stub(ecdsaUtils, 'createBackupKeyShares').resolves(fakeKeyShare);
+        sinon.stub(ecdsaUtils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({ mpcv2PublicKey: undefined });
+        sinon.stub(ecdsaUtils, 'getBackupGpgPubKey').resolves(fakeGpgKey);
+        sinon.stub(require('../../../../../../src/bitgo/utils/opengpgUtils'), 'generateGPGKeyPair').resolves(fakeGpgKey);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('forwards encryptionVersion: 2 to createUserKeychain', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });
+        assert.ok(createUserKeychainStub.calledOnce);
+        const userParams = createUserKeychainStub.firstCall.args[0];
+        assert.strictEqual(userParams.encryptionVersion, 2);
+    });
+    it('forwards encryptionVersion: 2 to createBackupKeychain', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });
+        assert.ok(createBackupKeychainStub.calledOnce);
+        const backupParams = createBackupKeychainStub.firstCall.args[0];
+        assert.strictEqual(backupParams.encryptionVersion, 2);
+    });
+    it('forwards encryptionVersion: undefined when not set', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass' });
+        assert.ok(createUserKeychainStub.calledOnce);
+        assert.ok(createBackupKeychainStub.calledOnce);
+        assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, undefined);
+        assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, undefined);
+    });
+    it('forwards encryptionVersion: 1 explicitly', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 1 });
+        assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, 1);
+        assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, 1);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecdsaEncryptionVersion.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { EcdsaUtils } from '../../../../../../src/bitgo/utils/tss/ecdsa/ecdsa';\nimport { BitGoBase, IBaseCoin } from '../../../../../../src';\n\n/**\n * Regression tests for the ECDSA MPCv1 createKeychains encryptionVersion bug.\n *\n * Previously, EcdsaUtils.createKeychains dropped `encryptionVersion` silently —\n * it was not declared in the params and was never forwarded to createUserKeychain\n * or createBackupKeychain, causing a version mismatch within a wallet: v2 for\n * encryptedWalletPassphrase but v1 for the user/backup keychains.\n */\ndescribe('EcdsaUtils.createKeychains - encryptionVersion forwarding', function () {\n  let ecdsaUtils: EcdsaUtils;\n  let createUserKeychainStub: sinon.SinonStub;\n  let createBackupKeychainStub: sinon.SinonStub;\n\n  const fakeKeychain = { id: 'key-id', pub: 'pub', commonKeychain: 'ckc', type: 'tss' as const };\n  const fakeGpgKey = { publicKey: 'pub', privateKey: 'prv' };\n  const fakeKeyShare = { userHeldKeyShare: {} };\n\n  beforeEach(function () {\n    const mockBitgo = { getEnv: sinon.stub().returns('test') } as unknown as BitGoBase;\n    const mockCoin = {} as unknown as IBaseCoin;\n\n    ecdsaUtils = new EcdsaUtils(mockBitgo, mockCoin);\n\n    createUserKeychainStub = sinon.stub(ecdsaUtils, 'createUserKeychain').resolves(fakeKeychain);\n    createBackupKeychainStub = sinon.stub(ecdsaUtils, 'createBackupKeychain').resolves(fakeKeychain);\n    sinon.stub(ecdsaUtils, 'createBitgoKeychain').resolves(fakeKeychain);\n    sinon.stub(ecdsaUtils, 'createBackupKeyShares').resolves(fakeKeyShare as any);\n    sinon.stub(ecdsaUtils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({ mpcv2PublicKey: undefined } as any);\n\n    sinon.stub(ecdsaUtils as any, 'getBackupGpgPubKey').resolves(fakeGpgKey);\n    sinon.stub(require('../../../../../../src/bitgo/utils/opengpgUtils'), 'generateGPGKeyPair').resolves(fakeGpgKey);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('forwards encryptionVersion: 2 to createUserKeychain', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });\n\n    assert.ok(createUserKeychainStub.calledOnce);\n    const userParams = createUserKeychainStub.firstCall.args[0];\n    assert.strictEqual(userParams.encryptionVersion, 2);\n  });\n\n  it('forwards encryptionVersion: 2 to createBackupKeychain', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });\n\n    assert.ok(createBackupKeychainStub.calledOnce);\n    const backupParams = createBackupKeychainStub.firstCall.args[0];\n    assert.strictEqual(backupParams.encryptionVersion, 2);\n  });\n\n  it('forwards encryptionVersion: undefined when not set', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass' });\n\n    assert.ok(createUserKeychainStub.calledOnce);\n    assert.ok(createBackupKeychainStub.calledOnce);\n    assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, undefined);\n    assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, undefined);\n  });\n\n  it('forwards encryptionVersion: 1 explicitly', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 1 });\n\n    assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, 1);\n    assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, 1);\n  });\n});\n"]}

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaMPCv2.d.ts

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

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaMPCv2.d.ts.map

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