@bitgo/passkey-crypto 0.0.1 → 0.3.0

package/dist/test/integration/passkeyLifecycle.test.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const derivePassword_1 = require("../../src/derivePassword");
+const deriveEnterpriseSalt_1 = require("../../src/deriveEnterpriseSalt");
+const registerPasskey_1 = require("../../src/registerPasskey");
+const attachPasskeyToWallet_1 = require("../../src/attachPasskeyToWallet");
+const derivePasskeyPrfKey_1 = require("../../src/derivePasskeyPrfKey");
+const removePasskeyFromWallet_1 = require("../../src/removePasskeyFromWallet");
+const removePasskeyFromAccount_1 = require("../../src/removePasskeyFromAccount");
+const mockBitGo_1 = require("./helpers/mockBitGo");
+const mockProvider_1 = require("./helpers/mockProvider");
+const fixtures_1 = require("./helpers/fixtures");
+// Use sjcl directly for round-trip encryption tests — same crypto as mockBitGo
+const sjcl = require('sjcl');
+const sjclEncrypt = (password, input) => JSON.stringify(sjcl.encrypt(password, input));
+const sjclDecrypt = (password, input) => sjcl.decrypt(password, JSON.parse(input));
+describe('passkey-crypto integration', function () {
+    let initialEncryptedPrv;
+    const PRIVATE_KEY = 'xprv-test-private-key-12345';
+    before(function () {
+        // Encrypt the private key with the existing passphrase (simulates what the server stores)
+        initialEncryptedPrv = sjclEncrypt(fixtures_1.EXISTING_PASSPHRASE, PRIVATE_KEY);
+    });
+    describe('register → attach', function () {
+        it('re-encrypts the private key under the PRF-derived password', async function () {
+            const { bitgo, keychainState } = (0, mockBitGo_1.makeMockBitGo)(initialEncryptedPrv);
+            const provider = (0, mockProvider_1.makeMockProvider)();
+            const device = await (0, registerPasskey_1.registerPasskey)({ bitgo, provider, label: 'test-key' });
+            assert.strictEqual(device.credentialId, fixtures_1.CREDENTIAL_ID);
+            assert.strictEqual(device.prfSupported, true);
+            await (0, attachPasskeyToWallet_1.attachPasskeyToWallet)({
+                bitgo,
+                coin: fixtures_1.COIN,
+                walletId: fixtures_1.WALLET_ID,
+                device,
+                existingPassphrase: fixtures_1.EXISTING_PASSPHRASE,
+                provider,
+            });
+            // Verify encryptedPrv round-trips with the PRF-derived password
+            const decrypted = sjclDecrypt((0, derivePassword_1.derivePassword)(fixtures_1.PRF_OUTPUT), keychainState.encryptedPrv);
+            assert.strictEqual(decrypted, PRIVATE_KEY);
+            // prfSalt stored in webauthnInfo must be valid base64url
+            assert.ok(keychainState.webauthnDevices);
+            assert.match(keychainState.webauthnDevices[0].prfSalt, /^[A-Za-z0-9\-_]+$/);
+        });
+    });
+    describe('attach → derivePasskeyPrfKey', function () {
+        it('derives the same passphrase used to re-encrypt during attach', async function () {
+            const { bitgo, keychainState, wallet } = (0, mockBitGo_1.makeMockBitGo)(initialEncryptedPrv);
+            const provider = (0, mockProvider_1.makeMockProvider)();
+            const device = { id: fixtures_1.DEVICE_MONGO_ID, credentialId: fixtures_1.CREDENTIAL_ID, prfSalt: fixtures_1.BASE_SALT, isPasskey: true };
+            await (0, attachPasskeyToWallet_1.attachPasskeyToWallet)({
+                bitgo,
+                coin: fixtures_1.COIN,
+                walletId: fixtures_1.WALLET_ID,
+                device,
+                existingPassphrase: fixtures_1.EXISTING_PASSPHRASE,
+                provider,
+            });
+            const derivedPassphrase = await (0, derivePasskeyPrfKey_1.derivePasskeyPrfKey)({ bitgo, wallet, provider });
+            // Same passphrase as what attach used — decrypts the stored key
+            assert.strictEqual(derivedPassphrase, (0, derivePassword_1.derivePassword)(fixtures_1.PRF_OUTPUT));
+            assert.strictEqual(sjclDecrypt(derivedPassphrase, keychainState.encryptedPrv), PRIVATE_KEY);
+        });
+    });
+    describe('full lifecycle (register → attach → derive → remove)', function () {
+        it('completes all steps and hits both DEL endpoints', async function () {
+            const { bitgo, wallet } = (0, mockBitGo_1.makeMockBitGo)(initialEncryptedPrv);
+            const provider = (0, mockProvider_1.makeMockProvider)();
+            const device = await (0, registerPasskey_1.registerPasskey)({ bitgo, provider, label: 'lifecycle-key' });
+            await (0, attachPasskeyToWallet_1.attachPasskeyToWallet)({
+                bitgo,
+                coin: fixtures_1.COIN,
+                walletId: fixtures_1.WALLET_ID,
+                device,
+                existingPassphrase: fixtures_1.EXISTING_PASSPHRASE,
+                provider,
+            });
+            const passphrase = await (0, derivePasskeyPrfKey_1.derivePasskeyPrfKey)({ bitgo, wallet, provider });
+            await (0, removePasskeyFromWallet_1.removePasskeyFromWallet)({ bitgo, coin: fixtures_1.COIN, walletId: fixtures_1.WALLET_ID, device, walletPassphrase: passphrase });
+            await (0, removePasskeyFromAccount_1.removePasskeyFromAccount)({ bitgo, device });
+            const delUrls = bitgo.del.args.map((a) => a[0]);
+            assert.ok(delUrls.some((url) => url.includes(`/key/${fixtures_1.KEYCHAIN_ID}/webauthndevice/${fixtures_1.DEVICE_MONGO_ID}`)));
+            assert.ok(delUrls.some((url) => url.includes(`/user/otp/${fixtures_1.DEVICE_MONGO_ID}`)));
+        });
+    });
+    describe('PRF salt derivation wiring', function () {
+        it('passes deriveEnterpriseSalt output as the eval salt in attachPasskeyToWallet', async function () {
+            const { bitgo } = (0, mockBitGo_1.makeMockBitGo)(initialEncryptedPrv);
+            const provider = (0, mockProvider_1.makeMockProvider)();
+            const device = { id: fixtures_1.DEVICE_MONGO_ID, credentialId: fixtures_1.CREDENTIAL_ID, prfSalt: fixtures_1.BASE_SALT, isPasskey: true };
+            await (0, attachPasskeyToWallet_1.attachPasskeyToWallet)({
+                bitgo,
+                coin: fixtures_1.COIN,
+                walletId: fixtures_1.WALLET_ID,
+                device,
+                existingPassphrase: fixtures_1.EXISTING_PASSPHRASE,
+                provider,
+            });
+            assert.strictEqual(provider.lastEvalByCredential?.[fixtures_1.CREDENTIAL_ID], (0, deriveEnterpriseSalt_1.deriveEnterpriseSalt)(fixtures_1.BASE_SALT, fixtures_1.ENTERPRISE_ID));
+        });
+    });
+    describe('error propagation', function () {
+        it('aborts removePasskeyFromWallet and does not DEL when passphrase is wrong', async function () {
+            const { bitgo } = (0, mockBitGo_1.makeMockBitGo)(initialEncryptedPrv);
+            const device = { id: fixtures_1.DEVICE_MONGO_ID, credentialId: fixtures_1.CREDENTIAL_ID, prfSalt: fixtures_1.BASE_SALT, isPasskey: true };
+            // Uses real sjcl decrypt — wrong passphrase genuinely fails decryptKeychainPrivateKey
+            await assert.rejects(() => (0, removePasskeyFromWallet_1.removePasskeyFromWallet)({
+                bitgo,
+                coin: fixtures_1.COIN,
+                walletId: fixtures_1.WALLET_ID,
+                device,
+                walletPassphrase: 'wrong-passphrase',
+            }), /Incorrect wallet passphrase/);
+            assert.strictEqual(bitgo.del.callCount, 0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"passkeyLifecycle.test.js","sourceRoot":"","sources":["../../../test/integration/passkeyLifecycle.test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport { derivePassword } from '../../src/derivePassword';\nimport { deriveEnterpriseSalt } from '../../src/deriveEnterpriseSalt';\nimport { registerPasskey } from '../../src/registerPasskey';\nimport { attachPasskeyToWallet } from '../../src/attachPasskeyToWallet';\nimport { derivePasskeyPrfKey } from '../../src/derivePasskeyPrfKey';\nimport { removePasskeyFromWallet } from '../../src/removePasskeyFromWallet';\nimport { removePasskeyFromAccount } from '../../src/removePasskeyFromAccount';\nimport { makeMockBitGo } from './helpers/mockBitGo';\nimport { makeMockProvider } from './helpers/mockProvider';\nimport {\n  ENTERPRISE_ID,\n  WALLET_ID,\n  COIN,\n  EXISTING_PASSPHRASE,\n  PRF_OUTPUT,\n  CREDENTIAL_ID,\n  DEVICE_MONGO_ID,\n  BASE_SALT,\n  KEYCHAIN_ID,\n} from './helpers/fixtures';\n\n// Use sjcl directly for round-trip encryption tests — same crypto as mockBitGo\nconst sjcl = require('sjcl');\nconst sjclEncrypt = (password: string, input: string) => JSON.stringify(sjcl.encrypt(password, input));\nconst sjclDecrypt = (password: string, input: string) => sjcl.decrypt(password, JSON.parse(input));\n\ndescribe('passkey-crypto integration', function () {\n  let initialEncryptedPrv: string;\n  const PRIVATE_KEY = 'xprv-test-private-key-12345';\n\n  before(function () {\n    // Encrypt the private key with the existing passphrase (simulates what the server stores)\n    initialEncryptedPrv = sjclEncrypt(EXISTING_PASSPHRASE, PRIVATE_KEY);\n  });\n\n  describe('register → attach', function () {\n    it('re-encrypts the private key under the PRF-derived password', async function () {\n      const { bitgo, keychainState } = makeMockBitGo(initialEncryptedPrv);\n      const provider = makeMockProvider();\n\n      const device = await registerPasskey({ bitgo, provider, label: 'test-key' });\n      assert.strictEqual(device.credentialId, CREDENTIAL_ID);\n      assert.strictEqual(device.prfSupported, true);\n\n      await attachPasskeyToWallet({\n        bitgo,\n        coin: COIN,\n        walletId: WALLET_ID,\n        device,\n        existingPassphrase: EXISTING_PASSPHRASE,\n        provider,\n      });\n\n      // Verify encryptedPrv round-trips with the PRF-derived password\n      const decrypted = sjclDecrypt(derivePassword(PRF_OUTPUT), keychainState.encryptedPrv);\n      assert.strictEqual(decrypted, PRIVATE_KEY);\n\n      // prfSalt stored in webauthnInfo must be valid base64url\n      assert.ok(keychainState.webauthnDevices);\n      assert.match(keychainState.webauthnDevices[0].prfSalt, /^[A-Za-z0-9\\-_]+$/);\n    });\n  });\n\n  describe('attach → derivePasskeyPrfKey', function () {\n    it('derives the same passphrase used to re-encrypt during attach', async function () {\n      const { bitgo, keychainState, wallet } = makeMockBitGo(initialEncryptedPrv);\n      const provider = makeMockProvider();\n\n      const device = { id: DEVICE_MONGO_ID, credentialId: CREDENTIAL_ID, prfSalt: BASE_SALT, isPasskey: true };\n      await attachPasskeyToWallet({\n        bitgo,\n        coin: COIN,\n        walletId: WALLET_ID,\n        device,\n        existingPassphrase: EXISTING_PASSPHRASE,\n        provider,\n      });\n\n      const derivedPassphrase = await derivePasskeyPrfKey({ bitgo, wallet, provider });\n\n      // Same passphrase as what attach used — decrypts the stored key\n      assert.strictEqual(derivedPassphrase, derivePassword(PRF_OUTPUT));\n      assert.strictEqual(sjclDecrypt(derivedPassphrase, keychainState.encryptedPrv), PRIVATE_KEY);\n    });\n  });\n\n  describe('full lifecycle (register → attach → derive → remove)', function () {\n    it('completes all steps and hits both DEL endpoints', async function () {\n      const { bitgo, wallet } = makeMockBitGo(initialEncryptedPrv);\n      const provider = makeMockProvider();\n\n      const device = await registerPasskey({ bitgo, provider, label: 'lifecycle-key' });\n      await attachPasskeyToWallet({\n        bitgo,\n        coin: COIN,\n        walletId: WALLET_ID,\n        device,\n        existingPassphrase: EXISTING_PASSPHRASE,\n        provider,\n      });\n\n      const passphrase = await derivePasskeyPrfKey({ bitgo, wallet, provider });\n      await removePasskeyFromWallet({ bitgo, coin: COIN, walletId: WALLET_ID, device, walletPassphrase: passphrase });\n      await removePasskeyFromAccount({ bitgo, device });\n\n      const delUrls = bitgo.del.args.map((a: string[]) => a[0]);\n      assert.ok(delUrls.some((url: string) => url.includes(`/key/${KEYCHAIN_ID}/webauthndevice/${DEVICE_MONGO_ID}`)));\n      assert.ok(delUrls.some((url: string) => url.includes(`/user/otp/${DEVICE_MONGO_ID}`)));\n    });\n  });\n\n  describe('PRF salt derivation wiring', function () {\n    it('passes deriveEnterpriseSalt output as the eval salt in attachPasskeyToWallet', async function () {\n      const { bitgo } = makeMockBitGo(initialEncryptedPrv);\n      const provider = makeMockProvider();\n\n      const device = { id: DEVICE_MONGO_ID, credentialId: CREDENTIAL_ID, prfSalt: BASE_SALT, isPasskey: true };\n      await attachPasskeyToWallet({\n        bitgo,\n        coin: COIN,\n        walletId: WALLET_ID,\n        device,\n        existingPassphrase: EXISTING_PASSPHRASE,\n        provider,\n      });\n\n      assert.strictEqual(\n        provider.lastEvalByCredential?.[CREDENTIAL_ID],\n        deriveEnterpriseSalt(BASE_SALT, ENTERPRISE_ID)\n      );\n    });\n  });\n\n  describe('error propagation', function () {\n    it('aborts removePasskeyFromWallet and does not DEL when passphrase is wrong', async function () {\n      const { bitgo } = makeMockBitGo(initialEncryptedPrv);\n      const device = { id: DEVICE_MONGO_ID, credentialId: CREDENTIAL_ID, prfSalt: BASE_SALT, isPasskey: true };\n\n      // Uses real sjcl decrypt — wrong passphrase genuinely fails decryptKeychainPrivateKey\n      await assert.rejects(\n        () =>\n          removePasskeyFromWallet({\n            bitgo,\n            coin: COIN,\n            walletId: WALLET_ID,\n            device,\n            walletPassphrase: 'wrong-passphrase',\n          }),\n        /Incorrect wallet passphrase/\n      );\n\n      assert.strictEqual(bitgo.del.callCount, 0);\n    });\n  });\n});\n"]}

package/dist/test/unit/attachPasskeyToWallet.test.d.ts

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

package/dist/test/unit/attachPasskeyToWallet.test.d.ts.map

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

package/dist/test/unit/attachPasskeyToWallet.test.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+const attachPasskeyToWallet_1 = require("../../src/attachPasskeyToWallet");
+describe('attachPasskeyToWallet', function () {
+    const coin = 'tbtc';
+    const walletId = 'wallet-abc123';
+    const keychainId = 'key-user-id';
+    const enterpriseId = 'enterprise-xyz';
+    const encryptedPrv = 'encrypted-prv-string';
+    const decryptedPrv = 'xprv-decrypted';
+    const existingPassphrase = 'correct-passphrase';
+    const reEncryptedPrv = 're-encrypted-prv';
+    const prfResultBuffer = new Uint8Array([0x1e, 0x5c, 0xb4, 0x78]).buffer;
+    const device = {
+        id: 'mongo-object-id-123',
+        credentialId: 'cred-id-456',
+        prfSalt: 'ZqJ64M2dL65zn2-Jxd58SMN2ILc9QjbCFxUTGHd_LC8',
+        isPasskey: true,
+    };
+    const mockAuthResult = {
+        prfResult: prfResultBuffer,
+        credentialId: 'cred-id-456',
+        otpCode: '123456',
+    };
+    const updatedKeychain = {
+        id: keychainId,
+        pub: 'xpub-123',
+        type: 'independent',
+        encryptedPrv,
+    };
+    let mockWallet;
+    let mockWallets;
+    let mockBaseCoin;
+    let mockBitGo;
+    let mockProvider;
+    beforeEach(function () {
+        mockWallet = {
+            type: sinon.stub().returns('hot'),
+            toJSON: sinon.stub().returns({ enterprise: enterpriseId }),
+            getEncryptedUserKeychain: sinon.stub().resolves({ id: keychainId, encryptedPrv }),
+        };
+        mockWallets = {
+            get: sinon.stub().resolves(mockWallet),
+        };
+        mockBaseCoin = {
+            wallets: sinon.stub().returns(mockWallets),
+        };
+        mockBitGo = {
+            url: sinon
+                .stub()
+                .callsFake((path, version) => `/api/v${version ?? 1}${path}`),
+            coin: sinon.stub().returns(mockBaseCoin),
+            put: sinon.stub(),
+            decrypt: sinon.stub(),
+            encrypt: sinon.stub(),
+        };
+        mockProvider = {
+            create: sinon.stub(),
+            get: sinon.stub(),
+        };
+        mockBitGo.decrypt.returns(decryptedPrv);
+        mockBitGo.encrypt.returns(reEncryptedPrv);
+        const putSendStub = sinon.stub().returns({ result: sinon.stub().resolves(updatedKeychain) });
+        mockBitGo.put.returns({ send: putSendStub });
+        mockProvider.get.resolves(mockAuthResult);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    async function callAttach(overrides) {
+        return (0, attachPasskeyToWallet_1.attachPasskeyToWallet)({
+            bitgo: mockBitGo,
+            coin,
+            walletId,
+            device,
+            existingPassphrase,
+            provider: mockProvider,
+            ...overrides,
+        });
+    }
+    it('should attach a passkey and return the updated keychain', async function () {
+        const result = await callAttach();
+        sinon.assert.calledWith(mockBitGo.coin, coin);
+        sinon.assert.calledWith(mockWallets.get, { id: walletId });
+        sinon.assert.calledOnce(mockWallet.type);
+        sinon.assert.calledOnce(mockWallet.getEncryptedUserKeychain);
+        sinon.assert.calledOnce(mockBitGo.decrypt);
+        sinon.assert.calledWithExactly(mockBitGo.decrypt, { password: existingPassphrase, input: encryptedPrv });
+        // provider.get called with evalByCredential keyed on device.credentialId
+        sinon.assert.calledOnce(mockProvider.get);
+        const getArgs = mockProvider.get.firstCall.args[0];
+        assert.ok(getArgs.evalByCredential);
+        assert.strictEqual(typeof getArgs.evalByCredential[device.credentialId], 'string');
+        // allowCredentials must be populated with the credential ID as an ArrayBuffer
+        assert.ok(Array.isArray(getArgs.publicKey.allowCredentials));
+        assert.strictEqual(getArgs.publicKey.allowCredentials.length, 1);
+        assert.strictEqual(getArgs.publicKey.allowCredentials[0].type, 'public-key');
+        assert.ok(getArgs.publicKey.allowCredentials[0].id instanceof ArrayBuffer);
+        // PUT called with correct shape
+        sinon.assert.calledOnce(mockBitGo.put);
+        sinon.assert.calledWith(mockBitGo.put, `/api/v2/${coin}/key/${keychainId}`);
+        const sendStub = mockBitGo.put.firstCall.returnValue.send;
+        sinon.assert.calledOnce(sendStub);
+        const putBody = sendStub.firstCall.args[0];
+        assert.ok(putBody.webauthnInfo);
+        assert.strictEqual(putBody.webauthnInfo.otpDeviceId, device.id);
+        // prfSalt must be base64url (URL-safe, no padding) as required by server validation
+        assert.match(putBody.webauthnInfo.prfSalt, /^[A-Za-z0-9\-_]+$/);
+        assert.strictEqual(typeof putBody.webauthnInfo.encryptedPrv, 'string');
+        assert.strictEqual(result.id, keychainId);
+    });
+    it('should decode credentialId containing base64url-specific characters (- and _)', async function () {
+        const deviceWithUrlChars = {
+            ...device,
+            credentialId: 'abc-def_ghi+jkl',
+        };
+        const result = await callAttach({ device: deviceWithUrlChars });
+        assert.ok(result);
+        const getArgs = mockProvider.get.firstCall.args[0];
+        assert.ok(getArgs.publicKey.allowCredentials[0].id instanceof ArrayBuffer);
+    });
+    it('should throw if device.prfSalt is undefined', async function () {
+        const deviceNoPrf = { ...device, prfSalt: undefined };
+        await assert.rejects(() => callAttach({ device: deviceNoPrf }), (err) => {
+            assert.strictEqual(err.message, 'PRF extension not supported by this device. Please use a different passkey.');
+            return true;
+        });
+        sinon.assert.notCalled(mockBitGo.coin);
+        sinon.assert.notCalled(mockBitGo.put);
+    });
+    it('should throw if wallet is not a hot wallet', async function () {
+        mockWallet.type.returns('cold');
+        await assert.rejects(() => callAttach(), (err) => {
+            assert.ok(err.message.includes('not a hot wallet'));
+            return true;
+        });
+        sinon.assert.notCalled(mockBitGo.put);
+    });
+    it('should throw if wallet has no enterprise', async function () {
+        mockWallet.toJSON.returns({ enterprise: undefined });
+        await assert.rejects(() => callAttach(), (err) => {
+            assert.ok(err.message.includes('has no enterprise'));
+            return true;
+        });
+    });
+    it('should throw if PRF assertion returns no result', async function () {
+        mockProvider.get.resolves({ ...mockAuthResult, prfResult: undefined });
+        await assert.rejects(() => callAttach(), (err) => {
+            assert.ok(err.message.includes('PRF assertion did not return a result'));
+            return true;
+        });
+        sinon.assert.notCalled(mockBitGo.put);
+    });
+    it('should propagate decrypt errors', async function () {
+        mockBitGo.decrypt.throws(new Error('decryption failed'));
+        await assert.rejects(() => callAttach(), (err) => {
+            assert.ok(err.message.includes('decryption failed'));
+            return true;
+        });
+        sinon.assert.notCalled(mockBitGo.put);
+    });
+    it('should use device.credentialId as the key in evalByCredential', async function () {
+        await callAttach();
+        const getArgs = mockProvider.get.firstCall.args[0];
+        const evalKeys = Object.keys(getArgs.evalByCredential);
+        assert.strictEqual(evalKeys.length, 1);
+        assert.strictEqual(evalKeys[0], device.credentialId);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attachPasskeyToWallet.test.js","sourceRoot":"","sources":["../../../test/unit/attachPasskeyToWallet.test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { attachPasskeyToWallet } from '../../src/attachPasskeyToWallet';\nimport { WebAuthnOtpDevice, PasskeyAuthResult, WebAuthnProvider } from '../../src/webAuthnTypes';\n\ndescribe('attachPasskeyToWallet', function () {\n  const coin = 'tbtc';\n  const walletId = 'wallet-abc123';\n  const keychainId = 'key-user-id';\n  const enterpriseId = 'enterprise-xyz';\n  const encryptedPrv = 'encrypted-prv-string';\n  const decryptedPrv = 'xprv-decrypted';\n  const existingPassphrase = 'correct-passphrase';\n  const reEncryptedPrv = 're-encrypted-prv';\n\n  const prfResultBuffer = new Uint8Array([0x1e, 0x5c, 0xb4, 0x78]).buffer;\n\n  const device: WebAuthnOtpDevice = {\n    id: 'mongo-object-id-123',\n    credentialId: 'cred-id-456',\n    prfSalt: 'ZqJ64M2dL65zn2-Jxd58SMN2ILc9QjbCFxUTGHd_LC8',\n    isPasskey: true,\n  };\n\n  const mockAuthResult: PasskeyAuthResult = {\n    prfResult: prfResultBuffer,\n    credentialId: 'cred-id-456',\n    otpCode: '123456',\n  };\n\n  const updatedKeychain = {\n    id: keychainId,\n    pub: 'xpub-123',\n    type: 'independent' as const,\n    encryptedPrv,\n  };\n\n  let mockWallet: {\n    type: sinon.SinonStub;\n    toJSON: sinon.SinonStub;\n    getEncryptedUserKeychain: sinon.SinonStub;\n  };\n\n  let mockWallets: {\n    get: sinon.SinonStub;\n  };\n\n  let mockBaseCoin: {\n    wallets: sinon.SinonStub;\n  };\n\n  let mockBitGo: {\n    url: sinon.SinonStub;\n    coin: sinon.SinonStub;\n    put: sinon.SinonStub;\n    decrypt: sinon.SinonStub;\n    encrypt: sinon.SinonStub;\n  };\n\n  let mockProvider: {\n    create: sinon.SinonStub;\n    get: sinon.SinonStub;\n  };\n\n  beforeEach(function () {\n    mockWallet = {\n      type: sinon.stub().returns('hot'),\n      toJSON: sinon.stub().returns({ enterprise: enterpriseId }),\n      getEncryptedUserKeychain: sinon.stub().resolves({ id: keychainId, encryptedPrv }),\n    };\n\n    mockWallets = {\n      get: sinon.stub().resolves(mockWallet),\n    };\n\n    mockBaseCoin = {\n      wallets: sinon.stub().returns(mockWallets),\n    };\n\n    mockBitGo = {\n      url: sinon\n        .stub<[path: string, version?: number], string>()\n        .callsFake((path, version) => `/api/v${version ?? 1}${path}`),\n      coin: sinon.stub().returns(mockBaseCoin),\n      put: sinon.stub(),\n      decrypt: sinon.stub(),\n      encrypt: sinon.stub(),\n    };\n\n    mockProvider = {\n      create: sinon.stub(),\n      get: sinon.stub(),\n    };\n\n    mockBitGo.decrypt.returns(decryptedPrv);\n    mockBitGo.encrypt.returns(reEncryptedPrv);\n\n    const putSendStub = sinon.stub().returns({ result: sinon.stub().resolves(updatedKeychain) });\n    mockBitGo.put.returns({ send: putSendStub });\n\n    mockProvider.get.resolves(mockAuthResult);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  async function callAttach(overrides?: Partial<Parameters<typeof attachPasskeyToWallet>[0]>) {\n    return attachPasskeyToWallet({\n      bitgo: mockBitGo as unknown as Parameters<typeof attachPasskeyToWallet>[0]['bitgo'],\n      coin,\n      walletId,\n      device,\n      existingPassphrase,\n      provider: mockProvider as unknown as WebAuthnProvider,\n      ...overrides,\n    });\n  }\n\n  it('should attach a passkey and return the updated keychain', async function () {\n    const result = await callAttach();\n\n    sinon.assert.calledWith(mockBitGo.coin, coin);\n    sinon.assert.calledWith(mockWallets.get, { id: walletId });\n    sinon.assert.calledOnce(mockWallet.type);\n    sinon.assert.calledOnce(mockWallet.getEncryptedUserKeychain);\n    sinon.assert.calledOnce(mockBitGo.decrypt);\n    sinon.assert.calledWithExactly(mockBitGo.decrypt, { password: existingPassphrase, input: encryptedPrv });\n\n    // provider.get called with evalByCredential keyed on device.credentialId\n    sinon.assert.calledOnce(mockProvider.get);\n    const getArgs = mockProvider.get.firstCall.args[0];\n    assert.ok(getArgs.evalByCredential);\n    assert.strictEqual(typeof getArgs.evalByCredential[device.credentialId], 'string');\n\n    // allowCredentials must be populated with the credential ID as an ArrayBuffer\n    assert.ok(Array.isArray(getArgs.publicKey.allowCredentials));\n    assert.strictEqual(getArgs.publicKey.allowCredentials.length, 1);\n    assert.strictEqual(getArgs.publicKey.allowCredentials[0].type, 'public-key');\n    assert.ok(getArgs.publicKey.allowCredentials[0].id instanceof ArrayBuffer);\n\n    // PUT called with correct shape\n    sinon.assert.calledOnce(mockBitGo.put);\n    sinon.assert.calledWith(mockBitGo.put, `/api/v2/${coin}/key/${keychainId}`);\n    const sendStub = mockBitGo.put.firstCall.returnValue.send;\n    sinon.assert.calledOnce(sendStub);\n    const putBody = sendStub.firstCall.args[0];\n    assert.ok(putBody.webauthnInfo);\n    assert.strictEqual(putBody.webauthnInfo.otpDeviceId, device.id);\n    // prfSalt must be base64url (URL-safe, no padding) as required by server validation\n    assert.match(putBody.webauthnInfo.prfSalt, /^[A-Za-z0-9\\-_]+$/);\n    assert.strictEqual(typeof putBody.webauthnInfo.encryptedPrv, 'string');\n\n    assert.strictEqual(result.id, keychainId);\n  });\n\n  it('should decode credentialId containing base64url-specific characters (- and _)', async function () {\n    const deviceWithUrlChars: WebAuthnOtpDevice = {\n      ...device,\n      credentialId: 'abc-def_ghi+jkl',\n    };\n\n    const result = await callAttach({ device: deviceWithUrlChars });\n    assert.ok(result);\n\n    const getArgs = mockProvider.get.firstCall.args[0];\n    assert.ok(getArgs.publicKey.allowCredentials[0].id instanceof ArrayBuffer);\n  });\n\n  it('should throw if device.prfSalt is undefined', async function () {\n    const deviceNoPrf: WebAuthnOtpDevice = { ...device, prfSalt: undefined };\n\n    await assert.rejects(\n      () => callAttach({ device: deviceNoPrf }),\n      (err: Error) => {\n        assert.strictEqual(err.message, 'PRF extension not supported by this device. Please use a different passkey.');\n        return true;\n      }\n    );\n\n    sinon.assert.notCalled(mockBitGo.coin);\n    sinon.assert.notCalled(mockBitGo.put);\n  });\n\n  it('should throw if wallet is not a hot wallet', async function () {\n    mockWallet.type.returns('cold');\n\n    await assert.rejects(\n      () => callAttach(),\n      (err: Error) => {\n        assert.ok(err.message.includes('not a hot wallet'));\n        return true;\n      }\n    );\n\n    sinon.assert.notCalled(mockBitGo.put);\n  });\n\n  it('should throw if wallet has no enterprise', async function () {\n    mockWallet.toJSON.returns({ enterprise: undefined });\n\n    await assert.rejects(\n      () => callAttach(),\n      (err: Error) => {\n        assert.ok(err.message.includes('has no enterprise'));\n        return true;\n      }\n    );\n  });\n\n  it('should throw if PRF assertion returns no result', async function () {\n    mockProvider.get.resolves({ ...mockAuthResult, prfResult: undefined });\n\n    await assert.rejects(\n      () => callAttach(),\n      (err: Error) => {\n        assert.ok(err.message.includes('PRF assertion did not return a result'));\n        return true;\n      }\n    );\n\n    sinon.assert.notCalled(mockBitGo.put);\n  });\n\n  it('should propagate decrypt errors', async function () {\n    mockBitGo.decrypt.throws(new Error('decryption failed'));\n\n    await assert.rejects(\n      () => callAttach(),\n      (err: Error) => {\n        assert.ok(err.message.includes('decryption failed'));\n        return true;\n      }\n    );\n\n    sinon.assert.notCalled(mockBitGo.put);\n  });\n\n  it('should use device.credentialId as the key in evalByCredential', async function () {\n    await callAttach();\n\n    const getArgs = mockProvider.get.firstCall.args[0];\n    const evalKeys = Object.keys(getArgs.evalByCredential);\n    assert.strictEqual(evalKeys.length, 1);\n    assert.strictEqual(evalKeys[0], device.credentialId);\n  });\n});\n"]}

package/dist/test/unit/base64url.test.d.ts

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

package/dist/test/unit/base64url.test.d.ts.map

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

package/dist/test/unit/base64url.test.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const base64url_1 = require("../../src/base64url");
+describe('base64url helpers', function () {
+    describe('toBase64Url', function () {
+        it('replaces +, / and strips padding', function () {
+            assert.strictEqual((0, base64url_1.toBase64Url)('a+b/c=='), 'a-b_c');
+        });
+        it('is a no-op on already-base64url input', function () {
+            assert.strictEqual((0, base64url_1.toBase64Url)('a-b_c'), 'a-b_c');
+        });
+        it('handles empty string', function () {
+            assert.strictEqual((0, base64url_1.toBase64Url)(''), '');
+        });
+    });
+    describe('bufferToBase64Url', function () {
+        it('encodes a Buffer to unpadded base64url', function () {
+            // bytes that produce + and / in standard base64
+            const buf = Buffer.from([0xfb, 0xff, 0xbf]);
+            assert.strictEqual(buf.toString('base64'), '+/+/');
+            assert.strictEqual((0, base64url_1.bufferToBase64Url)(buf), '-_-_');
+        });
+        it('encodes an ArrayBuffer to unpadded base64url', function () {
+            const ab = new Uint8Array([0xff, 0xfe, 0xfd]).buffer;
+            assert.strictEqual((0, base64url_1.bufferToBase64Url)(ab), '__79');
+        });
+    });
+    describe('base64UrlToBuffer', function () {
+        it('round-trips through bufferToBase64Url', function () {
+            const original = Buffer.from([0x00, 0xff, 0x10, 0x20, 0xab, 0xcd]);
+            const encoded = (0, base64url_1.bufferToBase64Url)(original);
+            const decoded = (0, base64url_1.base64UrlToBuffer)(encoded);
+            assert.deepStrictEqual(decoded, original);
+        });
+        it('decodes base64url with - and _ chars', function () {
+            const decoded = (0, base64url_1.base64UrlToBuffer)('-_-_');
+            assert.deepStrictEqual(decoded, Buffer.from([0xfb, 0xff, 0xbf]));
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/deriveEnterpriseSalt.test.d.ts

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

package/dist/test/unit/deriveEnterpriseSalt.test.d.ts.map

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

package/dist/test/unit/deriveEnterpriseSalt.test.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const src_1 = require("../../src");
+// Real fixture values captured from a live environment (DB + browser devtools)
+const REAL_FIXTURE = {
+    basePrfSalt: 'ZqJ64M2dL65zn2-Jxd58SMN2ILc9QjbCFxUTGHd_LC8',
+    enterpriseId: '69c2aea1a3d7bc07f7f775c0ca86b0ec',
+    // base64url encoding of the HMAC-SHA256(baseSalt_decoded, enterpriseId) digest.
+    // Same encoding the server stores and the WebAuthn PRF extension consumes — keeping
+    // one encoding everywhere avoids the hex/base64url mismatch that broke browser PRF.
+    expectedDerivedSalt: 'oiasOqzkuyuEz_8043-3IXYghSu3LV4N_a1MLIRzmU8',
+};
+describe('deriveEnterpriseSalt', function () {
+    it('produces the correct derived salt for real fixture values', function () {
+        // Verifies SDK output matches what the retail UI produces for the same inputs,
+        // ensuring clients can move between SDK and retail app seamlessly.
+        assert.strictEqual((0, src_1.deriveEnterpriseSalt)(REAL_FIXTURE.basePrfSalt, REAL_FIXTURE.enterpriseId), REAL_FIXTURE.expectedDerivedSalt);
+    });
+    it('is deterministic — same inputs always produce the same salt', function () {
+        const first = (0, src_1.deriveEnterpriseSalt)(REAL_FIXTURE.basePrfSalt, REAL_FIXTURE.enterpriseId);
+        const second = (0, src_1.deriveEnterpriseSalt)(REAL_FIXTURE.basePrfSalt, REAL_FIXTURE.enterpriseId);
+        assert.ok(first);
+        assert.strictEqual(first, second);
+    });
+    it('produces different salts for different enterpriseIds with the same prfSalt', function () {
+        const saltA = (0, src_1.deriveEnterpriseSalt)(REAL_FIXTURE.basePrfSalt, REAL_FIXTURE.enterpriseId);
+        const saltB = (0, src_1.deriveEnterpriseSalt)(REAL_FIXTURE.basePrfSalt, 'different-enterprise-id');
+        assert.notStrictEqual(saltA, saltB);
+    });
+    it('produces different salts for different prfSalts with the same enterpriseId', function () {
+        const saltA = (0, src_1.deriveEnterpriseSalt)(REAL_FIXTURE.basePrfSalt, REAL_FIXTURE.enterpriseId);
+        const saltB = (0, src_1.deriveEnterpriseSalt)('deadbeefcafebabe0102030405060708', REAL_FIXTURE.enterpriseId);
+        assert.notStrictEqual(saltA, saltB);
+    });
+    it('returns a non-empty unpadded base64url string', function () {
+        const result = (0, src_1.deriveEnterpriseSalt)(REAL_FIXTURE.basePrfSalt, REAL_FIXTURE.enterpriseId);
+        assert.strictEqual(typeof result, 'string');
+        assert.ok(result.length > 0);
+        // Base64url alphabet, no padding. SHA-256 = 32 bytes → 43 base64url chars.
+        assert.match(result, /^[A-Za-z0-9_-]{43}$/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/derivePasskeyPrfKey.test.d.ts

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

package/dist/test/unit/derivePasskeyPrfKey.test.d.ts.map

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