@bitgo-beta/passkey-crypto 0.0.1-beta.8 → 0.0.1-beta.80

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

@@ -0,0 +1,222 @@
+"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");
+const derivePassword_1 = require("../../src/derivePassword");
+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(),
+            decryptAsync: sinon.stub(),
+            encryptAsync: sinon.stub(),
+        };
+        mockProvider = {
+            create: sinon.stub(),
+            get: sinon.stub(),
+        };
+        mockBitGo.decryptAsync.resolves(decryptedPrv);
+        mockBitGo.encryptAsync.resolves(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.decryptAsync);
+        sinon.assert.calledWithExactly(mockBitGo.decryptAsync, { 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');
+        // encryptAsync must be called with encryptionVersion 2
+        sinon.assert.calledOnce(mockBitGo.encryptAsync);
+        sinon.assert.calledWithMatch(mockBitGo.encryptAsync, { encryptionVersion: 2 });
+        assert.strictEqual(result.id, keychainId);
+    });
+    it('should re-encrypt the private key as a v2 Argon2id envelope', async function () {
+        const expectedPrfPassword = (0, derivePassword_1.derivePassword)(prfResultBuffer);
+        await callAttach();
+        // The PRF-derived password and the decrypted xprv must be passed to encryptAsync
+        sinon.assert.calledWithMatch(mockBitGo.encryptAsync, {
+            password: expectedPrfPassword,
+            input: decryptedPrv,
+            encryptionVersion: 2,
+        });
+        // The v2 blob returned by encryptAsync is what gets stored on the server
+        const putBody = mockBitGo.put.firstCall.returnValue.send.firstCall.args[0];
+        assert.strictEqual(putBody.webauthnInfo.encryptedPrv, reEncryptedPrv);
+    });
+    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.decryptAsync.rejects(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 { derivePassword } from '../../src/derivePassword';\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    decryptAsync: sinon.SinonStub;\n    encryptAsync: 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      decryptAsync: sinon.stub(),\n      encryptAsync: sinon.stub(),\n    };\n\n    mockProvider = {\n      create: sinon.stub(),\n      get: sinon.stub(),\n    };\n\n    mockBitGo.decryptAsync.resolves(decryptedPrv);\n    mockBitGo.encryptAsync.resolves(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.decryptAsync);\n    sinon.assert.calledWithExactly(mockBitGo.decryptAsync, { 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    // encryptAsync must be called with encryptionVersion 2\n    sinon.assert.calledOnce(mockBitGo.encryptAsync);\n    sinon.assert.calledWithMatch(mockBitGo.encryptAsync, { encryptionVersion: 2 });\n\n    assert.strictEqual(result.id, keychainId);\n  });\n\n  it('should re-encrypt the private key as a v2 Argon2id envelope', async function () {\n    const expectedPrfPassword = derivePassword(prfResultBuffer);\n\n    await callAttach();\n\n    // The PRF-derived password and the decrypted xprv must be passed to encryptAsync\n    sinon.assert.calledWithMatch(mockBitGo.encryptAsync, {\n      password: expectedPrfPassword,\n      input: decryptedPrv,\n      encryptionVersion: 2,\n    });\n\n    // The v2 blob returned by encryptAsync is what gets stored on the server\n    const putBody = mockBitGo.put.firstCall.returnValue.send.firstCall.args[0];\n    assert.strictEqual(putBody.webauthnInfo.encryptedPrv, reEncryptedPrv);\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.decryptAsync.rejects(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.js

@@ -39,7 +39,10 @@ const src_1 = require("../../src");
 const REAL_FIXTURE = {
     basePrfSalt: 'ZqJ64M2dL65zn2-Jxd58SMN2ILc9QjbCFxUTGHd_LC8',
     enterpriseId: '69c2aea1a3d7bc07f7f775c0ca86b0ec',
-    expectedDerivedSalt: 'oiasOqzkuyuEz/8043+3IXYghSu3LV4N/a1MLIRzmU8=',
+    // 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 () {
@@ -63,11 +66,12 @@ describe('deriveEnterpriseSalt', function () {
         const saltB = (0, src_1.deriveEnterpriseSalt)('deadbeefcafebabe0102030405060708', REAL_FIXTURE.enterpriseId);
         assert.notStrictEqual(saltA, saltB);
     });
-    it('returns a non-empty base64 string', function () {
+    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);
-        assert.match(result, /^[A-Za-z0-9+/]+=*$/);
+        // 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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
+//# 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":""}

package/dist/test/unit/derivePasskeyPrfKey.test.js

@@ -0,0 +1,152 @@
+"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 derivePasskeyPrfKey_1 = require("../../src/derivePasskeyPrfKey");
+describe('derivePasskeyPrfKey', function () {
+    const mockDevices = [
+        {
+            otpDeviceId: 'device-1',
+            authenticatorInfo: { credID: 'cred-aaa', fmt: 'none', publicKey: 'pk-1' },
+            prfSalt: 'salt-aaa',
+            encryptedPrv: 'enc-prv-1',
+        },
+        {
+            otpDeviceId: 'device-2',
+            authenticatorInfo: { credID: 'cred-bbb', fmt: 'none', publicKey: 'pk-2' },
+            prfSalt: 'salt-bbb',
+            encryptedPrv: 'enc-prv-2',
+        },
+    ];
+    function makeWallet(devices) {
+        return {
+            getEncryptedUserKeychain: sinon.stub().resolves({
+                id: 'keychain-id',
+                pub: 'xpub123',
+                encryptedPrv: 'encrypted-prv',
+                type: 'independent',
+                webauthnDevices: devices,
+            }),
+        };
+    }
+    function makeBitGo(challenge = 'dGVzdC1jaGFsbGVuZ2U=') {
+        return {
+            url: sinon.stub().callsFake((path) => `https://app.bitgo.com/api/v2${path}`),
+            get: sinon.stub().returns({
+                result: sinon.stub().resolves({ challenge }),
+            }),
+        };
+    }
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('should return a hex string on happy path', async function () {
+        const prfResult = new Uint8Array([0xde, 0xad, 0xbe, 0xef]).buffer;
+        const mockProvider = {
+            create: sinon.stub(),
+            get: sinon.stub().resolves({
+                prfResult,
+                credentialId: 'cred-aaa',
+                otpCode: 'otp-123',
+            }),
+        };
+        const wallet = makeWallet(mockDevices);
+        const mockBitGo = makeBitGo();
+        const result = await (0, derivePasskeyPrfKey_1.derivePasskeyPrfKey)({
+            bitgo: mockBitGo,
+            wallet: wallet,
+            provider: mockProvider,
+        });
+        // derivePassword converts ArrayBuffer to hex
+        assert.strictEqual(result, 'deadbeef');
+        assert.ok(mockProvider.get.calledOnce);
+        // Verify evalByCredential was passed
+        const getCallArgs = mockProvider.get.firstCall.args[0];
+        assert.strictEqual(getCallArgs.evalByCredential['cred-aaa'], 'salt-aaa');
+        assert.strictEqual(getCallArgs.evalByCredential['cred-bbb'], 'salt-bbb');
+        // Verify bitgo was used to fetch the assertion challenge
+        assert.ok(mockBitGo.get.calledOnce);
+        assert.ok(mockBitGo.url.calledWith('/user/otp/webauthn/auth', 2));
+    });
+    it("should throw 'No passkey devices available' when no devices", async function () {
+        const wallet = makeWallet(undefined);
+        const mockProvider = { create: sinon.stub(), get: sinon.stub() };
+        await assert.rejects(() => (0, derivePasskeyPrfKey_1.derivePasskeyPrfKey)({ bitgo: makeBitGo(), wallet: wallet, provider: mockProvider }), (err) => {
+            assert.strictEqual(err.message, 'No passkey devices available');
+            return true;
+        });
+    });
+    it("should throw 'No passkey devices available' when devices array is empty", async function () {
+        const wallet = makeWallet([]);
+        const mockProvider = { create: sinon.stub(), get: sinon.stub() };
+        await assert.rejects(() => (0, derivePasskeyPrfKey_1.derivePasskeyPrfKey)({ bitgo: makeBitGo(), wallet: wallet, provider: mockProvider }), (err) => {
+            assert.strictEqual(err.message, 'No passkey devices available');
+            return true;
+        });
+    });
+    it("should throw 'No passkey devices available with a valid PRF salt' when no device has prfSalt", async function () {
+        const devicesWithoutSalt = [
+            {
+                otpDeviceId: 'device-1',
+                authenticatorInfo: { credID: 'cred-aaa', fmt: 'none', publicKey: 'pk-1' },
+                prfSalt: '', // empty — buildEvalByCredential skips falsy prfSalt
+                encryptedPrv: 'enc-prv-1',
+            },
+        ];
+        const wallet = makeWallet(devicesWithoutSalt);
+        const mockProvider = { create: sinon.stub(), get: sinon.stub() };
+        await assert.rejects(() => (0, derivePasskeyPrfKey_1.derivePasskeyPrfKey)({ bitgo: makeBitGo(), wallet: wallet, provider: mockProvider }), (err) => {
+            assert.strictEqual(err.message, 'No passkey devices available with a valid PRF salt');
+            return true;
+        });
+    });
+    it("should throw 'Could not identify which passkey device was used' when credentialId not found", async function () {
+        const mockProvider = {
+            create: sinon.stub(),
+            get: sinon.stub().resolves({
+                prfResult: new ArrayBuffer(32),
+                credentialId: 'unknown-cred-id',
+                otpCode: 'otp-123',
+            }),
+        };
+        const wallet = makeWallet(mockDevices);
+        await assert.rejects(() => (0, derivePasskeyPrfKey_1.derivePasskeyPrfKey)({ bitgo: makeBitGo(), wallet: wallet, provider: mockProvider }), (err) => {
+            assert.strictEqual(err.message, 'Could not identify which passkey device was used');
+            return true;
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"derivePasskeyPrfKey.test.js","sourceRoot":"","sources":["../../../test/unit/derivePasskeyPrfKey.test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { derivePasskeyPrfKey } from '../../src/derivePasskeyPrfKey';\n\ndescribe('derivePasskeyPrfKey', function () {\n  const mockDevices = [\n    {\n      otpDeviceId: 'device-1',\n      authenticatorInfo: { credID: 'cred-aaa', fmt: 'none' as const, publicKey: 'pk-1' },\n      prfSalt: 'salt-aaa',\n      encryptedPrv: 'enc-prv-1',\n    },\n    {\n      otpDeviceId: 'device-2',\n      authenticatorInfo: { credID: 'cred-bbb', fmt: 'none' as const, publicKey: 'pk-2' },\n      prfSalt: 'salt-bbb',\n      encryptedPrv: 'enc-prv-2',\n    },\n  ];\n\n  function makeWallet(devices: typeof mockDevices | undefined) {\n    return {\n      getEncryptedUserKeychain: sinon.stub().resolves({\n        id: 'keychain-id',\n        pub: 'xpub123',\n        encryptedPrv: 'encrypted-prv',\n        type: 'independent',\n        webauthnDevices: devices,\n      }),\n    };\n  }\n\n  function makeBitGo(challenge = 'dGVzdC1jaGFsbGVuZ2U=') {\n    return {\n      url: sinon.stub().callsFake((path: string) => `https://app.bitgo.com/api/v2${path}`),\n      get: sinon.stub().returns({\n        result: sinon.stub().resolves({ challenge }),\n      }),\n    };\n  }\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('should return a hex string on happy path', async function () {\n    const prfResult = new Uint8Array([0xde, 0xad, 0xbe, 0xef]).buffer;\n\n    const mockProvider = {\n      create: sinon.stub(),\n      get: sinon.stub().resolves({\n        prfResult,\n        credentialId: 'cred-aaa',\n        otpCode: 'otp-123',\n      }),\n    };\n\n    const wallet = makeWallet(mockDevices);\n    const mockBitGo = makeBitGo();\n\n    const result = await derivePasskeyPrfKey({\n      bitgo: mockBitGo as any,\n      wallet: wallet as any,\n      provider: mockProvider,\n    });\n\n    // derivePassword converts ArrayBuffer to hex\n    assert.strictEqual(result, 'deadbeef');\n    assert.ok(mockProvider.get.calledOnce);\n    // Verify evalByCredential was passed\n    const getCallArgs = mockProvider.get.firstCall.args[0];\n    assert.strictEqual(getCallArgs.evalByCredential['cred-aaa'], 'salt-aaa');\n    assert.strictEqual(getCallArgs.evalByCredential['cred-bbb'], 'salt-bbb');\n    // Verify bitgo was used to fetch the assertion challenge\n    assert.ok(mockBitGo.get.calledOnce);\n    assert.ok(mockBitGo.url.calledWith('/user/otp/webauthn/auth', 2));\n  });\n\n  it(\"should throw 'No passkey devices available' when no devices\", async function () {\n    const wallet = makeWallet(undefined);\n    const mockProvider = { create: sinon.stub(), get: sinon.stub() };\n\n    await assert.rejects(\n      () => derivePasskeyPrfKey({ bitgo: makeBitGo() as any, wallet: wallet as any, provider: mockProvider }),\n      (err: Error) => {\n        assert.strictEqual(err.message, 'No passkey devices available');\n        return true;\n      }\n    );\n  });\n\n  it(\"should throw 'No passkey devices available' when devices array is empty\", async function () {\n    const wallet = makeWallet([] as any);\n    const mockProvider = { create: sinon.stub(), get: sinon.stub() };\n\n    await assert.rejects(\n      () => derivePasskeyPrfKey({ bitgo: makeBitGo() as any, wallet: wallet as any, provider: mockProvider }),\n      (err: Error) => {\n        assert.strictEqual(err.message, 'No passkey devices available');\n        return true;\n      }\n    );\n  });\n\n  it(\"should throw 'No passkey devices available with a valid PRF salt' when no device has prfSalt\", async function () {\n    const devicesWithoutSalt = [\n      {\n        otpDeviceId: 'device-1',\n        authenticatorInfo: { credID: 'cred-aaa', fmt: 'none' as const, publicKey: 'pk-1' },\n        prfSalt: '', // empty — buildEvalByCredential skips falsy prfSalt\n        encryptedPrv: 'enc-prv-1',\n      },\n    ];\n\n    const wallet = makeWallet(devicesWithoutSalt as any);\n    const mockProvider = { create: sinon.stub(), get: sinon.stub() };\n\n    await assert.rejects(\n      () => derivePasskeyPrfKey({ bitgo: makeBitGo() as any, wallet: wallet as any, provider: mockProvider }),\n      (err: Error) => {\n        assert.strictEqual(err.message, 'No passkey devices available with a valid PRF salt');\n        return true;\n      }\n    );\n  });\n\n  it(\"should throw 'Could not identify which passkey device was used' when credentialId not found\", async function () {\n    const mockProvider = {\n      create: sinon.stub(),\n      get: sinon.stub().resolves({\n        prfResult: new ArrayBuffer(32),\n        credentialId: 'unknown-cred-id',\n        otpCode: 'otp-123',\n      }),\n    };\n\n    const wallet = makeWallet(mockDevices);\n\n    await assert.rejects(\n      () => derivePasskeyPrfKey({ bitgo: makeBitGo() as any, wallet: wallet as any, provider: mockProvider }),\n      (err: Error) => {\n        assert.strictEqual(err.message, 'Could not identify which passkey device was used');\n        return true;\n      }\n    );\n  });\n});\n"]}

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

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

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

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