@bitgo/sdk-core 37.5.0 → 37.7.0

package/dist/test/unit/bitgo/wallet/walletsExternalSigner.js

@@ -0,0 +1,320 @@
+"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"));
+require("should");
+const wallets_1 = require("../../../../src/bitgo/wallet/wallets");
+const wallet_1 = require("../../../../src/bitgo/wallet/wallet");
+describe('Wallets - external signer onchain wallet generation', function () {
+    let wallets;
+    let mockBitGo;
+    let mockBaseCoin;
+    let mockKeychains;
+    let createKeychainCallback;
+    let sendStub;
+    const userPub = 'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';
+    const backupPub = 'xpub661MyMwAqRbcGczjuMoRm6dXaLDEhW1u34gKenbeYqAix21mdUKJyuyu5F1rzYGVxyL6tmgBUAEPrEz92mBXjByMRiJdba9wpnN37RLLAXa';
+    const bitgoPub = 'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5fTtTQBm';
+    beforeEach(function () {
+        createKeychainCallback = sinon.stub();
+        createKeychainCallback.withArgs({ source: 'user', coin: 'tbtc' }).resolves({
+            pub: userPub,
+            type: 'independent',
+            source: 'user',
+        });
+        createKeychainCallback.withArgs({ source: 'backup', coin: 'tbtc' }).resolves({
+            pub: backupPub,
+            type: 'independent',
+            source: 'backup',
+        });
+        mockKeychains = {
+            add: sinon.stub().callsFake(async (params) => ({
+                id: `${params.source}-key-id`,
+                pub: params.pub,
+                source: params.source,
+            })),
+            createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', pub: bitgoPub }),
+        };
+        const mockWalletData = { id: 'wallet-id', keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'] };
+        sendStub = sinon.stub().returns({
+            result: sinon.stub().resolves(mockWalletData),
+        });
+        mockBitGo = {
+            post: sinon.stub().returns({ send: sendStub }),
+            setRequestTracer: sinon.stub(),
+        };
+        mockBaseCoin = {
+            isEVM: sinon.stub().returns(false),
+            supportsTss: sinon.stub().returns(true),
+            getFamily: sinon.stub().returns('btc'),
+            getChain: sinon.stub().returns('tbtc'),
+            getDefaultMultisigType: sinon.stub().returns('onchain'),
+            keychains: sinon.stub().returns(mockKeychains),
+            url: sinon.stub().returns('/api/v2/tbtc/wallet/add'),
+            getConfig: sinon.stub().returns({ features: [] }),
+            supplementGenerateWallet: sinon.stub().callsFake((walletParams) => Promise.resolve(walletParams)),
+            isValidPub: sinon.stub().returns(true),
+        };
+        wallets = new wallets_1.Wallets(mockBitGo, mockBaseCoin);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('generateWalletWithExternalSigner', function () {
+        it('should create user and backup keys via callback and create wallet', async function () {
+            const result = await wallets.generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                enterprise: 'enterprise-id',
+                createKeychainCallback,
+            });
+            assert.strictEqual(createKeychainCallback.callCount, 2);
+            assert.strictEqual(mockKeychains.add.callCount, 2);
+            assert.strictEqual(mockKeychains.createBitGo.calledOnce, true);
+            assert.strictEqual(mockBitGo.post.calledOnce, true);
+            const addUserParams = mockKeychains.add.getCall(0).args[0];
+            addUserParams.should.have.property('pub', userPub);
+            addUserParams.should.have.property('keyType', 'independent');
+            addUserParams.should.have.property('source', 'user');
+            const walletBody = sendStub.firstCall.args[0];
+            walletBody.keys.should.deepEqual(['user-key-id', 'backup-key-id', 'bitgo-key-id']);
+            walletBody.label.should.equal('External Signer Wallet');
+            walletBody.enterprise.should.equal('enterprise-id');
+            result.responseType.should.equal('WalletWithKeychains');
+            assert.strictEqual(result.userKeychain.pub, userPub);
+            assert.strictEqual(result.backupKeychain.pub, backupPub);
+            assert.strictEqual(result.bitgoKeychain.pub, bitgoPub);
+        });
+        it('should pass advanced wallet type through to wallet/add', async function () {
+            await wallets.generateWalletWithExternalSigner({
+                label: 'Advanced Wallet',
+                enterprise: 'enterprise-id',
+                type: 'advanced',
+                createKeychainCallback,
+            });
+            const walletBody = sendStub.firstCall.args[0];
+            walletBody.type.should.equal('advanced');
+        });
+        it('should reject when callback source does not match requested source', async function () {
+            createKeychainCallback.withArgs({ source: 'user', coin: 'tbtc' }).resolves({
+                pub: userPub,
+                type: 'independent',
+                source: 'backup',
+            });
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('Failed to create user keychain: createKeychainCallback returned source backup, expected user');
+        });
+        it('should reject invalid type from callback', async function () {
+            const badTypeCallback = sinon.stub();
+            badTypeCallback.withArgs({ source: 'user', coin: 'tbtc' }).resolves({
+                pub: userPub,
+                type: 'tss',
+                source: 'user',
+            });
+            badTypeCallback.withArgs({ source: 'backup', coin: 'tbtc' }).resolves({
+                pub: backupPub,
+                type: 'independent',
+                source: 'backup',
+            });
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                createKeychainCallback: badTypeCallback,
+            })
+                .should.be.rejectedWith("Failed to create user keychain: createKeychainCallback returned invalid type tss, expected 'independent' for onchain multisig");
+        });
+        it('should reject TSS multisig type', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'TSS Wallet',
+                multisigType: 'tss',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('external signer wallet generation is only supported for onchain multisig wallets');
+        });
+        it('should reject custodial wallet type', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'Custodial Wallet',
+                type: 'custodial',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('external signer wallet generation is not supported for custodial onchain wallets');
+        });
+        it('should reject passcodeEncryptionCode', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'Wallet',
+                passcodeEncryptionCode: 'some-code',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('passcodeEncryptionCode is not supported for external signer wallet generation');
+        });
+        it('should reject webauthnInfo', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'Wallet',
+                webauthnInfo: { otpDeviceId: 'dev-id', prfSalt: 'salt', passphrase: 'pass' },
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('webauthnInfo is not supported for external signer wallet generation');
+        });
+        it('should reject isDistributedCustody without enterprise', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'DC Wallet',
+                type: 'cold',
+                isDistributedCustody: true,
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('must provide enterprise when creating distributed custody wallet');
+        });
+        it('should reject isDistributedCustody with non-cold type', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'DC Wallet',
+                type: 'hot',
+                isDistributedCustody: true,
+                enterprise: 'enterprise-id',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('distributed custody wallets must be type: cold');
+        });
+        it('should reject when callback returns invalid pub for coin', async function () {
+            // only invalidate user pub so the rejection source is deterministic
+            mockBaseCoin.isValidPub.callsFake((pub) => pub !== userPub);
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('Failed to create user keychain: createKeychainCallback returned invalid pub for user key on tbtc');
+        });
+        it('should wrap error when callback throws', async function () {
+            createKeychainCallback.withArgs({ source: 'user', coin: 'tbtc' }).rejects(new Error('HSM unreachable'));
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('Failed to create user keychain: HSM unreachable');
+        });
+        it('should reject with backup keychain error when backup callback throws', async function () {
+            createKeychainCallback.withArgs({ source: 'backup', coin: 'tbtc' }).rejects(new Error('HSM unreachable'));
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('Failed to create backup keychain: HSM unreachable');
+            assert.strictEqual(mockBitGo.post.callCount, 0);
+        });
+        it('should wrap non-Error thrown by callback', async function () {
+            createKeychainCallback
+                .withArgs({ source: 'user', coin: 'tbtc' })
+                .returns(Promise.reject('plain string rejection'));
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('Failed to create user keychain: plain string rejection');
+        });
+        it('should forward keySignatures to wallet params when provided', async function () {
+            const keySignatures = {
+                backup: 'deadbeef01',
+                bitgo: 'deadbeef02',
+            };
+            await wallets.generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                enterprise: 'enterprise-id',
+                createKeychainCallback,
+                keySignatures,
+            });
+            const walletBody = sendStub.firstCall.args[0];
+            walletBody.should.have.property('keySignatures');
+            walletBody.keySignatures.should.deepEqual(keySignatures);
+        });
+        it('should not include keySignatures in wallet params when not provided', async function () {
+            await wallets.generateWalletWithExternalSigner({
+                label: 'External Signer Wallet',
+                enterprise: 'enterprise-id',
+                createKeychainCallback,
+            });
+            const walletBody = sendStub.firstCall.args[0];
+            walletBody.should.not.have.property('keySignatures');
+        });
+    });
+    describe('generateWallet with createKeychainCallback', function () {
+        it('should delegate to generateWalletWithExternalSigner', async function () {
+            const generateWalletWithExternalSignerStub = sinon.stub(wallets, 'generateWalletWithExternalSigner').resolves({
+                responseType: 'WalletWithKeychains',
+                wallet: sinon.createStubInstance(wallet_1.Wallet),
+                userKeychain: { id: 'user-key-id', pub: userPub, type: 'independent' },
+                backupKeychain: { id: 'backup-key-id', pub: backupPub, type: 'independent' },
+                bitgoKeychain: { id: 'bitgo-key-id', pub: bitgoPub, type: 'independent' },
+            });
+            await wallets.generateWallet({
+                label: 'Delegated Wallet',
+                createKeychainCallback,
+            });
+            assert.strictEqual(generateWalletWithExternalSignerStub.calledOnce, true);
+            generateWalletWithExternalSignerStub.firstCall.args[0].label.should.equal('Delegated Wallet');
+        });
+        it('should reject when createKeychainCallback is combined with passphrase', async function () {
+            await wallets
+                .generateWallet({
+                label: 'Invalid Wallet',
+                passphrase: 'secret',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('createKeychainCallback cannot be used with passphrase');
+        });
+        it('should reject when createKeychainCallback is combined with userKey', async function () {
+            await wallets
+                .generateWallet({
+                label: 'Invalid Wallet',
+                userKey: 'xpub...',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('createKeychainCallback cannot be used with userKey');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletsExternalSigner.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsExternalSigner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\n\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\nimport { CreateKeychainCallback } from '../../../../src/bitgo/wallet/iWallets';\nimport { Wallet } from '../../../../src/bitgo/wallet/wallet';\n\ndescribe('Wallets - external signer onchain wallet generation', function () {\n  let wallets: Wallets;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n  let mockKeychains: any;\n  let createKeychainCallback: sinon.SinonStub<Parameters<CreateKeychainCallback>, ReturnType<CreateKeychainCallback>>;\n  let sendStub: sinon.SinonStub;\n\n  const userPub =\n    'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';\n  const backupPub =\n    'xpub661MyMwAqRbcGczjuMoRm6dXaLDEhW1u34gKenbeYqAix21mdUKJyuyu5F1rzYGVxyL6tmgBUAEPrEz92mBXjByMRiJdba9wpnN37RLLAXa';\n  const bitgoPub =\n    'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5fTtTQBm';\n\n  beforeEach(function () {\n    createKeychainCallback = sinon.stub();\n    createKeychainCallback.withArgs({ source: 'user', coin: 'tbtc' }).resolves({\n      pub: userPub,\n      type: 'independent',\n      source: 'user',\n    });\n    createKeychainCallback.withArgs({ source: 'backup', coin: 'tbtc' }).resolves({\n      pub: backupPub,\n      type: 'independent',\n      source: 'backup',\n    });\n\n    mockKeychains = {\n      add: sinon.stub().callsFake(async (params: { pub: string; source: string }) => ({\n        id: `${params.source}-key-id`,\n        pub: params.pub,\n        source: params.source,\n      })),\n      createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', pub: bitgoPub }),\n    };\n\n    const mockWalletData = { id: 'wallet-id', keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'] };\n\n    sendStub = sinon.stub().returns({\n      result: sinon.stub().resolves(mockWalletData),\n    });\n    mockBitGo = {\n      post: sinon.stub().returns({ send: sendStub }),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      isEVM: sinon.stub().returns(false),\n      supportsTss: sinon.stub().returns(true),\n      getFamily: sinon.stub().returns('btc'),\n      getChain: sinon.stub().returns('tbtc'),\n      getDefaultMultisigType: sinon.stub().returns('onchain'),\n      keychains: sinon.stub().returns(mockKeychains),\n      url: sinon.stub().returns('/api/v2/tbtc/wallet/add'),\n      getConfig: sinon.stub().returns({ features: [] }),\n      supplementGenerateWallet: sinon.stub().callsFake((walletParams: unknown) => Promise.resolve(walletParams)),\n      isValidPub: sinon.stub().returns(true),\n    };\n\n    wallets = new Wallets(mockBitGo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('generateWalletWithExternalSigner', function () {\n    it('should create user and backup keys via callback and create wallet', async function () {\n      const result = await wallets.generateWalletWithExternalSigner({\n        label: 'External Signer Wallet',\n        enterprise: 'enterprise-id',\n        createKeychainCallback,\n      });\n\n      assert.strictEqual(createKeychainCallback.callCount, 2);\n      assert.strictEqual(mockKeychains.add.callCount, 2);\n      assert.strictEqual(mockKeychains.createBitGo.calledOnce, true);\n      assert.strictEqual(mockBitGo.post.calledOnce, true);\n\n      const addUserParams = mockKeychains.add.getCall(0).args[0];\n      addUserParams.should.have.property('pub', userPub);\n      addUserParams.should.have.property('keyType', 'independent');\n      addUserParams.should.have.property('source', 'user');\n\n      const walletBody = sendStub.firstCall.args[0];\n      walletBody.keys.should.deepEqual(['user-key-id', 'backup-key-id', 'bitgo-key-id']);\n      walletBody.label.should.equal('External Signer Wallet');\n      walletBody.enterprise.should.equal('enterprise-id');\n\n      result.responseType.should.equal('WalletWithKeychains');\n      assert.strictEqual(result.userKeychain.pub, userPub);\n      assert.strictEqual(result.backupKeychain.pub, backupPub);\n      assert.strictEqual(result.bitgoKeychain.pub, bitgoPub);\n    });\n\n    it('should pass advanced wallet type through to wallet/add', async function () {\n      await wallets.generateWalletWithExternalSigner({\n        label: 'Advanced Wallet',\n        enterprise: 'enterprise-id',\n        type: 'advanced',\n        createKeychainCallback,\n      });\n\n      const walletBody = sendStub.firstCall.args[0];\n      walletBody.type.should.equal('advanced');\n    });\n\n    it('should reject when callback source does not match requested source', async function () {\n      createKeychainCallback.withArgs({ source: 'user', coin: 'tbtc' }).resolves({\n        pub: userPub,\n        type: 'independent',\n        source: 'backup',\n      });\n\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'External Signer Wallet',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith(\n          'Failed to create user keychain: createKeychainCallback returned source backup, expected user'\n        );\n    });\n\n    it('should reject invalid type from callback', async function () {\n      const badTypeCallback = sinon.stub();\n      badTypeCallback.withArgs({ source: 'user', coin: 'tbtc' }).resolves({\n        pub: userPub,\n        type: 'tss',\n        source: 'user',\n      });\n      badTypeCallback.withArgs({ source: 'backup', coin: 'tbtc' }).resolves({\n        pub: backupPub,\n        type: 'independent',\n        source: 'backup',\n      });\n\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'External Signer Wallet',\n          createKeychainCallback: badTypeCallback,\n        })\n        .should.be.rejectedWith(\n          \"Failed to create user keychain: createKeychainCallback returned invalid type tss, expected 'independent' for onchain multisig\"\n        );\n    });\n\n    it('should reject TSS multisig type', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'TSS Wallet',\n          multisigType: 'tss',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('external signer wallet generation is only supported for onchain multisig wallets');\n    });\n\n    it('should reject custodial wallet type', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'Custodial Wallet',\n          type: 'custodial',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('external signer wallet generation is not supported for custodial onchain wallets');\n    });\n\n    it('should reject passcodeEncryptionCode', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'Wallet',\n          passcodeEncryptionCode: 'some-code',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('passcodeEncryptionCode is not supported for external signer wallet generation');\n    });\n\n    it('should reject webauthnInfo', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'Wallet',\n          webauthnInfo: { otpDeviceId: 'dev-id', prfSalt: 'salt', passphrase: 'pass' },\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('webauthnInfo is not supported for external signer wallet generation');\n    });\n\n    it('should reject isDistributedCustody without enterprise', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'DC Wallet',\n          type: 'cold',\n          isDistributedCustody: true,\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('must provide enterprise when creating distributed custody wallet');\n    });\n\n    it('should reject isDistributedCustody with non-cold type', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'DC Wallet',\n          type: 'hot',\n          isDistributedCustody: true,\n          enterprise: 'enterprise-id',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('distributed custody wallets must be type: cold');\n    });\n\n    it('should reject when callback returns invalid pub for coin', async function () {\n      // only invalidate user pub so the rejection source is deterministic\n      mockBaseCoin.isValidPub.callsFake((pub: string) => pub !== userPub);\n\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'External Signer Wallet',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith(\n          'Failed to create user keychain: createKeychainCallback returned invalid pub for user key on tbtc'\n        );\n    });\n\n    it('should wrap error when callback throws', async function () {\n      createKeychainCallback.withArgs({ source: 'user', coin: 'tbtc' }).rejects(new Error('HSM unreachable'));\n\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'External Signer Wallet',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('Failed to create user keychain: HSM unreachable');\n    });\n\n    it('should reject with backup keychain error when backup callback throws', async function () {\n      createKeychainCallback.withArgs({ source: 'backup', coin: 'tbtc' }).rejects(new Error('HSM unreachable'));\n\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'External Signer Wallet',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('Failed to create backup keychain: HSM unreachable');\n\n      assert.strictEqual(mockBitGo.post.callCount, 0);\n    });\n\n    it('should wrap non-Error thrown by callback', async function () {\n      createKeychainCallback\n        .withArgs({ source: 'user', coin: 'tbtc' })\n        .returns(Promise.reject('plain string rejection'));\n\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'External Signer Wallet',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('Failed to create user keychain: plain string rejection');\n    });\n\n    it('should forward keySignatures to wallet params when provided', async function () {\n      const keySignatures = {\n        backup: 'deadbeef01',\n        bitgo: 'deadbeef02',\n      };\n\n      await wallets.generateWalletWithExternalSigner({\n        label: 'External Signer Wallet',\n        enterprise: 'enterprise-id',\n        createKeychainCallback,\n        keySignatures,\n      });\n\n      const walletBody = sendStub.firstCall.args[0];\n      walletBody.should.have.property('keySignatures');\n      walletBody.keySignatures.should.deepEqual(keySignatures);\n    });\n\n    it('should not include keySignatures in wallet params when not provided', async function () {\n      await wallets.generateWalletWithExternalSigner({\n        label: 'External Signer Wallet',\n        enterprise: 'enterprise-id',\n        createKeychainCallback,\n      });\n\n      const walletBody = sendStub.firstCall.args[0];\n      walletBody.should.not.have.property('keySignatures');\n    });\n  });\n\n  describe('generateWallet with createKeychainCallback', function () {\n    it('should delegate to generateWalletWithExternalSigner', async function () {\n      const generateWalletWithExternalSignerStub = sinon.stub(wallets, 'generateWalletWithExternalSigner').resolves({\n        responseType: 'WalletWithKeychains',\n        wallet: sinon.createStubInstance(Wallet),\n        userKeychain: { id: 'user-key-id', pub: userPub, type: 'independent' as const },\n        backupKeychain: { id: 'backup-key-id', pub: backupPub, type: 'independent' as const },\n        bitgoKeychain: { id: 'bitgo-key-id', pub: bitgoPub, type: 'independent' as const },\n      });\n\n      await wallets.generateWallet({\n        label: 'Delegated Wallet',\n        createKeychainCallback,\n      });\n\n      assert.strictEqual(generateWalletWithExternalSignerStub.calledOnce, true);\n      generateWalletWithExternalSignerStub.firstCall.args[0].label.should.equal('Delegated Wallet');\n    });\n\n    it('should reject when createKeychainCallback is combined with passphrase', async function () {\n      await wallets\n        .generateWallet({\n          label: 'Invalid Wallet',\n          passphrase: 'secret',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('createKeychainCallback cannot be used with passphrase');\n    });\n\n    it('should reject when createKeychainCallback is combined with userKey', async function () {\n      await wallets\n        .generateWallet({\n          label: 'Invalid Wallet',\n          userKey: 'xpub...',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('createKeychainCallback cannot be used with userKey');\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/wallet/walletsWebauthn.js

@@ -86,7 +86,7 @@ describe('Wallets - WebAuthn wallet creation', function () {
         sinon.restore();
     });
     describe('generateWallet with webauthnInfo', function () {
-        it('should add webauthnDevices to keychain params when webauthnInfo is provided', async function () {
+        it('should add webauthnInfo (with enterpriseId) to keychain params when webauthnInfo is provided', async function () {
             const webauthnInfo = {
                 otpDeviceId: 'device-123',
                 prfSalt: 'salt-abc',
@@ -95,15 +95,17 @@ describe('Wallets - WebAuthn wallet creation', function () {
             await wallets.generateWallet({
                 label: 'Test Wallet',
                 passphrase: 'wallet-passphrase',
+                enterprise: 'enterprise-123',
                 webauthnInfo,
             });
             assert.strictEqual(mockKeychains.add.calledOnce, true);
             const addParams = mockKeychains.add.firstCall.args[0];
-            addParams.should.have.property('webauthnDevices');
-            addParams.webauthnDevices.should.have.length(1);
-            addParams.webauthnDevices[0].should.have.property('otpDeviceId', webauthnInfo.otpDeviceId);
-            addParams.webauthnDevices[0].should.have.property('prfSalt', webauthnInfo.prfSalt);
-            addParams.webauthnDevices[0].should.have.property('encryptedPrv');
+            addParams.should.not.have.property('webauthnDevices');
+            addParams.should.have.property('webauthnInfo');
+            addParams.webauthnInfo.should.have.property('otpDeviceId', webauthnInfo.otpDeviceId);
+            addParams.webauthnInfo.should.have.property('prfSalt', webauthnInfo.prfSalt);
+            addParams.webauthnInfo.should.have.property('enterpriseId', 'enterprise-123');
+            addParams.webauthnInfo.should.have.property('encryptedPrv');
         });
         it('should encrypt user private key with the webauthn passphrase', async function () {
             const webauthnPassphrase = 'prf-derived-passphrase';
@@ -118,7 +120,7 @@ describe('Wallets - WebAuthn wallet creation', function () {
             });
             const addParams = mockKeychains.add.firstCall.args[0];
             const expectedEncryptedPrv = `encrypted:${webauthnPassphrase}:${userPrv}`;
-            addParams.webauthnDevices[0].should.have.property('encryptedPrv', expectedEncryptedPrv);
+            addParams.webauthnInfo.should.have.property('encryptedPrv', expectedEncryptedPrv);
         });
         it('should also encrypt user private key with wallet passphrase when webauthnInfo is provided', async function () {
             const walletPassphrase = 'wallet-passphrase';
@@ -152,17 +154,18 @@ describe('Wallets - WebAuthn wallet creation', function () {
             passwordsUsed.should.containEql(walletPassphrase);
             passwordsUsed.should.containEql(webauthnPassphrase);
         });
-        it('should not add webauthnDevices when webauthnInfo is not provided', async function () {
+        it('should not add webauthnInfo when webauthnInfo is not provided', async function () {
             await wallets.generateWallet({
                 label: 'Test Wallet',
                 passphrase: 'wallet-passphrase',
             });
             assert.strictEqual(mockKeychains.add.calledOnce, true);
             const addParams = mockKeychains.add.firstCall.args[0];
+            addParams.should.not.have.property('webauthnInfo');
             addParams.should.not.have.property('webauthnDevices');
         });
-        it('should not add webauthnDevices when userKey is explicitly provided (no prv available)', async function () {
-            // When a user-provided public key is used, there is no private key to encrypt, so webauthnDevices is skipped
+        it('should not add webauthnInfo when userKey is explicitly provided (no prv available)', async function () {
+            // When a user-provided public key is used, there is no private key to encrypt, so webauthnInfo is skipped
             await wallets.generateWallet({
                 label: 'Test Wallet',
                 userKey: userPub,
@@ -173,10 +176,11 @@ describe('Wallets - WebAuthn wallet creation', function () {
                     passphrase: 'prf-derived-passphrase',
                 },
             });
-            // add is called for both user keychain (pub-only) and backup keychain - neither should have webauthnDevices
+            // add is called for both user keychain (pub-only) and backup keychain - neither should have webauthnInfo
             const allAddCalls = mockKeychains.add.getCalls();
             assert.ok(allAddCalls.length > 0, 'expected keychains().add to be called at least once');
             for (const call of allAddCalls) {
+                call.args[0].should.not.have.property('webauthnInfo');
                 call.args[0].should.not.have.property('webauthnDevices');
             }
         });
@@ -197,4 +201,4 @@ describe('Wallets - WebAuthn wallet creation', function () {
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletsWebauthn.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsWebauthn.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\n\ndescribe('Wallets - WebAuthn wallet creation', function () {\n  let wallets: Wallets;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n  let mockKeychains: any;\n\n  const userPrv = 'xprvSomeUserPrivateKey';\n  const userPub =\n    'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';\n  const backupPub =\n    'xpub661MyMwAqRbcGczjuMoRm6dXaLDEhW1u34gKenbeYqAix21mdUKJyuyu5F1rzYGVxyL6tmgBUAEPrEz92mBXjByMRiJdba9wpnN37RLLAXa';\n  const bitgoPub =\n    'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5fTtTQBm';\n\n  beforeEach(function () {\n    mockKeychains = {\n      create: sinon.stub().returns({ pub: userPub, prv: userPrv }),\n      add: sinon.stub().resolves({ id: 'user-key-id', pub: userPub, encryptedPrv: 'encrypted-prv' }),\n      createBackup: sinon.stub().resolves({ id: 'backup-key-id', pub: backupPub }),\n      createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', pub: bitgoPub }),\n    };\n\n    const mockWalletData = { id: 'wallet-id', keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'] };\n\n    mockBitGo = {\n      post: sinon.stub().returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletData),\n        }),\n      }),\n      encrypt: sinon\n        .stub()\n        .callsFake(({ password, input }: { password: string; input: string }) => `encrypted:${password}:${input}`),\n      encryptAsync: sinon\n        .stub()\n        .callsFake(\n          async ({ password, input }: { password: string; input: string }) => `encrypted:${password}:${input}`\n        ),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      isEVM: sinon.stub().returns(false),\n      supportsTss: sinon.stub().returns(false),\n      getFamily: sinon.stub().returns('btc'),\n      getDefaultMultisigType: sinon.stub().returns('onchain'),\n      keychains: sinon.stub().returns(mockKeychains),\n      url: sinon.stub().returns('/test/url'),\n      isValidMofNSetup: sinon.stub().returns(true),\n      getConfig: sinon.stub().returns({ features: [] }),\n      supplementGenerateWallet: sinon.stub().callsFake((params: any) => Promise.resolve(params)),\n      signMessage: sinon.stub().resolves(Buffer.from('aabbcc', 'hex')),\n    };\n\n    wallets = new Wallets(mockBitGo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('generateWallet with webauthnInfo', function () {\n    it('should add webauthnDevices to keychain params when webauthnInfo is provided', async function () {\n      const webauthnInfo = {\n        otpDeviceId: 'device-123',\n        prfSalt: 'salt-abc',\n        passphrase: 'prf-derived-passphrase',\n      };\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo,\n      });\n\n      assert.strictEqual(mockKeychains.add.calledOnce, true);\n      const addParams = mockKeychains.add.firstCall.args[0];\n      addParams.should.have.property('webauthnDevices');\n      addParams.webauthnDevices.should.have.length(1);\n      addParams.webauthnDevices[0].should.have.property('otpDeviceId', webauthnInfo.otpDeviceId);\n      addParams.webauthnDevices[0].should.have.property('prfSalt', webauthnInfo.prfSalt);\n      addParams.webauthnDevices[0].should.have.property('encryptedPrv');\n    });\n\n    it('should encrypt user private key with the webauthn passphrase', async function () {\n      const webauthnPassphrase = 'prf-derived-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: webauthnPassphrase,\n        },\n      });\n\n      const addParams = mockKeychains.add.firstCall.args[0];\n      const expectedEncryptedPrv = `encrypted:${webauthnPassphrase}:${userPrv}`;\n      addParams.webauthnDevices[0].should.have.property('encryptedPrv', expectedEncryptedPrv);\n    });\n\n    it('should also encrypt user private key with wallet passphrase when webauthnInfo is provided', async function () {\n      const walletPassphrase = 'wallet-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: walletPassphrase,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      const addParams = mockKeychains.add.firstCall.args[0];\n      const expectedEncryptedPrv = `encrypted:${walletPassphrase}:${userPrv}`;\n      addParams.should.have.property('encryptedPrv', expectedEncryptedPrv);\n    });\n\n    it('should use separate encrypt calls for wallet passphrase and webauthn passphrase', async function () {\n      const walletPassphrase = 'wallet-passphrase';\n      const webauthnPassphrase = 'prf-derived-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: walletPassphrase,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: webauthnPassphrase,\n        },\n      });\n\n      const encryptCalls = mockBitGo.encryptAsync.getCalls();\n      const passwordsUsed = encryptCalls.map((call: sinon.SinonSpyCall) => call.args[0].password);\n      passwordsUsed.should.containEql(walletPassphrase);\n      passwordsUsed.should.containEql(webauthnPassphrase);\n    });\n\n    it('should not add webauthnDevices when webauthnInfo is not provided', async function () {\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n      });\n\n      assert.strictEqual(mockKeychains.add.calledOnce, true);\n      const addParams = mockKeychains.add.firstCall.args[0];\n      addParams.should.not.have.property('webauthnDevices');\n    });\n\n    it('should not add webauthnDevices when userKey is explicitly provided (no prv available)', async function () {\n      // When a user-provided public key is used, there is no private key to encrypt, so webauthnDevices is skipped\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        userKey: userPub,\n        backupXpub: backupPub,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      // add is called for both user keychain (pub-only) and backup keychain - neither should have webauthnDevices\n      const allAddCalls = mockKeychains.add.getCalls();\n      assert.ok(allAddCalls.length > 0, 'expected keychains().add to be called at least once');\n      for (const call of allAddCalls) {\n        call.args[0].should.not.have.property('webauthnDevices');\n      }\n    });\n\n    it('should return wallet with keychains when webauthnInfo is provided', async function () {\n      const result = await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      result.should.have.property('wallet');\n      result.should.have.property('userKeychain');\n      result.should.have.property('backupKeychain');\n      result.should.have.property('bitgoKeychain');\n    });\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletsWebauthn.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsWebauthn.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,6CAA+B;AAC/B,kBAAgB;AAChB,kEAA+D;AAE/D,QAAQ,CAAC,oCAAoC,EAAE;IAC7C,IAAI,OAAgB,CAAC;IACrB,IAAI,SAAc,CAAC;IACnB,IAAI,YAAiB,CAAC;IACtB,IAAI,aAAkB,CAAC;IAEvB,MAAM,OAAO,GAAG,wBAAwB,CAAC;IACzC,MAAM,OAAO,GACX,iHAAiH,CAAC;IACpH,MAAM,SAAS,GACb,iHAAiH,CAAC;IACpH,MAAM,QAAQ,GACZ,iHAAiH,CAAC;IAEpH,UAAU,CAAC;QACT,aAAa,GAAG;YACd,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;YAC5D,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,aAAa,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,CAAC;YAC9F,YAAY,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;YAC5E,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;SAC1E,CAAC;QAEF,MAAM,cAAc,GAAG,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,aAAa,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,CAAC;QAEnG,SAAS,GAAG;YACV,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC;gBACzB,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC;oBACzB,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC;iBAC9C,CAAC;aACH,CAAC;YACF,OAAO,EAAE,KAAK;iBACX,IAAI,EAAE;iBACN,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAuC,EAAE,EAAE,CAAC,aAAa,QAAQ,IAAI,KAAK,EAAE,CAAC;YAC5G,YAAY,EAAE,KAAK;iBAChB,IAAI,EAAE;iBACN,SAAS,CACR,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAuC,EAAE,EAAE,CAAC,aAAa,QAAQ,IAAI,KAAK,EAAE,CACrG;YACH,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE;SAC/B,CAAC;QAEF,YAAY,GAAG;YACb,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;YAClC,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;YACxC,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;YACtC,sBAAsB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC;YACvD,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC;YAC9C,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC;YACtC,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;YAC5C,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;YACjD,wBAAwB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC1F,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;SACjE,CAAC;QAEF,OAAO,GAAG,IAAI,iBAAO,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC;QACR,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,kCAAkC,EAAE;QAC3C,EAAE,CAAC,8FAA8F,EAAE,KAAK;YACtG,MAAM,YAAY,GAAG;gBACnB,WAAW,EAAE,YAAY;gBACzB,OAAO,EAAE,UAAU;gBACnB,UAAU,EAAE,wBAAwB;aACrC,CAAC;YAEF,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,aAAa;gBACpB,UAAU,EAAE,mBAAmB;gBAC/B,UAAU,EAAE,gBAAgB;gBAC5B,YAAY;aACb,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YACvD,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACtD,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YACtD,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YAC/C,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;YACrF,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;YAC7E,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;YAC9E,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8DAA8D,EAAE,KAAK;YACtE,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;YAEpD,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,aAAa;gBACpB,UAAU,EAAE,mBAAmB;gBAC/B,YAAY,EAAE;oBACZ,WAAW,EAAE,YAAY;oBACzB,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,kBAAkB;iBAC/B;aACF,CAAC,CAAC;YAEH,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACtD,MAAM,oBAAoB,GAAG,aAAa,kBAAkB,IAAI,OAAO,EAAE,CAAC;YAC1E,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;QACpF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2FAA2F,EAAE,KAAK;YACnG,MAAM,gBAAgB,GAAG,mBAAmB,CAAC;YAE7C,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,aAAa;gBACpB,UAAU,EAAE,gBAAgB;gBAC5B,YAAY,EAAE;oBACZ,WAAW,EAAE,YAAY;oBACzB,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,wBAAwB;iBACrC;aACF,CAAC,CAAC;YAEH,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACtD,MAAM,oBAAoB,GAAG,aAAa,gBAAgB,IAAI,OAAO,EAAE,CAAC;YACxE,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iFAAiF,EAAE,KAAK;YACzF,MAAM,gBAAgB,GAAG,mBAAmB,CAAC;YAC7C,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;YAEpD,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,aAAa;gBACpB,UAAU,EAAE,gBAAgB;gBAC5B,YAAY,EAAE;oBACZ,WAAW,EAAE,YAAY;oBACzB,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,kBAAkB;iBAC/B;aACF,CAAC,CAAC;YAEH,MAAM,YAAY,GAAG,SAAS,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YACvD,MAAM,aAAa,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,IAAwB,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC5F,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;YAClD,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+DAA+D,EAAE,KAAK;YACvE,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,aAAa;gBACpB,UAAU,EAAE,mBAAmB;aAChC,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YACvD,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACtD,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YACnD,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oFAAoF,EAAE,KAAK;YAC5F,0GAA0G;YAC1G,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,aAAa;gBACpB,OAAO,EAAE,OAAO;gBAChB,UAAU,EAAE,SAAS;gBACrB,YAAY,EAAE;oBACZ,WAAW,EAAE,YAAY;oBACzB,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,wBAAwB;iBACrC;aACF,CAAC,CAAC;YAEH,yGAAyG;YACzG,MAAM,WAAW,GAAG,aAAa,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;YACjD,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,qDAAqD,CAAC,CAAC;YACzF,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;gBAC/B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;gBACtD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mEAAmE,EAAE,KAAK;YAC3E,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC1C,KAAK,EAAE,aAAa;gBACpB,UAAU,EAAE,mBAAmB;gBAC/B,YAAY,EAAE;oBACZ,WAAW,EAAE,YAAY;oBACzB,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,wBAAwB;iBACrC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACtC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;YAC9C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\n\ndescribe('Wallets - WebAuthn wallet creation', function () {\n  let wallets: Wallets;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n  let mockKeychains: any;\n\n  const userPrv = 'xprvSomeUserPrivateKey';\n  const userPub =\n    'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';\n  const backupPub =\n    'xpub661MyMwAqRbcGczjuMoRm6dXaLDEhW1u34gKenbeYqAix21mdUKJyuyu5F1rzYGVxyL6tmgBUAEPrEz92mBXjByMRiJdba9wpnN37RLLAXa';\n  const bitgoPub =\n    'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5fTtTQBm';\n\n  beforeEach(function () {\n    mockKeychains = {\n      create: sinon.stub().returns({ pub: userPub, prv: userPrv }),\n      add: sinon.stub().resolves({ id: 'user-key-id', pub: userPub, encryptedPrv: 'encrypted-prv' }),\n      createBackup: sinon.stub().resolves({ id: 'backup-key-id', pub: backupPub }),\n      createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', pub: bitgoPub }),\n    };\n\n    const mockWalletData = { id: 'wallet-id', keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'] };\n\n    mockBitGo = {\n      post: sinon.stub().returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletData),\n        }),\n      }),\n      encrypt: sinon\n        .stub()\n        .callsFake(({ password, input }: { password: string; input: string }) => `encrypted:${password}:${input}`),\n      encryptAsync: sinon\n        .stub()\n        .callsFake(\n          async ({ password, input }: { password: string; input: string }) => `encrypted:${password}:${input}`\n        ),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      isEVM: sinon.stub().returns(false),\n      supportsTss: sinon.stub().returns(false),\n      getFamily: sinon.stub().returns('btc'),\n      getDefaultMultisigType: sinon.stub().returns('onchain'),\n      keychains: sinon.stub().returns(mockKeychains),\n      url: sinon.stub().returns('/test/url'),\n      isValidMofNSetup: sinon.stub().returns(true),\n      getConfig: sinon.stub().returns({ features: [] }),\n      supplementGenerateWallet: sinon.stub().callsFake((params: any) => Promise.resolve(params)),\n      signMessage: sinon.stub().resolves(Buffer.from('aabbcc', 'hex')),\n    };\n\n    wallets = new Wallets(mockBitGo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('generateWallet with webauthnInfo', function () {\n    it('should add webauthnInfo (with enterpriseId) to keychain params when webauthnInfo is provided', async function () {\n      const webauthnInfo = {\n        otpDeviceId: 'device-123',\n        prfSalt: 'salt-abc',\n        passphrase: 'prf-derived-passphrase',\n      };\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        enterprise: 'enterprise-123',\n        webauthnInfo,\n      });\n\n      assert.strictEqual(mockKeychains.add.calledOnce, true);\n      const addParams = mockKeychains.add.firstCall.args[0];\n      addParams.should.not.have.property('webauthnDevices');\n      addParams.should.have.property('webauthnInfo');\n      addParams.webauthnInfo.should.have.property('otpDeviceId', webauthnInfo.otpDeviceId);\n      addParams.webauthnInfo.should.have.property('prfSalt', webauthnInfo.prfSalt);\n      addParams.webauthnInfo.should.have.property('enterpriseId', 'enterprise-123');\n      addParams.webauthnInfo.should.have.property('encryptedPrv');\n    });\n\n    it('should encrypt user private key with the webauthn passphrase', async function () {\n      const webauthnPassphrase = 'prf-derived-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: webauthnPassphrase,\n        },\n      });\n\n      const addParams = mockKeychains.add.firstCall.args[0];\n      const expectedEncryptedPrv = `encrypted:${webauthnPassphrase}:${userPrv}`;\n      addParams.webauthnInfo.should.have.property('encryptedPrv', expectedEncryptedPrv);\n    });\n\n    it('should also encrypt user private key with wallet passphrase when webauthnInfo is provided', async function () {\n      const walletPassphrase = 'wallet-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: walletPassphrase,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      const addParams = mockKeychains.add.firstCall.args[0];\n      const expectedEncryptedPrv = `encrypted:${walletPassphrase}:${userPrv}`;\n      addParams.should.have.property('encryptedPrv', expectedEncryptedPrv);\n    });\n\n    it('should use separate encrypt calls for wallet passphrase and webauthn passphrase', async function () {\n      const walletPassphrase = 'wallet-passphrase';\n      const webauthnPassphrase = 'prf-derived-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: walletPassphrase,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: webauthnPassphrase,\n        },\n      });\n\n      const encryptCalls = mockBitGo.encryptAsync.getCalls();\n      const passwordsUsed = encryptCalls.map((call: sinon.SinonSpyCall) => call.args[0].password);\n      passwordsUsed.should.containEql(walletPassphrase);\n      passwordsUsed.should.containEql(webauthnPassphrase);\n    });\n\n    it('should not add webauthnInfo when webauthnInfo is not provided', async function () {\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n      });\n\n      assert.strictEqual(mockKeychains.add.calledOnce, true);\n      const addParams = mockKeychains.add.firstCall.args[0];\n      addParams.should.not.have.property('webauthnInfo');\n      addParams.should.not.have.property('webauthnDevices');\n    });\n\n    it('should not add webauthnInfo when userKey is explicitly provided (no prv available)', async function () {\n      // When a user-provided public key is used, there is no private key to encrypt, so webauthnInfo is skipped\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        userKey: userPub,\n        backupXpub: backupPub,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      // add is called for both user keychain (pub-only) and backup keychain - neither should have webauthnInfo\n      const allAddCalls = mockKeychains.add.getCalls();\n      assert.ok(allAddCalls.length > 0, 'expected keychains().add to be called at least once');\n      for (const call of allAddCalls) {\n        call.args[0].should.not.have.property('webauthnInfo');\n        call.args[0].should.not.have.property('webauthnDevices');\n      }\n    });\n\n    it('should return wallet with keychains when webauthnInfo is provided', async function () {\n      const result = await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      result.should.have.property('wallet');\n      result.should.have.property('userKeychain');\n      result.should.have.property('backupKeychain');\n      result.should.have.property('bitgoKeychain');\n    });\n  });\n});\n"]}