@bitgo-beta/sdk-core 8.2.1-beta.1813 → 8.2.1-beta.1815

package/dist/test/unit/bitgo/wallet/walletsExternalSigner.d.ts

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

package/dist/test/unit/bitgo/wallet/walletsExternalSigner.d.ts.map

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

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

@@ -0,0 +1,310 @@
+"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 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 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"]}