@bitgo-beta/sdk-api 1.10.1-beta.212 → 1.10.1-beta.2121

package/dist/test/unit/bitgoAPI.js

@@ -0,0 +1,1339 @@
+"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"));
+require("should");
+const bitgoAPI_1 = require("../../src/bitgoAPI");
+const proxy_agent_1 = require("proxy-agent");
+const sinon = __importStar(require("sinon"));
+const nock_1 = __importDefault(require("nock"));
+describe('Constructor', function () {
+    describe('cookiesPropagationEnabled argument', function () {
+        it('cookiesPropagationEnabled is enabled explicitly', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                cookiesPropagationEnabled: true,
+            });
+            bitgo.should.have.property('cookiesPropagationEnabled');
+            bitgo.cookiesPropagationEnabled.should.equal(true);
+        });
+        it('cookiesPropagationEnabled is disabled explicitly', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                cookiesPropagationEnabled: false,
+            });
+            bitgo.should.have.property('cookiesPropagationEnabled');
+            bitgo.cookiesPropagationEnabled.should.equal(false);
+        });
+        it('cookiesPropagationEnabled is disabled by default', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            bitgo.should.have.property('cookiesPropagationEnabled');
+            bitgo.cookiesPropagationEnabled.should.equal(false);
+        });
+    });
+    describe('requestIdPrefix argument', function () {
+        afterEach(function () {
+            nock_1.default.cleanAll();
+        });
+        it('should prepend requestIdPrefix to Request-ID header when set', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                requestIdPrefix: 'test-prefix-',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', /^test-prefix-/)
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => '12345',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+        it('should not modify Request-ID header when requestIdPrefix is not set', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', /^12345$/)
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => '12345',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+        it('should correctly format Request-ID with prefix and numeric sequence', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                requestIdPrefix: 'myapp-v1-',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', 'myapp-v1-trace-123')
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => 'trace-123',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+        it('should work with empty string prefix', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                requestIdPrefix: '',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', 'abc-123')
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => 'abc-123',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+    });
+    describe('http proxy agent', function () {
+        it('http proxy agent shall be created when proxy(customProxyagent) is set', function () {
+            const customProxyAgent = new proxy_agent_1.ProxyAgent({
+                getProxyForUrl: () => 'http://localhost:3000',
+            });
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                customProxyAgent,
+            });
+            bitgo.should.have.property('_customProxyAgent', customProxyAgent);
+        });
+        it('bitgo api is still initiated when proxy(customProxyAgent) is not set', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            bitgo.should.have.property('_customProxyAgent', undefined);
+        });
+    });
+    describe('verifyAddress', function () {
+        it('should successfully verify a base58 address', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+            });
+            bitgo.verifyAddress({ address: '2N6paT2TU4N1XpaZjJiApWJXoeyrL3UWpkZ' }).should.be.true();
+        });
+        it('should successfully verify a bech32 address', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+            });
+            bitgo
+                .verifyAddress({ address: 'tb1qguzyk4w6kaqtpsczs5aj0w8r7598jq36egm8e98wqph3rwmex68seslgsg' })
+                .should.be.true();
+        });
+    });
+    describe('url', function () {
+        it('should return the correct URL for version 1', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';
+            const result = bitgo.url(path, 1);
+            result.should.equal(expectedUrl);
+        });
+        it('should return the correct URL for version 2', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v2/test-path';
+            const result = bitgo.url(path, 2);
+            result.should.equal(expectedUrl);
+        });
+        it('should return the correct URL for version 3', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v3/test-path';
+            const result = bitgo.url(path, 3);
+            result.should.equal(expectedUrl);
+        });
+        it('should default to version 1 if no version is provided', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';
+            const result = bitgo.url(path);
+            result.should.equal(expectedUrl);
+        });
+    });
+    describe('decryptKeys', function () {
+        let bitgo;
+        beforeEach(function () {
+            bitgo = new bitgoAPI_1.BitGoAPI({ env: 'test' });
+        });
+        afterEach(function () {
+            sinon.restore();
+        });
+        it('should throw if no params are provided', async function () {
+            // @ts-expect-error - intentionally calling with no params for test
+            await bitgo.decryptKeys().should.be.rejectedWith('Missing parameter: walletIdEncryptedKeyPairs');
+        });
+        it('should throw if walletIdEncryptedKeyPairs is missing', async function () {
+            await bitgo
+                // @ts-expect-error - intentionally missing required param
+                .decryptKeys({ password: 'password123' })
+                .should.be.rejectedWith('Missing parameter: walletIdEncryptedKeyPairs');
+        });
+        it('should throw if password is missing', async function () {
+            // @ts-expect-error - intentionally missing required param
+            await bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [] }).should.be.rejectedWith('Missing parameter: password');
+        });
+        it('should throw if walletIdEncryptedKeyPairs is not an array', async function () {
+            await bitgo
+                // @ts-expect-error - intentionally providing wrong type
+                .decryptKeys({ walletIdEncryptedKeyPairs: 'not an array', password: 'password123' })
+                .should.be.rejectedWith('walletIdEncryptedKeyPairs must be an array');
+        });
+        it('should return empty array for empty walletIdEncryptedKeyPairs', async function () {
+            const result = await bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [], password: 'password123' });
+            result.should.be.an.Array();
+            result.should.be.empty();
+        });
+        it('should throw if any walletId is missing or not a string', async function () {
+            await bitgo
+                .decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    // @ts-expect-error - intentionally missing walletId
+                    { encryptedPrv: 'encrypted-data' },
+                ],
+                password: 'password123',
+            })
+                .should.be.rejectedWith('each key pair must have a string walletId');
+            await bitgo
+                .decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    // @ts-expect-error - intentionally providing wrong type
+                    { walletId: 123, encryptedPrv: 'encrypted-data' },
+                ],
+                password: 'password123',
+            })
+                .should.be.rejectedWith('each key pair must have a string walletId');
+        });
+        it('should throw if any encryptedPrv is missing or not a string', async function () {
+            await bitgo
+                .decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    // @ts-expect-error - intentionally missing encryptedPrv
+                    { walletId: 'wallet-id-1' },
+                ],
+                password: 'password123',
+            })
+                .should.be.rejectedWith('each key pair must have a string encryptedPrv');
+            await bitgo
+                .decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    // @ts-expect-error - intentionally providing wrong type
+                    { walletId: 'wallet-id-1', encryptedPrv: 123 },
+                ],
+                password: 'password123',
+            })
+                .should.be.rejectedWith('each key pair must have a string encryptedPrv');
+        });
+    });
+    describe('decryptKeys', function () {
+        let bitgo;
+        beforeEach(function () {
+            bitgo = new bitgoAPI_1.BitGoAPI({ env: 'test' });
+        });
+        afterEach(function () {
+            sinon.restore();
+        });
+        it('should return walletIds of keys that failed to decrypt', async function () {
+            const decryptAsyncStub = sinon.stub(bitgo, 'decrypt');
+            decryptAsyncStub.onFirstCall().resolves('decrypted-key-1');
+            decryptAsyncStub.onSecondCall().rejects(new Error('decryption failed'));
+            const result = await bitgo.decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },
+                    { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },
+                ],
+                password: 'password123',
+            });
+            result.should.be.an.Array();
+            result.should.have.length(1);
+            result[0].should.equal('wallet-id-2');
+        });
+        it('should correctly process multiple wallet keys', async function () {
+            const decryptAsyncStub = sinon.stub(bitgo, 'decrypt');
+            decryptAsyncStub
+                .withArgs({ input: 'encrypted-data-2', password: 'password123' })
+                .rejects(new Error('decryption failed'));
+            decryptAsyncStub
+                .withArgs({ input: 'encrypted-data-4', password: 'password123' })
+                .rejects(new Error('decryption failed'));
+            decryptAsyncStub.resolves('success');
+            const result = await bitgo.decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },
+                    { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },
+                    { walletId: 'wallet-id-3', encryptedPrv: 'encrypted-data-3' },
+                    { walletId: 'wallet-id-4', encryptedPrv: 'encrypted-data-4' },
+                ],
+                password: 'password123',
+            });
+            decryptAsyncStub.callCount.should.equal(4);
+            result.should.be.an.Array();
+            result.should.have.length(2);
+            result.should.containDeep(['wallet-id-2', 'wallet-id-4']);
+        });
+    });
+    describe('User-Agent header based on environment', function () {
+        afterEach(function () {
+            nock_1.default.cleanAll();
+            sinon.restore();
+        });
+        it('should set User-Agent header when running in Node.js (typeof window === undefined)', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                userAgent: 'TestAgent/1.0',
+            });
+            // Ensure we're in a Node.js environment by verifying window is undefined
+            (typeof window).should.equal('undefined');
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('User-Agent', 'TestAgent/1.0')
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => 'test-123',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+        it('should not set User-Agent header when running in browser (typeof window !== undefined)', async function () {
+            // Mock the window object to simulate browser environment
+            const windowStub = { location: 'mock' };
+            global.window = windowStub;
+            try {
+                const bitgo = new bitgoAPI_1.BitGoAPI({
+                    env: 'custom',
+                    customRootURI: 'https://app.example.local',
+                    userAgent: 'TestAgent/1.0',
+                });
+                const scope = (0, nock_1.default)('https://app.example.local')
+                    .get('/api/v1/ping')
+                    .reply(function () {
+                    // Verify User-Agent header is NOT set to our custom value
+                    const userAgent = this.req.headers['user-agent'];
+                    if (userAgent && userAgent.includes('TestAgent/1.0')) {
+                        throw new Error('User-Agent should not be set in browser environment');
+                    }
+                    return [200, { status: 'ok' }];
+                });
+                await bitgo.ping({
+                    reqId: {
+                        toString: () => 'test-123',
+                        inc: () => {
+                            /* mock */
+                        },
+                    },
+                });
+                scope.isDone().should.be.true();
+            }
+            finally {
+                // Clean up the global window mock
+                delete global.window;
+            }
+        });
+    });
+    describe('hmacAuthStrategy token lifecycle', function () {
+        const ROOT = 'https://app.example.local';
+        // Builds a mock strategy whose setToken / clearToken are sinon stubs.
+        function makeStrategy(overrides = {}) {
+            const setTokenStub = sinon.stub().resolves();
+            const clearTokenStub = sinon.stub().resolves();
+            const strategy = {
+                calculateRequestHeaders: sinon.stub().resolves({ hmac: 'hmac', timestamp: 1, tokenHash: 'hash' }),
+                verifyResponse: sinon.stub().resolves({
+                    isValid: true,
+                    expectedHmac: 'hmac',
+                    signatureSubject: '',
+                    isInResponseValidityWindow: true,
+                    verificationTime: Date.now(),
+                }),
+                calculateHMAC: sinon.stub().resolves('hashed-pw'),
+                setToken: setTokenStub,
+                clearToken: clearTokenStub,
+                ...overrides,
+            };
+            return { strategy, setTokenStub, clearTokenStub };
+        }
+        afterEach(function () {
+            nock_1.default.cleanAll();
+            sinon.restore();
+        });
+        describe('authenticate()', function () {
+            it('calls setToken with the access_token received from the server', async function () {
+                const { strategy, setTokenStub } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                (0, nock_1.default)(ROOT)
+                    .post('/api/auth/v1/session')
+                    .reply(200, {
+                    user: { username: 'test@example.com' },
+                    access_token: 'v2xmyaccesstoken',
+                });
+                await bitgo.authenticate({ username: 'test@example.com', password: 'hunter2' });
+                setTokenStub.calledOnce.should.be.true();
+                setTokenStub.firstCall.args[0].should.equal('v2xmyaccesstoken');
+            });
+            it('awaits setToken before making ensureEcdhKeychain requests', async function () {
+                // This is the core regression test: if setToken is not awaited, the
+                // strategy's key material won't be ready before calculateRequestHeaders
+                // is called for the GET /user/settings request, and it would throw.
+                let keyReady = false;
+                const { strategy } = makeStrategy({
+                    setToken: sinon.stub().callsFake(async () => {
+                        // Simulate non-trivial async key derivation (like crypto.subtle.importKey).
+                        await new Promise((resolve) => setImmediate(resolve));
+                        keyReady = true;
+                    }),
+                    calculateRequestHeaders: sinon.stub().callsFake(async () => {
+                        if (!keyReady) {
+                            throw new Error('No token available. Call setToken() or restoreToken() first.');
+                        }
+                        return { hmac: 'hmac', timestamp: Date.now(), tokenHash: 'hash' };
+                    }),
+                });
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                (0, nock_1.default)(ROOT)
+                    .post('/api/auth/v1/session')
+                    .reply(200, {
+                    user: { username: 'test@example.com' },
+                    access_token: 'v2xmytoken',
+                });
+                // The GET /user/settings request made by ensureUserEcdhKeychainIsCreated
+                // must succeed — it would throw if setToken wasn't awaited first.
+                (0, nock_1.default)(ROOT)
+                    .get('/api/v1/user/settings')
+                    .reply(200, {
+                    settings: { ecdhKeychain: 'xpub123' },
+                });
+                await bitgo.authenticate({
+                    username: 'test@example.com',
+                    password: 'hunter2',
+                    ensureEcdhKeychain: true,
+                });
+                keyReady.should.be.true();
+            });
+        });
+        describe('authenticateWithPasskey()', function () {
+            const validPasskey = JSON.stringify({
+                id: 'credential-id',
+                rawId: 'raw-id',
+                type: 'public-key',
+                response: {
+                    authenticatorData: 'auth-data',
+                    clientDataJSON: 'client-data',
+                    signature: 'sig',
+                    userHandle: 'user-handle-123',
+                },
+            });
+            it('calls setToken with the access_token received from the server', async function () {
+                const { strategy, setTokenStub } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                (0, nock_1.default)(ROOT)
+                    .post('/api/auth/v1/session')
+                    .reply(200, {
+                    user: { username: 'test@example.com' },
+                    access_token: 'v2xpasskeytoken',
+                });
+                await bitgo.authenticateWithPasskey(validPasskey);
+                setTokenStub.calledOnce.should.be.true();
+                setTokenStub.firstCall.args[0].should.equal('v2xpasskeytoken');
+            });
+        });
+        describe('clearAsync()', function () {
+            it('clears _token and calls clearToken on the strategy', async function () {
+                const { strategy, clearTokenStub } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                bitgo.authenticateWithAccessToken({ accessToken: 'v2xsometoken' });
+                bitgo._token.should.equal('v2xsometoken');
+                await bitgo.clearAsync();
+                (bitgo._token === undefined).should.be.true();
+                clearTokenStub.calledOnce.should.be.true();
+            });
+        });
+        describe('refreshToken()', function () {
+            it('calls setToken with the new access_token from the OAuth response', async function () {
+                const { strategy, setTokenStub } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({
+                    env: 'custom',
+                    customRootURI: ROOT,
+                    hmacAuthStrategy: strategy,
+                    clientId: 'client-id',
+                    clientSecret: 'client-secret',
+                });
+                bitgo._refreshToken = 'old-refresh-token';
+                (0, nock_1.default)(ROOT).post('/oauth/token').reply(200, {
+                    access_token: 'v2xnewtoken',
+                    refresh_token: 'new-refresh-token',
+                });
+                await bitgo.refreshToken();
+                setTokenStub.calledOnce.should.be.true();
+                setTokenStub.firstCall.args[0].should.equal('v2xnewtoken');
+            });
+        });
+        describe('authenticateWithAuthCode()', function () {
+            it('calls setToken with the access_token from the OAuth response', async function () {
+                const { strategy, setTokenStub } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({
+                    env: 'custom',
+                    customRootURI: ROOT,
+                    hmacAuthStrategy: strategy,
+                    clientId: 'client-id',
+                    clientSecret: 'client-secret',
+                });
+                (0, nock_1.default)(ROOT).post('/oauth/token').reply(200, {
+                    access_token: 'v2xauthcodetoken',
+                    refresh_token: 'refresh-token',
+                });
+                // authenticateWithAuthCode calls this.me() after setting the token
+                (0, nock_1.default)(ROOT)
+                    .get('/api/v1/user/me')
+                    .reply(200, {
+                    user: { username: 'test@example.com' },
+                });
+                await bitgo.authenticateWithAuthCode({ authCode: 'my-auth-code' });
+                setTokenStub.calledOnce.should.be.true();
+                setTokenStub.firstCall.args[0].should.equal('v2xauthcodetoken');
+            });
+        });
+        describe('sync token-setting methods', function () {
+            it('authenticateWithAccessToken does not call setToken (synchronous — caller must invoke setToken on the strategy manually)', function () {
+                const { strategy, setTokenStub } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                bitgo.authenticateWithAccessToken({ accessToken: 'v2xsynctoken' });
+                setTokenStub.called.should.be.false();
+            });
+            it('fromJSON does not call setToken (synchronous — caller must invoke setToken on the strategy manually)', function () {
+                const { strategy, setTokenStub } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                bitgo.fromJSON({ user: { username: 'test@example.com' }, token: 'v2xjsontoken' });
+                setTokenStub.called.should.be.false();
+            });
+        });
+        describe('addAccessToken()', function () {
+            const validParams = {
+                label: 'test-token',
+                scope: ['wallet_view_all'],
+                duration: 3600,
+            };
+            it('should force V1 auth and return plain token when ecdhXprv is absent, even if hmacAuthStrategy is authenticated (SSO/enterprise users)', async function () {
+                // Regression test for WCN-1790 / ANT-963: HMAC request signing and ECDH response
+                // encryption are orthogonal. forceV1Auth tells the server to return a plaintext token
+                // instead of ECDH-encrypting it. It must be set whenever ecdhXprv is absent,
+                // regardless of whether the HMAC strategy is active.
+                const { strategy } = makeStrategy({
+                    isAuthenticated: sinon.stub().returns(true),
+                });
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                // Do NOT set _ecdhXprv — simulates SSO/enterprise session (Okta, Entra, etc.)
+                bitgo.authenticateWithAccessToken({ accessToken: 'v2xstrategytoken' });
+                const scope = (0, nock_1.default)(ROOT).post('/api/auth/v1/accesstoken').reply(200, {
+                    token: 'v2xnewplaintoken',
+                    label: 'test-token',
+                });
+                const result = await bitgo.addAccessToken(validParams);
+                scope.isDone().should.be.true();
+                // forceV1Auth MUST be set — server returns plaintext token since we have no decryption key
+                result.warning.should.match(/protocol downgrade/);
+                result.token.should.equal('v2xnewplaintoken');
+            });
+            it('should not call handleTokenIssuance when ecdhXprv is present but the server returned a plaintext token', async function () {
+                const handleTokenSpy = sinon.spy(bitgoAPI_1.BitGoAPI.prototype, 'handleTokenIssuance');
+                const { strategy } = makeStrategy({
+                    isAuthenticated: sinon.stub().returns(true),
+                });
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                bitgo.fromJSON({
+                    user: { username: 'test@example.com' },
+                    token: 'a'.repeat(40),
+                    ecdhXprv: 'xprv-test-key',
+                });
+                (0, nock_1.default)(ROOT).post('/api/auth/v1/accesstoken').reply(200, {
+                    token: 'v2xplaintextfromv1',
+                    label: 'test-token',
+                });
+                try {
+                    const result = await bitgo.addAccessToken(validParams);
+                    handleTokenSpy.called.should.be.false();
+                    result.token.should.equal('v2xplaintextfromv1');
+                }
+                finally {
+                    handleTokenSpy.restore();
+                }
+            });
+            it('should not call handleTokenIssuance when ecdhXprv is absent', async function () {
+                const handleTokenSpy = sinon.spy(bitgoAPI_1.BitGoAPI.prototype, 'handleTokenIssuance');
+                const { strategy } = makeStrategy({
+                    isAuthenticated: sinon.stub().returns(true),
+                });
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                bitgo.authenticateWithAccessToken({ accessToken: 'v2xstrategytoken' });
+                (0, nock_1.default)(ROOT).post('/api/auth/v1/accesstoken').reply(200, {
+                    token: 'v2xplaintoken',
+                    label: 'test-token',
+                });
+                const result = await bitgo.addAccessToken(validParams);
+                // handleTokenIssuance must not be called — no ecdhXprv to decrypt with
+                handleTokenSpy.called.should.be.false();
+                result.token.should.equal('v2xplaintoken');
+                handleTokenSpy.restore();
+            });
+            it('should force V1 auth when ecdhXprv is absent and strategy is not authenticated', async function () {
+                const { strategy } = makeStrategy({
+                    isAuthenticated: sinon.stub().returns(false),
+                });
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                bitgo.authenticateWithAccessToken({ accessToken: 'v2xlegacytoken' });
+                (0, nock_1.default)(ROOT).post('/api/auth/v1/accesstoken').reply(200, {
+                    token: 'v2xlegacyresult',
+                    label: 'test-token',
+                });
+                const result = await bitgo.addAccessToken(validParams);
+                result.warning.should.match(/protocol downgrade/);
+            });
+            it('should force V1 auth when isAuthenticated is not defined on strategy', async function () {
+                const { strategy } = makeStrategy();
+                const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+                bitgo.authenticateWithAccessToken({ accessToken: 'v2xnoauthmethod' });
+                (0, nock_1.default)(ROOT).post('/api/auth/v1/accesstoken').reply(200, {
+                    token: 'v2xresult',
+                    label: 'test-token',
+                });
+                const result = await bitgo.addAccessToken(validParams);
+                // Without isAuthenticated, should fall back to V1 auth
+                result.warning.should.match(/protocol downgrade/);
+            });
+        });
+    });
+    describe('constants parameter', function () {
+        it('should allow passing constants via options and expose via fetchConstants', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                clientConstants: { maxFeeRate: '123123123123123' },
+            });
+            const constants = await bitgo.fetchConstants();
+            constants.should.have.property('maxFeeRate', '123123123123123');
+        });
+        it('should refresh constants when cache has expired', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            // Set up cached constants with an expired cache
+            bitgoAPI_1.BitGoAPI._constants = bitgoAPI_1.BitGoAPI._constants || {};
+            bitgoAPI_1.BitGoAPI._constantsExpire = bitgoAPI_1.BitGoAPI._constantsExpire || {};
+            bitgoAPI_1.BitGoAPI._constants['custom'] = { maxFeeRate: 'old-value' };
+            bitgoAPI_1.BitGoAPI._constantsExpire['custom'] = new Date(Date.now() - 1000); // Expired 1 second ago
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/client/constants')
+                .reply(200, {
+                constants: { maxFeeRate: 'new-value', newConstant: 'added' },
+            });
+            const constants = await bitgo.fetchConstants();
+            // Should return the new constants from the server
+            constants.should.have.property('maxFeeRate', 'new-value');
+            constants.should.have.property('newConstant', 'added');
+            scope.isDone().should.be.true();
+            nock_1.default.cleanAll();
+        });
+        it('should use cached constants when cache is still valid', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            // Set up cached constants with a future expiry
+            const cachedConstants = { maxFeeRate: 'cached-value', anotherSetting: 'cached-setting' };
+            bitgoAPI_1.BitGoAPI._constants = bitgoAPI_1.BitGoAPI._constants || {};
+            bitgoAPI_1.BitGoAPI._constantsExpire = bitgoAPI_1.BitGoAPI._constantsExpire || {};
+            bitgoAPI_1.BitGoAPI._constants['custom'] = cachedConstants;
+            bitgoAPI_1.BitGoAPI._constantsExpire['custom'] = new Date(Date.now() + 5 * 60 * 1000); // Valid for 5 more minutes
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/client/constants')
+                .reply(200, { constants: { shouldNotBeUsed: true } });
+            const constants = await bitgo.fetchConstants();
+            // Should return the cached constants
+            constants.should.deepEqual(cachedConstants);
+            // Verify that no HTTP request was made (since cache was valid)
+            scope.isDone().should.be.false();
+            nock_1.default.cleanAll();
+        });
+        it('should use cached constants when no cache expiry is set', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            // Set up cached constants with no expiry
+            const cachedConstants = { maxFeeRate: 'no-expiry-value' };
+            bitgoAPI_1.BitGoAPI._constants = bitgoAPI_1.BitGoAPI._constants || {};
+            bitgoAPI_1.BitGoAPI._constantsExpire = bitgoAPI_1.BitGoAPI._constantsExpire || {};
+            bitgoAPI_1.BitGoAPI._constants['custom'] = cachedConstants;
+            bitgoAPI_1.BitGoAPI._constantsExpire['custom'] = undefined;
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/client/constants')
+                .reply(200, { constants: { shouldNotBeUsed: true } });
+            const constants = await bitgo.fetchConstants();
+            // Should return the cached constants
+            constants.should.deepEqual(cachedConstants);
+            // Verify that no HTTP request was made (since no expiry means cache is always valid)
+            scope.isDone().should.be.false();
+            nock_1.default.cleanAll();
+        });
+    });
+    describe('packKeychainsFFD', function () {
+        let bitgo;
+        before(function () {
+            bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: 'https://app.example.local' });
+        });
+        function ffd(keychains, v2Keychains, maxBatchSizeBytes) {
+            return bitgo.packKeychainsFFD(keychains, v2Keychains, maxBatchSizeBytes);
+        }
+        it('returns an empty array when both inputs are empty', function () {
+            const bins = ffd({}, {}, 1024);
+            bins.should.be.an.Array();
+            bins.should.have.length(0);
+        });
+        it('packs all items into a single bin when they fit within the limit', function () {
+            // Each entry: 2-byte id + 10-byte value = 12 bytes; 5 entries = 60 bytes < 200 limit
+            const keychains = { k1: 'aaaaaaaaaa', k2: 'bbbbbbbbbb', k3: 'cccccccccc' };
+            const v2Keychains = { v1: 'dddddddddd', v2: 'eeeeeeeeee' };
+            const bins = ffd(keychains, v2Keychains, 200);
+            bins.should.have.length(1);
+            Object.keys(bins[0].v1Batch).should.have.length(3);
+            Object.keys(bins[0].v2Batch).should.have.length(2);
+        });
+        it('splits into multiple bins when a single bin cannot fit all items', function () {
+            // id='k1' (2 bytes) + 600-char value = 602 bytes; 2 entries exceed 700-byte limit
+            const keychains = { k1: 'x'.repeat(600), k2: 'y'.repeat(600) };
+            const bins = ffd(keychains, {}, 700);
+            bins.should.have.length(2);
+        });
+        it('throws when a single item exceeds maxBatchSizeBytes', function () {
+            // id='k1' (2 bytes) + 200-char value = 202 bytes > 100-byte limit
+            const keychains = { k1: 'x'.repeat(200) };
+            try {
+                ffd(keychains, {}, 100);
+                throw new Error('Expected error not thrown');
+            }
+            catch (e) {
+                e.message.should.match(/exceeds the maximum batch size/);
+            }
+        });
+        it('places V1 keychains in v1Batch and V2 keychains in v2Batch', function () {
+            const keychains = { k1: 'v1value' };
+            const v2Keychains = { k2: 'v2value' };
+            const bins = ffd(keychains, v2Keychains, 10000);
+            bins.should.have.length(1);
+            bins[0].v1Batch.should.have.property('k1', 'v1value');
+            bins[0].v2Batch.should.have.property('k2', 'v2value');
+            bins[0].v1Batch.should.not.have.property('k2');
+            bins[0].v2Batch.should.not.have.property('k1');
+        });
+        it('uses FFD ordering so the largest item is packed first', function () {
+            // 'big': id(3) + 497 bytes = 500 bytes; 's1','s2': id(2) + 98 bytes = 100 bytes each
+            // maxBatchSizeBytes = 600
+            // FFD order (descending): big(500), s1(100), s2(100)
+            //   bin0: big(500). s1: 500+100=600 <=600, fits. s2: 600+100=700 > 600, new bin1.
+            //   Result: bin0={big,s1}, bin1={s2}
+            const keychains = { big: 'x'.repeat(497), s1: 'y'.repeat(98), s2: 'z'.repeat(98) };
+            const bins = ffd(keychains, {}, 600);
+            bins.should.have.length(2);
+            // 'big' should share its bin with one small item (FFD packs the largest first)
+            const binWithBig = bins.find((b) => 'big' in b.v1Batch);
+            Object.keys(binWithBig.v1Batch).should.have.length(2);
+        });
+    });
+    describe('processKeychainPasswordUpdatesInBatches', function () {
+        const ROOT = 'https://app.example.local';
+        let bitgo;
+        beforeEach(function () {
+            const strategy = {
+                calculateRequestHeaders: sinon.stub().resolves({ hmac: 'hmac', timestamp: Date.now(), tokenHash: 'hash' }),
+                verifyResponse: sinon.stub().resolves({
+                    isValid: true,
+                    expectedHmac: 'hmac',
+                    signatureSubject: '',
+                    isInResponseValidityWindow: true,
+                    verificationTime: Date.now(),
+                }),
+                calculateHMAC: sinon.stub().resolves('hashed-pw'),
+                setToken: sinon.stub().resolves(),
+                clearToken: sinon.stub().resolves(),
+            };
+            bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+        });
+        afterEach(function () {
+            nock_1.default.cleanAll();
+            sinon.restore();
+        });
+        async function runBatches(keychains, v2Keychains, maxBatchSizeKB, maxRetries = 3) {
+            return bitgo.processKeychainPasswordUpdatesInBatches(keychains, v2Keychains, maxBatchSizeKB, maxRetries);
+        }
+        it('makes a single PUT request for a small payload', async function () {
+            const scope = (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').reply(200, {});
+            await runBatches({ k1: 'small' }, {}, 1024);
+            scope.isDone().should.be.true();
+        });
+        it('makes two PUT requests when the payload spans two bins', async function () {
+            // id='k1'(2) + 600 = 602 bytes each; 2 entries exceed 1 KB limit => 2 bins
+            const keychains = { k1: 'x'.repeat(600), k2: 'y'.repeat(600) };
+            const scope = (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').twice().reply(200, {});
+            await runBatches(keychains, {}, 1);
+            scope.isDone().should.be.true();
+        });
+        it('retries a failed batch and succeeds on the second attempt', async function () {
+            (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').reply(500, { error: 'internal error' });
+            (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').reply(200, {});
+            // Should not throw
+            await runBatches({ k1: 'value' }, {}, 1024, 3);
+        });
+        it('throws after exhausting all retries on persistent HTTP errors', async function () {
+            (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').times(3).reply(500, { error: 'internal error' });
+            let thrownError;
+            try {
+                await runBatches({ k1: 'value' }, {}, 1024, 3);
+            }
+            catch (e) {
+                thrownError = e;
+            }
+            thrownError.message.should.match(/failed after 3 retries/);
+        });
+        it('throws after exhausting all retries when the server reports failed keychains', async function () {
+            (0, nock_1.default)(ROOT)
+                .put('/api/v2/user/keychains')
+                .times(3)
+                .reply(200, { failed: { v1: { k1: 'encryption error' } } });
+            let thrownError;
+            try {
+                await runBatches({ k1: 'value' }, {}, 1024, 3);
+            }
+            catch (e) {
+                thrownError = e;
+            }
+            thrownError.message.should.match(/had failed keychains/);
+        });
+        it('issues one empty PUT when both keychain maps are empty', async function () {
+            const scope = (0, nock_1.default)(ROOT).put('/api/v2/user/keychains', { keychains: {}, v2_keychains: {} }).reply(200, {});
+            await runBatches({}, {}, 1024);
+            scope.isDone().should.be.true();
+        });
+    });
+    describe('changePassword batching flow', function () {
+        const ROOT = 'https://app.example.local';
+        let bitgo;
+        let sandbox;
+        let v1UpdatePasswordStub;
+        let v2UpdatePasswordStub;
+        beforeEach(function () {
+            sandbox = sinon.createSandbox();
+            const strategy = {
+                calculateRequestHeaders: sandbox.stub().resolves({ hmac: 'hmac', timestamp: Date.now(), tokenHash: 'hash' }),
+                verifyResponse: sandbox.stub().resolves({
+                    isValid: true,
+                    expectedHmac: 'hmac',
+                    signatureSubject: '',
+                    isInResponseValidityWindow: true,
+                    verificationTime: Date.now(),
+                }),
+                calculateHMAC: sandbox.stub().resolves('hashed-pw'),
+                setToken: sandbox.stub().resolves(),
+                clearToken: sandbox.stub().resolves(),
+            };
+            bitgo = new bitgoAPI_1.BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });
+            bitgo._user = { username: 'test@bitgo.com' };
+            sandbox.stub(bitgo, 'verifyPassword').resolves(true);
+            v1UpdatePasswordStub = sandbox.stub().resolves({ keychains: { k1: 'v1enc' }, version: 25 });
+            sandbox.stub(bitgo, 'keychains').returns({
+                updatePassword: v1UpdatePasswordStub,
+            });
+            v2UpdatePasswordStub = sandbox.stub().resolves({ v2k1: 'v2enc' });
+            sandbox.stub(bitgo, 'coin').returns({
+                keychains: () => ({
+                    updatePassword: v2UpdatePasswordStub,
+                }),
+            });
+        });
+        afterEach(function () {
+            nock_1.default.cleanAll();
+            sandbox.restore();
+        });
+        it('calls PUT /user/keychains and POST /user/changepassword without keychains when batching is enabled', async function () {
+            (0, nock_1.default)(ROOT)
+                .get('/api/v2/user/checkBatchingPasswordFlow')
+                .query(true)
+                .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });
+            const batchPutScope = (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').reply(200, {});
+            const changePassScope = (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !body.keychains && !body.v2_keychains)
+                .reply(200, {});
+            await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });
+            batchPutScope.isDone().should.be.true();
+            changePassScope.isDone().should.be.true();
+        });
+        it('stages an empty batch and changes password when no keychains are re-encryptable', async function () {
+            v1UpdatePasswordStub.resolves({ keychains: {}, version: 25 });
+            v2UpdatePasswordStub.resolves({});
+            (0, nock_1.default)(ROOT)
+                .get('/api/v2/user/checkBatchingPasswordFlow')
+                .query(true)
+                .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });
+            const batchPutScope = (0, nock_1.default)(ROOT)
+                .put('/api/v2/user/keychains', { keychains: {}, v2_keychains: {} })
+                .reply(200, {});
+            const changePassScope = (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !body.keychains && !body.v2_keychains)
+                .reply(200, {});
+            await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });
+            batchPutScope.isDone().should.be.true();
+            changePassScope.isDone().should.be.true();
+        });
+        it('sends keychains in the POST body (legacy flow) when the server disables batching', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            const legacyScope = (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });
+            legacyScope.isDone().should.be.true();
+        });
+        it('falls back to legacy flow when the batching check request fails', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(503, { error: 'service unavailable' });
+            const legacyScope = (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });
+            legacyScope.isDone().should.be.true();
+        });
+        it('forwards encryptionVersion to both v1 and v2 keychains().updatePassword calls', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw', encryptionVersion: 2 });
+            sinon.assert.calledWithMatch(v1UpdatePasswordStub, { encryptionVersion: 2 });
+            sinon.assert.calledWithMatch(v2UpdatePasswordStub, { encryptionVersion: 2 });
+        });
+        it('creates one encryption session, passes it to both keychain update calls, and destroys it', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => {
+                if (!body || typeof body !== 'object') {
+                    return false;
+                }
+                return 'keychains' in body && 'v2_keychains' in body;
+            })
+                .reply(200, {});
+            const destroy = sandbox.stub();
+            const session = {
+                encrypt: sandbox.stub().resolves('session-encrypted'),
+                decrypt: sandbox.stub().resolves('session-decrypted'),
+                destroy,
+            };
+            const createSession = sandbox.stub(bitgo, 'createEncryptionSession').resolves(session);
+            await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw', encryptionVersion: 2 });
+            sinon.assert.calledOnce(createSession);
+            sinon.assert.calledWithExactly(createSession, 'newpw', 2);
+            // Call-site truth: the params object reaches both updatePassword calls, but the
+            // deprecated v1-leg (src/v1/keychains.ts) ignores encryptionSession/encryptionVersion
+            // and preserves each envelope's version -- see test/unit/v1/keychains.ts. Only the
+            // coin-leg consumes the session.
+            sinon.assert.calledWithMatch(v1UpdatePasswordStub, {
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+            });
+            sinon.assert.calledWithMatch(v1UpdatePasswordStub, {
+                encryptionVersion: 2,
+                encryptionSession: session,
+            });
+            sinon.assert.calledWithMatch(v2UpdatePasswordStub, {
+                encryptionVersion: 2,
+                encryptionSession: session,
+            });
+            sinon.assert.calledOnce(destroy);
+        });
+        it('emits keychains/started, monotonic keychains/updated events, then finalizing/started and finalizing/completed', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            v1UpdatePasswordStub.callsFake(async (params) => {
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });
+                params.progressCallback?.({ status: 'skipped', currentKeychainId: 'xpub2' });
+                // one map entry per emitted event, since the map's size now feeds the v2 total
+                return { keychains: { k1: 'v1enc', k2: 'v1enc2' }, version: 25 };
+            });
+            v2UpdatePasswordStub.callsFake(async (params) => {
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub3' });
+                return { v2k1: 'v2enc' };
+            });
+            const events = [];
+            await bitgo.changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: (progress) => events.push(progress),
+            });
+            events.should.deepEqual([
+                { phase: 'keychains', status: 'started', completed: 0, attempted: 0, succeeded: 0, skipped: 0 },
+                {
+                    phase: 'keychains',
+                    status: 'updated',
+                    completed: 1,
+                    attempted: 1,
+                    succeeded: 1,
+                    skipped: 0,
+                    total: undefined,
+                    currentKeychainId: 'xpub1',
+                    keychainVersion: 'v1',
+                },
+                {
+                    phase: 'keychains',
+                    status: 'updated',
+                    completed: 2,
+                    attempted: 2,
+                    succeeded: 1,
+                    skipped: 1,
+                    total: undefined,
+                    currentKeychainId: 'xpub2',
+                    keychainVersion: 'v1',
+                },
+                {
+                    phase: 'keychains',
+                    status: 'updated',
+                    completed: 3,
+                    attempted: 3,
+                    succeeded: 2,
+                    skipped: 1,
+                    total: undefined,
+                    currentKeychainId: 'xpub3',
+                    keychainVersion: 'v2',
+                },
+                { phase: 'finalizing', status: 'started' },
+                { phase: 'finalizing', status: 'completed' },
+            ]);
+        });
+        it('forwards a truthful total from the v2 lower-level callback into every keychains/updated event', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            v2UpdatePasswordStub.callsFake(async (params) => {
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1', total: 2 });
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub2', total: 2 });
+                return { v2k1: 'v2enc', v2k2: 'v2enc2' };
+            });
+            const events = [];
+            await bitgo.changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: (progress) => events.push(progress),
+            });
+            const v2Events = events.filter((e) => e.phase === 'keychains' && e.status === 'updated' && e.keychainVersion === 'v2');
+            // the v1 stub keeps its default 1-entry map, so v2 events forward 1 (v1) + 2 (v2) = 3
+            v2Events.every((e) => e.total === 3).should.be.true();
+        });
+        it('covers both keychain sets in the total so mixed v1/v2 accounts complete exactly (2 v1 + 32 v2 = 34 of 34)', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            v1UpdatePasswordStub.callsFake(async (params) => {
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub2' });
+                return { keychains: { k1: 'v1enc', k2: 'v1enc2' }, version: 25 };
+            });
+            v2UpdatePasswordStub.callsFake(async (params) => {
+                for (let i = 1; i <= 32; i++) {
+                    params.progressCallback?.({ status: 'updated', currentKeychainId: `v2key-${i}`, total: 32 });
+                }
+                return { v2k1: 'v2enc' };
+            });
+            const events = [];
+            await bitgo.changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: (progress) => events.push(progress),
+            });
+            const keychainEvents = events.filter((e) => e.phase === 'keychains' && e.status === 'updated');
+            const v1Events = keychainEvents.filter((e) => e.keychainVersion === 'v1');
+            const v2Events = keychainEvents.filter((e) => e.keychainVersion === 'v2');
+            // v1 events stay indeterminate: the v1 set has no server-provided count
+            v1Events.should.have.length(2);
+            v1Events.every((e) => e.total === undefined).should.be.true();
+            // v2 events carry the combined denominator: 2 (v1 set) + 32 (totalCount)
+            v2Events.should.have.length(32);
+            v2Events.every((e) => e.total === 34).should.be.true();
+            // the counter completes exactly instead of overshooting the total
+            const last = v2Events[v2Events.length - 1];
+            last.completed.should.equal(34);
+            last.total.should.equal(34);
+        });
+        it('emits a terminal total for v1-only accounts so the counter can render n of n', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            v1UpdatePasswordStub.callsFake(async (params) => {
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub2' });
+                return { keychains: { k1: 'v1enc', k2: 'v1enc2' }, version: 25 };
+            });
+            // a v1-only account: the v2 walk finds nothing and emits nothing
+            v2UpdatePasswordStub.callsFake(async () => ({}));
+            const events = [];
+            await bitgo.changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: (progress) => events.push(progress),
+            });
+            const keychainEvents = events.filter((e) => e.phase === 'keychains' && e.status === 'updated');
+            const v1Events = keychainEvents.filter((e) => e.keychainVersion === 'v1');
+            v1Events.should.have.length(2);
+            v1Events.every((e) => e.total === undefined).should.be.true();
+            // no v2 event ever arrived, so the terminal keychains/updated event carries the
+            // client-known v1 set size as the denominator: 2 of 2, immediately before finalizing
+            const last = keychainEvents[keychainEvents.length - 1];
+            last.completed.should.equal(2);
+            last.total.should.equal(2);
+            events[events.length - 2].should.deepEqual({ phase: 'finalizing', status: 'started' });
+        });
+        it('does not let a throwing progressCallback abort the rotation', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });
+            const changePassScope = (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            await bitgo.changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: () => {
+                    throw new Error('observer boom');
+                },
+            });
+            changePassScope.isDone().should.be.true();
+        });
+        it('emits no finalizing/completed and no legacy fallback when the batching-path final POST fails', async function () {
+            (0, nock_1.default)(ROOT)
+                .get('/api/v2/user/checkBatchingPasswordFlow')
+                .query(true)
+                .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });
+            (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').reply(200, {});
+            const changePassScope = (0, nock_1.default)(ROOT).post('/api/v1/user/changepassword').reply(500, { error: 'boom' });
+            const events = [];
+            await bitgo
+                .changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: (progress) => events.push(progress),
+            })
+                .should.be.rejected();
+            changePassScope.isDone().should.be.true();
+            events.some((e) => e.phase === 'finalizing' && e.status === 'completed').should.be.false();
+        });
+        it('completes exactly once via legacy fallback when the batching check fails', async function () {
+            (0, nock_1.default)(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(503, { error: 'service unavailable' });
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !!body.keychains && !!body.v2_keychains)
+                .reply(200, {});
+            const events = [];
+            await bitgo.changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: (progress) => events.push(progress),
+            });
+            events.filter((e) => e.phase === 'finalizing' && e.status === 'completed').should.have.length(1);
+        });
+        it('does not add keychain events or double-count when a transport batch is retried', async function () {
+            (0, nock_1.default)(ROOT)
+                .get('/api/v2/user/checkBatchingPasswordFlow')
+                .query(true)
+                .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });
+            (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').reply(500, { error: 'transient' });
+            (0, nock_1.default)(ROOT).put('/api/v2/user/keychains').reply(200, {});
+            (0, nock_1.default)(ROOT)
+                .post('/api/v1/user/changepassword', (body) => !body.keychains && !body.v2_keychains)
+                .reply(200, {});
+            v1UpdatePasswordStub.callsFake(async (params) => {
+                params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });
+                return { keychains: { k1: 'v1enc' }, version: 25 };
+            });
+            const events = [];
+            await bitgo.changePassword({
+                oldPassword: 'oldpw',
+                newPassword: 'newpw',
+                progressCallback: (progress) => events.push(progress),
+            });
+            const keychainEvents = events.filter((e) => e.phase === 'keychains' && e.status === 'updated');
+            // one real keychain event plus the terminal denominator event for this v1-only
+            // account — the retried transport must contribute neither a duplicate event
+            // nor a double-count to either
+            keychainEvents.should.have.length(2);
+            keychainEvents[0].should.have.properties({ succeeded: 1, skipped: 0, attempted: 1, completed: 1 });
+            keychainEvents[1].should.have.properties({ succeeded: 1, skipped: 0, attempted: 1, completed: 1, total: 1 });
+        });
+    });
+    describe('createUserEcdhKeychain - encryptionVersion threading', function () {
+        const ROOT = 'https://app.bitgo-test.com';
+        let bitgo;
+        beforeEach(function () {
+            bitgo = new bitgoAPI_1.BitGoAPI({ env: 'test' });
+        });
+        afterEach(function () {
+            nock_1.default.cleanAll();
+            sinon.restore();
+        });
+        it('passes encryptionVersion: 2 to encrypt', async function () {
+            const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');
+            (0, nock_1.default)(ROOT).post('/api/v1/keychain').reply(200, { xpub: 'xpub123', id: 'key-id' });
+            await bitgo.createUserEcdhKeychain('loginPassword', 2);
+            assert.ok(encryptAsyncSpy.calledOnce);
+            assert.strictEqual(encryptAsyncSpy.firstCall.args[0].encryptionVersion, 2);
+        });
+        it('passes encryptionVersion: undefined when not set (defaults to v1)', async function () {
+            const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');
+            (0, nock_1.default)(ROOT).post('/api/v1/keychain').reply(200, { xpub: 'xpub123', id: 'key-id' });
+            await bitgo.createUserEcdhKeychain('loginPassword');
+            assert.ok(encryptAsyncSpy.calledOnce);
+            assert.strictEqual(encryptAsyncSpy.firstCall.args[0].encryptionVersion, undefined);
+        });
+    });
+    describe('splitSecret - encryptionVersion threading', function () {
+        let bitgo;
+        beforeEach(function () {
+            bitgo = new bitgoAPI_1.BitGoAPI({ env: 'test' });
+        });
+        afterEach(function () {
+            sinon.restore();
+        });
+        it('passes encryptionVersion: 2 to every encrypt shard call', async function () {
+            const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');
+            const passwords = ['pw1', 'pw2', 'pw3'];
+            await bitgo.splitSecret({
+                seed: 'a'.repeat(64),
+                passwords,
+                m: 2,
+                encryptionVersion: 2,
+            });
+            assert.strictEqual(encryptAsyncSpy.callCount, 3, 'should encrypt each shard');
+            for (const call of encryptAsyncSpy.getCalls()) {
+                assert.strictEqual(call.args[0].encryptionVersion, 2);
+            }
+        });
+        it('passes encryptionVersion: undefined when not set', async function () {
+            const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');
+            await bitgo.splitSecret({
+                seed: 'b'.repeat(64),
+                passwords: ['pw1', 'pw2'],
+                m: 2,
+            });
+            assert.strictEqual(encryptAsyncSpy.callCount, 2);
+            for (const call of encryptAsyncSpy.getCalls()) {
+                assert.strictEqual(call.args[0].encryptionVersion, undefined);
+            }
+        });
+    });
+});
+describe('wallets() v1 facade', function () {
+    it('returns BitGoApiV1Wallets with bitgo reference and all prototype methods', function () {
+        const bitgo = new bitgoAPI_1.BitGoAPI({ env: 'test' });
+        const wallets = bitgo.wallets();
+        wallets.bitgo.should.equal(bitgo);
+        wallets.list.should.be.a.Function();
+        wallets.get.should.be.a.Function();
+        wallets.getWallet.should.be.a.Function();
+        wallets.add.should.be.a.Function();
+        wallets.remove.should.be.a.Function();
+        wallets.acceptShare.should.be.a.Function();
+        wallets.createWalletWithKeychains.should.be.a.Function();
+        wallets.createForwardWallet.should.be.a.Function();
+        wallets.createKey.should.be.a.Function();
+        wallets.listInvites.should.be.a.Function();
+        wallets.cancelInvite.should.be.a.Function();
+        wallets.listShares.should.be.a.Function();
+        wallets.getShare.should.be.a.Function();
+        wallets.updateShare.should.be.a.Function();
+        wallets.cancelShare.should.be.a.Function();
+        wallets.resendShareInvite.should.be.a.Function();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bitgoAPI.js","sourceRoot":"","sources":["../../../test/unit/bitgoAPI.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport 'should';\nimport { BitGoAPI } from '../../src/bitgoAPI';\nimport { ProxyAgent } from 'proxy-agent';\nimport * as sinon from 'sinon';\nimport nock from 'nock';\nimport type { IHmacAuthStrategy } from '@bitgo-beta/sdk-hmac';\nimport type { IEncryptionSession } from '@bitgo-beta/sdk-core';\nimport type { PasswordRotationProgress } from '../../src/types';\n\ndescribe('Constructor', function () {\n  describe('cookiesPropagationEnabled argument', function () {\n    it('cookiesPropagationEnabled is enabled explicitly', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        cookiesPropagationEnabled: true,\n      });\n\n      bitgo.should.have.property('cookiesPropagationEnabled');\n      bitgo.cookiesPropagationEnabled.should.equal(true);\n    });\n\n    it('cookiesPropagationEnabled is disabled explicitly', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        cookiesPropagationEnabled: false,\n      });\n\n      bitgo.should.have.property('cookiesPropagationEnabled');\n      bitgo.cookiesPropagationEnabled.should.equal(false);\n    });\n\n    it('cookiesPropagationEnabled is disabled by default', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      bitgo.should.have.property('cookiesPropagationEnabled');\n      bitgo.cookiesPropagationEnabled.should.equal(false);\n    });\n  });\n\n  describe('requestIdPrefix argument', function () {\n    afterEach(function () {\n      nock.cleanAll();\n    });\n\n    it('should prepend requestIdPrefix to Request-ID header when set', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        requestIdPrefix: 'test-prefix-',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', /^test-prefix-/)\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => '12345',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should not modify Request-ID header when requestIdPrefix is not set', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', /^12345$/)\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => '12345',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should correctly format Request-ID with prefix and numeric sequence', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        requestIdPrefix: 'myapp-v1-',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', 'myapp-v1-trace-123')\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => 'trace-123',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should work with empty string prefix', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        requestIdPrefix: '',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', 'abc-123')\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => 'abc-123',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n  });\n  describe('http proxy agent', function () {\n    it('http proxy agent shall be created when proxy(customProxyagent) is set', function () {\n      const customProxyAgent = new ProxyAgent({\n        getProxyForUrl: () => 'http://localhost:3000',\n      });\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        customProxyAgent,\n      });\n\n      bitgo.should.have.property('_customProxyAgent', customProxyAgent);\n    });\n\n    it('bitgo api is still initiated when proxy(customProxyAgent) is not set', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      bitgo.should.have.property('_customProxyAgent', undefined);\n    });\n  });\n\n  describe('verifyAddress', function () {\n    it('should successfully verify a base58 address', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n      });\n\n      bitgo.verifyAddress({ address: '2N6paT2TU4N1XpaZjJiApWJXoeyrL3UWpkZ' }).should.be.true();\n    });\n\n    it('should successfully verify a bech32 address', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n      });\n\n      bitgo\n        .verifyAddress({ address: 'tb1qguzyk4w6kaqtpsczs5aj0w8r7598jq36egm8e98wqph3rwmex68seslgsg' })\n        .should.be.true();\n    });\n  });\n\n  describe('url', function () {\n    it('should return the correct URL for version 1', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';\n      const result = bitgo.url(path, 1);\n      result.should.equal(expectedUrl);\n    });\n\n    it('should return the correct URL for version 2', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v2/test-path';\n      const result = bitgo.url(path, 2);\n      result.should.equal(expectedUrl);\n    });\n\n    it('should return the correct URL for version 3', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v3/test-path';\n      const result = bitgo.url(path, 3);\n      result.should.equal(expectedUrl);\n    });\n\n    it('should default to version 1 if no version is provided', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';\n      const result = bitgo.url(path);\n      result.should.equal(expectedUrl);\n    });\n  });\n\n  describe('decryptKeys', function () {\n    let bitgo: BitGoAPI;\n\n    beforeEach(function () {\n      bitgo = new BitGoAPI({ env: 'test' });\n    });\n\n    afterEach(function () {\n      sinon.restore();\n    });\n\n    it('should throw if no params are provided', async function () {\n      // @ts-expect-error - intentionally calling with no params for test\n      await bitgo.decryptKeys().should.be.rejectedWith('Missing parameter: walletIdEncryptedKeyPairs');\n    });\n\n    it('should throw if walletIdEncryptedKeyPairs is missing', async function () {\n      await bitgo\n        // @ts-expect-error - intentionally missing required param\n        .decryptKeys({ password: 'password123' })\n        .should.be.rejectedWith('Missing parameter: walletIdEncryptedKeyPairs');\n    });\n\n    it('should throw if password is missing', async function () {\n      // @ts-expect-error - intentionally missing required param\n      await bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [] }).should.be.rejectedWith('Missing parameter: password');\n    });\n\n    it('should throw if walletIdEncryptedKeyPairs is not an array', async function () {\n      await bitgo\n        // @ts-expect-error - intentionally providing wrong type\n        .decryptKeys({ walletIdEncryptedKeyPairs: 'not an array', password: 'password123' })\n        .should.be.rejectedWith('walletIdEncryptedKeyPairs must be an array');\n    });\n\n    it('should return empty array for empty walletIdEncryptedKeyPairs', async function () {\n      const result = await bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [], password: 'password123' });\n      result.should.be.an.Array();\n      result.should.be.empty();\n    });\n\n    it('should throw if any walletId is missing or not a string', async function () {\n      await bitgo\n        .decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            // @ts-expect-error - intentionally missing walletId\n            { encryptedPrv: 'encrypted-data' },\n          ],\n          password: 'password123',\n        })\n        .should.be.rejectedWith('each key pair must have a string walletId');\n\n      await bitgo\n        .decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            // @ts-expect-error - intentionally providing wrong type\n            { walletId: 123, encryptedPrv: 'encrypted-data' },\n          ],\n          password: 'password123',\n        })\n        .should.be.rejectedWith('each key pair must have a string walletId');\n    });\n\n    it('should throw if any encryptedPrv is missing or not a string', async function () {\n      await bitgo\n        .decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            // @ts-expect-error - intentionally missing encryptedPrv\n            { walletId: 'wallet-id-1' },\n          ],\n          password: 'password123',\n        })\n        .should.be.rejectedWith('each key pair must have a string encryptedPrv');\n\n      await bitgo\n        .decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            // @ts-expect-error - intentionally providing wrong type\n            { walletId: 'wallet-id-1', encryptedPrv: 123 },\n          ],\n          password: 'password123',\n        })\n        .should.be.rejectedWith('each key pair must have a string encryptedPrv');\n    });\n  });\n\n  describe('decryptKeys', function () {\n    let bitgo: BitGoAPI;\n\n    beforeEach(function () {\n      bitgo = new BitGoAPI({ env: 'test' });\n    });\n\n    afterEach(function () {\n      sinon.restore();\n    });\n\n    it('should return walletIds of keys that failed to decrypt', async function () {\n      const decryptAsyncStub = sinon.stub(bitgo, 'decrypt');\n      decryptAsyncStub.onFirstCall().resolves('decrypted-key-1');\n      decryptAsyncStub.onSecondCall().rejects(new Error('decryption failed'));\n\n      const result = await bitgo.decryptKeys({\n        walletIdEncryptedKeyPairs: [\n          { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },\n          { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },\n        ],\n        password: 'password123',\n      });\n\n      result.should.be.an.Array();\n      result.should.have.length(1);\n      result[0].should.equal('wallet-id-2');\n    });\n\n    it('should correctly process multiple wallet keys', async function () {\n      const decryptAsyncStub = sinon.stub(bitgo, 'decrypt');\n      decryptAsyncStub\n        .withArgs({ input: 'encrypted-data-2', password: 'password123' })\n        .rejects(new Error('decryption failed'));\n      decryptAsyncStub\n        .withArgs({ input: 'encrypted-data-4', password: 'password123' })\n        .rejects(new Error('decryption failed'));\n      decryptAsyncStub.resolves('success');\n\n      const result = await bitgo.decryptKeys({\n        walletIdEncryptedKeyPairs: [\n          { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },\n          { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },\n          { walletId: 'wallet-id-3', encryptedPrv: 'encrypted-data-3' },\n          { walletId: 'wallet-id-4', encryptedPrv: 'encrypted-data-4' },\n        ],\n        password: 'password123',\n      });\n\n      decryptAsyncStub.callCount.should.equal(4);\n      result.should.be.an.Array();\n      result.should.have.length(2);\n      result.should.containDeep(['wallet-id-2', 'wallet-id-4']);\n    });\n  });\n\n  describe('User-Agent header based on environment', function () {\n    afterEach(function () {\n      nock.cleanAll();\n      sinon.restore();\n    });\n\n    it('should set User-Agent header when running in Node.js (typeof window === undefined)', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        userAgent: 'TestAgent/1.0',\n      });\n\n      // Ensure we're in a Node.js environment by verifying window is undefined\n      (typeof window).should.equal('undefined');\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('User-Agent', 'TestAgent/1.0')\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => 'test-123',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should not set User-Agent header when running in browser (typeof window !== undefined)', async function () {\n      // Mock the window object to simulate browser environment\n      const windowStub = { location: 'mock' };\n      (global as any).window = windowStub;\n\n      try {\n        const bitgo = new BitGoAPI({\n          env: 'custom',\n          customRootURI: 'https://app.example.local',\n          userAgent: 'TestAgent/1.0',\n        });\n\n        const scope = nock('https://app.example.local')\n          .get('/api/v1/ping')\n          .reply(function () {\n            // Verify User-Agent header is NOT set to our custom value\n            const userAgent = this.req.headers['user-agent'];\n            if (userAgent && userAgent.includes('TestAgent/1.0')) {\n              throw new Error('User-Agent should not be set in browser environment');\n            }\n            return [200, { status: 'ok' }];\n          });\n\n        await bitgo.ping({\n          reqId: {\n            toString: () => 'test-123',\n            inc: () => {\n              /* mock */\n            },\n          } as any,\n        });\n\n        scope.isDone().should.be.true();\n      } finally {\n        // Clean up the global window mock\n        delete (global as any).window;\n      }\n    });\n  });\n\n  describe('hmacAuthStrategy token lifecycle', function () {\n    const ROOT = 'https://app.example.local';\n\n    // Builds a mock strategy whose setToken / clearToken are sinon stubs.\n    function makeStrategy(overrides: Partial<IHmacAuthStrategy> = {}): {\n      strategy: IHmacAuthStrategy;\n      setTokenStub: sinon.SinonStub;\n      clearTokenStub: sinon.SinonStub;\n    } {\n      const setTokenStub = sinon.stub().resolves();\n      const clearTokenStub = sinon.stub().resolves();\n      const strategy: IHmacAuthStrategy = {\n        calculateRequestHeaders: sinon.stub().resolves({ hmac: 'hmac', timestamp: 1, tokenHash: 'hash' }),\n        verifyResponse: sinon.stub().resolves({\n          isValid: true,\n          expectedHmac: 'hmac',\n          signatureSubject: '',\n          isInResponseValidityWindow: true,\n          verificationTime: Date.now(),\n        }),\n        calculateHMAC: sinon.stub().resolves('hashed-pw'),\n        setToken: setTokenStub,\n        clearToken: clearTokenStub,\n        ...overrides,\n      };\n      return { strategy, setTokenStub, clearTokenStub };\n    }\n\n    afterEach(function () {\n      nock.cleanAll();\n      sinon.restore();\n    });\n\n    describe('authenticate()', function () {\n      it('calls setToken with the access_token received from the server', async function () {\n        const { strategy, setTokenStub } = makeStrategy();\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n\n        nock(ROOT)\n          .post('/api/auth/v1/session')\n          .reply(200, {\n            user: { username: 'test@example.com' },\n            access_token: 'v2xmyaccesstoken',\n          });\n\n        await bitgo.authenticate({ username: 'test@example.com', password: 'hunter2' });\n\n        setTokenStub.calledOnce.should.be.true();\n        setTokenStub.firstCall.args[0].should.equal('v2xmyaccesstoken');\n      });\n\n      it('awaits setToken before making ensureEcdhKeychain requests', async function () {\n        // This is the core regression test: if setToken is not awaited, the\n        // strategy's key material won't be ready before calculateRequestHeaders\n        // is called for the GET /user/settings request, and it would throw.\n        let keyReady = false;\n        const { strategy } = makeStrategy({\n          setToken: sinon.stub().callsFake(async () => {\n            // Simulate non-trivial async key derivation (like crypto.subtle.importKey).\n            await new Promise<void>((resolve) => setImmediate(resolve));\n            keyReady = true;\n          }),\n          calculateRequestHeaders: sinon.stub().callsFake(async () => {\n            if (!keyReady) {\n              throw new Error('No token available. Call setToken() or restoreToken() first.');\n            }\n            return { hmac: 'hmac', timestamp: Date.now(), tokenHash: 'hash' };\n          }),\n        });\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n\n        nock(ROOT)\n          .post('/api/auth/v1/session')\n          .reply(200, {\n            user: { username: 'test@example.com' },\n            access_token: 'v2xmytoken',\n          });\n        // The GET /user/settings request made by ensureUserEcdhKeychainIsCreated\n        // must succeed — it would throw if setToken wasn't awaited first.\n        nock(ROOT)\n          .get('/api/v1/user/settings')\n          .reply(200, {\n            settings: { ecdhKeychain: 'xpub123' },\n          });\n\n        await bitgo.authenticate({\n          username: 'test@example.com',\n          password: 'hunter2',\n          ensureEcdhKeychain: true,\n        });\n\n        keyReady.should.be.true();\n      });\n    });\n\n    describe('authenticateWithPasskey()', function () {\n      const validPasskey = JSON.stringify({\n        id: 'credential-id',\n        rawId: 'raw-id',\n        type: 'public-key',\n        response: {\n          authenticatorData: 'auth-data',\n          clientDataJSON: 'client-data',\n          signature: 'sig',\n          userHandle: 'user-handle-123',\n        },\n      });\n\n      it('calls setToken with the access_token received from the server', async function () {\n        const { strategy, setTokenStub } = makeStrategy();\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n\n        nock(ROOT)\n          .post('/api/auth/v1/session')\n          .reply(200, {\n            user: { username: 'test@example.com' },\n            access_token: 'v2xpasskeytoken',\n          });\n\n        await bitgo.authenticateWithPasskey(validPasskey);\n\n        setTokenStub.calledOnce.should.be.true();\n        setTokenStub.firstCall.args[0].should.equal('v2xpasskeytoken');\n      });\n    });\n\n    describe('clearAsync()', function () {\n      it('clears _token and calls clearToken on the strategy', async function () {\n        const { strategy, clearTokenStub } = makeStrategy();\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n\n        bitgo.authenticateWithAccessToken({ accessToken: 'v2xsometoken' });\n        (bitgo as any)._token.should.equal('v2xsometoken');\n\n        await bitgo.clearAsync();\n\n        ((bitgo as any)._token === undefined).should.be.true();\n        clearTokenStub.calledOnce.should.be.true();\n      });\n    });\n\n    describe('refreshToken()', function () {\n      it('calls setToken with the new access_token from the OAuth response', async function () {\n        const { strategy, setTokenStub } = makeStrategy();\n        const bitgo = new BitGoAPI({\n          env: 'custom',\n          customRootURI: ROOT,\n          hmacAuthStrategy: strategy,\n          clientId: 'client-id',\n          clientSecret: 'client-secret',\n        });\n        (bitgo as any)._refreshToken = 'old-refresh-token';\n\n        nock(ROOT).post('/oauth/token').reply(200, {\n          access_token: 'v2xnewtoken',\n          refresh_token: 'new-refresh-token',\n        });\n\n        await bitgo.refreshToken();\n\n        setTokenStub.calledOnce.should.be.true();\n        setTokenStub.firstCall.args[0].should.equal('v2xnewtoken');\n      });\n    });\n\n    describe('authenticateWithAuthCode()', function () {\n      it('calls setToken with the access_token from the OAuth response', async function () {\n        const { strategy, setTokenStub } = makeStrategy();\n        const bitgo = new BitGoAPI({\n          env: 'custom',\n          customRootURI: ROOT,\n          hmacAuthStrategy: strategy,\n          clientId: 'client-id',\n          clientSecret: 'client-secret',\n        });\n\n        nock(ROOT).post('/oauth/token').reply(200, {\n          access_token: 'v2xauthcodetoken',\n          refresh_token: 'refresh-token',\n        });\n        // authenticateWithAuthCode calls this.me() after setting the token\n        nock(ROOT)\n          .get('/api/v1/user/me')\n          .reply(200, {\n            user: { username: 'test@example.com' },\n          });\n\n        await bitgo.authenticateWithAuthCode({ authCode: 'my-auth-code' });\n\n        setTokenStub.calledOnce.should.be.true();\n        setTokenStub.firstCall.args[0].should.equal('v2xauthcodetoken');\n      });\n    });\n\n    describe('sync token-setting methods', function () {\n      it('authenticateWithAccessToken does not call setToken (synchronous — caller must invoke setToken on the strategy manually)', function () {\n        const { strategy, setTokenStub } = makeStrategy();\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n\n        bitgo.authenticateWithAccessToken({ accessToken: 'v2xsynctoken' });\n\n        setTokenStub.called.should.be.false();\n      });\n\n      it('fromJSON does not call setToken (synchronous — caller must invoke setToken on the strategy manually)', function () {\n        const { strategy, setTokenStub } = makeStrategy();\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n\n        (bitgo as any).fromJSON({ user: { username: 'test@example.com' }, token: 'v2xjsontoken' });\n\n        setTokenStub.called.should.be.false();\n      });\n    });\n\n    describe('addAccessToken()', function () {\n      const validParams = {\n        label: 'test-token',\n        scope: ['wallet_view_all'],\n        duration: 3600,\n      };\n\n      it('should force V1 auth and return plain token when ecdhXprv is absent, even if hmacAuthStrategy is authenticated (SSO/enterprise users)', async function () {\n        // Regression test for WCN-1790 / ANT-963: HMAC request signing and ECDH response\n        // encryption are orthogonal. forceV1Auth tells the server to return a plaintext token\n        // instead of ECDH-encrypting it. It must be set whenever ecdhXprv is absent,\n        // regardless of whether the HMAC strategy is active.\n        const { strategy } = makeStrategy({\n          isAuthenticated: sinon.stub().returns(true),\n        });\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n        // Do NOT set _ecdhXprv — simulates SSO/enterprise session (Okta, Entra, etc.)\n        bitgo.authenticateWithAccessToken({ accessToken: 'v2xstrategytoken' });\n\n        const scope = nock(ROOT).post('/api/auth/v1/accesstoken').reply(200, {\n          token: 'v2xnewplaintoken',\n          label: 'test-token',\n        });\n\n        const result = await bitgo.addAccessToken(validParams);\n\n        scope.isDone().should.be.true();\n        // forceV1Auth MUST be set — server returns plaintext token since we have no decryption key\n        (result as any).warning.should.match(/protocol downgrade/);\n        result.token.should.equal('v2xnewplaintoken');\n      });\n\n      it('should not call handleTokenIssuance when ecdhXprv is present but the server returned a plaintext token', async function () {\n        const handleTokenSpy = sinon.spy(BitGoAPI.prototype, 'handleTokenIssuance');\n        const { strategy } = makeStrategy({\n          isAuthenticated: sinon.stub().returns(true),\n        });\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n        bitgo.fromJSON({\n          user: { username: 'test@example.com' },\n          token: 'a'.repeat(40),\n          ecdhXprv: 'xprv-test-key',\n        });\n\n        nock(ROOT).post('/api/auth/v1/accesstoken').reply(200, {\n          token: 'v2xplaintextfromv1',\n          label: 'test-token',\n        });\n\n        try {\n          const result = await bitgo.addAccessToken(validParams);\n\n          handleTokenSpy.called.should.be.false();\n          result.token.should.equal('v2xplaintextfromv1');\n        } finally {\n          handleTokenSpy.restore();\n        }\n      });\n\n      it('should not call handleTokenIssuance when ecdhXprv is absent', async function () {\n        const handleTokenSpy = sinon.spy(BitGoAPI.prototype, 'handleTokenIssuance');\n        const { strategy } = makeStrategy({\n          isAuthenticated: sinon.stub().returns(true),\n        });\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n        bitgo.authenticateWithAccessToken({ accessToken: 'v2xstrategytoken' });\n\n        nock(ROOT).post('/api/auth/v1/accesstoken').reply(200, {\n          token: 'v2xplaintoken',\n          label: 'test-token',\n        });\n\n        const result = await bitgo.addAccessToken(validParams);\n\n        // handleTokenIssuance must not be called — no ecdhXprv to decrypt with\n        handleTokenSpy.called.should.be.false();\n        result.token.should.equal('v2xplaintoken');\n\n        handleTokenSpy.restore();\n      });\n\n      it('should force V1 auth when ecdhXprv is absent and strategy is not authenticated', async function () {\n        const { strategy } = makeStrategy({\n          isAuthenticated: sinon.stub().returns(false),\n        });\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n        bitgo.authenticateWithAccessToken({ accessToken: 'v2xlegacytoken' });\n\n        nock(ROOT).post('/api/auth/v1/accesstoken').reply(200, {\n          token: 'v2xlegacyresult',\n          label: 'test-token',\n        });\n\n        const result = await bitgo.addAccessToken(validParams);\n\n        (result as any).warning.should.match(/protocol downgrade/);\n      });\n\n      it('should force V1 auth when isAuthenticated is not defined on strategy', async function () {\n        const { strategy } = makeStrategy();\n        const bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n        bitgo.authenticateWithAccessToken({ accessToken: 'v2xnoauthmethod' });\n\n        nock(ROOT).post('/api/auth/v1/accesstoken').reply(200, {\n          token: 'v2xresult',\n          label: 'test-token',\n        });\n\n        const result = await bitgo.addAccessToken(validParams);\n\n        // Without isAuthenticated, should fall back to V1 auth\n        (result as any).warning.should.match(/protocol downgrade/);\n      });\n    });\n  });\n\n  describe('constants parameter', function () {\n    it('should allow passing constants via options and expose via fetchConstants', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        clientConstants: { maxFeeRate: '123123123123123' },\n      });\n\n      const constants = await bitgo.fetchConstants();\n      constants.should.have.property('maxFeeRate', '123123123123123');\n    });\n\n    it('should refresh constants when cache has expired', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      // Set up cached constants with an expired cache\n      (BitGoAPI as any)._constants = (BitGoAPI as any)._constants || {};\n      (BitGoAPI as any)._constantsExpire = (BitGoAPI as any)._constantsExpire || {};\n      (BitGoAPI as any)._constants['custom'] = { maxFeeRate: 'old-value' };\n      (BitGoAPI as any)._constantsExpire['custom'] = new Date(Date.now() - 1000); // Expired 1 second ago\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/client/constants')\n        .reply(200, {\n          constants: { maxFeeRate: 'new-value', newConstant: 'added' },\n        });\n\n      const constants = await bitgo.fetchConstants();\n\n      // Should return the new constants from the server\n      constants.should.have.property('maxFeeRate', 'new-value');\n      constants.should.have.property('newConstant', 'added');\n\n      scope.isDone().should.be.true();\n\n      nock.cleanAll();\n    });\n\n    it('should use cached constants when cache is still valid', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      // Set up cached constants with a future expiry\n      const cachedConstants = { maxFeeRate: 'cached-value', anotherSetting: 'cached-setting' };\n      (BitGoAPI as any)._constants = (BitGoAPI as any)._constants || {};\n      (BitGoAPI as any)._constantsExpire = (BitGoAPI as any)._constantsExpire || {};\n      (BitGoAPI as any)._constants['custom'] = cachedConstants;\n      (BitGoAPI as any)._constantsExpire['custom'] = new Date(Date.now() + 5 * 60 * 1000); // Valid for 5 more minutes\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/client/constants')\n        .reply(200, { constants: { shouldNotBeUsed: true } });\n\n      const constants = await bitgo.fetchConstants();\n\n      // Should return the cached constants\n      constants.should.deepEqual(cachedConstants);\n\n      // Verify that no HTTP request was made (since cache was valid)\n      scope.isDone().should.be.false();\n\n      nock.cleanAll();\n    });\n\n    it('should use cached constants when no cache expiry is set', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      // Set up cached constants with no expiry\n      const cachedConstants = { maxFeeRate: 'no-expiry-value' };\n      (BitGoAPI as any)._constants = (BitGoAPI as any)._constants || {};\n      (BitGoAPI as any)._constantsExpire = (BitGoAPI as any)._constantsExpire || {};\n      (BitGoAPI as any)._constants['custom'] = cachedConstants;\n      (BitGoAPI as any)._constantsExpire['custom'] = undefined;\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/client/constants')\n        .reply(200, { constants: { shouldNotBeUsed: true } });\n\n      const constants = await bitgo.fetchConstants();\n\n      // Should return the cached constants\n      constants.should.deepEqual(cachedConstants);\n\n      // Verify that no HTTP request was made (since no expiry means cache is always valid)\n      scope.isDone().should.be.false();\n\n      nock.cleanAll();\n    });\n  });\n\n  describe('packKeychainsFFD', function () {\n    let bitgo: BitGoAPI;\n\n    before(function () {\n      bitgo = new BitGoAPI({ env: 'custom', customRootURI: 'https://app.example.local' });\n    });\n\n    function ffd(\n      keychains: Record<string, string>,\n      v2Keychains: Record<string, string>,\n      maxBatchSizeBytes: number\n    ): Array<{ v1Batch: Record<string, string>; v2Batch: Record<string, string>; sizeBytes: number }> {\n      return (bitgo as any).packKeychainsFFD(keychains, v2Keychains, maxBatchSizeBytes);\n    }\n\n    it('returns an empty array when both inputs are empty', function () {\n      const bins = ffd({}, {}, 1024);\n      bins.should.be.an.Array();\n      bins.should.have.length(0);\n    });\n\n    it('packs all items into a single bin when they fit within the limit', function () {\n      // Each entry: 2-byte id + 10-byte value = 12 bytes; 5 entries = 60 bytes < 200 limit\n      const keychains = { k1: 'aaaaaaaaaa', k2: 'bbbbbbbbbb', k3: 'cccccccccc' };\n      const v2Keychains = { v1: 'dddddddddd', v2: 'eeeeeeeeee' };\n      const bins = ffd(keychains, v2Keychains, 200);\n      bins.should.have.length(1);\n      Object.keys(bins[0].v1Batch).should.have.length(3);\n      Object.keys(bins[0].v2Batch).should.have.length(2);\n    });\n\n    it('splits into multiple bins when a single bin cannot fit all items', function () {\n      // id='k1' (2 bytes) + 600-char value = 602 bytes; 2 entries exceed 700-byte limit\n      const keychains = { k1: 'x'.repeat(600), k2: 'y'.repeat(600) };\n      const bins = ffd(keychains, {}, 700);\n      bins.should.have.length(2);\n    });\n\n    it('throws when a single item exceeds maxBatchSizeBytes', function () {\n      // id='k1' (2 bytes) + 200-char value = 202 bytes > 100-byte limit\n      const keychains = { k1: 'x'.repeat(200) };\n      try {\n        ffd(keychains, {}, 100);\n        throw new Error('Expected error not thrown');\n      } catch (e) {\n        e.message.should.match(/exceeds the maximum batch size/);\n      }\n    });\n\n    it('places V1 keychains in v1Batch and V2 keychains in v2Batch', function () {\n      const keychains = { k1: 'v1value' };\n      const v2Keychains = { k2: 'v2value' };\n      const bins = ffd(keychains, v2Keychains, 10000);\n      bins.should.have.length(1);\n      bins[0].v1Batch.should.have.property('k1', 'v1value');\n      bins[0].v2Batch.should.have.property('k2', 'v2value');\n      bins[0].v1Batch.should.not.have.property('k2');\n      bins[0].v2Batch.should.not.have.property('k1');\n    });\n\n    it('uses FFD ordering so the largest item is packed first', function () {\n      // 'big': id(3) + 497 bytes = 500 bytes; 's1','s2': id(2) + 98 bytes = 100 bytes each\n      // maxBatchSizeBytes = 600\n      // FFD order (descending): big(500), s1(100), s2(100)\n      //   bin0: big(500). s1: 500+100=600 <=600, fits. s2: 600+100=700 > 600, new bin1.\n      //   Result: bin0={big,s1}, bin1={s2}\n      const keychains = { big: 'x'.repeat(497), s1: 'y'.repeat(98), s2: 'z'.repeat(98) };\n      const bins = ffd(keychains, {}, 600);\n      bins.should.have.length(2);\n      // 'big' should share its bin with one small item (FFD packs the largest first)\n      const binWithBig = bins.find((b) => 'big' in b.v1Batch)!;\n      Object.keys(binWithBig.v1Batch).should.have.length(2);\n    });\n  });\n\n  describe('processKeychainPasswordUpdatesInBatches', function () {\n    const ROOT = 'https://app.example.local';\n    let bitgo: BitGoAPI;\n\n    beforeEach(function () {\n      const strategy: IHmacAuthStrategy = {\n        calculateRequestHeaders: sinon.stub().resolves({ hmac: 'hmac', timestamp: Date.now(), tokenHash: 'hash' }),\n        verifyResponse: sinon.stub().resolves({\n          isValid: true,\n          expectedHmac: 'hmac',\n          signatureSubject: '',\n          isInResponseValidityWindow: true,\n          verificationTime: Date.now(),\n        }),\n        calculateHMAC: sinon.stub().resolves('hashed-pw'),\n        setToken: sinon.stub().resolves(),\n        clearToken: sinon.stub().resolves(),\n      };\n      bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n    });\n\n    afterEach(function () {\n      nock.cleanAll();\n      sinon.restore();\n    });\n\n    async function runBatches(\n      keychains: Record<string, string>,\n      v2Keychains: Record<string, string>,\n      maxBatchSizeKB: number,\n      maxRetries = 3\n    ): Promise<void> {\n      return (bitgo as any).processKeychainPasswordUpdatesInBatches(keychains, v2Keychains, maxBatchSizeKB, maxRetries);\n    }\n\n    it('makes a single PUT request for a small payload', async function () {\n      const scope = nock(ROOT).put('/api/v2/user/keychains').reply(200, {});\n      await runBatches({ k1: 'small' }, {}, 1024);\n      scope.isDone().should.be.true();\n    });\n\n    it('makes two PUT requests when the payload spans two bins', async function () {\n      // id='k1'(2) + 600 = 602 bytes each; 2 entries exceed 1 KB limit => 2 bins\n      const keychains = { k1: 'x'.repeat(600), k2: 'y'.repeat(600) };\n      const scope = nock(ROOT).put('/api/v2/user/keychains').twice().reply(200, {});\n      await runBatches(keychains, {}, 1);\n      scope.isDone().should.be.true();\n    });\n\n    it('retries a failed batch and succeeds on the second attempt', async function () {\n      nock(ROOT).put('/api/v2/user/keychains').reply(500, { error: 'internal error' });\n      nock(ROOT).put('/api/v2/user/keychains').reply(200, {});\n      // Should not throw\n      await runBatches({ k1: 'value' }, {}, 1024, 3);\n    });\n\n    it('throws after exhausting all retries on persistent HTTP errors', async function () {\n      nock(ROOT).put('/api/v2/user/keychains').times(3).reply(500, { error: 'internal error' });\n      let thrownError: Error | undefined;\n      try {\n        await runBatches({ k1: 'value' }, {}, 1024, 3);\n      } catch (e) {\n        thrownError = e;\n      }\n      thrownError!.message.should.match(/failed after 3 retries/);\n    });\n\n    it('throws after exhausting all retries when the server reports failed keychains', async function () {\n      nock(ROOT)\n        .put('/api/v2/user/keychains')\n        .times(3)\n        .reply(200, { failed: { v1: { k1: 'encryption error' } } });\n      let thrownError: Error | undefined;\n      try {\n        await runBatches({ k1: 'value' }, {}, 1024, 3);\n      } catch (e) {\n        thrownError = e;\n      }\n      thrownError!.message.should.match(/had failed keychains/);\n    });\n\n    it('issues one empty PUT when both keychain maps are empty', async function () {\n      const scope = nock(ROOT).put('/api/v2/user/keychains', { keychains: {}, v2_keychains: {} }).reply(200, {});\n      await runBatches({}, {}, 1024);\n      scope.isDone().should.be.true();\n    });\n  });\n\n  describe('changePassword batching flow', function () {\n    const ROOT = 'https://app.example.local';\n    let bitgo: BitGoAPI;\n    let sandbox: sinon.SinonSandbox;\n    let v1UpdatePasswordStub: sinon.SinonStub;\n    let v2UpdatePasswordStub: sinon.SinonStub;\n\n    beforeEach(function () {\n      sandbox = sinon.createSandbox();\n\n      const strategy: IHmacAuthStrategy = {\n        calculateRequestHeaders: sandbox.stub().resolves({ hmac: 'hmac', timestamp: Date.now(), tokenHash: 'hash' }),\n        verifyResponse: sandbox.stub().resolves({\n          isValid: true,\n          expectedHmac: 'hmac',\n          signatureSubject: '',\n          isInResponseValidityWindow: true,\n          verificationTime: Date.now(),\n        }),\n        calculateHMAC: sandbox.stub().resolves('hashed-pw'),\n        setToken: sandbox.stub().resolves(),\n        clearToken: sandbox.stub().resolves(),\n      };\n\n      bitgo = new BitGoAPI({ env: 'custom', customRootURI: ROOT, hmacAuthStrategy: strategy });\n      (bitgo as any)._user = { username: 'test@bitgo.com' };\n\n      sandbox.stub(bitgo, 'verifyPassword').resolves(true);\n\n      v1UpdatePasswordStub = sandbox.stub().resolves({ keychains: { k1: 'v1enc' }, version: 25 });\n      sandbox.stub(bitgo, 'keychains').returns({\n        updatePassword: v1UpdatePasswordStub,\n      } as any);\n\n      v2UpdatePasswordStub = sandbox.stub().resolves({ v2k1: 'v2enc' });\n      sandbox.stub(bitgo, 'coin').returns({\n        keychains: () => ({\n          updatePassword: v2UpdatePasswordStub,\n        }),\n      } as any);\n    });\n\n    afterEach(function () {\n      nock.cleanAll();\n      sandbox.restore();\n    });\n\n    it('calls PUT /user/keychains and POST /user/changepassword without keychains when batching is enabled', async function () {\n      nock(ROOT)\n        .get('/api/v2/user/checkBatchingPasswordFlow')\n        .query(true)\n        .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });\n\n      const batchPutScope = nock(ROOT).put('/api/v2/user/keychains').reply(200, {});\n\n      const changePassScope = nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !body.keychains && !body.v2_keychains)\n        .reply(200, {});\n\n      await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });\n\n      batchPutScope.isDone().should.be.true();\n      changePassScope.isDone().should.be.true();\n    });\n\n    it('stages an empty batch and changes password when no keychains are re-encryptable', async function () {\n      v1UpdatePasswordStub.resolves({ keychains: {}, version: 25 });\n      v2UpdatePasswordStub.resolves({});\n      nock(ROOT)\n        .get('/api/v2/user/checkBatchingPasswordFlow')\n        .query(true)\n        .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });\n      const batchPutScope = nock(ROOT)\n        .put('/api/v2/user/keychains', { keychains: {}, v2_keychains: {} })\n        .reply(200, {});\n      const changePassScope = nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !body.keychains && !body.v2_keychains)\n        .reply(200, {});\n      await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });\n      batchPutScope.isDone().should.be.true();\n      changePassScope.isDone().should.be.true();\n    });\n\n    it('sends keychains in the POST body (legacy flow) when the server disables batching', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n\n      const legacyScope = nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });\n\n      legacyScope.isDone().should.be.true();\n    });\n\n    it('falls back to legacy flow when the batching check request fails', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(503, { error: 'service unavailable' });\n\n      const legacyScope = nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw' });\n\n      legacyScope.isDone().should.be.true();\n    });\n\n    it('forwards encryptionVersion to both v1 and v2 keychains().updatePassword calls', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw', encryptionVersion: 2 });\n\n      sinon.assert.calledWithMatch(v1UpdatePasswordStub, { encryptionVersion: 2 });\n      sinon.assert.calledWithMatch(v2UpdatePasswordStub, { encryptionVersion: 2 });\n    });\n    it('creates one encryption session, passes it to both keychain update calls, and destroys it', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: unknown) => {\n          if (!body || typeof body !== 'object') {\n            return false;\n          }\n          return 'keychains' in body && 'v2_keychains' in body;\n        })\n        .reply(200, {});\n\n      const destroy = sandbox.stub();\n      const session: IEncryptionSession = {\n        encrypt: sandbox.stub().resolves('session-encrypted'),\n        decrypt: sandbox.stub().resolves('session-decrypted'),\n        destroy,\n      };\n      const createSession = sandbox.stub(bitgo, 'createEncryptionSession').resolves(session);\n\n      await bitgo.changePassword({ oldPassword: 'oldpw', newPassword: 'newpw', encryptionVersion: 2 });\n\n      sinon.assert.calledOnce(createSession);\n      sinon.assert.calledWithExactly(createSession, 'newpw', 2);\n      // Call-site truth: the params object reaches both updatePassword calls, but the\n      // deprecated v1-leg (src/v1/keychains.ts) ignores encryptionSession/encryptionVersion\n      // and preserves each envelope's version -- see test/unit/v1/keychains.ts. Only the\n      // coin-leg consumes the session.\n      sinon.assert.calledWithMatch(v1UpdatePasswordStub, {\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n      });\n      sinon.assert.calledWithMatch(v1UpdatePasswordStub, {\n        encryptionVersion: 2,\n        encryptionSession: session,\n      });\n      sinon.assert.calledWithMatch(v2UpdatePasswordStub, {\n        encryptionVersion: 2,\n        encryptionSession: session,\n      });\n      sinon.assert.calledOnce(destroy);\n    });\n\n    it('emits keychains/started, monotonic keychains/updated events, then finalizing/started and finalizing/completed', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      v1UpdatePasswordStub.callsFake(async (params: { progressCallback?: (p: unknown) => void }) => {\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });\n        params.progressCallback?.({ status: 'skipped', currentKeychainId: 'xpub2' });\n        // one map entry per emitted event, since the map's size now feeds the v2 total\n        return { keychains: { k1: 'v1enc', k2: 'v1enc2' }, version: 25 };\n      });\n      v2UpdatePasswordStub.callsFake(async (params: { progressCallback?: (p: unknown) => void }) => {\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub3' });\n        return { v2k1: 'v2enc' };\n      });\n\n      const events: PasswordRotationProgress[] = [];\n      await bitgo.changePassword({\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n        progressCallback: (progress) => events.push(progress),\n      });\n\n      events.should.deepEqual([\n        { phase: 'keychains', status: 'started', completed: 0, attempted: 0, succeeded: 0, skipped: 0 },\n        {\n          phase: 'keychains',\n          status: 'updated',\n          completed: 1,\n          attempted: 1,\n          succeeded: 1,\n          skipped: 0,\n          total: undefined,\n          currentKeychainId: 'xpub1',\n          keychainVersion: 'v1',\n        },\n        {\n          phase: 'keychains',\n          status: 'updated',\n          completed: 2,\n          attempted: 2,\n          succeeded: 1,\n          skipped: 1,\n          total: undefined,\n          currentKeychainId: 'xpub2',\n          keychainVersion: 'v1',\n        },\n        {\n          phase: 'keychains',\n          status: 'updated',\n          completed: 3,\n          attempted: 3,\n          succeeded: 2,\n          skipped: 1,\n          total: undefined,\n          currentKeychainId: 'xpub3',\n          keychainVersion: 'v2',\n        },\n        { phase: 'finalizing', status: 'started' },\n        { phase: 'finalizing', status: 'completed' },\n      ]);\n    });\n\n    it('forwards a truthful total from the v2 lower-level callback into every keychains/updated event', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      v2UpdatePasswordStub.callsFake(async (params: { progressCallback?: (p: unknown) => void }) => {\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1', total: 2 });\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub2', total: 2 });\n        return { v2k1: 'v2enc', v2k2: 'v2enc2' };\n      });\n\n      const events: PasswordRotationProgress[] = [];\n      await bitgo.changePassword({\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n        progressCallback: (progress) => events.push(progress),\n      });\n\n      const v2Events = events.filter(\n        (e): e is Extract<PasswordRotationProgress, { phase: 'keychains' }> =>\n          e.phase === 'keychains' && e.status === 'updated' && e.keychainVersion === 'v2'\n      );\n      // the v1 stub keeps its default 1-entry map, so v2 events forward 1 (v1) + 2 (v2) = 3\n      v2Events.every((e) => e.total === 3).should.be.true();\n    });\n\n    it('covers both keychain sets in the total so mixed v1/v2 accounts complete exactly (2 v1 + 32 v2 = 34 of 34)', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      v1UpdatePasswordStub.callsFake(async (params: { progressCallback?: (p: unknown) => void }) => {\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub2' });\n        return { keychains: { k1: 'v1enc', k2: 'v1enc2' }, version: 25 };\n      });\n      v2UpdatePasswordStub.callsFake(async (params: { progressCallback?: (p: unknown) => void }) => {\n        for (let i = 1; i <= 32; i++) {\n          params.progressCallback?.({ status: 'updated', currentKeychainId: `v2key-${i}`, total: 32 });\n        }\n        return { v2k1: 'v2enc' };\n      });\n\n      const events: PasswordRotationProgress[] = [];\n      await bitgo.changePassword({\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n        progressCallback: (progress) => events.push(progress),\n      });\n\n      const keychainEvents = events.filter(\n        (e): e is Extract<PasswordRotationProgress, { phase: 'keychains' }> =>\n          e.phase === 'keychains' && e.status === 'updated'\n      );\n      const v1Events = keychainEvents.filter((e) => e.keychainVersion === 'v1');\n      const v2Events = keychainEvents.filter((e) => e.keychainVersion === 'v2');\n\n      // v1 events stay indeterminate: the v1 set has no server-provided count\n      v1Events.should.have.length(2);\n      v1Events.every((e) => e.total === undefined).should.be.true();\n\n      // v2 events carry the combined denominator: 2 (v1 set) + 32 (totalCount)\n      v2Events.should.have.length(32);\n      v2Events.every((e) => e.total === 34).should.be.true();\n\n      // the counter completes exactly instead of overshooting the total\n      const last = v2Events[v2Events.length - 1];\n      last.completed.should.equal(34);\n      last.total!.should.equal(34);\n    });\n\n    it('emits a terminal total for v1-only accounts so the counter can render n of n', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      v1UpdatePasswordStub.callsFake(async (params: { progressCallback?: (p: unknown) => void }) => {\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub2' });\n        return { keychains: { k1: 'v1enc', k2: 'v1enc2' }, version: 25 };\n      });\n      // a v1-only account: the v2 walk finds nothing and emits nothing\n      v2UpdatePasswordStub.callsFake(async () => ({}));\n\n      const events: PasswordRotationProgress[] = [];\n      await bitgo.changePassword({\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n        progressCallback: (progress) => events.push(progress),\n      });\n\n      const keychainEvents = events.filter(\n        (e): e is Extract<PasswordRotationProgress, { phase: 'keychains' }> =>\n          e.phase === 'keychains' && e.status === 'updated'\n      );\n      const v1Events = keychainEvents.filter((e) => e.keychainVersion === 'v1');\n      v1Events.should.have.length(2);\n      v1Events.every((e) => e.total === undefined).should.be.true();\n\n      // no v2 event ever arrived, so the terminal keychains/updated event carries the\n      // client-known v1 set size as the denominator: 2 of 2, immediately before finalizing\n      const last = keychainEvents[keychainEvents.length - 1];\n      last.completed.should.equal(2);\n      last.total!.should.equal(2);\n      events[events.length - 2].should.deepEqual({ phase: 'finalizing', status: 'started' });\n    });\n\n    it('does not let a throwing progressCallback abort the rotation', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(200, { isBatchingFlowEnabled: false });\n      const changePassScope = nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      await bitgo.changePassword({\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n        progressCallback: () => {\n          throw new Error('observer boom');\n        },\n      });\n\n      changePassScope.isDone().should.be.true();\n    });\n\n    it('emits no finalizing/completed and no legacy fallback when the batching-path final POST fails', async function () {\n      nock(ROOT)\n        .get('/api/v2/user/checkBatchingPasswordFlow')\n        .query(true)\n        .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });\n      nock(ROOT).put('/api/v2/user/keychains').reply(200, {});\n      const changePassScope = nock(ROOT).post('/api/v1/user/changepassword').reply(500, { error: 'boom' });\n\n      const events: PasswordRotationProgress[] = [];\n      await bitgo\n        .changePassword({\n          oldPassword: 'oldpw',\n          newPassword: 'newpw',\n          progressCallback: (progress) => events.push(progress),\n        })\n        .should.be.rejected();\n\n      changePassScope.isDone().should.be.true();\n      events.some((e) => e.phase === 'finalizing' && e.status === 'completed').should.be.false();\n    });\n\n    it('completes exactly once via legacy fallback when the batching check fails', async function () {\n      nock(ROOT).get('/api/v2/user/checkBatchingPasswordFlow').query(true).reply(503, { error: 'service unavailable' });\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !!body.keychains && !!body.v2_keychains)\n        .reply(200, {});\n\n      const events: PasswordRotationProgress[] = [];\n      await bitgo.changePassword({\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n        progressCallback: (progress) => events.push(progress),\n      });\n\n      events.filter((e) => e.phase === 'finalizing' && e.status === 'completed').should.have.length(1);\n    });\n\n    it('does not add keychain events or double-count when a transport batch is retried', async function () {\n      nock(ROOT)\n        .get('/api/v2/user/checkBatchingPasswordFlow')\n        .query(true)\n        .reply(200, { isBatchingFlowEnabled: true, maxBatchSizeKB: 900 });\n      nock(ROOT).put('/api/v2/user/keychains').reply(500, { error: 'transient' });\n      nock(ROOT).put('/api/v2/user/keychains').reply(200, {});\n      nock(ROOT)\n        .post('/api/v1/user/changepassword', (body: any) => !body.keychains && !body.v2_keychains)\n        .reply(200, {});\n\n      v1UpdatePasswordStub.callsFake(async (params: { progressCallback?: (p: unknown) => void }) => {\n        params.progressCallback?.({ status: 'updated', currentKeychainId: 'xpub1' });\n        return { keychains: { k1: 'v1enc' }, version: 25 };\n      });\n\n      const events: PasswordRotationProgress[] = [];\n      await bitgo.changePassword({\n        oldPassword: 'oldpw',\n        newPassword: 'newpw',\n        progressCallback: (progress) => events.push(progress),\n      });\n\n      const keychainEvents = events.filter((e) => e.phase === 'keychains' && e.status === 'updated');\n      // one real keychain event plus the terminal denominator event for this v1-only\n      // account — the retried transport must contribute neither a duplicate event\n      // nor a double-count to either\n      keychainEvents.should.have.length(2);\n      keychainEvents[0].should.have.properties({ succeeded: 1, skipped: 0, attempted: 1, completed: 1 });\n      keychainEvents[1].should.have.properties({ succeeded: 1, skipped: 0, attempted: 1, completed: 1, total: 1 });\n    });\n  });\n\n  describe('createUserEcdhKeychain - encryptionVersion threading', function () {\n    const ROOT = 'https://app.bitgo-test.com';\n    let bitgo: BitGoAPI;\n\n    beforeEach(function () {\n      bitgo = new BitGoAPI({ env: 'test' });\n    });\n\n    afterEach(function () {\n      nock.cleanAll();\n      sinon.restore();\n    });\n\n    it('passes encryptionVersion: 2 to encrypt', async function () {\n      const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');\n      nock(ROOT).post('/api/v1/keychain').reply(200, { xpub: 'xpub123', id: 'key-id' });\n\n      await bitgo.createUserEcdhKeychain('loginPassword', 2);\n\n      assert.ok(encryptAsyncSpy.calledOnce);\n      assert.strictEqual(encryptAsyncSpy.firstCall.args[0].encryptionVersion, 2);\n    });\n\n    it('passes encryptionVersion: undefined when not set (defaults to v1)', async function () {\n      const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');\n      nock(ROOT).post('/api/v1/keychain').reply(200, { xpub: 'xpub123', id: 'key-id' });\n\n      await bitgo.createUserEcdhKeychain('loginPassword');\n\n      assert.ok(encryptAsyncSpy.calledOnce);\n      assert.strictEqual(encryptAsyncSpy.firstCall.args[0].encryptionVersion, undefined);\n    });\n  });\n\n  describe('splitSecret - encryptionVersion threading', function () {\n    let bitgo: BitGoAPI;\n\n    beforeEach(function () {\n      bitgo = new BitGoAPI({ env: 'test' });\n    });\n\n    afterEach(function () {\n      sinon.restore();\n    });\n\n    it('passes encryptionVersion: 2 to every encrypt shard call', async function () {\n      const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');\n      const passwords = ['pw1', 'pw2', 'pw3'];\n\n      await bitgo.splitSecret({\n        seed: 'a'.repeat(64),\n        passwords,\n        m: 2,\n        encryptionVersion: 2,\n      });\n\n      assert.strictEqual(encryptAsyncSpy.callCount, 3, 'should encrypt each shard');\n      for (const call of encryptAsyncSpy.getCalls()) {\n        assert.strictEqual(call.args[0].encryptionVersion, 2);\n      }\n    });\n\n    it('passes encryptionVersion: undefined when not set', async function () {\n      const encryptAsyncSpy = sinon.spy(bitgo, 'encrypt');\n\n      await bitgo.splitSecret({\n        seed: 'b'.repeat(64),\n        passwords: ['pw1', 'pw2'],\n        m: 2,\n      });\n\n      assert.strictEqual(encryptAsyncSpy.callCount, 2);\n      for (const call of encryptAsyncSpy.getCalls()) {\n        assert.strictEqual(call.args[0].encryptionVersion, undefined);\n      }\n    });\n  });\n});\n\ndescribe('wallets() v1 facade', function () {\n  it('returns BitGoApiV1Wallets with bitgo reference and all prototype methods', function () {\n    const bitgo = new BitGoAPI({ env: 'test' });\n    const wallets = bitgo.wallets();\n    wallets.bitgo.should.equal(bitgo);\n    wallets.list.should.be.a.Function();\n    wallets.get.should.be.a.Function();\n    wallets.getWallet.should.be.a.Function();\n    wallets.add.should.be.a.Function();\n    wallets.remove.should.be.a.Function();\n    wallets.acceptShare.should.be.a.Function();\n    wallets.createWalletWithKeychains.should.be.a.Function();\n    wallets.createForwardWallet.should.be.a.Function();\n    wallets.createKey.should.be.a.Function();\n    wallets.listInvites.should.be.a.Function();\n    wallets.cancelInvite.should.be.a.Function();\n    wallets.listShares.should.be.a.Function();\n    wallets.getShare.should.be.a.Function();\n    wallets.updateShare.should.be.a.Function();\n    wallets.cancelShare.should.be.a.Function();\n    wallets.resendShareInvite.should.be.a.Function();\n  });\n});\n"]}