@bitgo/sdk-core 38.18.0 → 38.20.0

package/dist/src/bitgo/webauthn/base64url.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Base64url encoding helpers.
+ *
+ * Base64url uses the same alphabet as standard base64 except `+` becomes `-`,
+ * `/` becomes `_`, and padding (`=`) is stripped. Browser WebAuthn APIs and
+ * the BitGo server both use base64url for credential IDs and PRF salts, so we
+ * normalise to it everywhere on the client to avoid mismatches caused by
+ * mixing encodings.
+ */
+/** Converts a standard base64 string (or already-base64url string) to base64url. */
+export declare function toBase64Url(s: string): string;
+/** Encodes an ArrayBuffer or Buffer as a base64url string (no padding). */
+export declare function bufferToBase64Url(buffer: ArrayBuffer | Buffer): string;
+/** Decodes a base64url string into a Buffer. */
+export declare function base64UrlToBuffer(s: string): Buffer;
+//# sourceMappingURL=base64url.d.ts.map

package/dist/src/bitgo/webauthn/base64url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64url.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/webauthn/base64url.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,oFAAoF;AACpF,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,CAEtE;AAED,gDAAgD;AAChD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/src/bitgo/webauthn/base64url.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Base64url encoding helpers.
+ *
+ * Base64url uses the same alphabet as standard base64 except `+` becomes `-`,
+ * `/` becomes `_`, and padding (`=`) is stripped. Browser WebAuthn APIs and
+ * the BitGo server both use base64url for credential IDs and PRF salts, so we
+ * normalise to it everywhere on the client to avoid mismatches caused by
+ * mixing encodings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64Url = toBase64Url;
+exports.bufferToBase64Url = bufferToBase64Url;
+exports.base64UrlToBuffer = base64UrlToBuffer;
+/** Converts a standard base64 string (or already-base64url string) to base64url. */
+function toBase64Url(s) {
+    return s.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+/** Encodes an ArrayBuffer or Buffer as a base64url string (no padding). */
+function bufferToBase64Url(buffer) {
+    return toBase64Url(Buffer.from(buffer).toString('base64'));
+}
+/** Decodes a base64url string into a Buffer. */
+function base64UrlToBuffer(s) {
+    return Buffer.from(s.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/webauthn/deriveEnterpriseSalt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derives an enterprise-scoped PRF salt to prevent cross-enterprise key reuse.
+ *
+ * Computes HMAC-SHA256(key=prfSalt_base64url_decoded, data=enterpriseId_utf8).
+ * The baseSalt must always come from the server — never generate it client-side.
+ *
+ * Returns base64url so the same encoding is used everywhere the salt is handled
+ * (server storage, PRF eval input, prfHelpers lookup). Mixing encodings
+ * (e.g. hex on the client, base64url on the server) caused the PRF to receive
+ * different bytes during attach vs derive in browser environments where
+ * `Buffer.toString('hex')` is unreliable.
+ *
+ * @param baseSalt - Server-provided base64url-encoded PRF salt
+ * @param enterpriseId - Enterprise identifier
+ * @returns Base64url-encoded HMAC-SHA256 digest (no padding)
+ */
+export declare function deriveEnterpriseSalt(baseSalt: string, enterpriseId: string): string;
+//# sourceMappingURL=deriveEnterpriseSalt.d.ts.map

package/dist/src/bitgo/webauthn/deriveEnterpriseSalt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveEnterpriseSalt.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/webauthn/deriveEnterpriseSalt.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAGnF"}

package/dist/src/bitgo/webauthn/deriveEnterpriseSalt.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveEnterpriseSalt = deriveEnterpriseSalt;
+const crypto_1 = require("crypto");
+const base64url_1 = require("./base64url");
+/**
+ * Derives an enterprise-scoped PRF salt to prevent cross-enterprise key reuse.
+ *
+ * Computes HMAC-SHA256(key=prfSalt_base64url_decoded, data=enterpriseId_utf8).
+ * The baseSalt must always come from the server — never generate it client-side.
+ *
+ * Returns base64url so the same encoding is used everywhere the salt is handled
+ * (server storage, PRF eval input, prfHelpers lookup). Mixing encodings
+ * (e.g. hex on the client, base64url on the server) caused the PRF to receive
+ * different bytes during attach vs derive in browser environments where
+ * `Buffer.toString('hex')` is unreliable.
+ *
+ * @param baseSalt - Server-provided base64url-encoded PRF salt
+ * @param enterpriseId - Enterprise identifier
+ * @returns Base64url-encoded HMAC-SHA256 digest (no padding)
+ */
+function deriveEnterpriseSalt(baseSalt, enterpriseId) {
+    const keyBytes = (0, base64url_1.base64UrlToBuffer)(baseSalt);
+    return (0, base64url_1.toBase64Url)((0, crypto_1.createHmac)('sha256', keyBytes).update(enterpriseId).digest('base64'));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/webauthn/derivePassword.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Derives a wallet passphrase from a WebAuthn PRF result.
+ *
+ * The PRF output (ArrayBuffer) is hex-encoded and used directly as the
+ * walletPassphrase for SJCL-based encryption (bitgo.encrypt).
+ *
+ * @param prfResult - Raw PRF output from WebAuthn credential assertion
+ * @returns Lowercase hex string to use as walletPassphrase
+ */
+export declare function derivePassword(prfResult: ArrayBuffer): string;
+//# sourceMappingURL=derivePassword.d.ts.map

package/dist/src/bitgo/webauthn/derivePassword.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivePassword.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/webauthn/derivePassword.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,WAAW,GAAG,MAAM,CAE7D"}

package/dist/src/bitgo/webauthn/derivePassword.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivePassword = derivePassword;
+/**
+ * Derives a wallet passphrase from a WebAuthn PRF result.
+ *
+ * The PRF output (ArrayBuffer) is hex-encoded and used directly as the
+ * walletPassphrase for SJCL-based encryption (bitgo.encrypt).
+ *
+ * @param prfResult - Raw PRF output from WebAuthn credential assertion
+ * @returns Lowercase hex string to use as walletPassphrase
+ */
+function derivePassword(prfResult) {
+    return Buffer.from(prfResult).toString('hex');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVyaXZlUGFzc3dvcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYml0Z28vd2ViYXV0aG4vZGVyaXZlUGFzc3dvcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFTQSx3Q0FFQztBQVhEOzs7Ozs7OztHQVFHO0FBQ0gsU0FBZ0IsY0FBYyxDQUFDLFNBQXNCO0lBQ25ELE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDaEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGVyaXZlcyBhIHdhbGxldCBwYXNzcGhyYXNlIGZyb20gYSBXZWJBdXRobiBQUkYgcmVzdWx0LlxuICpcbiAqIFRoZSBQUkYgb3V0cHV0IChBcnJheUJ1ZmZlcikgaXMgaGV4LWVuY29kZWQgYW5kIHVzZWQgZGlyZWN0bHkgYXMgdGhlXG4gKiB3YWxsZXRQYXNzcGhyYXNlIGZvciBTSkNMLWJhc2VkIGVuY3J5cHRpb24gKGJpdGdvLmVuY3J5cHQpLlxuICpcbiAqIEBwYXJhbSBwcmZSZXN1bHQgLSBSYXcgUFJGIG91dHB1dCBmcm9tIFdlYkF1dGhuIGNyZWRlbnRpYWwgYXNzZXJ0aW9uXG4gKiBAcmV0dXJucyBMb3dlcmNhc2UgaGV4IHN0cmluZyB0byB1c2UgYXMgd2FsbGV0UGFzc3BocmFzZVxuICovXG5leHBvcnQgZnVuY3Rpb24gZGVyaXZlUGFzc3dvcmQocHJmUmVzdWx0OiBBcnJheUJ1ZmZlcik6IHN0cmluZyB7XG4gIHJldHVybiBCdWZmZXIuZnJvbShwcmZSZXN1bHQpLnRvU3RyaW5nKCdoZXgnKTtcbn1cbiJdfQ==

package/dist/src/bitgo/webauthn/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base64url';
+export * from './deriveEnterpriseSalt';
+export * from './derivePassword';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/bitgo/webauthn/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/webauthn/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC"}

package/dist/src/bitgo/webauthn/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base64url"), exports);
+__exportStar(require("./deriveEnterpriseSalt"), exports);
+__exportStar(require("./derivePassword"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYml0Z28vd2ViYXV0aG4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QjtBQUM1Qix5REFBdUM7QUFDdkMsbURBQWlDO0FBQ2pDLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZTY0dXJsJztcbmV4cG9ydCAqIGZyb20gJy4vZGVyaXZlRW50ZXJwcmlzZVNhbHQnO1xuZXhwb3J0ICogZnJvbSAnLi9kZXJpdmVQYXNzd29yZCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/src/bitgo/webauthn/types.d.ts

@@ -0,0 +1,18 @@
+export type { WebAuthnOtpDevice } from '@bitgo/public-types';
+/** Result of a WebAuthn assertion with the PRF extension. */
+export interface PasskeyAuthResult {
+    prfResult: ArrayBuffer | undefined;
+    credentialId: string;
+    otpCode: string;
+}
+/** Options for WebAuthnProvider.get(). */
+export interface PasskeyGetOptions {
+    publicKey: PublicKeyCredentialRequestOptions;
+    evalByCredential?: Record<string, string>;
+}
+/** Abstraction over the WebAuthn credential API. */
+export interface WebAuthnProvider {
+    create(options: PublicKeyCredentialCreationOptions): Promise<PublicKeyCredential>;
+    get(options: PasskeyGetOptions): Promise<PasskeyAuthResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/bitgo/webauthn/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/webauthn/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,WAAW,GAAG,SAAS,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,0CAA0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,iCAAiC,CAAC;IAC7C,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,oDAAoD;AACpD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,OAAO,EAAE,kCAAkC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAClF,GAAG,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC7D"}

package/dist/src/bitgo/webauthn/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYml0Z28vd2ViYXV0aG4vdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgV2ViQXV0aG5PdHBEZXZpY2UgfSBmcm9tICdAYml0Z28vcHVibGljLXR5cGVzJztcblxuLyoqIFJlc3VsdCBvZiBhIFdlYkF1dGhuIGFzc2VydGlvbiB3aXRoIHRoZSBQUkYgZXh0ZW5zaW9uLiAqL1xuZXhwb3J0IGludGVyZmFjZSBQYXNza2V5QXV0aFJlc3VsdCB7XG4gIHByZlJlc3VsdDogQXJyYXlCdWZmZXIgfCB1bmRlZmluZWQ7XG4gIGNyZWRlbnRpYWxJZDogc3RyaW5nO1xuICBvdHBDb2RlOiBzdHJpbmc7XG59XG5cbi8qKiBPcHRpb25zIGZvciBXZWJBdXRoblByb3ZpZGVyLmdldCgpLiAqL1xuZXhwb3J0IGludGVyZmFjZSBQYXNza2V5R2V0T3B0aW9ucyB7XG4gIHB1YmxpY0tleTogUHVibGljS2V5Q3JlZGVudGlhbFJlcXVlc3RPcHRpb25zO1xuICBldmFsQnlDcmVkZW50aWFsPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcbn1cblxuLyoqIEFic3RyYWN0aW9uIG92ZXIgdGhlIFdlYkF1dGhuIGNyZWRlbnRpYWwgQVBJLiAqL1xuZXhwb3J0IGludGVyZmFjZSBXZWJBdXRoblByb3ZpZGVyIHtcbiAgY3JlYXRlKG9wdGlvbnM6IFB1YmxpY0tleUNyZWRlbnRpYWxDcmVhdGlvbk9wdGlvbnMpOiBQcm9taXNlPFB1YmxpY0tleUNyZWRlbnRpYWw+O1xuICBnZXQob3B0aW9uczogUGFzc2tleUdldE9wdGlvbnMpOiBQcm9taXNlPFBhc3NrZXlBdXRoUmVzdWx0Pjtcbn1cbiJdfQ==

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

@@ -36,6 +36,7 @@ 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';
@@ -163,4 +164,263 @@ describe('Keychains.createBackup', function () {
         });
     });
 });
-//# 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';\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"]}
+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"]}