@bitgo-beta/sdk-core 8.2.1-beta.192 → 8.2.1-beta.1921

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

@@ -0,0 +1,670 @@
+"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 utils_1 = require("../../../../src/bitgo/utils");
+const statics_1 = require("@bitgo-beta/statics");
+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((params) => Promise.resolve({ 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),
+            getMPCAlgorithm: sinon.stub().returns('ecdsa'),
+            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((params) => Promise.resolve(params)),
+            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 without TSS callbacks', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                createKeychainCallback,
+            })
+                .should.be.rejectedWith('ecdsaMPCv2Callbacks is required for ECDSA TSS wallet generation with external signer');
+        });
+        it('should route to onchain when createKeychainCallback is provided on a TSS-default coin', async function () {
+            mockBaseCoin.getDefaultMultisigType.returns('tss');
+            await wallets.generateWalletWithExternalSigner({
+                label: 'Onchain on TSS coin',
+                enterprise: 'enterprise-id',
+                createKeychainCallback,
+            });
+            assert.strictEqual(createKeychainCallback.callCount, 2);
+            assert.strictEqual(mockKeychains.createBitGo.calledOnce, true);
+        });
+        it('should reject when both createKeychainCallback and MPC callbacks are provided', async function () {
+            await wallets
+                .generateWalletWithExternalSigner({
+                label: 'Ambiguous Wallet',
+                enterprise: 'enterprise-id',
+                createKeychainCallback,
+                ecdsaMPCv2Callbacks: {
+                    initializeCallback: sinon.stub(),
+                    round2Callback: sinon.stub(),
+                    round3Callback: sinon.stub(),
+                    finalizeCallback: sinon.stub(),
+                },
+            })
+                .should.be.rejectedWith('createKeychainCallback cannot be used together with MPC TSS key generation callbacks');
+        });
+        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 () {
+            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('generateWalletWithExternalSigner - ECDSA MPCv2 TSS', function () {
+        let ecdsaCallbacks;
+        let ecdsaMockBaseCoin;
+        let ecdsaWallets;
+        const commonKeychain = 'abc123commonkeychain';
+        beforeEach(function () {
+            const mpcState = { encryptedData: 'data', encryptedDataKey: 'data-key' };
+            ecdsaCallbacks = {
+                initializeCallback: sinon.stub().resolves({
+                    userGpgPublicKey: 'user-gpg-pub',
+                    backupGpgPublicKey: 'backup-gpg-pub',
+                    round1Messages: { broadcastMessages: [], p2pMessages: [] },
+                    userState: mpcState,
+                    backupState: mpcState,
+                }),
+                round2Callback: sinon.stub().resolves({
+                    round2Messages: { broadcastMessages: [], p2pMessages: [] },
+                    userState: mpcState,
+                    backupState: mpcState,
+                }),
+                round3Callback: sinon.stub().resolves({
+                    round3Messages: { broadcastMessages: [], p2pMessages: [] },
+                    userState: mpcState,
+                    backupState: mpcState,
+                }),
+                finalizeCallback: sinon.stub().resolves({ commonKeychain }),
+            };
+            const mockEcdsaBitGo = {
+                post: sinon.stub().returns({
+                    send: sinon.stub().returns({ result: sinon.stub().resolves({ id: 'tss-wallet-id' }) }),
+                }),
+                get: sinon.stub().returns({ result: sinon.stub().resolves({ coinSettings: {} }) }),
+                setRequestTracer: sinon.stub(),
+                microservicesUrl: sinon.stub().returns('/api/v2/tss/settings'),
+            };
+            ecdsaMockBaseCoin = {
+                isEVM: sinon.stub().returns(false),
+                supportsTss: sinon.stub().returns(true),
+                getMPCAlgorithm: sinon.stub().returns('ecdsa'),
+                getFamily: sinon.stub().returns('eth'),
+                getChain: sinon.stub().returns('teth'),
+                getDefaultMultisigType: sinon.stub().returns('tss'),
+                keychains: sinon.stub().returns({ add: sinon.stub() }),
+                url: sinon.stub().returns('/api/v2/teth/wallet/add'),
+                getConfig: sinon.stub().returns({ features: [] }),
+                supplementGenerateWallet: sinon.stub().callsFake((params) => Promise.resolve(params)),
+            };
+            ecdsaWallets = new wallets_1.Wallets(mockEcdsaBitGo, ecdsaMockBaseCoin);
+            sinon.stub(ecdsaWallets, 'generateMpcWalletWithExternalSigner').resolves({
+                responseType: 'WalletWithKeychains',
+                wallet: sinon.createStubInstance(wallet_1.Wallet),
+                userKeychain: { id: 'user-key-id', commonKeychain, type: 'tss' },
+                backupKeychain: { id: 'backup-key-id', commonKeychain, type: 'tss' },
+                bitgoKeychain: { id: 'bitgo-key-id', commonKeychain, type: 'tss' },
+            });
+        });
+        it('should route to generateMpcWalletWithExternalSigner for tss multisig type', async function () {
+            const result = await ecdsaWallets.generateWalletWithExternalSigner({
+                label: 'ECDSA TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                ecdsaMPCv2Callbacks: ecdsaCallbacks,
+            });
+            result.responseType.should.equal('WalletWithKeychains');
+            assert.strictEqual(ecdsaWallets.generateMpcWalletWithExternalSigner.calledOnce, true);
+        });
+        it('should reject without enterprise', async function () {
+            sinon.restore();
+            ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');
+            await ecdsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'ECDSA TSS Wallet',
+                multisigType: 'tss',
+                ecdsaMPCv2Callbacks: ecdsaCallbacks,
+            })
+                .should.be.rejectedWith('enterprise is required for TSS wallet generation with external signer');
+        });
+        it('should reject without ecdsaMPCv2Callbacks for ecdsa coin', async function () {
+            sinon.restore();
+            ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');
+            await ecdsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'ECDSA TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+            })
+                .should.be.rejectedWith('ecdsaMPCv2Callbacks is required for ECDSA TSS wallet generation with external signer');
+        });
+        it('should reject when coin does not support TSS', async function () {
+            sinon.restore();
+            ecdsaMockBaseCoin.supportsTss = sinon.stub().returns(false);
+            ecdsaMockBaseCoin.getFamily = sinon.stub().returns('btc');
+            await ecdsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'ECDSA TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                ecdsaMPCv2Callbacks: ecdsaCallbacks,
+            })
+                .should.be.rejectedWith('coin btc does not support TSS at this time');
+        });
+        it('should reject EVM coin with invalid walletVersion', async function () {
+            sinon.restore();
+            ecdsaMockBaseCoin.isEVM = sinon.stub().returns(true);
+            ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');
+            await ecdsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'ECDSA TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                walletVersion: 4,
+                ecdsaMPCv2Callbacks: ecdsaCallbacks,
+            })
+                .should.be.rejectedWith('EVM TSS wallets are only supported for wallet version 5 and 6');
+        });
+        it('should reject custodial TSS wallet', async function () {
+            sinon.restore();
+            ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');
+            await ecdsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'Custodial TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                type: 'custodial',
+                ecdsaMPCv2Callbacks: ecdsaCallbacks,
+            })
+                .should.be.rejectedWith('custodial TSS wallets are not supported for external signer wallet generation');
+        });
+        it('should reject passphrase on TSS path', async function () {
+            sinon.restore();
+            ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');
+            await ecdsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                ecdsaMPCv2Callbacks: ecdsaCallbacks,
+                passphrase: 'secret',
+            })
+                .should.be.rejectedWith('passphrase cannot be used with TSS external signer wallet generation');
+        });
+        it('should reject ECDSA MPCv1 wallet version 3', async function () {
+            sinon.restore();
+            ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');
+            await ecdsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'MPCv1 Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                walletVersion: 3,
+                ecdsaMPCv2Callbacks: ecdsaCallbacks,
+            })
+                .should.be.rejectedWith('ECDSA MPCv1 (wallet version 3) is not supported for external signer wallet generation');
+        });
+        describe('wallet/add integration (unstubbed generateMpcWalletWithExternalSigner)', function () {
+            let send;
+            let integrationCallbacks;
+            // Builds a fresh Wallets instance with only createKeychainsWithExternalSigner stubbed,
+            // so the routing/version/wallet-add logic in generateMpcWalletWithExternalSigner actually runs.
+            function createIntegrationWallets(coinOverrides = {}, bitgoOverrides = {}) {
+                sinon.restore();
+                const mpcState = { encryptedData: 'data', encryptedDataKey: 'data-key' };
+                integrationCallbacks = {
+                    initializeCallback: sinon.stub().resolves({
+                        userGpgPublicKey: 'user-gpg-pub',
+                        backupGpgPublicKey: 'backup-gpg-pub',
+                        round1Messages: { broadcastMessages: [], p2pMessages: [] },
+                        userState: mpcState,
+                        backupState: mpcState,
+                    }),
+                    round2Callback: sinon.stub().resolves({
+                        round2Messages: { broadcastMessages: [], p2pMessages: [] },
+                        userState: mpcState,
+                        backupState: mpcState,
+                    }),
+                    round3Callback: sinon.stub().resolves({
+                        round3Messages: { broadcastMessages: [], p2pMessages: [] },
+                        userState: mpcState,
+                        backupState: mpcState,
+                    }),
+                    finalizeCallback: sinon.stub().resolves({ commonKeychain }),
+                };
+                send = sinon.stub().returns({ result: sinon.stub().resolves({ id: 'tss-wallet-id' }) });
+                const integrationBitGo = {
+                    post: sinon.stub().returns({ send }),
+                    get: sinon.stub().returns({ result: sinon.stub().resolves({ coinSettings: {} }) }),
+                    setRequestTracer: sinon.stub(),
+                    microservicesUrl: sinon.stub().returns('/api/v2/tss/settings'),
+                    ...bitgoOverrides,
+                };
+                const integrationCoin = {
+                    isEVM: sinon.stub().returns(false),
+                    supportsTss: sinon.stub().returns(true),
+                    getMPCAlgorithm: sinon.stub().returns('ecdsa'),
+                    getFamily: sinon.stub().returns('eth'),
+                    getChain: sinon.stub().returns('teth'),
+                    getDefaultMultisigType: sinon.stub().returns('tss'),
+                    getConfig: sinon.stub().returns({ features: [statics_1.CoinFeature.MPCV2] }),
+                    keychains: sinon.stub().returns({ add: sinon.stub() }),
+                    url: sinon.stub().returns('/api/v2/teth/wallet/add'),
+                    supplementGenerateWallet: sinon.stub().callsFake((params) => Promise.resolve(params)),
+                    ...coinOverrides,
+                };
+                sinon.stub(utils_1.ECDSAUtils.EcdsaMPCv2Utils.prototype, 'createKeychainsWithExternalSigner').resolves({
+                    userKeychain: { id: 'user-key-id', commonKeychain, type: 'tss' },
+                    backupKeychain: { id: 'backup-key-id', commonKeychain, type: 'tss' },
+                    bitgoKeychain: { id: 'bitgo-key-id', commonKeychain, type: 'tss' },
+                });
+                return new wallets_1.Wallets(integrationBitGo, integrationCoin);
+            }
+            it('should pass advanced wallet type through to wallet/add', async function () {
+                const integrationWallets = createIntegrationWallets();
+                await integrationWallets.generateWalletWithExternalSigner({
+                    label: 'Advanced TSS Wallet',
+                    type: 'advanced',
+                    multisigType: 'tss',
+                    enterprise: 'enterprise-id',
+                    ecdsaMPCv2Callbacks: integrationCallbacks,
+                });
+                send.firstCall.args[0].type.should.equal('advanced');
+            });
+            it('should default EVM walletVersion to 5 when TSS settings specify MPCv2', async function () {
+                const integrationWallets = createIntegrationWallets({ isEVM: sinon.stub().returns(true) }, {
+                    get: sinon.stub().returns({
+                        result: sinon.stub().resolves({
+                            coinSettings: { eth: { walletCreationSettings: { multiSigTypeVersion: 'MPCv2' } } },
+                        }),
+                    }),
+                });
+                await integrationWallets.generateWalletWithExternalSigner({
+                    label: 'EVM TSS Wallet',
+                    type: 'advanced',
+                    multisigType: 'tss',
+                    enterprise: 'enterprise-id',
+                    ecdsaMPCv2Callbacks: integrationCallbacks,
+                });
+                send.firstCall.args[0].walletVersion.should.equal(5);
+            });
+            it('should forward explicit walletVersion to wallet/add', async function () {
+                const integrationWallets = createIntegrationWallets({ isEVM: sinon.stub().returns(true) });
+                await integrationWallets.generateWalletWithExternalSigner({
+                    label: 'EVM TSS Wallet v6',
+                    type: 'advanced',
+                    multisigType: 'tss',
+                    enterprise: 'enterprise-id',
+                    walletVersion: 6,
+                    ecdsaMPCv2Callbacks: integrationCallbacks,
+                });
+                send.firstCall.args[0].walletVersion.should.equal(6);
+            });
+        });
+    });
+    describe('generateWalletWithExternalSigner - EdDSA TSS', function () {
+        let eddsaCallbacks;
+        let eddsaMockBaseCoin;
+        let eddsaWallets;
+        const commonKeychain = 'eddsa-common-keychain';
+        beforeEach(function () {
+            const keyShare = (pub, prv, proof) => ({
+                publicShare: pub,
+                privateShare: prv,
+                privateShareProof: proof,
+                vssProof: `${proof}-vss`,
+                gpgKey: `${pub}-gpg`,
+            });
+            const mpcState = { encryptedData: 'data', encryptedDataKey: 'data-key' };
+            eddsaCallbacks = {
+                initializeCallback: sinon.stub().resolves({
+                    userGpgPublicKey: 'user-gpg-pub',
+                    backupGpgPublicKey: 'backup-gpg-pub',
+                    userToBitgoKeyShare: keyShare('upub', 'uprv-enc', 'uproof'),
+                    backupToBitgoKeyShare: keyShare('bpub', 'bprv-enc', 'bproof'),
+                    userState: mpcState,
+                    backupState: mpcState,
+                    backupToUserCounterPartyKeyShare: keyShare('ucp', 'ucp-prv', 'ucp-proof'),
+                }),
+                finalizeCallback: sinon.stub().resolves({ commonKeychain }),
+            };
+            const mockEddsaBitGo = {
+                post: sinon.stub().returns({
+                    send: sinon.stub().returns({ result: sinon.stub().resolves({ id: 'eddsa-wallet-id' }) }),
+                }),
+                setRequestTracer: sinon.stub(),
+            };
+            eddsaMockBaseCoin = {
+                isEVM: sinon.stub().returns(false),
+                supportsTss: sinon.stub().returns(true),
+                getMPCAlgorithm: sinon.stub().returns('eddsa'),
+                getFamily: sinon.stub().returns('sol'),
+                getChain: sinon.stub().returns('tsol'),
+                getDefaultMultisigType: sinon.stub().returns('tss'),
+                keychains: sinon.stub().returns({ add: sinon.stub() }),
+                url: sinon.stub().returns('/api/v2/tsol/wallet/add'),
+                getConfig: sinon.stub().returns({ features: [] }),
+                supplementGenerateWallet: sinon.stub().callsFake((params) => Promise.resolve(params)),
+            };
+            eddsaWallets = new wallets_1.Wallets(mockEddsaBitGo, eddsaMockBaseCoin);
+            sinon.stub(eddsaWallets, 'generateMpcWalletWithExternalSigner').resolves({
+                responseType: 'WalletWithKeychains',
+                wallet: sinon.createStubInstance(wallet_1.Wallet),
+                userKeychain: { id: 'user-key-id', commonKeychain, type: 'tss' },
+                backupKeychain: { id: 'backup-key-id', commonKeychain, type: 'tss' },
+                bitgoKeychain: { id: 'bitgo-key-id', commonKeychain, type: 'tss' },
+            });
+        });
+        it('should route to generateMpcWalletWithExternalSigner for tss EdDSA coin', async function () {
+            const result = await eddsaWallets.generateWalletWithExternalSigner({
+                label: 'EdDSA TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+                eddsaCallbacks,
+            });
+            result.responseType.should.equal('WalletWithKeychains');
+            assert.strictEqual(eddsaWallets.generateMpcWalletWithExternalSigner.calledOnce, true);
+        });
+        it('should reject without eddsaCallbacks for eddsa coin', async function () {
+            sinon.restore();
+            eddsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('eddsa');
+            await eddsaWallets
+                .generateWalletWithExternalSigner({
+                label: 'EdDSA TSS Wallet',
+                multisigType: 'tss',
+                enterprise: 'enterprise-id',
+            })
+                .should.be.rejectedWith('eddsaCallbacks is required for EdDSA TSS wallet generation with external signer');
+        });
+    });
+    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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,6CAA+B;AAC/B,kBAAgB;AAEhB,kEAA+D;AAC/D,uDAAyD;AACzD,iDAAkD;AAMlD,gEAA6D;AAE7D,QAAQ,CAAC,qDAAqD,EAAE;IAC9D,IAAI,OAAgB,CAAC;IACrB,IAAI,SAAc,CAAC;IACnB,IAAI,YAAiB,CAAC;IACtB,IAAI,aAAkB,CAAC;IACvB,IAAI,sBAA+G,CAAC;IACpH,IAAI,QAAyB,CAAC;IAE9B,MAAM,OAAO,GACX,iHAAiH,CAAC;IACpH,MAAM,SAAS,GACb,iHAAiH,CAAC;IACpH,MAAM,QAAQ,GACZ,iHAAiH,CAAC;IAEpH,UAAU,CAAC;QACT,sBAAsB,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QACtC,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC;YACzE,GAAG,EAAE,OAAO;YACZ,IAAI,EAAE,aAAa;YACnB,MAAM,EAAE,MAAM;SACf,CAAC,CAAC;QACH,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC;YAC3E,GAAG,EAAE,SAAS;YACd,IAAI,EAAE,aAAa;YACnB,MAAM,EAAE,QAAQ;SACjB,CAAC,CAAC;QAEH,aAAa,GAAG;YACd,GAAG,EAAE,KAAK;iBACP,IAAI,EAAE;iBACN,SAAS,CAAC,CAAC,MAAW,EAAE,EAAE,CACzB,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,EAAE,MAAM,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CACpG;YACH,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,QAAQ,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC;YAC9B,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC;SAC9C,CAAC,CAAC;QACH,SAAS,GAAG;YACV,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;YAC9C,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,IAAI,CAAC;YACvC,eAAe,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;YAC9C,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;YACtC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,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,yBAAyB,CAAC;YACpD,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,UAAU,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;SACvC,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,mEAAmE,EAAE,KAAK;YAC3E,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,gCAAgC,CAAC;gBAC5D,KAAK,EAAE,wBAAwB;gBAC/B,UAAU,EAAE,eAAe;gBAC3B,sBAAsB;aACvB,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,sBAAsB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YACxD,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YACnD,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YAC/D,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YAEpD,MAAM,aAAa,GAAG,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC3D,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACnD,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC7D,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAErD,MAAM,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9C,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,aAAa,EAAE,eAAe,EAAE,cAAc,CAAC,CAAC,CAAC;YACnF,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;YACxD,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAEpD,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;YACxD,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YACrD,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;YACzD,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACzD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wDAAwD,EAAE,KAAK;YAChE,MAAM,OAAO,CAAC,gCAAgC,CAAC;gBAC7C,KAAK,EAAE,iBAAiB;gBACxB,UAAU,EAAE,eAAe;gBAC3B,IAAI,EAAE,UAAU;gBAChB,sBAAsB;aACvB,CAAC,CAAC;YAEH,MAAM,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9C,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oEAAoE,EAAE,KAAK;YAC5E,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC;gBACzE,GAAG,EAAE,OAAO;gBACZ,IAAI,EAAE,aAAa;gBACnB,MAAM,EAAE,QAAQ;aACjB,CAAC,CAAC;YAEH,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,wBAAwB;gBAC/B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CACrB,8FAA8F,CAC/F,CAAC;QACN,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,KAAK;YAClD,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YACrC,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC;gBAClE,GAAG,EAAE,OAAO;gBACZ,IAAI,EAAE,KAAK;gBACX,MAAM,EAAE,MAAM;aACf,CAAC,CAAC;YACH,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC;gBACpE,GAAG,EAAE,SAAS;gBACd,IAAI,EAAE,aAAa;gBACnB,MAAM,EAAE,QAAQ;aACjB,CAAC,CAAC;YAEH,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,wBAAwB;gBAC/B,sBAAsB,EAAE,eAAe;aACxC,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CACrB,+HAA+H,CAChI,CAAC;QACN,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE,KAAK;YAC/D,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,YAAY;gBACnB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,sFAAsF,CAAC,CAAC;QACpH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uFAAuF,EAAE,KAAK;YAC/F,YAAY,CAAC,sBAAsB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAEnD,MAAM,OAAO,CAAC,gCAAgC,CAAC;gBAC7C,KAAK,EAAE,qBAAqB;gBAC5B,UAAU,EAAE,eAAe;gBAC3B,sBAAsB;aACvB,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,sBAAsB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YACxD,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+EAA+E,EAAE,KAAK;YACvF,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,kBAAkB;gBACzB,UAAU,EAAE,eAAe;gBAC3B,sBAAsB;gBACtB,mBAAmB,EAAE;oBACnB,kBAAkB,EAAE,KAAK,CAAC,IAAI,EAAE;oBAChC,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE;oBAC5B,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE;oBAC5B,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE;iBAC/B;aACF,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,sFAAsF,CAAC,CAAC;QACpH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qCAAqC,EAAE,KAAK;YAC7C,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,kBAAkB;gBACzB,IAAI,EAAE,WAAW;gBACjB,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,kFAAkF,CAAC,CAAC;QAChH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,KAAK;YAC9C,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,QAAQ;gBACf,sBAAsB,EAAE,WAAW;gBACnC,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,+EAA+E,CAAC,CAAC;QAC7G,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4BAA4B,EAAE,KAAK;YACpC,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,QAAQ;gBACf,YAAY,EAAE,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE;gBAC5E,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,qEAAqE,CAAC,CAAC;QACnG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE,KAAK;YAC/D,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,WAAW;gBAClB,IAAI,EAAE,MAAM;gBACZ,oBAAoB,EAAE,IAAI;gBAC1B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,kEAAkE,CAAC,CAAC;QAChG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE,KAAK;YAC/D,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,WAAW;gBAClB,IAAI,EAAE,KAAK;gBACX,oBAAoB,EAAE,IAAI;gBAC1B,UAAU,EAAE,eAAe;gBAC3B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,gDAAgD,CAAC,CAAC;QAC9E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0DAA0D,EAAE,KAAK;YAClE,YAAY,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,GAAW,EAAE,EAAE,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;YAEpE,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,wBAAwB;gBAC/B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CACrB,kGAAkG,CACnG,CAAC;QACN,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wCAAwC,EAAE,KAAK;YAChD,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAExG,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,wBAAwB;gBAC/B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,iDAAiD,CAAC,CAAC;QAC/E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sEAAsE,EAAE,KAAK;YAC9E,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAE1G,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,wBAAwB;gBAC/B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,mDAAmD,CAAC,CAAC;YAE/E,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,KAAK;YAClD,sBAAsB;iBACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;iBAC1C,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC,CAAC;YAErD,MAAM,OAAO;iBACV,gCAAgC,CAAC;gBAChC,KAAK,EAAE,wBAAwB;gBAC/B,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,wDAAwD,CAAC,CAAC;QACtF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6DAA6D,EAAE,KAAK;YACrE,MAAM,aAAa,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;YAEpE,MAAM,OAAO,CAAC,gCAAgC,CAAC;gBAC7C,KAAK,EAAE,wBAAwB;gBAC/B,UAAU,EAAE,eAAe;gBAC3B,sBAAsB;gBACtB,aAAa;aACd,CAAC,CAAC;YAEH,MAAM,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9C,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YACjD,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qEAAqE,EAAE,KAAK;YAC7E,MAAM,OAAO,CAAC,gCAAgC,CAAC;gBAC7C,KAAK,EAAE,wBAAwB;gBAC/B,UAAU,EAAE,eAAe;gBAC3B,sBAAsB;aACvB,CAAC,CAAC;YAEH,MAAM,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9C,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oDAAoD,EAAE;QAC7D,IAAI,cAAyC,CAAC;QAC9C,IAAI,iBAAsB,CAAC;QAC3B,IAAI,YAAqB,CAAC;QAE1B,MAAM,cAAc,GAAG,sBAAsB,CAAC;QAE9C,UAAU,CAAC;YACT,MAAM,QAAQ,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC;YACzE,cAAc,GAAG;gBACf,kBAAkB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;oBACxC,gBAAgB,EAAE,cAAc;oBAChC,kBAAkB,EAAE,gBAAgB;oBACpC,cAAc,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;oBAC1D,SAAS,EAAE,QAAQ;oBACnB,WAAW,EAAE,QAAQ;iBACtB,CAAC;gBACF,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;oBACpC,cAAc,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;oBAC1D,SAAS,EAAE,QAAQ;oBACnB,WAAW,EAAE,QAAQ;iBACtB,CAAC;gBACF,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;oBACpC,cAAc,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;oBAC1D,SAAS,EAAE,QAAQ;oBACnB,WAAW,EAAE,QAAQ;iBACtB,CAAC;gBACF,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;aAC5D,CAAC;YAEF,MAAM,cAAc,GAAG;gBACrB,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC;oBACzB,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,CAAC,EAAE,CAAC;iBACvF,CAAC;gBACF,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;gBAClF,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE;gBAC9B,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,sBAAsB,CAAC;aAC/D,CAAC;YAEF,iBAAiB,GAAG;gBAClB,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;gBAClC,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;gBACvC,eAAe,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;gBAC9C,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;gBACtC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;gBACtC,sBAAsB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnD,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;gBACtD,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,yBAAyB,CAAC;gBACpD,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;gBACjD,wBAAwB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;aAC3F,CAAC;YAEF,YAAY,GAAG,IAAI,iBAAO,CAAC,cAAqB,EAAE,iBAAiB,CAAC,CAAC;YACrE,KAAK,CAAC,IAAI,CAAC,YAAmB,EAAE,qCAAqC,CAAC,CAAC,QAAQ,CAAC;gBAC9E,YAAY,EAAE,qBAA8B;gBAC5C,MAAM,EAAE,KAAK,CAAC,kBAAkB,CAAC,eAAM,CAAC;gBACxC,YAAY,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;gBAChE,cAAc,EAAE,EAAE,EAAE,EAAE,eAAe,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;gBACpE,aAAa,EAAE,EAAE,EAAE,EAAE,cAAc,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;aACnE,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2EAA2E,EAAE,KAAK;YACnF,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,gCAAgC,CAAC;gBACjE,KAAK,EAAE,kBAAkB;gBACzB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,mBAAmB,EAAE,cAAc;aACpC,CAAC,CAAC;YAEH,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;YACxD,MAAM,CAAC,WAAW,CAAE,YAAoB,CAAC,mCAAmC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QACjG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kCAAkC,EAAE,KAAK;YAC1C,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAElE,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,kBAAkB;gBACzB,YAAY,EAAE,KAAK;gBACnB,mBAAmB,EAAE,cAAc;aACpC,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,uEAAuE,CAAC,CAAC;QACrG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0DAA0D,EAAE,KAAK;YAClE,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAElE,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,kBAAkB;gBACzB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;aAC5B,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,sFAAsF,CAAC,CAAC;QACpH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE,KAAK;YACtD,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC5D,iBAAiB,CAAC,SAAS,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAE1D,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,kBAAkB;gBACzB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,mBAAmB,EAAE,cAAc;aACpC,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,4CAA4C,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mDAAmD,EAAE,KAAK;YAC3D,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACrD,iBAAiB,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAElE,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,kBAAkB;gBACzB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,aAAa,EAAE,CAAC;gBAChB,mBAAmB,EAAE,cAAc;aACpC,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,+DAA+D,CAAC,CAAC;QAC7F,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oCAAoC,EAAE,KAAK;YAC5C,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAElE,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,sBAAsB;gBAC7B,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,IAAI,EAAE,WAAW;gBACjB,mBAAmB,EAAE,cAAc;aACpC,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,+EAA+E,CAAC,CAAC;QAC7G,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,KAAK;YAC9C,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAElE,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,YAAY;gBACnB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,mBAAmB,EAAE,cAAc;gBACnC,UAAU,EAAE,QAAQ;aACkE,CAAC;iBACxF,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,sEAAsE,CAAC,CAAC;QACpG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,KAAK;YACpD,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAElE,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,cAAc;gBACrB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,aAAa,EAAE,CAAC;gBAChB,mBAAmB,EAAE,cAAc;aACpC,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CACrB,uFAAuF,CACxF,CAAC;QACN,CAAC,CAAC,CAAC;QAEH,QAAQ,CAAC,wEAAwE,EAAE;YACjF,IAAI,IAAqB,CAAC;YAC1B,IAAI,oBAA+C,CAAC;YAEpD,uFAAuF;YACvF,gGAAgG;YAChG,SAAS,wBAAwB,CAC/B,gBAAyC,EAAE,EAC3C,iBAA0C,EAAE;gBAE5C,KAAK,CAAC,OAAO,EAAE,CAAC;gBAEhB,MAAM,QAAQ,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC;gBACzE,oBAAoB,GAAG;oBACrB,kBAAkB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;wBACxC,gBAAgB,EAAE,cAAc;wBAChC,kBAAkB,EAAE,gBAAgB;wBACpC,cAAc,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;wBAC1D,SAAS,EAAE,QAAQ;wBACnB,WAAW,EAAE,QAAQ;qBACtB,CAAC;oBACF,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;wBACpC,cAAc,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;wBAC1D,SAAS,EAAE,QAAQ;wBACnB,WAAW,EAAE,QAAQ;qBACtB,CAAC;oBACF,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;wBACpC,cAAc,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;wBAC1D,SAAS,EAAE,QAAQ;wBACnB,WAAW,EAAE,QAAQ;qBACtB,CAAC;oBACF,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;iBAC5D,CAAC;gBAEF,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,CAAC,EAAE,CAAC,CAAC;gBACxF,MAAM,gBAAgB,GAAG;oBACvB,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC;oBACpC,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;oBAClF,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE;oBAC9B,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,sBAAsB,CAAC;oBAC9D,GAAG,cAAc;iBAClB,CAAC;gBACF,MAAM,eAAe,GAAG;oBACtB,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;oBAClC,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;oBACvC,eAAe,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;oBAC9C,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;oBACtC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;oBACtC,sBAAsB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;oBACnD,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,qBAAW,CAAC,KAAK,CAAC,EAAE,CAAC;oBAClE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;oBACtD,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,yBAAyB,CAAC;oBACpD,wBAAwB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBAC1F,GAAG,aAAa;iBACjB,CAAC;gBAEF,KAAK,CAAC,IAAI,CAAC,kBAAU,CAAC,eAAe,CAAC,SAAS,EAAE,mCAAmC,CAAC,CAAC,QAAQ,CAAC;oBAC7F,YAAY,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;oBAChE,cAAc,EAAE,EAAE,EAAE,EAAE,eAAe,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;oBACpE,aAAa,EAAE,EAAE,EAAE,EAAE,cAAc,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;iBACnE,CAAC,CAAC;gBAEH,OAAO,IAAI,iBAAO,CAAC,gBAAuB,EAAE,eAAsB,CAAC,CAAC;YACtE,CAAC;YAED,EAAE,CAAC,wDAAwD,EAAE,KAAK;gBAChE,MAAM,kBAAkB,GAAG,wBAAwB,EAAE,CAAC;gBAEtD,MAAM,kBAAkB,CAAC,gCAAgC,CAAC;oBACxD,KAAK,EAAE,qBAAqB;oBAC5B,IAAI,EAAE,UAAU;oBAChB,YAAY,EAAE,KAAK;oBACnB,UAAU,EAAE,eAAe;oBAC3B,mBAAmB,EAAE,oBAAoB;iBAC1C,CAAC,CAAC;gBAEH,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,uEAAuE,EAAE,KAAK;gBAC/E,MAAM,kBAAkB,GAAG,wBAAwB,CACjD,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EACrC;oBACE,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC;wBACxB,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;4BAC5B,YAAY,EAAE,EAAE,GAAG,EAAE,EAAE,sBAAsB,EAAE,EAAE,mBAAmB,EAAE,OAAO,EAAE,EAAE,EAAE;yBACpF,CAAC;qBACH,CAAC;iBACH,CACF,CAAC;gBAEF,MAAM,kBAAkB,CAAC,gCAAgC,CAAC;oBACxD,KAAK,EAAE,gBAAgB;oBACvB,IAAI,EAAE,UAAU;oBAChB,YAAY,EAAE,KAAK;oBACnB,UAAU,EAAE,eAAe;oBAC3B,mBAAmB,EAAE,oBAAoB;iBAC1C,CAAC,CAAC;gBAEH,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,qDAAqD,EAAE,KAAK;gBAC7D,MAAM,kBAAkB,GAAG,wBAAwB,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAE3F,MAAM,kBAAkB,CAAC,gCAAgC,CAAC;oBACxD,KAAK,EAAE,mBAAmB;oBAC1B,IAAI,EAAE,UAAU;oBAChB,YAAY,EAAE,KAAK;oBACnB,UAAU,EAAE,eAAe;oBAC3B,aAAa,EAAE,CAAC;oBAChB,mBAAmB,EAAE,oBAAoB;iBAC1C,CAAC,CAAC;gBAEH,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,8CAA8C,EAAE;QACvD,IAAI,cAAoC,CAAC;QACzC,IAAI,iBAAsB,CAAC;QAC3B,IAAI,YAAqB,CAAC;QAE1B,MAAM,cAAc,GAAG,uBAAuB,CAAC;QAE/C,UAAU,CAAC;YACT,MAAM,QAAQ,GAAG,CAAC,GAAW,EAAE,GAAW,EAAE,KAAa,EAAE,EAAE,CAAC,CAAC;gBAC7D,WAAW,EAAE,GAAG;gBAChB,YAAY,EAAE,GAAG;gBACjB,iBAAiB,EAAE,KAAK;gBACxB,QAAQ,EAAE,GAAG,KAAK,MAAM;gBACxB,MAAM,EAAE,GAAG,GAAG,MAAM;aACrB,CAAC,CAAC;YACH,MAAM,QAAQ,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC;YACzE,cAAc,GAAG;gBACf,kBAAkB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC;oBACxC,gBAAgB,EAAE,cAAc;oBAChC,kBAAkB,EAAE,gBAAgB;oBACpC,mBAAmB,EAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC;oBAC3D,qBAAqB,EAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC;oBAC7D,SAAS,EAAE,QAAQ;oBACnB,WAAW,EAAE,QAAQ;oBACrB,gCAAgC,EAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC;iBAC1E,CAAC;gBACF,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;aAC5D,CAAC;YAEF,MAAM,cAAc,GAAG;gBACrB,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC;oBACzB,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;iBACzF,CAAC;gBACF,gBAAgB,EAAE,KAAK,CAAC,IAAI,EAAE;aAC/B,CAAC;YAEF,iBAAiB,GAAG;gBAClB,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;gBAClC,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;gBACvC,eAAe,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;gBAC9C,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;gBACtC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;gBACtC,sBAAsB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnD,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;gBACtD,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,yBAAyB,CAAC;gBACpD,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;gBACjD,wBAAwB,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;aAC3F,CAAC;YAEF,YAAY,GAAG,IAAI,iBAAO,CAAC,cAAqB,EAAE,iBAAiB,CAAC,CAAC;YACrE,KAAK,CAAC,IAAI,CAAC,YAAmB,EAAE,qCAAqC,CAAC,CAAC,QAAQ,CAAC;gBAC9E,YAAY,EAAE,qBAA8B;gBAC5C,MAAM,EAAE,KAAK,CAAC,kBAAkB,CAAC,eAAM,CAAC;gBACxC,YAAY,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;gBAChE,cAAc,EAAE,EAAE,EAAE,EAAE,eAAe,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;gBACpE,aAAa,EAAE,EAAE,EAAE,EAAE,cAAc,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE;aACnE,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wEAAwE,EAAE,KAAK;YAChF,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,gCAAgC,CAAC;gBACjE,KAAK,EAAE,kBAAkB;gBACzB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;gBAC3B,cAAc;aACf,CAAC,CAAC;YAEH,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;YACxD,MAAM,CAAC,WAAW,CAAE,YAAoB,CAAC,mCAAmC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QACjG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE,KAAK;YAC7D,KAAK,CAAC,OAAO,EAAE,CAAC;YAChB,iBAAiB,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAElE,MAAM,YAAY;iBACf,gCAAgC,CAAC;gBAChC,KAAK,EAAE,kBAAkB;gBACzB,YAAY,EAAE,KAAK;gBACnB,UAAU,EAAE,eAAe;aAC5B,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,iFAAiF,CAAC,CAAC;QAC/G,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,4CAA4C,EAAE;QACrD,EAAE,CAAC,qDAAqD,EAAE,KAAK;YAC7D,MAAM,oCAAoC,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,kCAAkC,CAAC,CAAC,QAAQ,CAAC;gBAC5G,YAAY,EAAE,qBAAqB;gBACnC,MAAM,EAAE,KAAK,CAAC,kBAAkB,CAAC,eAAM,CAAC;gBACxC,YAAY,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,aAAsB,EAAE;gBAC/E,cAAc,EAAE,EAAE,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,aAAsB,EAAE;gBACrF,aAAa,EAAE,EAAE,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAsB,EAAE;aACnF,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,cAAc,CAAC;gBAC3B,KAAK,EAAE,kBAAkB;gBACzB,sBAAsB;aACvB,CAAC,CAAC;YAEH,MAAM,CAAC,WAAW,CAAC,oCAAoC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YAC1E,oCAAoC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAChG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uEAAuE,EAAE,KAAK;YAC/E,MAAM,OAAO;iBACV,cAAc,CAAC;gBACd,KAAK,EAAE,gBAAgB;gBACvB,UAAU,EAAE,QAAQ;gBACpB,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,uDAAuD,CAAC,CAAC;QACrF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oEAAoE,EAAE,KAAK;YAC5E,MAAM,OAAO;iBACV,cAAc,CAAC;gBACd,KAAK,EAAE,gBAAgB;gBACvB,OAAO,EAAE,SAAS;gBAClB,sBAAsB;aACvB,CAAC;iBACD,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,oDAAoD,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\n\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\nimport { ECDSAUtils } from '../../../../src/bitgo/utils';\nimport { CoinFeature } from '@bitgo-beta/statics';\nimport {\n  CreateKeychainCallback,\n  EcdsaMPCv2KeyGenCallbacks,\n  EddsaKeyGenCallbacks,\n} 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\n        .stub()\n        .callsFake((params: any) =>\n          Promise.resolve({ id: `${params?.source ?? ''}-key-id`, pub: params?.pub, 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      getMPCAlgorithm: sinon.stub().returns('ecdsa'),\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((params: any) => Promise.resolve(params)),\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 without TSS callbacks', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'TSS Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          createKeychainCallback,\n        })\n        .should.be.rejectedWith('ecdsaMPCv2Callbacks is required for ECDSA TSS wallet generation with external signer');\n    });\n\n    it('should route to onchain when createKeychainCallback is provided on a TSS-default coin', async function () {\n      mockBaseCoin.getDefaultMultisigType.returns('tss');\n\n      await wallets.generateWalletWithExternalSigner({\n        label: 'Onchain on TSS coin',\n        enterprise: 'enterprise-id',\n        createKeychainCallback,\n      });\n\n      assert.strictEqual(createKeychainCallback.callCount, 2);\n      assert.strictEqual(mockKeychains.createBitGo.calledOnce, true);\n    });\n\n    it('should reject when both createKeychainCallback and MPC callbacks are provided', async function () {\n      await wallets\n        .generateWalletWithExternalSigner({\n          label: 'Ambiguous Wallet',\n          enterprise: 'enterprise-id',\n          createKeychainCallback,\n          ecdsaMPCv2Callbacks: {\n            initializeCallback: sinon.stub(),\n            round2Callback: sinon.stub(),\n            round3Callback: sinon.stub(),\n            finalizeCallback: sinon.stub(),\n          },\n        })\n        .should.be.rejectedWith('createKeychainCallback cannot be used together with MPC TSS key generation callbacks');\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      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 = { backup: 'deadbeef01', bitgo: 'deadbeef02' };\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('generateWalletWithExternalSigner - ECDSA MPCv2 TSS', function () {\n    let ecdsaCallbacks: EcdsaMPCv2KeyGenCallbacks;\n    let ecdsaMockBaseCoin: any;\n    let ecdsaWallets: Wallets;\n\n    const commonKeychain = 'abc123commonkeychain';\n\n    beforeEach(function () {\n      const mpcState = { encryptedData: 'data', encryptedDataKey: 'data-key' };\n      ecdsaCallbacks = {\n        initializeCallback: sinon.stub().resolves({\n          userGpgPublicKey: 'user-gpg-pub',\n          backupGpgPublicKey: 'backup-gpg-pub',\n          round1Messages: { broadcastMessages: [], p2pMessages: [] },\n          userState: mpcState,\n          backupState: mpcState,\n        }),\n        round2Callback: sinon.stub().resolves({\n          round2Messages: { broadcastMessages: [], p2pMessages: [] },\n          userState: mpcState,\n          backupState: mpcState,\n        }),\n        round3Callback: sinon.stub().resolves({\n          round3Messages: { broadcastMessages: [], p2pMessages: [] },\n          userState: mpcState,\n          backupState: mpcState,\n        }),\n        finalizeCallback: sinon.stub().resolves({ commonKeychain }),\n      };\n\n      const mockEcdsaBitGo = {\n        post: sinon.stub().returns({\n          send: sinon.stub().returns({ result: sinon.stub().resolves({ id: 'tss-wallet-id' }) }),\n        }),\n        get: sinon.stub().returns({ result: sinon.stub().resolves({ coinSettings: {} }) }),\n        setRequestTracer: sinon.stub(),\n        microservicesUrl: sinon.stub().returns('/api/v2/tss/settings'),\n      };\n\n      ecdsaMockBaseCoin = {\n        isEVM: sinon.stub().returns(false),\n        supportsTss: sinon.stub().returns(true),\n        getMPCAlgorithm: sinon.stub().returns('ecdsa'),\n        getFamily: sinon.stub().returns('eth'),\n        getChain: sinon.stub().returns('teth'),\n        getDefaultMultisigType: sinon.stub().returns('tss'),\n        keychains: sinon.stub().returns({ add: sinon.stub() }),\n        url: sinon.stub().returns('/api/v2/teth/wallet/add'),\n        getConfig: sinon.stub().returns({ features: [] }),\n        supplementGenerateWallet: sinon.stub().callsFake((params: any) => Promise.resolve(params)),\n      };\n\n      ecdsaWallets = new Wallets(mockEcdsaBitGo as any, ecdsaMockBaseCoin);\n      sinon.stub(ecdsaWallets as any, 'generateMpcWalletWithExternalSigner').resolves({\n        responseType: 'WalletWithKeychains' as const,\n        wallet: sinon.createStubInstance(Wallet),\n        userKeychain: { id: 'user-key-id', commonKeychain, type: 'tss' },\n        backupKeychain: { id: 'backup-key-id', commonKeychain, type: 'tss' },\n        bitgoKeychain: { id: 'bitgo-key-id', commonKeychain, type: 'tss' },\n      });\n    });\n\n    it('should route to generateMpcWalletWithExternalSigner for tss multisig type', async function () {\n      const result = await ecdsaWallets.generateWalletWithExternalSigner({\n        label: 'ECDSA TSS Wallet',\n        multisigType: 'tss',\n        enterprise: 'enterprise-id',\n        ecdsaMPCv2Callbacks: ecdsaCallbacks,\n      });\n\n      result.responseType.should.equal('WalletWithKeychains');\n      assert.strictEqual((ecdsaWallets as any).generateMpcWalletWithExternalSigner.calledOnce, true);\n    });\n\n    it('should reject without enterprise', async function () {\n      sinon.restore();\n      ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');\n\n      await ecdsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'ECDSA TSS Wallet',\n          multisigType: 'tss',\n          ecdsaMPCv2Callbacks: ecdsaCallbacks,\n        })\n        .should.be.rejectedWith('enterprise is required for TSS wallet generation with external signer');\n    });\n\n    it('should reject without ecdsaMPCv2Callbacks for ecdsa coin', async function () {\n      sinon.restore();\n      ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');\n\n      await ecdsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'ECDSA TSS Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n        })\n        .should.be.rejectedWith('ecdsaMPCv2Callbacks is required for ECDSA TSS wallet generation with external signer');\n    });\n\n    it('should reject when coin does not support TSS', async function () {\n      sinon.restore();\n      ecdsaMockBaseCoin.supportsTss = sinon.stub().returns(false);\n      ecdsaMockBaseCoin.getFamily = sinon.stub().returns('btc');\n\n      await ecdsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'ECDSA TSS Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          ecdsaMPCv2Callbacks: ecdsaCallbacks,\n        })\n        .should.be.rejectedWith('coin btc does not support TSS at this time');\n    });\n\n    it('should reject EVM coin with invalid walletVersion', async function () {\n      sinon.restore();\n      ecdsaMockBaseCoin.isEVM = sinon.stub().returns(true);\n      ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');\n\n      await ecdsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'ECDSA TSS Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          walletVersion: 4,\n          ecdsaMPCv2Callbacks: ecdsaCallbacks,\n        })\n        .should.be.rejectedWith('EVM TSS wallets are only supported for wallet version 5 and 6');\n    });\n\n    it('should reject custodial TSS wallet', async function () {\n      sinon.restore();\n      ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');\n\n      await ecdsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'Custodial TSS Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          type: 'custodial',\n          ecdsaMPCv2Callbacks: ecdsaCallbacks,\n        })\n        .should.be.rejectedWith('custodial TSS wallets are not supported for external signer wallet generation');\n    });\n\n    it('should reject passphrase on TSS path', async function () {\n      sinon.restore();\n      ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');\n\n      await ecdsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'TSS Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          ecdsaMPCv2Callbacks: ecdsaCallbacks,\n          passphrase: 'secret',\n        } as Parameters<Wallets['generateWalletWithExternalSigner']>[0] & { passphrase: string })\n        .should.be.rejectedWith('passphrase cannot be used with TSS external signer wallet generation');\n    });\n\n    it('should reject ECDSA MPCv1 wallet version 3', async function () {\n      sinon.restore();\n      ecdsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('ecdsa');\n\n      await ecdsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'MPCv1 Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          walletVersion: 3,\n          ecdsaMPCv2Callbacks: ecdsaCallbacks,\n        })\n        .should.be.rejectedWith(\n          'ECDSA MPCv1 (wallet version 3) is not supported for external signer wallet generation'\n        );\n    });\n\n    describe('wallet/add integration (unstubbed generateMpcWalletWithExternalSigner)', function () {\n      let send: sinon.SinonStub;\n      let integrationCallbacks: EcdsaMPCv2KeyGenCallbacks;\n\n      // Builds a fresh Wallets instance with only createKeychainsWithExternalSigner stubbed,\n      // so the routing/version/wallet-add logic in generateMpcWalletWithExternalSigner actually runs.\n      function createIntegrationWallets(\n        coinOverrides: Record<string, unknown> = {},\n        bitgoOverrides: Record<string, unknown> = {}\n      ) {\n        sinon.restore();\n\n        const mpcState = { encryptedData: 'data', encryptedDataKey: 'data-key' };\n        integrationCallbacks = {\n          initializeCallback: sinon.stub().resolves({\n            userGpgPublicKey: 'user-gpg-pub',\n            backupGpgPublicKey: 'backup-gpg-pub',\n            round1Messages: { broadcastMessages: [], p2pMessages: [] },\n            userState: mpcState,\n            backupState: mpcState,\n          }),\n          round2Callback: sinon.stub().resolves({\n            round2Messages: { broadcastMessages: [], p2pMessages: [] },\n            userState: mpcState,\n            backupState: mpcState,\n          }),\n          round3Callback: sinon.stub().resolves({\n            round3Messages: { broadcastMessages: [], p2pMessages: [] },\n            userState: mpcState,\n            backupState: mpcState,\n          }),\n          finalizeCallback: sinon.stub().resolves({ commonKeychain }),\n        };\n\n        send = sinon.stub().returns({ result: sinon.stub().resolves({ id: 'tss-wallet-id' }) });\n        const integrationBitGo = {\n          post: sinon.stub().returns({ send }),\n          get: sinon.stub().returns({ result: sinon.stub().resolves({ coinSettings: {} }) }),\n          setRequestTracer: sinon.stub(),\n          microservicesUrl: sinon.stub().returns('/api/v2/tss/settings'),\n          ...bitgoOverrides,\n        };\n        const integrationCoin = {\n          isEVM: sinon.stub().returns(false),\n          supportsTss: sinon.stub().returns(true),\n          getMPCAlgorithm: sinon.stub().returns('ecdsa'),\n          getFamily: sinon.stub().returns('eth'),\n          getChain: sinon.stub().returns('teth'),\n          getDefaultMultisigType: sinon.stub().returns('tss'),\n          getConfig: sinon.stub().returns({ features: [CoinFeature.MPCV2] }),\n          keychains: sinon.stub().returns({ add: sinon.stub() }),\n          url: sinon.stub().returns('/api/v2/teth/wallet/add'),\n          supplementGenerateWallet: sinon.stub().callsFake((params: any) => Promise.resolve(params)),\n          ...coinOverrides,\n        };\n\n        sinon.stub(ECDSAUtils.EcdsaMPCv2Utils.prototype, 'createKeychainsWithExternalSigner').resolves({\n          userKeychain: { id: 'user-key-id', commonKeychain, type: 'tss' },\n          backupKeychain: { id: 'backup-key-id', commonKeychain, type: 'tss' },\n          bitgoKeychain: { id: 'bitgo-key-id', commonKeychain, type: 'tss' },\n        });\n\n        return new Wallets(integrationBitGo as any, integrationCoin as any);\n      }\n\n      it('should pass advanced wallet type through to wallet/add', async function () {\n        const integrationWallets = createIntegrationWallets();\n\n        await integrationWallets.generateWalletWithExternalSigner({\n          label: 'Advanced TSS Wallet',\n          type: 'advanced',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          ecdsaMPCv2Callbacks: integrationCallbacks,\n        });\n\n        send.firstCall.args[0].type.should.equal('advanced');\n      });\n\n      it('should default EVM walletVersion to 5 when TSS settings specify MPCv2', async function () {\n        const integrationWallets = createIntegrationWallets(\n          { isEVM: sinon.stub().returns(true) },\n          {\n            get: sinon.stub().returns({\n              result: sinon.stub().resolves({\n                coinSettings: { eth: { walletCreationSettings: { multiSigTypeVersion: 'MPCv2' } } },\n              }),\n            }),\n          }\n        );\n\n        await integrationWallets.generateWalletWithExternalSigner({\n          label: 'EVM TSS Wallet',\n          type: 'advanced',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          ecdsaMPCv2Callbacks: integrationCallbacks,\n        });\n\n        send.firstCall.args[0].walletVersion.should.equal(5);\n      });\n\n      it('should forward explicit walletVersion to wallet/add', async function () {\n        const integrationWallets = createIntegrationWallets({ isEVM: sinon.stub().returns(true) });\n\n        await integrationWallets.generateWalletWithExternalSigner({\n          label: 'EVM TSS Wallet v6',\n          type: 'advanced',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n          walletVersion: 6,\n          ecdsaMPCv2Callbacks: integrationCallbacks,\n        });\n\n        send.firstCall.args[0].walletVersion.should.equal(6);\n      });\n    });\n  });\n\n  describe('generateWalletWithExternalSigner - EdDSA TSS', function () {\n    let eddsaCallbacks: EddsaKeyGenCallbacks;\n    let eddsaMockBaseCoin: any;\n    let eddsaWallets: Wallets;\n\n    const commonKeychain = 'eddsa-common-keychain';\n\n    beforeEach(function () {\n      const keyShare = (pub: string, prv: string, proof: string) => ({\n        publicShare: pub,\n        privateShare: prv,\n        privateShareProof: proof,\n        vssProof: `${proof}-vss`,\n        gpgKey: `${pub}-gpg`,\n      });\n      const mpcState = { encryptedData: 'data', encryptedDataKey: 'data-key' };\n      eddsaCallbacks = {\n        initializeCallback: sinon.stub().resolves({\n          userGpgPublicKey: 'user-gpg-pub',\n          backupGpgPublicKey: 'backup-gpg-pub',\n          userToBitgoKeyShare: keyShare('upub', 'uprv-enc', 'uproof'),\n          backupToBitgoKeyShare: keyShare('bpub', 'bprv-enc', 'bproof'),\n          userState: mpcState,\n          backupState: mpcState,\n          backupToUserCounterPartyKeyShare: keyShare('ucp', 'ucp-prv', 'ucp-proof'),\n        }),\n        finalizeCallback: sinon.stub().resolves({ commonKeychain }),\n      };\n\n      const mockEddsaBitGo = {\n        post: sinon.stub().returns({\n          send: sinon.stub().returns({ result: sinon.stub().resolves({ id: 'eddsa-wallet-id' }) }),\n        }),\n        setRequestTracer: sinon.stub(),\n      };\n\n      eddsaMockBaseCoin = {\n        isEVM: sinon.stub().returns(false),\n        supportsTss: sinon.stub().returns(true),\n        getMPCAlgorithm: sinon.stub().returns('eddsa'),\n        getFamily: sinon.stub().returns('sol'),\n        getChain: sinon.stub().returns('tsol'),\n        getDefaultMultisigType: sinon.stub().returns('tss'),\n        keychains: sinon.stub().returns({ add: sinon.stub() }),\n        url: sinon.stub().returns('/api/v2/tsol/wallet/add'),\n        getConfig: sinon.stub().returns({ features: [] }),\n        supplementGenerateWallet: sinon.stub().callsFake((params: any) => Promise.resolve(params)),\n      };\n\n      eddsaWallets = new Wallets(mockEddsaBitGo as any, eddsaMockBaseCoin);\n      sinon.stub(eddsaWallets as any, 'generateMpcWalletWithExternalSigner').resolves({\n        responseType: 'WalletWithKeychains' as const,\n        wallet: sinon.createStubInstance(Wallet),\n        userKeychain: { id: 'user-key-id', commonKeychain, type: 'tss' },\n        backupKeychain: { id: 'backup-key-id', commonKeychain, type: 'tss' },\n        bitgoKeychain: { id: 'bitgo-key-id', commonKeychain, type: 'tss' },\n      });\n    });\n\n    it('should route to generateMpcWalletWithExternalSigner for tss EdDSA coin', async function () {\n      const result = await eddsaWallets.generateWalletWithExternalSigner({\n        label: 'EdDSA TSS Wallet',\n        multisigType: 'tss',\n        enterprise: 'enterprise-id',\n        eddsaCallbacks,\n      });\n\n      result.responseType.should.equal('WalletWithKeychains');\n      assert.strictEqual((eddsaWallets as any).generateMpcWalletWithExternalSigner.calledOnce, true);\n    });\n\n    it('should reject without eddsaCallbacks for eddsa coin', async function () {\n      sinon.restore();\n      eddsaMockBaseCoin.getMPCAlgorithm = sinon.stub().returns('eddsa');\n\n      await eddsaWallets\n        .generateWalletWithExternalSigner({\n          label: 'EdDSA TSS Wallet',\n          multisigType: 'tss',\n          enterprise: 'enterprise-id',\n        })\n        .should.be.rejectedWith('eddsaCallbacks is required for EdDSA TSS wallet generation with external signer');\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"]}