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

package/dist/test/unit/bitgo/keychain/keychains.js

@@ -0,0 +1,426 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon = __importStar(require("sinon"));
+require("should");
+const src_1 = require("../../../../src");
+const errors_1 = require("../../../../src/bitgo/errors");
+/** Slot-④ roots are generated as XLM keychains, then persisted as raw pub||chain-code base32. */
+const STRKEY_PUB = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';
+const SAFE_ID = 'safe-1';
+const XPUB = 'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';
+const BASE32_ROOT = /^[A-Z2-7]{103}$/;
+describe('Keychains.createBackup', function () {
+    let keychains;
+    let send;
+    let mockBitGo;
+    /** The body actually handed to `.send()` — i.e. what goes on the wire. */
+    function sentBody() {
+        return send.firstCall.args[0];
+    }
+    function buildKeychains(pub = STRKEY_PUB) {
+        const mockBaseCoin = {
+            url: sinon.stub().callsFake((path) => path),
+            generateKeyPair: sinon.stub().returns({ pub, prv: 'SOME_SEED' }),
+        };
+        return new src_1.Keychains(mockBitGo, mockBaseCoin);
+    }
+    beforeEach(function () {
+        send = sinon.stub().returns({ result: sinon.stub().resolves({ id: 'backup-key-id' }) });
+        mockBitGo = {
+            post: sinon.stub().returns({ send }),
+            encrypt: sinon.stub().resolves('encrypted-prv'),
+            setRequestTracer: sinon.stub(),
+        };
+        keychains = buildKeychains();
+    });
+    describe('safe child key registration', function () {
+        it('serializes the hardened derivation path', async function () {
+            await keychains.add({
+                pub: XPUB,
+                source: 'user',
+                keyType: 'independent',
+                parent: 'user-root-id',
+                safeId: SAFE_ID,
+                derivedFromParentWithPath: "m/7'",
+            });
+            const derivedPath = sentBody().derivedFromParentWithPath;
+            if (typeof derivedPath !== 'string') {
+                throw new Error('expected derivedFromParentWithPath to be serialized');
+            }
+            derivedPath.should.equal("m/7'");
+        });
+    });
+    describe('safe ed25519Multisig root (slot ④)', function () {
+        it('posts raw public key plus chain code as unpadded base32', async function () {
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            const pub = sentBody().pub;
+            BASE32_ROOT.test(pub).should.equal(true);
+            (0, src_1.decodeDerivableEd25519Pub)(pub)
+                .pub.toString('hex')
+                .should.match(/^[0-9a-f]{64}$/);
+            (0, src_1.decodeDerivableEd25519Pub)(pub)
+                .chainCode.toString('hex')
+                .should.match(/^[0-9a-f]{64}$/);
+        });
+        it('mints a different chain code for each backup key', async function () {
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            const first = (0, src_1.decodeDerivableEd25519Pub)(send.firstCall.args[0].pub).chainCode;
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            const second = (0, src_1.decodeDerivableEd25519Pub)(send.secondCall.args[0].pub).chainCode;
+            first.equals(second).should.equal(false);
+        });
+        it('sends no separate chainCode field', async function () {
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            sentBody().should.not.have.property('chainCode');
+        });
+        it('still encrypts and returns the un-composed prv', async function () {
+            const result = await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            sentBody().encryptedPrv.should.equal('encrypted-prv');
+            result.prv.should.equal('SOME_SEED');
+        });
+    });
+    describe('leaves every other key untouched', function () {
+        it('does not compose without a safeId, even for an ed25519 coin', async function () {
+            await keychains.createBackup({ passphrase: 'pw' });
+            const body = sentBody();
+            body.pub.should.equal(STRKEY_PUB);
+            body.pub.length.should.equal(56);
+        });
+        it('does not compose a safe secp256k1Multisig root', async function () {
+            const btcKeychains = buildKeychains(XPUB);
+            await btcKeychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            sentBody().pub.should.equal(XPUB);
+        });
+        it('sends a body with no chainCode and source backup', async function () {
+            await keychains.createBackup({ passphrase: 'pw' });
+            const body = sentBody();
+            body.should.not.have.property('chainCode');
+            body.source.should.equal('backup');
+            body.encryptedPrv.should.equal('encrypted-prv');
+        });
+        it('leaves a KRS-provider backup key untouched', async function () {
+            await keychains.createBackup({ provider: 'krs-provider', safeId: SAFE_ID });
+            const body = sentBody();
+            (body.pub === undefined).should.be.true();
+            body.provider.should.equal('krs-provider');
+        });
+    });
+    describe('password rotation encryption session', function () {
+        it('uses the supplied session for the new encrypted private key', async function () {
+            mockBitGo.decrypt = sinon.stub().resolves('decrypted-prv');
+            const sessionEncrypt = sinon.stub().resolves('session-encrypted');
+            const session = {
+                encrypt: sessionEncrypt,
+                decrypt: sinon.stub().resolves('decrypted-prv'),
+                destroy: sinon.stub(),
+            };
+            const updatedKeychain = await keychains.updateSingleKeychainPassword({
+                keychain: {
+                    id: 'key-id',
+                    encryptedPrv: 'legacy-encrypted-prv',
+                    type: 'independent',
+                },
+                oldPassword: 'old-password',
+                newPassword: 'new-password',
+                encryptionVersion: 2,
+                encryptionSession: session,
+            });
+            sessionEncrypt.calledOnceWithExactly('decrypted-prv').should.equal(true);
+            mockBitGo.encrypt.called.should.equal(false);
+            updatedKeychain.encryptedPrv.should.equal('session-encrypted');
+        });
+    });
+});
+describe('Keychains.updatePassword (safe mode)', function () {
+    const SAFE_ID = 'safe-123';
+    const OLD_PASSWORD = 'old-passphrase';
+    const NEW_PASSWORD = 'new-passphrase';
+    let keychains;
+    let decryptStub;
+    let sessionEncrypt;
+    let sessionDestroy;
+    let createEncryptionSession;
+    let url;
+    let put;
+    let send;
+    function sentBodies() {
+        return send.getCalls().map((call) => call.args[0]);
+    }
+    function key(id, overrides = {}) {
+        return { id, pub: `pub-${id}`, type: 'independent', encryptedPrv: `enc:prv-${id}`, ...overrides };
+    }
+    function stubListPages(pages) {
+        const listStub = sinon.stub(keychains, 'list');
+        listStub.callsFake(async (params = {}) => {
+            const pageIndex = params.prevId === undefined ? 0 : Number(params.prevId);
+            return {
+                keys: pages[pageIndex],
+                nextBatchPrevId: pageIndex + 1 < pages.length ? String(pageIndex + 1) : undefined,
+            };
+        });
+        return listStub;
+    }
+    beforeEach(function () {
+        sessionEncrypt = sinon.stub().callsFake(async (plaintext) => `enc:${plaintext}`);
+        sessionDestroy = sinon.spy();
+        createEncryptionSession = sinon.stub().resolves({ encrypt: sessionEncrypt, destroy: sessionDestroy });
+        decryptStub = sinon.stub().callsFake(async ({ input, password }) => {
+            if (password !== OLD_PASSWORD) {
+                throw new Error('incorrect password');
+            }
+            if (!input.startsWith('enc:')) {
+                throw new Error('incorrect password');
+            }
+            return input.slice('enc:'.length);
+        });
+        send = sinon.stub().returns({ result: sinon.stub().resolves({ updates: [] }) });
+        put = sinon.stub().returns({ send });
+        url = sinon.stub().callsFake((path) => path);
+        // BitGoBase and IBaseCoin are large surfaces; the tests only exercise these members.
+        const bitgo = {
+            decrypt: decryptStub,
+            createEncryptionSession,
+            encrypt: sinon.stub().resolves('new-envelope'),
+            put,
+            url,
+            setRequestTracer: sinon.stub(),
+        };
+        const baseCoin = {
+            url: sinon.stub().callsFake((path) => path),
+            generateKeyPair: sinon.stub(),
+        };
+        keychains = new src_1.Keychains(bitgo, baseCoin);
+    });
+    it('walks all pages, rotates every envelope-bearing key and persists with one batch PUT', async function () {
+        const listStub = stubListPages([
+            [key('root-ecdsa-user'), key('msig-child', { encryptedPrv: undefined })],
+            [key('root-eddsa-user'), key('mpc-child-user')],
+        ]);
+        send.returns({ result: sinon.stub().resolves({ updates: [{ keyId: 'x', updated: true }] }) });
+        const response = await keychains.updatePassword({
+            oldPassword: OLD_PASSWORD,
+            newPassword: NEW_PASSWORD,
+            safeId: SAFE_ID,
+        });
+        // the walk is safe-scoped and paginated
+        sinon.assert.calledWith(listStub.getCall(0), { limit: 500, prevId: undefined, safeId: SAFE_ID });
+        sinon.assert.calledWith(listStub.getCall(1), { limit: 500, prevId: '1', safeId: SAFE_ID });
+        // one shared session, one Argon2
+        sinon.assert.calledOnce(createEncryptionSession);
+        sinon.assert.calledWith(createEncryptionSession, NEW_PASSWORD, undefined);
+        // keychains without an encryptedPrv are skipped; every rotation carries compare-and-swap
+        const bodies = sentBodies();
+        bodies.length.should.equal(1);
+        bodies[0].updates.map((u) => u.keyId).should.deepEqual(['root-ecdsa-user', 'root-eddsa-user', 'mpc-child-user']);
+        for (const update of bodies[0].updates) {
+            update.encryptedPrv.should.equal(`enc:prv-${update.keyId}`);
+            update.expectedOldEncryptedPrv.should.equal(`enc:prv-${update.keyId}`);
+        }
+        sinon.assert.calledOnce(put);
+        sinon.assert.calledWith(url, '/key/bulk', 2);
+        // the batch response is passed through
+        response.updates.should.deepEqual([{ keyId: 'x', updated: true }]);
+        // the SDK-owned session is destroyed afterwards
+        sinon.assert.calledOnce(sessionDestroy);
+    });
+    it('fails fast on the first undecryptable envelope with zero writes', async function () {
+        stubListPages([[key('good-1'), key('stale', { encryptedPrv: 'corrupt-envelope' }), key('good-2')]]);
+        await keychains
+            .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID })
+            .should.be.rejectedWith(/stale/);
+        sinon.assert.notCalled(put);
+        sinon.assert.calledOnce(sessionDestroy);
+    });
+    it('rejects with IncorrectPasswordError naming the offending key', async function () {
+        stubListPages([[key('stale', { encryptedPrv: 'corrupt-envelope' })]]);
+        try {
+            await keychains.updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID });
+            throw new Error('expected updatePassword to reject');
+        }
+        catch (e) {
+            e.name.should.equal('IncorrectPasswordError');
+            e.message.should.match(/failed to decrypt keychain stale with the old passphrase/);
+        }
+    });
+    it('rejects with IncorrectPasswordError when the old passphrase does not match', async function () {
+        stubListPages([[key('root-1')]]);
+        await keychains
+            .updatePassword({ oldPassword: 'totally-wrong', newPassword: NEW_PASSWORD, safeId: SAFE_ID })
+            .should.be.rejectedWith(errors_1.IncorrectPasswordError);
+        sinon.assert.notCalled(put);
+    });
+    it('re-encrypts through a caller-provided session without destroying it', async function () {
+        stubListPages([[key('root-1')]]);
+        const encryptedByCaller = [];
+        let callerDestroyed = false;
+        const callerSession = {
+            encrypt: async (plaintext) => {
+                encryptedByCaller.push(plaintext);
+                return 'caller-session-envelope';
+            },
+            decrypt: async () => '',
+            destroy: () => {
+                callerDestroyed = true;
+            },
+        };
+        await keychains.updatePassword({
+            oldPassword: OLD_PASSWORD,
+            newPassword: NEW_PASSWORD,
+            safeId: SAFE_ID,
+            encryptionSession: callerSession,
+        });
+        sinon.assert.notCalled(createEncryptionSession);
+        encryptedByCaller.should.deepEqual(['prv-root-1']);
+        callerDestroyed.should.equal(false);
+    });
+    it('passes an explicit encryptionVersion to the session factory', async function () {
+        stubListPages([[key('root-1')]]);
+        await keychains.updatePassword({
+            oldPassword: OLD_PASSWORD,
+            newPassword: NEW_PASSWORD,
+            safeId: SAFE_ID,
+            encryptionVersion: 1,
+        });
+        sinon.assert.calledOnce(createEncryptionSession);
+        sinon.assert.calledWith(createEncryptionSession, NEW_PASSWORD, 1);
+    });
+    it('chunks the batch past the server transaction budget and merges the responses', async function () {
+        const page = Array.from({ length: 501 }, (_, i) => key(`key-${i}`));
+        stubListPages([page]);
+        send.callsFake((body) => ({
+            result: sinon.stub().resolves({ updates: body.updates.map((u) => ({ keyId: u.keyId, updated: true })) }),
+        }));
+        const response = await keychains.updatePassword({
+            oldPassword: OLD_PASSWORD,
+            newPassword: NEW_PASSWORD,
+            safeId: SAFE_ID,
+        });
+        sinon.assert.calledTwice(put);
+        sentBodies()[0].updates.length.should.equal(500);
+        sentBodies()[1].updates.length.should.equal(1);
+        response.updates.length.should.equal(501);
+    });
+    it('propagates a mid-chunk failure after earlier chunks were sent and destroys the session', async function () {
+        const page = Array.from({ length: 501 }, (_, i) => key(`key-${i}`));
+        stubListPages([page]);
+        let chunkIndex = 0;
+        send.callsFake((body) => {
+            chunkIndex += 1;
+            if (chunkIndex === 2) {
+                return { result: sinon.stub().rejects(new Error('boom')) };
+            }
+            return {
+                result: sinon.stub().resolves({ updates: body.updates.map((u) => ({ keyId: u.keyId, updated: true })) }),
+            };
+        });
+        await keychains
+            .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID })
+            .should.be.rejectedWith('boom');
+        // the first chunk went out before the second failed; the SDK-owned session is destroyed
+        sinon.assert.calledTwice(put);
+        sentBodies()[0].updates.length.should.equal(500);
+        sinon.assert.calledOnce(sessionDestroy);
+    });
+    it('rejects a chunk response missing the updates array', async function () {
+        stubListPages([[key('root-1')]]);
+        send.returns({ result: sinon.stub().resolves({ unexpected: true }) });
+        await keychains
+            .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID })
+            .should.be.rejectedWith(/invalid key bulk update response/);
+        sinon.assert.calledOnce(sessionDestroy);
+    });
+    it('rotates nothing and issues no PUT when the safe has no encrypted keys', async function () {
+        stubListPages([[key('msig-child', { encryptedPrv: undefined }), key('placeholder', { encryptedPrv: undefined })]]);
+        const response = await keychains.updatePassword({
+            oldPassword: OLD_PASSWORD,
+            newPassword: NEW_PASSWORD,
+            safeId: SAFE_ID,
+        });
+        response.updates.should.deepEqual([]);
+        sinon.assert.notCalled(put);
+        sinon.assert.notCalled(createEncryptionSession);
+    });
+    it('rejects a non-string safeId', async function () {
+        // deliberate: proves the runtime guard rejects a non-string safeId
+        const unsafeId = 42;
+        await keychains
+            .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: unsafeId })
+            .should.be.rejectedWith('Expecting parameter string: safeId but found number');
+    });
+    it('keeps legacy mode write-free', async function () {
+        // getEncryptionVersion re-parses the old envelope in the legacy path, so it must be JSON
+        const legacyKey = key('user-key', { encryptedPrv: JSON.stringify({ v: 1 }) });
+        decryptStub.callsFake(async () => 'prv-user-key');
+        sinon.stub(keychains, 'list').resolves({ keys: [legacyKey], nextBatchPrevId: undefined });
+        const changedKeys = await keychains.updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD });
+        changedKeys.should.deepEqual({ 'pub-user-key': 'new-envelope' });
+        sinon.assert.notCalled(put);
+    });
+    it('keeps skipping undecryptable keys in legacy mode', async function () {
+        // getEncryptionVersion re-parses the old envelope in the legacy path, so it must be JSON
+        const goodEnvelope = JSON.stringify({ v: 1, ct: 'prv-good' });
+        decryptStub.callsFake(async ({ input }) => {
+            if (input !== goodEnvelope) {
+                throw new Error('private key is incorrect');
+            }
+            return 'prv-good';
+        });
+        sinon.stub(keychains, 'list').resolves({
+            keys: [key('bad', { encryptedPrv: 'corrupt-envelope' }), key('good', { encryptedPrv: goodEnvelope })],
+            nextBatchPrevId: undefined,
+        });
+        const changedKeys = await keychains.updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD });
+        changedKeys.should.deepEqual({ 'pub-good': 'new-envelope' });
+        sinon.assert.notCalled(put);
+    });
+});
+describe('Keychains.list safeId filter', function () {
+    it('forwards safeId as a query parameter', async function () {
+        const query = sinon.stub();
+        const chain = { query, result: sinon.stub().resolves({ keys: [] }) };
+        query.returns(chain);
+        // BitGoBase and IBaseCoin are large surfaces; the tests only exercise these members.
+        const get = sinon.stub().returns(chain);
+        // BitGoBase and IBaseCoin are large surfaces; the tests only exercise these members.
+        const bitgo = { get };
+        const baseCoin = { url: sinon.stub().callsFake((path) => path) };
+        const listKeychains = new src_1.Keychains(bitgo, baseCoin);
+        await listKeychains.list({ safeId: 'safe-123' });
+        sinon.assert.calledWith(get, '/key');
+        sinon.assert.calledWith(query, { safeId: 'safe-123' });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keychains.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/keychain/keychains.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sinon from 'sinon';\nimport 'should';\nimport { Keychains, decodeDerivableEd25519Pub } from '../../../../src';\nimport type { IEncryptionSession } from '../../../../src/api';\nimport type { BitGoBase } from '../../../../src/bitgo/bitgoBase';\nimport { IncorrectPasswordError } from '../../../../src/bitgo/errors';\nimport type { IBaseCoin } from '../../../../src/bitgo/baseCoin/iBaseCoin';\nimport type { Keychain, ListKeychainOptions } from '../../../../src/bitgo/keychain/iKeychains';\n\n/** Slot-④ roots are generated as XLM keychains, then persisted as raw pub||chain-code base32. */\nconst STRKEY_PUB = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';\nconst SAFE_ID = 'safe-1';\nconst XPUB =\n  'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';\nconst BASE32_ROOT = /^[A-Z2-7]{103}$/;\n\ndescribe('Keychains.createBackup', function () {\n  let keychains: Keychains;\n  let send: sinon.SinonStub;\n  let mockBitGo: any;\n\n  /** The body actually handed to `.send()` — i.e. what goes on the wire. */\n  function sentBody(): Record<string, unknown> {\n    return send.firstCall.args[0];\n  }\n\n  function buildKeychains(pub = STRKEY_PUB): Keychains {\n    const mockBaseCoin = {\n      url: sinon.stub().callsFake((path: string) => path),\n      generateKeyPair: sinon.stub().returns({ pub, prv: 'SOME_SEED' }),\n    };\n    return new Keychains(mockBitGo, mockBaseCoin as any);\n  }\n\n  beforeEach(function () {\n    send = sinon.stub().returns({ result: sinon.stub().resolves({ id: 'backup-key-id' }) });\n    mockBitGo = {\n      post: sinon.stub().returns({ send }),\n      encrypt: sinon.stub().resolves('encrypted-prv'),\n      setRequestTracer: sinon.stub(),\n    };\n    keychains = buildKeychains();\n  });\n\n  describe('safe child key registration', function () {\n    it('serializes the hardened derivation path', async function () {\n      await keychains.add({\n        pub: XPUB,\n        source: 'user',\n        keyType: 'independent',\n        parent: 'user-root-id',\n        safeId: SAFE_ID,\n        derivedFromParentWithPath: \"m/7'\",\n      });\n\n      const derivedPath = sentBody().derivedFromParentWithPath;\n      if (typeof derivedPath !== 'string') {\n        throw new Error('expected derivedFromParentWithPath to be serialized');\n      }\n      derivedPath.should.equal(\"m/7'\");\n    });\n  });\n\n  describe('safe ed25519Multisig root (slot ④)', function () {\n    it('posts raw public key plus chain code as unpadded base32', async function () {\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n\n      const pub = sentBody().pub as string;\n      BASE32_ROOT.test(pub).should.equal(true);\n      decodeDerivableEd25519Pub(pub)\n        .pub.toString('hex')\n        .should.match(/^[0-9a-f]{64}$/);\n      decodeDerivableEd25519Pub(pub)\n        .chainCode.toString('hex')\n        .should.match(/^[0-9a-f]{64}$/);\n    });\n\n    it('mints a different chain code for each backup key', async function () {\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      const first = decodeDerivableEd25519Pub(send.firstCall.args[0].pub).chainCode;\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      const second = decodeDerivableEd25519Pub(send.secondCall.args[0].pub).chainCode;\n      first.equals(second).should.equal(false);\n    });\n\n    it('sends no separate chainCode field', async function () {\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      sentBody().should.not.have.property('chainCode');\n    });\n\n    it('still encrypts and returns the un-composed prv', async function () {\n      const result = await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      sentBody().encryptedPrv!.should.equal('encrypted-prv');\n      result.prv!.should.equal('SOME_SEED');\n    });\n  });\n\n  describe('leaves every other key untouched', function () {\n    it('does not compose without a safeId, even for an ed25519 coin', async function () {\n      await keychains.createBackup({ passphrase: 'pw' });\n      const body = sentBody();\n      body.pub!.should.equal(STRKEY_PUB);\n      (body.pub as string).length.should.equal(56);\n    });\n\n    it('does not compose a safe secp256k1Multisig root', async function () {\n      const btcKeychains = buildKeychains(XPUB);\n      await btcKeychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      sentBody().pub!.should.equal(XPUB);\n    });\n\n    it('sends a body with no chainCode and source backup', async function () {\n      await keychains.createBackup({ passphrase: 'pw' });\n\n      const body = sentBody();\n      body.should.not.have.property('chainCode');\n      body.source!.should.equal('backup');\n      body.encryptedPrv!.should.equal('encrypted-prv');\n    });\n\n    it('leaves a KRS-provider backup key untouched', async function () {\n      await keychains.createBackup({ provider: 'krs-provider', safeId: SAFE_ID });\n\n      const body = sentBody();\n      (body.pub === undefined).should.be.true();\n      body.provider!.should.equal('krs-provider');\n    });\n  });\n  describe('password rotation encryption session', function () {\n    it('uses the supplied session for the new encrypted private key', async function () {\n      mockBitGo.decrypt = sinon.stub().resolves('decrypted-prv');\n      const sessionEncrypt = sinon.stub().resolves('session-encrypted');\n      const session: IEncryptionSession = {\n        encrypt: sessionEncrypt,\n        decrypt: sinon.stub().resolves('decrypted-prv'),\n        destroy: sinon.stub(),\n      };\n\n      const updatedKeychain = await keychains.updateSingleKeychainPassword({\n        keychain: {\n          id: 'key-id',\n          encryptedPrv: 'legacy-encrypted-prv',\n          type: 'independent',\n        },\n        oldPassword: 'old-password',\n        newPassword: 'new-password',\n        encryptionVersion: 2,\n        encryptionSession: session,\n      });\n\n      sessionEncrypt.calledOnceWithExactly('decrypted-prv').should.equal(true);\n      mockBitGo.encrypt.called.should.equal(false);\n      updatedKeychain.encryptedPrv!.should.equal('session-encrypted');\n    });\n  });\n});\n\ndescribe('Keychains.updatePassword (safe mode)', function () {\n  const SAFE_ID = 'safe-123';\n  const OLD_PASSWORD = 'old-passphrase';\n  const NEW_PASSWORD = 'new-passphrase';\n\n  let keychains: Keychains;\n  let decryptStub: sinon.SinonStub;\n  let sessionEncrypt: sinon.SinonStub;\n  let sessionDestroy: sinon.SinonSpy;\n  let createEncryptionSession: sinon.SinonStub;\n  let url: sinon.SinonStub;\n  let put: sinon.SinonStub;\n  let send: sinon.SinonStub;\n\n  /** sinon records untyped args; this is the only shape updateSafePassword puts on the wire. */\n  interface SentBulkBody {\n    updates: { keyId: string; encryptedPrv: string; expectedOldEncryptedPrv: string }[];\n  }\n\n  function sentBodies(): SentBulkBody[] {\n    return send.getCalls().map((call) => call.args[0] as SentBulkBody);\n  }\n\n  function key(id: string, overrides: Partial<Keychain> = {}): Keychain {\n    return { id, pub: `pub-${id}`, type: 'independent', encryptedPrv: `enc:prv-${id}`, ...overrides };\n  }\n\n  function stubListPages(pages: Keychain[][]): sinon.SinonStub {\n    const listStub = sinon.stub(keychains, 'list');\n    listStub.callsFake(async (params: ListKeychainOptions = {}) => {\n      const pageIndex = params.prevId === undefined ? 0 : Number(params.prevId);\n      return {\n        keys: pages[pageIndex],\n        nextBatchPrevId: pageIndex + 1 < pages.length ? String(pageIndex + 1) : undefined,\n      };\n    });\n    return listStub;\n  }\n\n  beforeEach(function () {\n    sessionEncrypt = sinon.stub().callsFake(async (plaintext: string) => `enc:${plaintext}`);\n    sessionDestroy = sinon.spy();\n    createEncryptionSession = sinon.stub().resolves({ encrypt: sessionEncrypt, destroy: sessionDestroy });\n    decryptStub = sinon.stub().callsFake(async ({ input, password }: { input: string; password: string }) => {\n      if (password !== OLD_PASSWORD) {\n        throw new Error('incorrect password');\n      }\n      if (!input.startsWith('enc:')) {\n        throw new Error('incorrect password');\n      }\n      return input.slice('enc:'.length);\n    });\n    send = sinon.stub().returns({ result: sinon.stub().resolves({ updates: [] }) });\n    put = sinon.stub().returns({ send });\n    url = sinon.stub().callsFake((path: string) => path);\n    // BitGoBase and IBaseCoin are large surfaces; the tests only exercise these members.\n    const bitgo = {\n      decrypt: decryptStub,\n      createEncryptionSession,\n      encrypt: sinon.stub().resolves('new-envelope'),\n      put,\n      url,\n      setRequestTracer: sinon.stub(),\n    } as unknown as BitGoBase;\n    const baseCoin = {\n      url: sinon.stub().callsFake((path: string) => path),\n      generateKeyPair: sinon.stub(),\n    } as unknown as IBaseCoin;\n    keychains = new Keychains(bitgo, baseCoin);\n  });\n\n  it('walks all pages, rotates every envelope-bearing key and persists with one batch PUT', async function () {\n    const listStub = stubListPages([\n      [key('root-ecdsa-user'), key('msig-child', { encryptedPrv: undefined })],\n      [key('root-eddsa-user'), key('mpc-child-user')],\n    ]);\n    send.returns({ result: sinon.stub().resolves({ updates: [{ keyId: 'x', updated: true }] }) });\n\n    const response = await keychains.updatePassword({\n      oldPassword: OLD_PASSWORD,\n      newPassword: NEW_PASSWORD,\n      safeId: SAFE_ID,\n    });\n\n    // the walk is safe-scoped and paginated\n    sinon.assert.calledWith(listStub.getCall(0), { limit: 500, prevId: undefined, safeId: SAFE_ID });\n    sinon.assert.calledWith(listStub.getCall(1), { limit: 500, prevId: '1', safeId: SAFE_ID });\n\n    // one shared session, one Argon2\n    sinon.assert.calledOnce(createEncryptionSession);\n    sinon.assert.calledWith(createEncryptionSession, NEW_PASSWORD, undefined);\n\n    // keychains without an encryptedPrv are skipped; every rotation carries compare-and-swap\n    const bodies = sentBodies();\n    bodies.length.should.equal(1);\n    bodies[0].updates.map((u) => u.keyId).should.deepEqual(['root-ecdsa-user', 'root-eddsa-user', 'mpc-child-user']);\n    for (const update of bodies[0].updates) {\n      update.encryptedPrv.should.equal(`enc:prv-${update.keyId}`);\n      update.expectedOldEncryptedPrv.should.equal(`enc:prv-${update.keyId}`);\n    }\n    sinon.assert.calledOnce(put);\n    sinon.assert.calledWith(url, '/key/bulk', 2);\n\n    // the batch response is passed through\n    response.updates.should.deepEqual([{ keyId: 'x', updated: true }]);\n\n    // the SDK-owned session is destroyed afterwards\n    sinon.assert.calledOnce(sessionDestroy);\n  });\n\n  it('fails fast on the first undecryptable envelope with zero writes', async function () {\n    stubListPages([[key('good-1'), key('stale', { encryptedPrv: 'corrupt-envelope' }), key('good-2')]]);\n\n    await keychains\n      .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID })\n      .should.be.rejectedWith(/stale/);\n\n    sinon.assert.notCalled(put);\n    sinon.assert.calledOnce(sessionDestroy);\n  });\n\n  it('rejects with IncorrectPasswordError naming the offending key', async function () {\n    stubListPages([[key('stale', { encryptedPrv: 'corrupt-envelope' })]]);\n\n    try {\n      await keychains.updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID });\n      throw new Error('expected updatePassword to reject');\n    } catch (e) {\n      (e as IncorrectPasswordError).name.should.equal('IncorrectPasswordError');\n      (e as IncorrectPasswordError).message.should.match(/failed to decrypt keychain stale with the old passphrase/);\n    }\n  });\n\n  it('rejects with IncorrectPasswordError when the old passphrase does not match', async function () {\n    stubListPages([[key('root-1')]]);\n\n    await keychains\n      .updatePassword({ oldPassword: 'totally-wrong', newPassword: NEW_PASSWORD, safeId: SAFE_ID })\n      .should.be.rejectedWith(IncorrectPasswordError);\n\n    sinon.assert.notCalled(put);\n  });\n\n  it('re-encrypts through a caller-provided session without destroying it', async function () {\n    stubListPages([[key('root-1')]]);\n    const encryptedByCaller: string[] = [];\n    let callerDestroyed = false;\n    const callerSession: IEncryptionSession = {\n      encrypt: async (plaintext: string) => {\n        encryptedByCaller.push(plaintext);\n        return 'caller-session-envelope';\n      },\n      decrypt: async () => '',\n      destroy: () => {\n        callerDestroyed = true;\n      },\n    };\n\n    await keychains.updatePassword({\n      oldPassword: OLD_PASSWORD,\n      newPassword: NEW_PASSWORD,\n      safeId: SAFE_ID,\n      encryptionSession: callerSession,\n    });\n\n    sinon.assert.notCalled(createEncryptionSession);\n    encryptedByCaller.should.deepEqual(['prv-root-1']);\n    callerDestroyed.should.equal(false);\n  });\n\n  it('passes an explicit encryptionVersion to the session factory', async function () {\n    stubListPages([[key('root-1')]]);\n\n    await keychains.updatePassword({\n      oldPassword: OLD_PASSWORD,\n      newPassword: NEW_PASSWORD,\n      safeId: SAFE_ID,\n      encryptionVersion: 1,\n    });\n\n    sinon.assert.calledOnce(createEncryptionSession);\n    sinon.assert.calledWith(createEncryptionSession, NEW_PASSWORD, 1);\n  });\n\n  it('chunks the batch past the server transaction budget and merges the responses', async function () {\n    const page = Array.from({ length: 501 }, (_, i) => key(`key-${i}`));\n    stubListPages([page]);\n    send.callsFake((body: SentBulkBody) => ({\n      result: sinon.stub().resolves({ updates: body.updates.map((u) => ({ keyId: u.keyId, updated: true })) }),\n    }));\n\n    const response = await keychains.updatePassword({\n      oldPassword: OLD_PASSWORD,\n      newPassword: NEW_PASSWORD,\n      safeId: SAFE_ID,\n    });\n\n    sinon.assert.calledTwice(put);\n    sentBodies()[0].updates.length.should.equal(500);\n    sentBodies()[1].updates.length.should.equal(1);\n    response.updates.length.should.equal(501);\n  });\n\n  it('propagates a mid-chunk failure after earlier chunks were sent and destroys the session', async function () {\n    const page = Array.from({ length: 501 }, (_, i) => key(`key-${i}`));\n    stubListPages([page]);\n    let chunkIndex = 0;\n    send.callsFake((body: SentBulkBody) => {\n      chunkIndex += 1;\n      if (chunkIndex === 2) {\n        return { result: sinon.stub().rejects(new Error('boom')) };\n      }\n      return {\n        result: sinon.stub().resolves({ updates: body.updates.map((u) => ({ keyId: u.keyId, updated: true })) }),\n      };\n    });\n\n    await keychains\n      .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID })\n      .should.be.rejectedWith('boom');\n\n    // the first chunk went out before the second failed; the SDK-owned session is destroyed\n    sinon.assert.calledTwice(put);\n    sentBodies()[0].updates.length.should.equal(500);\n    sinon.assert.calledOnce(sessionDestroy);\n  });\n\n  it('rejects a chunk response missing the updates array', async function () {\n    stubListPages([[key('root-1')]]);\n    send.returns({ result: sinon.stub().resolves({ unexpected: true }) });\n\n    await keychains\n      .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: SAFE_ID })\n      .should.be.rejectedWith(/invalid key bulk update response/);\n\n    sinon.assert.calledOnce(sessionDestroy);\n  });\n\n  it('rotates nothing and issues no PUT when the safe has no encrypted keys', async function () {\n    stubListPages([[key('msig-child', { encryptedPrv: undefined }), key('placeholder', { encryptedPrv: undefined })]]);\n\n    const response = await keychains.updatePassword({\n      oldPassword: OLD_PASSWORD,\n      newPassword: NEW_PASSWORD,\n      safeId: SAFE_ID,\n    });\n\n    response.updates.should.deepEqual([]);\n    sinon.assert.notCalled(put);\n    sinon.assert.notCalled(createEncryptionSession);\n  });\n\n  it('rejects a non-string safeId', async function () {\n    // deliberate: proves the runtime guard rejects a non-string safeId\n    const unsafeId = 42 as unknown as string;\n\n    await keychains\n      .updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD, safeId: unsafeId })\n      .should.be.rejectedWith('Expecting parameter string: safeId but found number');\n  });\n\n  it('keeps legacy mode write-free', async function () {\n    // getEncryptionVersion re-parses the old envelope in the legacy path, so it must be JSON\n    const legacyKey = key('user-key', { encryptedPrv: JSON.stringify({ v: 1 }) });\n    decryptStub.callsFake(async () => 'prv-user-key');\n    sinon.stub(keychains, 'list').resolves({ keys: [legacyKey], nextBatchPrevId: undefined });\n\n    const changedKeys = await keychains.updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD });\n\n    changedKeys.should.deepEqual({ 'pub-user-key': 'new-envelope' });\n    sinon.assert.notCalled(put);\n  });\n\n  it('keeps skipping undecryptable keys in legacy mode', async function () {\n    // getEncryptionVersion re-parses the old envelope in the legacy path, so it must be JSON\n    const goodEnvelope = JSON.stringify({ v: 1, ct: 'prv-good' });\n    decryptStub.callsFake(async ({ input }: { input: string; password: string }) => {\n      if (input !== goodEnvelope) {\n        throw new Error('private key is incorrect');\n      }\n      return 'prv-good';\n    });\n    sinon.stub(keychains, 'list').resolves({\n      keys: [key('bad', { encryptedPrv: 'corrupt-envelope' }), key('good', { encryptedPrv: goodEnvelope })],\n      nextBatchPrevId: undefined,\n    });\n\n    const changedKeys = await keychains.updatePassword({ oldPassword: OLD_PASSWORD, newPassword: NEW_PASSWORD });\n\n    changedKeys.should.deepEqual({ 'pub-good': 'new-envelope' });\n    sinon.assert.notCalled(put);\n  });\n});\n\ndescribe('Keychains.list safeId filter', function () {\n  it('forwards safeId as a query parameter', async function () {\n    const query = sinon.stub();\n    const chain = { query, result: sinon.stub().resolves({ keys: [] }) };\n    query.returns(chain);\n    // BitGoBase and IBaseCoin are large surfaces; the tests only exercise these members.\n    const get = sinon.stub().returns(chain);\n    // BitGoBase and IBaseCoin are large surfaces; the tests only exercise these members.\n    const bitgo = { get } as unknown as BitGoBase;\n    const baseCoin = { url: sinon.stub().callsFake((path: string) => path) } as unknown as IBaseCoin;\n    const listKeychains = new Keychains(bitgo, baseCoin);\n\n    await listKeychains.list({ safeId: 'safe-123' });\n\n    sinon.assert.calledWith(get, '/key');\n    sinon.assert.calledWith(query, { safeId: 'safe-123' });\n  });\n});\n"]}

package/dist/test/unit/bitgo/recovery/initiate.d.ts

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

package/dist/test/unit/bitgo/recovery/initiate.d.ts.map

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