@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

package/dist/test/unit/bitgo/wallet/walletsEncryptionVersion.js

@@ -0,0 +1,304 @@
+"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"));
+require("should");
+const wallets_1 = require("../../../../src/bitgo/wallet/wallets");
+const wallet_1 = require("../../../../src/bitgo/wallet/wallet");
+const bitcoin_1 = require("../../../../src/bitgo/bitcoin");
+const api_1 = require("../../../../src/api");
+describe('Wallets - encryptionVersion threading', function () {
+    let wallets;
+    let mockBitGo;
+    let mockBaseCoin;
+    let mockKeychains;
+    const userPrv = 'xprvSomeUserPrivateKey';
+    const userPub = 'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';
+    beforeEach(function () {
+        mockKeychains = {
+            create: sinon.stub().returns({ pub: userPub, prv: userPrv }),
+            add: sinon.stub().resolves({ id: 'user-key-id', pub: userPub, encryptedPrv: 'encrypted-prv' }),
+        };
+        mockBitGo = {
+            encrypt: sinon
+                .stub()
+                .callsFake(async ({ password, input }) => `enc:${password}:${input}`),
+            decrypt: sinon.stub().resolves('decryptedPrv'),
+            createEncryptionSession: sinon.stub().callsFake(async (password, encryptionVersion) => ({
+                encrypt: sinon
+                    .stub()
+                    .callsFake(async (input) => `session-enc:${password}:${encryptionVersion}:${input}`),
+                decrypt: sinon.stub().resolves('session-decrypted'),
+                destroy: sinon.stub(),
+            })),
+            get: sinon.stub().returns({ result: sinon.stub(), query: sinon.stub().returnsThis() }),
+            post: sinon.stub().returns({ send: sinon.stub().returns({ result: sinon.stub().resolves({}) }) }),
+            put: sinon.stub().returns({
+                send: sinon
+                    .stub()
+                    .returns({ result: sinon.stub().resolves({ acceptedWalletShares: [], walletShareUpdateErrors: [] }) }),
+            }),
+            getECDHKeychain: sinon.stub().resolves({ encryptedXprv: 'encXprv' }),
+            setRequestTracer: sinon.stub(),
+            url: sinon.stub().returns('/test/url'),
+        };
+        mockBaseCoin = {
+            keychains: sinon.stub().returns(mockKeychains),
+            url: sinon.stub().callsFake((path) => path),
+            getFamily: sinon.stub().returns('btc'),
+            getChain: sinon.stub().returns('btc'),
+            supportsTss: sinon.stub().returns(false),
+            getMPCAlgorithm: sinon.stub().returns('ecdsa'),
+        };
+        wallets = new wallets_1.Wallets(mockBitGo, mockBaseCoin);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('acceptShare', function () {
+        it('passes encryptionVersion: 2 to encrypt on the multiUserKeyRotationRequired path', async function () {
+            mockBitGo.get.returns({
+                result: sinon.stub().resolves({
+                    userMultiKeyRotationRequired: true,
+                    keychain: null,
+                    permissions: ['spend'],
+                    wallet: 'wallet-id',
+                }),
+            });
+            await wallets.acceptShare({
+                walletShareId: 'share-id',
+                userPassword: 'my-password',
+                encryptionVersion: 2,
+            });
+            assert.ok(mockBitGo.encrypt.called, 'encrypt should have been called');
+            const call = mockBitGo.encrypt.firstCall;
+            assert.strictEqual(call.args[0].encryptionVersion, 2);
+        });
+        it('passes encryptionVersion: undefined when not set', async function () {
+            mockBitGo.get.returns({
+                result: sinon.stub().resolves({
+                    userMultiKeyRotationRequired: true,
+                    keychain: null,
+                    permissions: ['spend'],
+                    wallet: 'wallet-id',
+                }),
+            });
+            await wallets.acceptShare({
+                walletShareId: 'share-id',
+                userPassword: 'my-password',
+            });
+            assert.ok(mockBitGo.encrypt.called);
+            const call = mockBitGo.encrypt.firstCall;
+            assert.strictEqual(call.args[0].encryptionVersion, undefined);
+        });
+    });
+    describe('bulkAcceptShare', function () {
+        const walletSharesList = {
+            incoming: [
+                {
+                    id: 'share-id',
+                    userMultiKeyRotationRequired: true,
+                    keychain: null,
+                    permissions: ['spend'],
+                },
+            ],
+            outgoing: [],
+        };
+        beforeEach(function () {
+            mockBitGo.get.returns({ result: sinon.stub().resolves(walletSharesList) });
+        });
+        it('passes encryptionVersion: 2 to the encryption session', async function () {
+            await wallets.bulkAcceptShare({
+                walletShareIds: ['share-id'],
+                userLoginPassword: 'login-password',
+                encryptionVersion: 2,
+            });
+            assert.ok(mockBitGo.createEncryptionSession.called);
+            const call = mockBitGo.createEncryptionSession.firstCall;
+            assert.strictEqual(call.args[1], 2);
+        });
+        it('passes encryptionVersion: undefined to the encryption session when not set', async function () {
+            await wallets.bulkAcceptShare({
+                walletShareIds: ['share-id'],
+                userLoginPassword: 'login-password',
+            });
+            assert.ok(mockBitGo.createEncryptionSession.called);
+            const call = mockBitGo.createEncryptionSession.firstCall;
+            assert.strictEqual(call.args[1], undefined);
+        });
+        it('processes shares in batches of 16 to avoid WASM memory exhaustion', async function () {
+            // 20 shares → 2 batches (16 + 4), verifying the batch boundary is crossed
+            const manyShares = Array.from({ length: 20 }, (_, i) => ({
+                id: `share-${i}`,
+                userMultiKeyRotationRequired: true,
+                keychain: null,
+                permissions: ['spend'],
+            }));
+            mockBitGo.get.returns({
+                result: sinon.stub().resolves({ incoming: manyShares, outgoing: [] }),
+            });
+            // Capture the session so we can inspect its encrypt call count
+            const sessionEncryptStub = sinon.stub().callsFake(async (input) => `session-enc:${input}`);
+            mockBitGo.createEncryptionSession = sinon.stub().resolves({
+                encrypt: sessionEncryptStub,
+                decrypt: sinon.stub(),
+                destroy: sinon.stub(),
+            });
+            await wallets.bulkAcceptShare({
+                walletShareIds: manyShares.map((s) => s.id),
+                userLoginPassword: 'login-password',
+            });
+            // Session created once, session.encrypt called once per share
+            assert.strictEqual(mockBitGo.createEncryptionSession.callCount, 1);
+            assert.strictEqual(sessionEncryptStub.callCount, 20);
+        });
+        it('never runs more than 16 shares concurrently', async function () {
+            let inFlight = 0;
+            let maxInFlight = 0;
+            const sessionEncryptStub = sinon.stub().callsFake(() => {
+                inFlight++;
+                maxInFlight = Math.max(maxInFlight, inFlight);
+                return Promise.resolve('encrypted').then((r) => {
+                    inFlight--;
+                    return r;
+                });
+            });
+            mockBitGo.createEncryptionSession = sinon.stub().resolves({
+                encrypt: sessionEncryptStub,
+                decrypt: sinon.stub(),
+                destroy: sinon.stub(),
+            });
+            const manyShares = Array.from({ length: 20 }, (_, i) => ({
+                id: `share-${i}`,
+                userMultiKeyRotationRequired: true,
+                keychain: null,
+                permissions: ['spend'],
+            }));
+            mockBitGo.get.returns({
+                result: sinon.stub().resolves({ incoming: manyShares, outgoing: [] }),
+            });
+            await wallets.bulkAcceptShare({
+                walletShareIds: manyShares.map((s) => s.id),
+                userLoginPassword: 'login-password',
+            });
+            assert.ok(maxInFlight <= 16, `expected max concurrency <= 16, got ${maxInFlight}`);
+            assert.strictEqual(sessionEncryptStub.callCount, 20);
+        });
+    });
+    describe('Wallet.shareWallet / createBulkWalletShare', function () {
+        let wallet;
+        let recipientPubKey;
+        beforeEach(function () {
+            recipientPubKey = (0, bitcoin_1.makeRandomKey)().publicKey.toString('hex');
+            const mockWalletData = {
+                id: 'wallet-id',
+                keys: ['key-1', 'key-2', 'key-3'],
+                coin: 'btc',
+                label: 'Test Wallet',
+                users: [],
+                multisigType: 'onchain',
+                type: 'hot',
+            };
+            mockBaseCoin.supportsTss = sinon.stub().returns(false);
+            mockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');
+            wallet = new wallet_1.Wallet(mockBitGo, mockBaseCoin, mockWalletData);
+        });
+        it('encryptPrvForUser encrypts to the ECDH secret at the high-entropy version', async function () {
+            await wallet.encryptPrvForUser('prv', 'pub', recipientPubKey, 'm/0', 2);
+            assert.ok(mockBitGo.encrypt.calledOnce, 'encrypt should have been called');
+            assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].encryptionVersion, api_1.HIGH_ENTROPY_ENCRYPTION_VERSION);
+        });
+        it('preserves the encryptionVersion position before a pre-decrypted keychain', async function () {
+            await wallet.prepareSharedKeychain(undefined, recipientPubKey, 'm/0', 2, {
+                prv: 'prv',
+                pub: 'pub',
+            });
+            assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].input, 'prv');
+            assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].encryptionVersion, api_1.HIGH_ENTROPY_ENCRYPTION_VERSION);
+        });
+        it('shareWallet ignores a caller-supplied encryptionVersion for the shared keychain', async function () {
+            sinon.stub(wallet, 'getDecryptedKeychainForSharing').resolves({ prv: 'prv', pub: 'pub' });
+            mockBitGo.getSharingKey = sinon.stub().resolves({ userId: 'user-id', pubkey: recipientPubKey, path: 'm/0' });
+            mockBitGo.post.returns({ send: sinon.stub().returns({ result: sinon.stub().resolves({}) }) });
+            await wallet.shareWallet({
+                email: 'test@test.com',
+                permissions: 'spend',
+                walletPassphrase: 'passphrase',
+                encryptionVersion: 2,
+            });
+            assert.ok(mockBitGo.encrypt.calledOnce, 'encrypt should have been called');
+            assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].encryptionVersion, api_1.HIGH_ENTROPY_ENCRYPTION_VERSION, 'the ECDH-keyed share must not be encrypted at the caller-requested version');
+        });
+        it('createBulkWalletShare ignores a caller-supplied encryptionVersion for every share', async function () {
+            sinon.stub(wallet, 'getDecryptedKeychainForSharing').resolves({ prv: 'prv', pub: 'pub' });
+            sinon.stub(wallet, 'createBulkKeyShares').resolves({ shares: [] });
+            await wallet.createBulkWalletShare({
+                walletPassphrase: 'passphrase',
+                keyShareOptions: [
+                    { userId: 'user-1', pubKey: recipientPubKey, path: 'm/0', permissions: ['spend'] },
+                    { userId: 'user-2', pubKey: recipientPubKey, path: 'm/1', permissions: ['spend'] },
+                ],
+                encryptionVersion: 2,
+            });
+            assert.strictEqual(mockBitGo.encrypt.callCount, 2, 'each recipient gets its own encryption');
+            for (const call of mockBitGo.encrypt.getCalls()) {
+                assert.strictEqual(call.args[0].encryptionVersion, api_1.HIGH_ENTROPY_ENCRYPTION_VERSION);
+            }
+        });
+    });
+    describe('Wallets.generateWallet', function () {
+        it('keeps human-passphrase encryption at the requested version and pins recovery encryption', async function () {
+            mockKeychains.createBackup = sinon.stub().resolves({ id: 'backup-key-id', pub: 'backup-pub' });
+            mockKeychains.createBitGo = sinon.stub().resolves({ id: 'bitgo-key-id', pub: 'bitgo-pub' });
+            mockBitGo.post.returns({ send: sinon.stub().returns({ result: sinon.stub().resolves({ id: 'wallet-id' }) }) });
+            mockBaseCoin.getDefaultMultisigType = sinon.stub().returns('onchain');
+            mockBaseCoin.isEVM = sinon.stub().returns(false);
+            mockBaseCoin.isValidMofNSetup = sinon.stub().returns(true);
+            mockBaseCoin.supplementGenerateWallet = sinon.stub().callsFake(async (params) => params);
+            mockBaseCoin.signMessage = sinon.stub().resolves(Buffer.from('aabbcc', 'hex'));
+            await wallets.generateWallet({
+                label: 'Test Wallet',
+                passphrase: 'wallet-passphrase',
+                passcodeEncryptionCode: 'recovery-code',
+                encryptionVersion: 2,
+            });
+            assert.strictEqual(mockBitGo.encrypt.callCount, 2);
+            assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].encryptionVersion, 2);
+            assert.strictEqual(mockBitGo.encrypt.secondCall.args[0].encryptionVersion, api_1.HIGH_ENTROPY_ENCRYPTION_VERSION);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletsEncryptionVersion.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsEncryptionVersion.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,6CAA+B;AAC/B,kBAAgB;AAChB,kEAA+D;AAC/D,gEAA6D;AAC7D,2DAA8D;AAC9D,6CAAsE;AAEtE,QAAQ,CAAC,uCAAuC,EAAE;IAChD,IAAI,OAAgB,CAAC;IACrB,IAAI,SAAc,CAAC;IACnB,IAAI,YAAiB,CAAC;IACtB,IAAI,aAAkB,CAAC;IAEvB,MAAM,OAAO,GAAG,wBAAwB,CAAC;IACzC,MAAM,OAAO,GACX,iHAAiH,CAAC;IAEpH,UAAU,CAAC;QACT,aAAa,GAAG;YACd,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;YAC5D,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,aAAa,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,CAAC;SAC/F,CAAC;QAEF,SAAS,GAAG;YACV,OAAO,EAAE,KAAK;iBACX,IAAI,EAAE;iBACN,SAAS,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAuC,EAAE,EAAE,CAAC,OAAO,QAAQ,IAAI,KAAK,EAAE,CAAC;YAC5G,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC;YAC9C,uBAAuB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,QAAgB,EAAE,iBAAyB,EAAE,EAAE,CAAC,CAAC;gBACtG,OAAO,EAAE,KAAK;qBACX,IAAI,EAAE;qBACN,SAAS,CAAC,KAAK,EAAE,KAAa,EAAE,EAAE,CAAC,eAAe,QAAQ,IAAI,iBAAiB,IAAI,KAAK,EAAE,CAAC;gBAC9F,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;gBACnD,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE;aACtB,CAAC,CAAC;YACH,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC;YACtF,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;YACjG,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC;gBACxB,IAAI,EAAE,KAAK;qBACR,IAAI,EAAE;qBACN,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,oBAAoB,EAAE,EAAE,EAAE,uBAAuB,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;aACzG,CAAC;YACF,eAAe,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC;YACpE,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE;YAC9B,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC;SACvC,CAAC;QAEF,YAAY,GAAG;YACb,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC;YAC9C,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC;YACnD,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;YACtC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;YACrC,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;YACxC,eAAe,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;SAC/C,CAAC;QAEF,OAAO,GAAG,IAAI,iBAAO,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC;QACR,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,aAAa,EAAE;QACtB,EAAE,CAAC,iFAAiF,EAAE,KAAK;YACzF,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC;gBACpB,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;oBAC5B,4BAA4B,EAAE,IAAI;oBAClC,QAAQ,EAAE,IAAI;oBACd,WAAW,EAAE,CAAC,OAAO,CAAC;oBACtB,MAAM,EAAE,WAAW;iBACpB,CAAC;aACH,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,WAAW,CAAC;gBACxB,aAAa,EAAE,UAAU;gBACzB,YAAY,EAAE,aAAa;gBAC3B,iBAAiB,EAAE,CAAC;aACrB,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,iCAAiC,CAAC,CAAC;YACvE,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,KAAK;YAC1D,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC;gBACpB,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;oBAC5B,4BAA4B,EAAE,IAAI;oBAClC,QAAQ,EAAE,IAAI;oBACd,WAAW,EAAE,CAAC,OAAO,CAAC;oBACtB,MAAM,EAAE,WAAW;iBACpB,CAAC;aACH,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,WAAW,CAAC;gBACxB,aAAa,EAAE,UAAU;gBACzB,YAAY,EAAE,aAAa;aAC5B,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACpC,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE;QAC1B,MAAM,gBAAgB,GAAG;YACvB,QAAQ,EAAE;gBACR;oBACE,EAAE,EAAE,UAAU;oBACd,4BAA4B,EAAE,IAAI;oBAClC,QAAQ,EAAE,IAAI;oBACd,WAAW,EAAE,CAAC,OAAO,CAAC;iBACvB;aACF;YACD,QAAQ,EAAE,EAAE;SACb,CAAC;QAEF,UAAU,CAAC;YACT,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;QAC7E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE,KAAK;YAC/D,MAAM,OAAO,CAAC,eAAe,CAAC;gBAC5B,cAAc,EAAE,CAAC,UAAU,CAAC;gBAC5B,iBAAiB,EAAE,gBAAgB;gBACnC,iBAAiB,EAAE,CAAC;aACrB,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;YACpD,MAAM,IAAI,GAAG,SAAS,CAAC,uBAAuB,CAAC,SAAS,CAAC;YACzD,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4EAA4E,EAAE,KAAK;YACpF,MAAM,OAAO,CAAC,eAAe,CAAC;gBAC5B,cAAc,EAAE,CAAC,UAAU,CAAC;gBAC5B,iBAAiB,EAAE,gBAAgB;aACpC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;YACpD,MAAM,IAAI,GAAG,SAAS,CAAC,uBAAuB,CAAC,SAAS,CAAC;YACzD,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mEAAmE,EAAE,KAAK;YAC3E,0EAA0E;YAC1E,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBACvD,EAAE,EAAE,SAAS,CAAC,EAAE;gBAChB,4BAA4B,EAAE,IAAI;gBAClC,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,CAAC,OAAO,CAAC;aACvB,CAAC,CAAC,CAAC;YACJ,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC;gBACpB,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;aACtE,CAAC,CAAC;YAEH,+DAA+D;YAC/D,MAAM,kBAAkB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,KAAa,EAAE,EAAE,CAAC,eAAe,KAAK,EAAE,CAAC,CAAC;YACnG,SAAS,CAAC,uBAAuB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;gBACxD,OAAO,EAAE,kBAAkB;gBAC3B,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE;gBACrB,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE;aACtB,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,eAAe,CAAC;gBAC5B,cAAc,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC3C,iBAAiB,EAAE,gBAAgB;aACpC,CAAC,CAAC;YAEH,8DAA8D;YAC9D,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,uBAAuB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YACnE,MAAM,CAAC,WAAW,CAAC,kBAAkB,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE,KAAK;YACrD,IAAI,QAAQ,GAAG,CAAC,CAAC;YACjB,IAAI,WAAW,GAAG,CAAC,CAAC;YAEpB,MAAM,kBAAkB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE;gBACrD,QAAQ,EAAE,CAAC;gBACX,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;gBAC9C,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;oBAC7C,QAAQ,EAAE,CAAC;oBACX,OAAO,CAAC,CAAC;gBACX,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YACH,SAAS,CAAC,uBAAuB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;gBACxD,OAAO,EAAE,kBAAkB;gBAC3B,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE;gBACrB,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE;aACtB,CAAC,CAAC;YAEH,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBACvD,EAAE,EAAE,SAAS,CAAC,EAAE;gBAChB,4BAA4B,EAAE,IAAI;gBAClC,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,CAAC,OAAO,CAAC;aACvB,CAAC,CAAC,CAAC;YACJ,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC;gBACpB,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;aACtE,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,eAAe,CAAC;gBAC5B,cAAc,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC3C,iBAAiB,EAAE,gBAAgB;aACpC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,WAAW,IAAI,EAAE,EAAE,uCAAuC,WAAW,EAAE,CAAC,CAAC;YACnF,MAAM,CAAC,WAAW,CAAC,kBAAkB,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,4CAA4C,EAAE;QACrD,IAAI,MAAc,CAAC;QACnB,IAAI,eAAuB,CAAC;QAE5B,UAAU,CAAC;YACT,eAAe,GAAG,IAAA,uBAAa,GAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC5D,MAAM,cAAc,GAAG;gBACrB,EAAE,EAAE,WAAW;gBACf,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC;gBACjC,IAAI,EAAE,KAAK;gBACX,KAAK,EAAE,aAAa;gBACpB,KAAK,EAAE,EAAE;gBACT,YAAY,EAAE,SAAS;gBACvB,IAAI,EAAE,KAAK;aACZ,CAAC;YACF,YAAY,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACvD,YAAY,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAC7D,MAAM,GAAG,IAAI,eAAM,CAAC,SAAS,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2EAA2E,EAAE,KAAK;YACnF,MAAM,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;YAExE,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,iCAAiC,CAAC,CAAC;YAC3E,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,qCAA+B,CAAC,CAAC;QAC7G,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0EAA0E,EAAE,KAAK;YAClF,MAAM,MAAM,CAAC,qBAAqB,CAAC,SAAS,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE;gBACvE,GAAG,EAAE,KAAK;gBACV,GAAG,EAAE,KAAK;aACX,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACrE,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,qCAA+B,CAAC,CAAC;QAC7G,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iFAAiF,EAAE,KAAK;YACzF,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,gCAAgC,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;YAC1F,SAAS,CAAC,aAAa,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YAC7G,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAE9F,MAAM,MAAM,CAAC,WAAW,CAAC;gBACvB,KAAK,EAAE,eAAe;gBACtB,WAAW,EAAE,OAAO;gBACpB,gBAAgB,EAAE,YAAY;gBAC9B,iBAAiB,EAAE,CAAC;aACrB,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,iCAAiC,CAAC,CAAC;YAC3E,MAAM,CAAC,WAAW,CAChB,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EACrD,qCAA+B,EAC/B,4EAA4E,CAC7E,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mFAAmF,EAAE,KAAK;YAC3F,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,gCAAgC,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;YAC1F,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;YAEnE,MAAM,MAAM,CAAC,qBAAqB,CAAC;gBACjC,gBAAgB,EAAE,YAAY;gBAC9B,eAAe,EAAE;oBACf,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE;oBAClF,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE;iBACnF;gBACD,iBAAiB,EAAE,CAAC;aACrB,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,EAAE,wCAAwC,CAAC,CAAC;YAC7F,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC;gBAChD,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,qCAA+B,CAAC,CAAC;YACtF,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,wBAAwB,EAAE;QACjC,EAAE,CAAC,yFAAyF,EAAE,KAAK;YACjG,aAAa,CAAC,YAAY,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,YAAY,EAAE,CAAC,CAAC;YAC/F,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC;YAC5F,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAC/G,YAAY,CAAC,sBAAsB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YACtE,YAAY,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACjD,YAAY,CAAC,gBAAgB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC3D,YAAY,CAAC,wBAAwB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,MAAe,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;YAClG,YAAY,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;YAE/E,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,aAAa;gBACpB,UAAU,EAAE,mBAAmB;gBAC/B,sBAAsB,EAAE,eAAe;gBACvC,iBAAiB,EAAE,CAAC;aACrB,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YACnD,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;YAC7E,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,qCAA+B,CAAC,CAAC;QAC9G,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\nimport { Wallet } from '../../../../src/bitgo/wallet/wallet';\nimport { makeRandomKey } from '../../../../src/bitgo/bitcoin';\nimport { HIGH_ENTROPY_ENCRYPTION_VERSION } from '../../../../src/api';\n\ndescribe('Wallets - encryptionVersion threading', function () {\n  let wallets: Wallets;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n  let mockKeychains: any;\n\n  const userPrv = 'xprvSomeUserPrivateKey';\n  const userPub =\n    'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';\n\n  beforeEach(function () {\n    mockKeychains = {\n      create: sinon.stub().returns({ pub: userPub, prv: userPrv }),\n      add: sinon.stub().resolves({ id: 'user-key-id', pub: userPub, encryptedPrv: 'encrypted-prv' }),\n    };\n\n    mockBitGo = {\n      encrypt: sinon\n        .stub()\n        .callsFake(async ({ password, input }: { password: string; input: string }) => `enc:${password}:${input}`),\n      decrypt: sinon.stub().resolves('decryptedPrv'),\n      createEncryptionSession: sinon.stub().callsFake(async (password: string, encryptionVersion?: 1 | 2) => ({\n        encrypt: sinon\n          .stub()\n          .callsFake(async (input: string) => `session-enc:${password}:${encryptionVersion}:${input}`),\n        decrypt: sinon.stub().resolves('session-decrypted'),\n        destroy: sinon.stub(),\n      })),\n      get: sinon.stub().returns({ result: sinon.stub(), query: sinon.stub().returnsThis() }),\n      post: sinon.stub().returns({ send: sinon.stub().returns({ result: sinon.stub().resolves({}) }) }),\n      put: sinon.stub().returns({\n        send: sinon\n          .stub()\n          .returns({ result: sinon.stub().resolves({ acceptedWalletShares: [], walletShareUpdateErrors: [] }) }),\n      }),\n      getECDHKeychain: sinon.stub().resolves({ encryptedXprv: 'encXprv' }),\n      setRequestTracer: sinon.stub(),\n      url: sinon.stub().returns('/test/url'),\n    };\n\n    mockBaseCoin = {\n      keychains: sinon.stub().returns(mockKeychains),\n      url: sinon.stub().callsFake((path: string) => path),\n      getFamily: sinon.stub().returns('btc'),\n      getChain: sinon.stub().returns('btc'),\n      supportsTss: sinon.stub().returns(false),\n      getMPCAlgorithm: sinon.stub().returns('ecdsa'),\n    };\n\n    wallets = new Wallets(mockBitGo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('acceptShare', function () {\n    it('passes encryptionVersion: 2 to encrypt on the multiUserKeyRotationRequired path', async function () {\n      mockBitGo.get.returns({\n        result: sinon.stub().resolves({\n          userMultiKeyRotationRequired: true,\n          keychain: null,\n          permissions: ['spend'],\n          wallet: 'wallet-id',\n        }),\n      });\n\n      await wallets.acceptShare({\n        walletShareId: 'share-id',\n        userPassword: 'my-password',\n        encryptionVersion: 2,\n      });\n\n      assert.ok(mockBitGo.encrypt.called, 'encrypt should have been called');\n      const call = mockBitGo.encrypt.firstCall;\n      assert.strictEqual(call.args[0].encryptionVersion, 2);\n    });\n\n    it('passes encryptionVersion: undefined when not set', async function () {\n      mockBitGo.get.returns({\n        result: sinon.stub().resolves({\n          userMultiKeyRotationRequired: true,\n          keychain: null,\n          permissions: ['spend'],\n          wallet: 'wallet-id',\n        }),\n      });\n\n      await wallets.acceptShare({\n        walletShareId: 'share-id',\n        userPassword: 'my-password',\n      });\n\n      assert.ok(mockBitGo.encrypt.called);\n      const call = mockBitGo.encrypt.firstCall;\n      assert.strictEqual(call.args[0].encryptionVersion, undefined);\n    });\n  });\n\n  describe('bulkAcceptShare', function () {\n    const walletSharesList = {\n      incoming: [\n        {\n          id: 'share-id',\n          userMultiKeyRotationRequired: true,\n          keychain: null,\n          permissions: ['spend'],\n        },\n      ],\n      outgoing: [],\n    };\n\n    beforeEach(function () {\n      mockBitGo.get.returns({ result: sinon.stub().resolves(walletSharesList) });\n    });\n\n    it('passes encryptionVersion: 2 to the encryption session', async function () {\n      await wallets.bulkAcceptShare({\n        walletShareIds: ['share-id'],\n        userLoginPassword: 'login-password',\n        encryptionVersion: 2,\n      });\n\n      assert.ok(mockBitGo.createEncryptionSession.called);\n      const call = mockBitGo.createEncryptionSession.firstCall;\n      assert.strictEqual(call.args[1], 2);\n    });\n\n    it('passes encryptionVersion: undefined to the encryption session when not set', async function () {\n      await wallets.bulkAcceptShare({\n        walletShareIds: ['share-id'],\n        userLoginPassword: 'login-password',\n      });\n\n      assert.ok(mockBitGo.createEncryptionSession.called);\n      const call = mockBitGo.createEncryptionSession.firstCall;\n      assert.strictEqual(call.args[1], undefined);\n    });\n\n    it('processes shares in batches of 16 to avoid WASM memory exhaustion', async function () {\n      // 20 shares → 2 batches (16 + 4), verifying the batch boundary is crossed\n      const manyShares = Array.from({ length: 20 }, (_, i) => ({\n        id: `share-${i}`,\n        userMultiKeyRotationRequired: true,\n        keychain: null,\n        permissions: ['spend'],\n      }));\n      mockBitGo.get.returns({\n        result: sinon.stub().resolves({ incoming: manyShares, outgoing: [] }),\n      });\n\n      // Capture the session so we can inspect its encrypt call count\n      const sessionEncryptStub = sinon.stub().callsFake(async (input: string) => `session-enc:${input}`);\n      mockBitGo.createEncryptionSession = sinon.stub().resolves({\n        encrypt: sessionEncryptStub,\n        decrypt: sinon.stub(),\n        destroy: sinon.stub(),\n      });\n\n      await wallets.bulkAcceptShare({\n        walletShareIds: manyShares.map((s) => s.id),\n        userLoginPassword: 'login-password',\n      });\n\n      // Session created once, session.encrypt called once per share\n      assert.strictEqual(mockBitGo.createEncryptionSession.callCount, 1);\n      assert.strictEqual(sessionEncryptStub.callCount, 20);\n    });\n\n    it('never runs more than 16 shares concurrently', async function () {\n      let inFlight = 0;\n      let maxInFlight = 0;\n\n      const sessionEncryptStub = sinon.stub().callsFake(() => {\n        inFlight++;\n        maxInFlight = Math.max(maxInFlight, inFlight);\n        return Promise.resolve('encrypted').then((r) => {\n          inFlight--;\n          return r;\n        });\n      });\n      mockBitGo.createEncryptionSession = sinon.stub().resolves({\n        encrypt: sessionEncryptStub,\n        decrypt: sinon.stub(),\n        destroy: sinon.stub(),\n      });\n\n      const manyShares = Array.from({ length: 20 }, (_, i) => ({\n        id: `share-${i}`,\n        userMultiKeyRotationRequired: true,\n        keychain: null,\n        permissions: ['spend'],\n      }));\n      mockBitGo.get.returns({\n        result: sinon.stub().resolves({ incoming: manyShares, outgoing: [] }),\n      });\n\n      await wallets.bulkAcceptShare({\n        walletShareIds: manyShares.map((s) => s.id),\n        userLoginPassword: 'login-password',\n      });\n\n      assert.ok(maxInFlight <= 16, `expected max concurrency <= 16, got ${maxInFlight}`);\n      assert.strictEqual(sessionEncryptStub.callCount, 20);\n    });\n  });\n\n  describe('Wallet.shareWallet / createBulkWalletShare', function () {\n    let wallet: Wallet;\n    let recipientPubKey: string;\n\n    beforeEach(function () {\n      recipientPubKey = makeRandomKey().publicKey.toString('hex');\n      const mockWalletData = {\n        id: 'wallet-id',\n        keys: ['key-1', 'key-2', 'key-3'],\n        coin: 'btc',\n        label: 'Test Wallet',\n        users: [],\n        multisigType: 'onchain',\n        type: 'hot',\n      };\n      mockBaseCoin.supportsTss = sinon.stub().returns(false);\n      mockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');\n      wallet = new Wallet(mockBitGo, mockBaseCoin, mockWalletData);\n    });\n\n    it('encryptPrvForUser encrypts to the ECDH secret at the high-entropy version', async function () {\n      await wallet.encryptPrvForUser('prv', 'pub', recipientPubKey, 'm/0', 2);\n\n      assert.ok(mockBitGo.encrypt.calledOnce, 'encrypt should have been called');\n      assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].encryptionVersion, HIGH_ENTROPY_ENCRYPTION_VERSION);\n    });\n\n    it('preserves the encryptionVersion position before a pre-decrypted keychain', async function () {\n      await wallet.prepareSharedKeychain(undefined, recipientPubKey, 'm/0', 2, {\n        prv: 'prv',\n        pub: 'pub',\n      });\n\n      assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].input, 'prv');\n      assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].encryptionVersion, HIGH_ENTROPY_ENCRYPTION_VERSION);\n    });\n\n    it('shareWallet ignores a caller-supplied encryptionVersion for the shared keychain', async function () {\n      sinon.stub(wallet, 'getDecryptedKeychainForSharing').resolves({ prv: 'prv', pub: 'pub' });\n      mockBitGo.getSharingKey = sinon.stub().resolves({ userId: 'user-id', pubkey: recipientPubKey, path: 'm/0' });\n      mockBitGo.post.returns({ send: sinon.stub().returns({ result: sinon.stub().resolves({}) }) });\n\n      await wallet.shareWallet({\n        email: 'test@test.com',\n        permissions: 'spend',\n        walletPassphrase: 'passphrase',\n        encryptionVersion: 2,\n      });\n\n      assert.ok(mockBitGo.encrypt.calledOnce, 'encrypt should have been called');\n      assert.strictEqual(\n        mockBitGo.encrypt.firstCall.args[0].encryptionVersion,\n        HIGH_ENTROPY_ENCRYPTION_VERSION,\n        'the ECDH-keyed share must not be encrypted at the caller-requested version'\n      );\n    });\n\n    it('createBulkWalletShare ignores a caller-supplied encryptionVersion for every share', async function () {\n      sinon.stub(wallet, 'getDecryptedKeychainForSharing').resolves({ prv: 'prv', pub: 'pub' });\n      sinon.stub(wallet, 'createBulkKeyShares').resolves({ shares: [] });\n\n      await wallet.createBulkWalletShare({\n        walletPassphrase: 'passphrase',\n        keyShareOptions: [\n          { userId: 'user-1', pubKey: recipientPubKey, path: 'm/0', permissions: ['spend'] },\n          { userId: 'user-2', pubKey: recipientPubKey, path: 'm/1', permissions: ['spend'] },\n        ],\n        encryptionVersion: 2,\n      });\n\n      assert.strictEqual(mockBitGo.encrypt.callCount, 2, 'each recipient gets its own encryption');\n      for (const call of mockBitGo.encrypt.getCalls()) {\n        assert.strictEqual(call.args[0].encryptionVersion, HIGH_ENTROPY_ENCRYPTION_VERSION);\n      }\n    });\n  });\n\n  describe('Wallets.generateWallet', function () {\n    it('keeps human-passphrase encryption at the requested version and pins recovery encryption', async function () {\n      mockKeychains.createBackup = sinon.stub().resolves({ id: 'backup-key-id', pub: 'backup-pub' });\n      mockKeychains.createBitGo = sinon.stub().resolves({ id: 'bitgo-key-id', pub: 'bitgo-pub' });\n      mockBitGo.post.returns({ send: sinon.stub().returns({ result: sinon.stub().resolves({ id: 'wallet-id' }) }) });\n      mockBaseCoin.getDefaultMultisigType = sinon.stub().returns('onchain');\n      mockBaseCoin.isEVM = sinon.stub().returns(false);\n      mockBaseCoin.isValidMofNSetup = sinon.stub().returns(true);\n      mockBaseCoin.supplementGenerateWallet = sinon.stub().callsFake(async (params: unknown) => params);\n      mockBaseCoin.signMessage = sinon.stub().resolves(Buffer.from('aabbcc', 'hex'));\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        passcodeEncryptionCode: 'recovery-code',\n        encryptionVersion: 2,\n      });\n\n      assert.strictEqual(mockBitGo.encrypt.callCount, 2);\n      assert.strictEqual(mockBitGo.encrypt.firstCall.args[0].encryptionVersion, 2);\n      assert.strictEqual(mockBitGo.encrypt.secondCall.args[0].encryptionVersion, HIGH_ENTROPY_ENCRYPTION_VERSION);\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/wallet/walletsEvmKeyring.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=walletsEvmKeyring.d.ts.map

package/dist/test/unit/bitgo/wallet/walletsEvmKeyring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletsEvmKeyring.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsEvmKeyring.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,CAAC"}

package/dist/test/unit/bitgo/wallet/walletsEvmKeyring.js

@@ -0,0 +1,216 @@
+"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"));
+require("should");
+const wallets_1 = require("../../../../src/bitgo/wallet/wallets");
+describe('Wallets', function () {
+    let wallets;
+    let mockBitGo;
+    let mockBaseCoin;
+    beforeEach(function () {
+        mockBitGo = {
+            post: sinon.stub(),
+            encrypt: sinon.stub(),
+            setRequestTracer: sinon.stub(),
+        };
+        mockBaseCoin = {
+            isEVM: sinon.stub(),
+            supportsTss: sinon.stub().returns(true),
+            getFamily: sinon.stub().returns('eth'),
+            getDefaultMultisigType: sinon.stub(),
+            keychains: sinon.stub(),
+            url: sinon.stub().returns('/test/url'),
+            isValidMofNSetup: sinon.stub(),
+            getConfig: sinon.stub().returns({ features: [] }),
+        };
+        wallets = new wallets_1.Wallets(mockBitGo, mockBaseCoin);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('EVM Keyring - generateWallet', function () {
+        beforeEach(function () {
+            mockBaseCoin.isEVM.returns(true);
+            mockBaseCoin.supportsTss.returns(true);
+            mockBaseCoin.getDefaultMultisigType.returns('tss');
+        });
+        it('should create EVM wallet with evmKeyRingReferenceWalletId', async function () {
+            const mockWalletResponse = {
+                id: '597f1f77bcf86cd799439011',
+                keys: ['user-key', 'backup-key', 'bitgo-key'],
+            };
+            mockBitGo.post.returns({
+                send: sinon.stub().returns({
+                    result: sinon.stub().resolves(mockWalletResponse),
+                }),
+            });
+            mockBaseCoin.keychains.returns({
+                get: sinon.stub().resolves({ id: 'keychain-id', pub: 'public-key' }),
+            });
+            const result = await wallets.generateWallet({
+                label: 'Test EVM Wallet',
+                evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+            });
+            result.should.have.property('wallet');
+            result.should.have.property('userKeychain');
+            result.should.have.property('backupKeychain');
+            result.should.have.property('bitgoKeychain');
+        });
+        it('should throw error if evmKeyRingReferenceWalletId provided for non-EVM chain', async function () {
+            mockBaseCoin.isEVM.returns(false);
+            try {
+                await wallets.generateWallet({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+        it('should throw error if evmKeyRingReferenceWalletId is not a string', async function () {
+            try {
+                await wallets.generateWallet({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: 123,
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('invalid evmKeyRingReferenceWalletId argument, expecting string');
+            }
+        });
+    });
+    describe('EVM Keyring - add method', function () {
+        beforeEach(function () {
+            mockBaseCoin.isEVM.returns(true);
+        });
+        it('should add EVM wallet with evmKeyRingReferenceWalletId without multisig validation', async function () {
+            const mockWalletResponse = {
+                id: 'new-wallet-id',
+                keys: ['user-key', 'backup-key', 'bitgo-key'],
+            };
+            mockBitGo.post.returns({
+                send: sinon.stub().returns({
+                    result: sinon.stub().resolves(mockWalletResponse),
+                }),
+            });
+            const result = await wallets.add({
+                label: 'Test EVM Wallet',
+                evmKeyRingReferenceWalletId: 'reference-wallet-id',
+            });
+            result.should.have.property('wallet');
+            mockBitGo.post.should.have.been.calledOnce;
+        });
+        it('should skip multisig validation for EVM wallets with evmKeyRingReferenceWalletId', async function () {
+            const mockWalletResponse = {
+                id: 'new-wallet-id',
+                keys: ['user-key', 'backup-key', 'bitgo-key'],
+            };
+            mockBitGo.post.returns({
+                send: sinon.stub().returns({
+                    result: sinon.stub().resolves(mockWalletResponse),
+                }),
+            });
+            // This should not throw error even without keys, m, n parameters
+            const result = await wallets.add({
+                label: 'Test EVM Wallet',
+                evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+                // No keys, m, n provided - should be fine for EVM keyring
+            });
+            result.should.have.property('wallet');
+        });
+        it('should throw error for non-EVM chains with evmKeyRingReferenceWalletId', async function () {
+            mockBaseCoin.isEVM.returns(false);
+            try {
+                await wallets.add({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+        it('should still validate multisig for regular wallets', async function () {
+            mockBaseCoin.isEVM.returns(true);
+            try {
+                await wallets.add({
+                    label: 'Test Wallet',
+                    type: 'hot',
+                    // No evmKeyRingReferenceWalletId, so should require keys, m, n
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('invalid argument');
+            }
+        });
+    });
+    describe('Non-EVM chains', function () {
+        beforeEach(function () {
+            mockBaseCoin.isEVM.returns(false);
+        });
+        it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in generateWallet', async function () {
+            try {
+                await wallets.generateWallet({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: 'reference-wallet-id',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+        it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in add', async function () {
+            try {
+                await wallets.add({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: 'reference-wallet-id',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletsEvmKeyring.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsEvmKeyring.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\n\ndescribe('Wallets', function () {\n  let wallets: Wallets;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n\n  beforeEach(function () {\n    mockBitGo = {\n      post: sinon.stub(),\n      encrypt: sinon.stub(),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      isEVM: sinon.stub(),\n      supportsTss: sinon.stub().returns(true),\n      getFamily: sinon.stub().returns('eth'),\n      getDefaultMultisigType: sinon.stub(),\n      keychains: sinon.stub(),\n      url: sinon.stub().returns('/test/url'),\n      isValidMofNSetup: sinon.stub(),\n      getConfig: sinon.stub().returns({ features: [] }),\n    };\n\n    wallets = new Wallets(mockBitGo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('EVM Keyring - generateWallet', function () {\n    beforeEach(function () {\n      mockBaseCoin.isEVM.returns(true);\n      mockBaseCoin.supportsTss.returns(true);\n      mockBaseCoin.getDefaultMultisigType.returns('tss');\n    });\n\n    it('should create EVM wallet with evmKeyRingReferenceWalletId', async function () {\n      const mockWalletResponse = {\n        id: '597f1f77bcf86cd799439011',\n        keys: ['user-key', 'backup-key', 'bitgo-key'],\n      };\n\n      mockBitGo.post.returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletResponse),\n        }),\n      } as any);\n\n      mockBaseCoin.keychains.returns({\n        get: sinon.stub().resolves({ id: 'keychain-id', pub: 'public-key' }),\n      } as any);\n\n      const result = await wallets.generateWallet({\n        label: 'Test EVM Wallet',\n        evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n      });\n\n      result.should.have.property('wallet');\n      result.should.have.property('userKeychain');\n      result.should.have.property('backupKeychain');\n      result.should.have.property('bitgoKeychain');\n    });\n\n    it('should throw error if evmKeyRingReferenceWalletId provided for non-EVM chain', async function () {\n      mockBaseCoin.isEVM.returns(false);\n\n      try {\n        await wallets.generateWallet({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n\n    it('should throw error if evmKeyRingReferenceWalletId is not a string', async function () {\n      try {\n        await wallets.generateWallet({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: 123 as any,\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('invalid evmKeyRingReferenceWalletId argument, expecting string');\n      }\n    });\n  });\n\n  describe('EVM Keyring - add method', function () {\n    beforeEach(function () {\n      mockBaseCoin.isEVM.returns(true);\n    });\n\n    it('should add EVM wallet with evmKeyRingReferenceWalletId without multisig validation', async function () {\n      const mockWalletResponse = {\n        id: 'new-wallet-id',\n        keys: ['user-key', 'backup-key', 'bitgo-key'],\n      };\n\n      mockBitGo.post.returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletResponse),\n        }),\n      } as any);\n\n      const result = await wallets.add({\n        label: 'Test EVM Wallet',\n        evmKeyRingReferenceWalletId: 'reference-wallet-id',\n      });\n\n      result.should.have.property('wallet');\n      mockBitGo.post.should.have.been.calledOnce;\n    });\n\n    it('should skip multisig validation for EVM wallets with evmKeyRingReferenceWalletId', async function () {\n      const mockWalletResponse = {\n        id: 'new-wallet-id',\n        keys: ['user-key', 'backup-key', 'bitgo-key'],\n      };\n\n      mockBitGo.post.returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletResponse),\n        }),\n      } as any);\n\n      // This should not throw error even without keys, m, n parameters\n      const result = await wallets.add({\n        label: 'Test EVM Wallet',\n        evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n        // No keys, m, n provided - should be fine for EVM keyring\n      });\n\n      result.should.have.property('wallet');\n    });\n\n    it('should throw error for non-EVM chains with evmKeyRingReferenceWalletId', async function () {\n      mockBaseCoin.isEVM.returns(false);\n\n      try {\n        await wallets.add({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n\n    it('should still validate multisig for regular wallets', async function () {\n      mockBaseCoin.isEVM.returns(true);\n\n      try {\n        await wallets.add({\n          label: 'Test Wallet',\n          type: 'hot',\n          // No evmKeyRingReferenceWalletId, so should require keys, m, n\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('invalid argument');\n      }\n    });\n  });\n\n  describe('Non-EVM chains', function () {\n    beforeEach(function () {\n      mockBaseCoin.isEVM.returns(false);\n    });\n\n    it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in generateWallet', async function () {\n      try {\n        await wallets.generateWallet({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: 'reference-wallet-id',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n\n    it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in add', async function () {\n      try {\n        await wallets.add({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: 'reference-wallet-id',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/wallet/walletsExternalSigner.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=walletsExternalSigner.d.ts.map

package/dist/test/unit/bitgo/wallet/walletsExternalSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletsExternalSigner.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsExternalSigner.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,CAAC"}