@bitgo-beta/sdk-core 8.2.1-beta.182 → 8.2.1-beta.1821

package/dist/src/bitgo/wallet/wallets.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -11,18 +15,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Wallets = void 0;
+exports.isWalletWithKeychains = isWalletWithKeychains;
 /**
  * @prettier
  */
@@ -30,11 +45,21 @@ const assert_1 = __importDefault(require("assert"));
 const bignumber_js_1 = require("bignumber.js");
 const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
 const _ = __importStar(require("lodash"));
+const statics_1 = require("@bitgo-beta/statics");
 const api_1 = require("../../api");
 const common = __importStar(require("../../common"));
 const ecdh_1 = require("../ecdh");
+const keychain_1 = require("../keychain");
 const utils_1 = require("../utils");
+const iWallets_1 = require("./iWallets");
 const wallet_1 = require("./wallet");
+const evmUtils_1 = require("../evm/evmUtils");
+/**
+ * Check if a wallet is a WalletWithKeychains
+ */
+function isWalletWithKeychains(wallet) {
+    return wallet.responseType === 'WalletWithKeychains';
+}
 class Wallets {
     constructor(bitgo, baseCoin) {
         this.bitgo = bitgo;
@@ -53,35 +78,10 @@ class Wallets {
      * @returns {*}
      */
     async list(params = {}) {
-        const queryObject = {};
         if (params.skip && params.prevId) {
             throw new Error('cannot specify both skip and prevId');
         }
-        if (params.getbalances) {
-            if (!_.isBoolean(params.getbalances)) {
-                throw new Error('invalid getbalances argument, expecting boolean');
-            }
-            queryObject.getbalances = params.getbalances;
-        }
-        if (params.prevId) {
-            if (!_.isString(params.prevId)) {
-                throw new Error('invalid prevId argument, expecting string');
-            }
-            queryObject.prevId = params.prevId;
-        }
-        if (params.limit) {
-            if (!_.isNumber(params.limit)) {
-                throw new Error('invalid limit argument, expecting number');
-            }
-            queryObject.limit = params.limit;
-        }
-        if (params.allTokens) {
-            if (!_.isBoolean(params.allTokens)) {
-                throw new Error('invalid allTokens argument, expecting boolean');
-            }
-            queryObject.allTokens = params.allTokens;
-        }
-        const body = (await this.bitgo.get(this.baseCoin.url('/wallet')).query(queryObject).result());
+        const body = (await this.bitgo.get(this.baseCoin.url('/wallet')).query(params).result());
         body.wallets = body.wallets.map((w) => new wallet_1.Wallet(this.bitgo, this.baseCoin, w));
         return body;
     }
@@ -101,8 +101,9 @@ class Wallets {
         if (typeof params.label !== 'string') {
             throw new Error('missing required string parameter label');
         }
-        // no need to pass keys for (single) custodial wallets
-        if (params.type !== 'custodial') {
+        (0, evmUtils_1.validateEvmKeyRingWalletParams)(params, this.baseCoin);
+        if (!params.evmKeyRingReferenceWalletId && params.type !== 'custodial') {
+            // no need to pass keys for (single) custodial wallets
             if (Array.isArray(params.keys) === false || !_.isNumber(params.m) || !_.isNumber(params.n)) {
                 throw new Error('invalid argument');
             }
@@ -114,8 +115,19 @@ class Wallets {
         if (params.gasPrice && !_.isNumber(params.gasPrice)) {
             throw new Error('invalid argument for gasPrice - number expected');
         }
-        if (params.walletVersion && !_.isNumber(params.walletVersion)) {
-            throw new Error('invalid argument for walletVersion - number expected');
+        if (params.walletVersion) {
+            if (!_.isNumber(params.walletVersion)) {
+                throw new Error('invalid argument for walletVersion - number expected');
+            }
+            if (params.multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa' && params.walletVersion === 3) {
+                const tssSettings = await this.bitgo
+                    .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))
+                    .result();
+                const multisigTypeVersion = tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.multiSigTypeVersion;
+                if (multisigTypeVersion === 'MPCv2') {
+                    params.walletVersion = 5;
+                }
+            }
         }
         if (params.tags && Array.isArray(params.tags) === false) {
             throw new Error('invalid argument for tags - array expected');
@@ -132,11 +144,104 @@ class Wallets {
         if (params.address && (!_.isString(params.address) || !this.baseCoin.isValidAddress(params.address))) {
             throw new Error('invalid argument for address - valid address string expected');
         }
-        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(params).result();
+        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(params).result();
         return {
             wallet: new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet),
         };
     }
+    async generateLightningWallet(params) {
+        const reqId = new utils_1.RequestTracer();
+        this.bitgo.setRequestTracer(reqId);
+        const { label, passphrase, enterprise, passcodeEncryptionCode, subType, lightningProvider, encryptionVersion } = params;
+        // TODO BTC-1899: only userAuth key is required for custodial lightning wallet. all 3 keys are required for self custodial lightning.
+        // to avoid changing the platform for custodial flow, let us all 3 keys both wallet types.
+        const keychainPromises = [undefined, 'userAuth', 'nodeAuth'].map((purpose) => {
+            return async () => {
+                const keychain = this.baseCoin.keychains().create();
+                const keychainParams = {
+                    pub: keychain.pub,
+                    encryptedPrv: await this.bitgo.encryptAsync({
+                        password: passphrase,
+                        input: keychain.prv,
+                        encryptionVersion,
+                    }),
+                    originalPasscodeEncryptionCode: purpose === undefined ? passcodeEncryptionCode : undefined,
+                    coinSpecific: purpose === undefined ? undefined : { [this.baseCoin.getChain()]: { purpose } },
+                    keyType: 'independent',
+                    source: 'user',
+                };
+                return await this.baseCoin.keychains().add(keychainParams);
+            };
+        });
+        const { userKeychain, userAuthKeychain, nodeAuthKeychain } = await (0, utils_1.promiseProps)({
+            userKeychain: keychainPromises[0](),
+            userAuthKeychain: keychainPromises[1](),
+            nodeAuthKeychain: keychainPromises[2](),
+        });
+        const walletParams = {
+            label,
+            m: 1,
+            n: 1,
+            type: 'hot',
+            subType,
+            enterprise,
+            keys: [userKeychain.id],
+            coinSpecific: { [this.baseCoin.getChain()]: { keys: [userAuthKeychain.id, nodeAuthKeychain.id] } },
+            lightningProvider,
+        };
+        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(walletParams).result();
+        const wallet = new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet);
+        return {
+            wallet,
+            userKeychain,
+            userAuthKeychain,
+            nodeAuthKeychain,
+            responseType: 'LightningWalletWithKeychains',
+        };
+    }
+    /**
+     * Generate a Go Account wallet
+     * @param params GenerateGoAccountWalletOptions
+     * @returns Promise<GoAccountWalletWithUserKeychain>
+     */
+    async generateGoAccountWallet(params) {
+        const reqId = new utils_1.RequestTracer();
+        this.bitgo.setRequestTracer(reqId);
+        const { label, passphrase, enterprise, passcodeEncryptionCode, encryptionVersion } = params;
+        const keychain = this.baseCoin.keychains().create();
+        const keychainParams = {
+            pub: keychain.pub,
+            encryptedPrv: await this.bitgo.encryptAsync({
+                password: passphrase,
+                input: keychain.prv,
+                encryptionVersion,
+            }),
+            originalPasscodeEncryptionCode: passcodeEncryptionCode,
+            keyType: 'independent',
+            source: 'user',
+        };
+        const userKeychain = await this.baseCoin.keychains().add(keychainParams);
+        const walletParams = {
+            label,
+            m: 1,
+            n: 1,
+            type: 'trading',
+            enterprise,
+            keys: [userKeychain.id],
+        };
+        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(walletParams).result();
+        const wallet = new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet);
+        const result = {
+            wallet,
+            userKeychain,
+            responseType: 'GoAccountWalletWithUserKeychain',
+        };
+        // Add warning if the user keychain has an encrypted private key
+        if (!_.isUndefined(userKeychain.encryptedPrv)) {
+            result.warning = 'Be sure to backup the user keychain -- it is not stored anywhere else!';
+        }
+        return result;
+    }
     /**
      * Generate a new wallet
      * 1. Creates the user keychain locally on the client, and encrypts it with the provided passphrase
@@ -150,7 +255,6 @@ class Wallets {
      * @param params.userKey User xpub
      * @param params.backupXpub Backup xpub
      * @param params.backupXpubProvider
-     * @param params.backupProvider Third party backup provider for TSS
      * @param params.enterprise the enterpriseId
      * @param params.disableTransactionNotifications
      * @param params.passcodeEncryptionCode optional this is a recovery code that can be used to decrypt the original passphrase in a recovery case.
@@ -170,13 +274,53 @@ class Wallets {
      * @returns {*}
      */
     async generateWallet(params = {}) {
+        // Assign the default multiSig type value based on the coin
+        if (!params.multisigType) {
+            params.multisigType = this.baseCoin.getDefaultMultisigType();
+        }
+        if (this.baseCoin.getFamily() === 'lnbtc') {
+            const options = (0, utils_1.decodeOrElse)(iWallets_1.GenerateLightningWalletOptionsCodec.name, iWallets_1.GenerateLightningWalletOptionsCodec, params, (errors) => {
+                throw new Error(`error(s) parsing generate lightning wallet request params: ${errors}`);
+            });
+            const walletData = await this.generateLightningWallet(options);
+            walletData.encryptedWalletPassphrase = await this.bitgo.encryptAsync({
+                input: options.passphrase,
+                password: options.passcodeEncryptionCode,
+                encryptionVersion: options.encryptionVersion,
+            });
+            return walletData;
+        }
+        // Go Account wallet generation
+        if (this.baseCoin.getFamily() === 'ofc' && params.type === 'trading') {
+            const options = (0, utils_1.decodeOrElse)(iWallets_1.GenerateGoAccountWalletOptionsCodec.name, iWallets_1.GenerateGoAccountWalletOptionsCodec, params, (errors) => {
+                throw new Error(`error(s) parsing generate go account request params: ${errors}`);
+            });
+            const walletData = await this.generateGoAccountWallet(options);
+            walletData.encryptedWalletPassphrase = await this.bitgo.encryptAsync({
+                input: options.passphrase,
+                password: options.passcodeEncryptionCode,
+                encryptionVersion: options.encryptionVersion,
+            });
+            return walletData;
+        }
         common.validateParams(params, ['label'], ['passphrase', 'userKey', 'backupXpub']);
         if (typeof params.label !== 'string') {
             throw new Error('missing required string parameter label');
         }
-        const { type = 'hot', label, passphrase, enterprise, isDistributedCustody } = params;
+        if (params.createKeychainCallback) {
+            return this.generateWalletWithExternalSigner(params);
+        }
+        const { type = 'hot', label, passphrase, enterprise, isDistributedCustody, evmKeyRingReferenceWalletId } = params;
         const isTss = params.multisigType === 'tss' && this.baseCoin.supportsTss();
         const canEncrypt = !!passphrase && typeof passphrase === 'string';
+        if ((0, evmUtils_1.validateEvmKeyRingWalletParams)(params, this.baseCoin)) {
+            return await (0, evmUtils_1.createEvmKeyRingWallet)({
+                label,
+                evmKeyRingReferenceWalletId: evmKeyRingReferenceWalletId,
+                bitgo: this.bitgo,
+                baseCoin: this.baseCoin,
+            });
+        }
         const walletParams = {
             label: label,
             m: 2,
@@ -195,19 +339,26 @@ class Wallets {
             }
             walletParams.enterprise = enterprise;
         }
-        // EVM TSS wallets must use wallet version 3
-        if ((isTss && this.baseCoin.isEVM()) !== (params.walletVersion === 3)) {
-            throw new Error('EVM TSS wallets are only supported for wallet version 3');
+        // EVM TSS wallets must use wallet version 3, 5 and 6
+        if (isTss &&
+            this.baseCoin.isEVM() &&
+            !evmKeyRingReferenceWalletId &&
+            !(params.walletVersion === 3 || params.walletVersion === 5 || params.walletVersion === 6)) {
+            throw new Error('EVM TSS wallets are only supported for wallet version 3, 5 and 6');
         }
         if (isTss) {
             if (!this.baseCoin.supportsTss()) {
                 throw new Error(`coin ${this.baseCoin.getFamily()} does not support TSS at this time`);
             }
-            assert_1.default(enterprise, 'enterprise is required for TSS wallet');
+            if ((params.walletVersion === 5 || params.walletVersion === 6) &&
+                !this.baseCoin.getConfig().features.includes(statics_1.CoinFeature.MPCV2)) {
+                throw new Error(`coin ${this.baseCoin.getFamily()} does not support TSS MPCv2 at this time`);
+            }
+            (0, assert_1.default)(enterprise, 'enterprise is required for TSS wallet');
             if (type === 'cold') {
                 // validate
-                assert_1.default(params.bitgoKeyId, 'bitgoKeyId is required for SMC TSS wallet');
-                assert_1.default(params.commonKeychain, 'commonKeychain is required for SMC TSS wallet');
+                (0, assert_1.default)(params.bitgoKeyId, 'bitgoKeyId is required for SMC TSS wallet');
+                (0, assert_1.default)(params.commonKeychain, 'commonKeychain is required for SMC TSS wallet');
                 return this.generateSMCMpcWallet({
                     multisigType: 'tss',
                     label,
@@ -226,31 +377,25 @@ class Wallets {
                     walletVersion: params.walletVersion,
                 });
             }
-            assert_1.default(passphrase, 'cannot generate TSS keys without passphrase');
-            return this.generateMpcWallet({
+            (0, assert_1.default)(passphrase, 'cannot generate TSS keys without passphrase');
+            const walletData = await this.generateMpcWallet({
                 multisigType: 'tss',
                 label,
                 passphrase,
                 originalPasscodeEncryptionCode: params.passcodeEncryptionCode,
                 enterprise,
                 walletVersion: params.walletVersion,
-                backupProvider: params.backupProvider,
+                webauthnInfo: params.webauthnInfo,
+                encryptionVersion: params.encryptionVersion,
             });
-        }
-        const isBlsDkg = params.multisigType ? params.multisigType === 'blsdkg' : this.baseCoin.supportsBlsDkg();
-        if (isBlsDkg) {
-            if (!this.baseCoin.supportsBlsDkg()) {
-                throw new Error(`coin ${this.baseCoin.getFamily()} does not support BLS-DKG at this time`);
-            }
-            assert_1.default(enterprise, 'enterprise is required for BLS-DKG wallet');
-            if (type === 'cold') {
-                throw new Error('BLS-DKG SMC wallets are not supported at this time');
-            }
-            if (type === 'custodial') {
-                throw new Error('BLS-DKG custodial wallets are not supported at this time');
+            if (params.passcodeEncryptionCode) {
+                walletData.encryptedWalletPassphrase = await this.bitgo.encryptAsync({
+                    input: passphrase,
+                    password: params.passcodeEncryptionCode,
+                    encryptionVersion: params.encryptionVersion,
+                });
             }
-            assert_1.default(passphrase, 'cannot generate BLS-DKG keys without passphrase');
-            return this.generateMpcWallet({ multisigType: 'blsdkg', label, passphrase, enterprise });
+            return walletData;
         }
         // Handle distributed custody
         if (isDistributedCustody) {
@@ -320,111 +465,311 @@ class Wallets {
         }
         let derivationPath = undefined;
         const reqId = new utils_1.RequestTracer();
-        // Add the user keychain
-        const userKeychainPromise = async () => {
-            let userKeychainParams;
-            let userKeychain;
-            // User provided user key
-            if (params.userKey) {
-                userKeychain = { pub: params.userKey };
-                userKeychainParams = userKeychain;
-                if (params.coldDerivationSeed) {
-                    // the derivation only makes sense when a key already exists
-                    const derivation = this.baseCoin.deriveKeyWithSeed({
-                        key: params.userKey,
-                        seed: params.coldDerivationSeed,
+        if (params.type === 'custodial' && (params.multisigType ?? 'onchain') === 'onchain') {
+            // for custodial multisig, when the wallet is created on the platfor side, the keys are not needed
+            walletParams.n = undefined;
+            walletParams.m = undefined;
+            walletParams.keys = undefined;
+            walletParams.keySignatures = undefined;
+            const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(walletParams).result(); // returns the ids
+            const userKeychain = this.baseCoin.keychains().get({ id: newWallet.keys[keychain_1.KeyIndices.USER], reqId });
+            const backupKeychain = this.baseCoin.keychains().get({ id: newWallet.keys[keychain_1.KeyIndices.BACKUP], reqId });
+            const bitgoKeychain = this.baseCoin.keychains().get({ id: newWallet.keys[keychain_1.KeyIndices.BITGO], reqId });
+            const [userKey, bitgoKey, backupKey] = await Promise.all([userKeychain, bitgoKeychain, backupKeychain]);
+            const result = {
+                wallet: new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet),
+                userKeychain: userKey,
+                backupKeychain: bitgoKey,
+                bitgoKeychain: backupKey,
+                responseType: 'WalletWithKeychains',
+            };
+            return result;
+        }
+        else {
+            const userKeychainPromise = async () => {
+                let userKeychainParams;
+                let userKeychain;
+                // User provided user key
+                if (params.userKey) {
+                    userKeychain = { pub: params.userKey };
+                    userKeychainParams = userKeychain;
+                    if (params.coldDerivationSeed) {
+                        // the derivation only makes sense when a key already exists
+                        const derivation = this.baseCoin.deriveKeyWithSeed({
+                            key: params.userKey,
+                            seed: params.coldDerivationSeed,
+                        });
+                        derivationPath = derivation.derivationPath;
+                        userKeychain.pub = derivation.key;
+                        userKeychain.derivedFromParentWithSeed = params.coldDerivationSeed;
+                    }
+                }
+                else {
+                    if (!canEncrypt) {
+                        throw new Error('cannot generate user keypair without passphrase');
+                    }
+                    // Create the user key.
+                    userKeychain = this.baseCoin.keychains().create();
+                    userKeychain.encryptedPrv = await this.bitgo.encryptAsync({
+                        password: passphrase,
+                        input: userKeychain.prv,
+                        encryptionVersion: params.encryptionVersion,
                     });
-                    derivationPath = derivation.derivationPath;
-                    userKeychain.pub = derivation.key;
-                    userKeychain.derivedFromParentWithSeed = params.coldDerivationSeed;
+                    userKeychainParams = {
+                        pub: userKeychain.pub,
+                        encryptedPrv: userKeychain.encryptedPrv,
+                        originalPasscodeEncryptionCode: params.passcodeEncryptionCode,
+                    };
+                    // If WebAuthn info is provided, store an additional copy of the private key encrypted
+                    // with the PRF-derived passphrase so the authenticator can later decrypt it.
+                    // Send it as `webauthnInfo` (single object, with enterpriseId) so the atomic
+                    // POST /key persists the passkey — the backend ignores the deprecated `webauthnDevices`.
+                    if (params.webauthnInfo && userKeychain.prv) {
+                        userKeychainParams.webauthnInfo = {
+                            otpDeviceId: params.webauthnInfo.otpDeviceId,
+                            prfSalt: params.webauthnInfo.prfSalt,
+                            enterpriseId: params.enterprise,
+                            encryptedPrv: await this.bitgo.encryptAsync({
+                                password: params.webauthnInfo.passphrase,
+                                input: userKeychain.prv,
+                                encryptionVersion: params.encryptionVersion,
+                            }),
+                        };
+                    }
                 }
-            }
-            else {
-                if (!canEncrypt) {
-                    throw new Error('cannot generate user keypair without passphrase');
+                userKeychainParams.reqId = reqId;
+                const newUserKeychain = await this.baseCoin.keychains().add(userKeychainParams);
+                return _.extend({}, newUserKeychain, userKeychain);
+            };
+            const backupKeychainPromise = async () => {
+                if (params.backupXpubProvider) {
+                    // If requested, use a KRS or backup key provider
+                    return this.baseCoin.keychains().createBackup({
+                        provider: params.backupXpubProvider || 'defaultRMGBackupProvider',
+                        disableKRSEmail: params.disableKRSEmail,
+                        krsSpecific: params.krsSpecific,
+                        type: this.baseCoin.getChain(),
+                        passphrase: params.passphrase,
+                        encryptionVersion: params.encryptionVersion,
+                        reqId,
+                    });
+                }
+                // User provided backup xpub
+                if (params.backupXpub) {
+                    // user provided backup ethereum address
+                    return this.baseCoin.keychains().add({
+                        pub: params.backupXpub,
+                        source: 'backup',
+                        reqId,
+                    });
+                }
+                else {
+                    if (!canEncrypt) {
+                        throw new Error('cannot generate backup keypair without passphrase');
+                    }
+                    // No provided backup xpub or address, so default to creating one here
+                    return this.baseCoin.keychains().createBackup({
+                        reqId,
+                        passphrase: params.passphrase,
+                        encryptionVersion: params.encryptionVersion,
+                    });
                 }
-                // Create the user key.
-                userKeychain = this.baseCoin.keychains().create();
-                userKeychain.encryptedPrv = this.bitgo.encrypt({ password: passphrase, input: userKeychain.prv });
-                userKeychainParams = {
-                    pub: userKeychain.pub,
-                    encryptedPrv: userKeychain.encryptedPrv,
-                    originalPasscodeEncryptionCode: params.passcodeEncryptionCode,
+            };
+            const { userKeychain, backupKeychain, bitgoKeychain } = await (0, utils_1.promiseProps)({
+                userKeychain: userKeychainPromise(),
+                backupKeychain: backupKeychainPromise(),
+                bitgoKeychain: this.baseCoin
+                    .keychains()
+                    .createBitGo({ enterprise: params.enterprise, reqId, isDistributedCustody: params.isDistributedCustody }),
+            });
+            walletParams.keys = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];
+            const { prv } = userKeychain;
+            if (_.isString(prv)) {
+                (0, assert_1.default)(backupKeychain.pub);
+                (0, assert_1.default)(bitgoKeychain.pub);
+                walletParams.keySignatures = {
+                    backup: (await this.baseCoin.signMessage({ prv }, backupKeychain.pub)).toString('hex'),
+                    bitgo: (await this.baseCoin.signMessage({ prv }, bitgoKeychain.pub)).toString('hex'),
                 };
             }
-            userKeychainParams.reqId = reqId;
-            const newUserKeychain = await this.baseCoin.keychains().add(userKeychainParams);
-            return _.extend({}, newUserKeychain, userKeychain);
-        };
-        const backupKeychainPromise = async () => {
-            if (params.backupXpubProvider) {
-                // If requested, use a KRS or backup key provider
-                return this.baseCoin.keychains().createBackup({
-                    provider: params.backupXpubProvider || 'defaultRMGBackupProvider',
-                    disableKRSEmail: params.disableKRSEmail,
-                    krsSpecific: params.krsSpecific,
-                    type: this.baseCoin.getChain(),
-                    reqId,
+            const keychains = {
+                userKeychain,
+                backupKeychain,
+                bitgoKeychain,
+            };
+            const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);
+            if (_.includes(['xrp', 'xlm', 'cspr'], this.baseCoin.getFamily()) && !_.isUndefined(params.rootPrivateKey)) {
+                walletParams.rootPrivateKey = params.rootPrivateKey;
+            }
+            this.bitgo.setRequestTracer(reqId);
+            const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();
+            const result = {
+                wallet: new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet),
+                userKeychain: userKeychain,
+                backupKeychain: backupKeychain,
+                bitgoKeychain: bitgoKeychain,
+                responseType: 'WalletWithKeychains',
+            };
+            if (!_.isUndefined(backupKeychain.prv)) {
+                result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';
+            }
+            if (!_.isUndefined(derivationPath)) {
+                userKeychain.derivationPath = derivationPath;
+            }
+            if (canEncrypt && params.passcodeEncryptionCode) {
+                result.encryptedWalletPassphrase = await this.bitgo.encryptAsync({
+                    input: passphrase,
+                    password: params.passcodeEncryptionCode,
+                    encryptionVersion: params.encryptionVersion,
                 });
             }
-            // User provided backup xpub
-            if (params.backupXpub) {
-                // user provided backup ethereum address
+            return result;
+        }
+    }
+    /**
+     * Generate an onchain multisig wallet using an external signer for user and backup key creation.
+     * 1. Calls createKeychainCallback for user and backup keys
+     * 2. Uploads keychains via keychains().add()
+     * 3. Creates the BitGo key on the service
+     * 4. Creates the wallet on BitGo with the 3 public keys
+     * @param params
+     */
+    async generateWalletWithExternalSigner(params) {
+        if (!_.isFunction(params.createKeychainCallback)) {
+            throw new Error('missing required function parameter createKeychainCallback');
+        }
+        const multisigType = params.multisigType ?? this.baseCoin.getDefaultMultisigType();
+        if (multisigType !== 'onchain') {
+            throw new Error('external signer wallet generation is only supported for onchain multisig wallets');
+        }
+        // these belong to the passphrase-based path and are incompatible with createKeychainCallback
+        const passphrasePathParams = ['passphrase', 'userKey', 'backupXpub', 'backupXpubProvider'];
+        for (const key of passphrasePathParams) {
+            if (!_.isUndefined(params[key])) {
+                throw new Error(`createKeychainCallback cannot be used with ${key}`);
+            }
+        }
+        const { label, createKeychainCallback, type = 'hot', enterprise, isDistributedCustody } = params;
+        if (type === 'custodial') {
+            throw new Error('external signer wallet generation is not supported for custodial onchain wallets');
+        }
+        if (!_.isUndefined(params.webauthnInfo)) {
+            throw new Error('webauthnInfo is not supported for external signer wallet generation');
+        }
+        if (!_.isUndefined(params.passcodeEncryptionCode)) {
+            throw new Error('passcodeEncryptionCode is not supported for external signer wallet generation');
+        }
+        if (isDistributedCustody) {
+            if (!enterprise) {
+                throw new Error('must provide enterprise when creating distributed custody wallet');
+            }
+            if (type !== 'cold') {
+                throw new Error('distributed custody wallets must be type: cold');
+            }
+        }
+        if (params.gasPrice && params.eip1559) {
+            throw new Error('can not use both eip1559 and gasPrice values');
+        }
+        const walletParams = {
+            label,
+            m: 2,
+            n: 3,
+            keys: [],
+            type,
+        };
+        if (!_.isUndefined(enterprise)) {
+            if (!_.isString(enterprise)) {
+                throw new Error('invalid enterprise argument, expecting string');
+            }
+            walletParams.enterprise = enterprise;
+        }
+        if (!_.isUndefined(params.disableTransactionNotifications)) {
+            if (!_.isBoolean(params.disableTransactionNotifications)) {
+                throw new Error('invalid disableTransactionNotifications argument, expecting boolean');
+            }
+            walletParams.disableTransactionNotifications = params.disableTransactionNotifications;
+        }
+        if (!_.isUndefined(params.gasPrice)) {
+            const gasPriceBN = new bignumber_js_1.BigNumber(params.gasPrice);
+            if (gasPriceBN.isNaN()) {
+                throw new Error('invalid gas price argument, expecting number or number as string');
+            }
+            walletParams.gasPrice = gasPriceBN.toString();
+        }
+        if (!_.isUndefined(params.eip1559) && !_.isEmpty(params.eip1559)) {
+            const maxFeePerGasBN = new bignumber_js_1.BigNumber(params.eip1559.maxFeePerGas);
+            if (maxFeePerGasBN.isNaN()) {
+                throw new Error('invalid max fee argument, expecting number or number as string');
+            }
+            const maxPriorityFeePerGasBN = new bignumber_js_1.BigNumber(params.eip1559.maxPriorityFeePerGas);
+            if (maxPriorityFeePerGasBN.isNaN()) {
+                throw new Error('invalid priority fee argument, expecting number or number as string');
+            }
+            walletParams.eip1559 = {
+                maxFeePerGas: maxFeePerGasBN.toString(),
+                maxPriorityFeePerGas: maxPriorityFeePerGasBN.toString(),
+            };
+        }
+        if (!_.isUndefined(params.walletVersion)) {
+            if (!_.isNumber(params.walletVersion)) {
+                throw new Error('invalid walletVersion provided, expecting number');
+            }
+            walletParams.walletVersion = params.walletVersion;
+        }
+        const reqId = new utils_1.RequestTracer();
+        const coin = this.baseCoin.getChain();
+        const createAndUploadKeychain = async (source) => {
+            try {
+                const keychainFromCallback = await createKeychainCallback({ source, coin });
+                if (keychainFromCallback.source !== source) {
+                    throw new Error(`createKeychainCallback returned source ${keychainFromCallback.source}, expected ${source}`);
+                }
+                if (keychainFromCallback.type !== 'independent') {
+                    throw new Error(`createKeychainCallback returned invalid type ${keychainFromCallback.type}, expected 'independent' for onchain multisig`);
+                }
+                if (!this.baseCoin.isValidPub(keychainFromCallback.pub)) {
+                    throw new Error(`createKeychainCallback returned invalid pub for ${source} key on ${coin}`);
+                }
                 return this.baseCoin.keychains().add({
-                    pub: params.backupXpub,
-                    source: 'backup',
+                    pub: keychainFromCallback.pub,
+                    keyType: keychainFromCallback.type,
+                    source: keychainFromCallback.source,
                     reqId,
                 });
             }
-            else {
-                if (!canEncrypt) {
-                    throw new Error('cannot generate backup keypair without passphrase');
-                }
-                // No provided backup xpub or address, so default to creating one here
-                return this.baseCoin.keychains().createBackup({ reqId });
+            catch (error) {
+                throw new Error(`Failed to create ${source} keychain: ${error instanceof Error ? error.message : String(error)}`);
             }
         };
-        const { userKeychain, backupKeychain, bitgoKeychain } = await utils_1.promiseProps({
-            userKeychain: userKeychainPromise(),
-            backupKeychain: backupKeychainPromise(),
+        const { userKeychain, backupKeychain, bitgoKeychain } = await (0, utils_1.promiseProps)({
+            userKeychain: createAndUploadKeychain('user'),
+            backupKeychain: createAndUploadKeychain('backup'),
             bitgoKeychain: this.baseCoin
                 .keychains()
-                .createBitGo({ enterprise: params.enterprise, reqId, isDistributedCustody: params.isDistributedCustody }),
+                .createBitGo({ enterprise, reqId, isDistributedCustody: params.isDistributedCustody }),
         });
         walletParams.keys = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];
-        const { prv } = userKeychain;
-        if (_.isString(prv)) {
-            assert_1.default(backupKeychain.pub);
-            assert_1.default(bitgoKeychain.pub);
-            walletParams.keySignatures = {
-                backup: (await this.baseCoin.signMessage({ prv }, backupKeychain.pub)).toString('hex'),
-                bitgo: (await this.baseCoin.signMessage({ prv }, bitgoKeychain.pub)).toString('hex'),
-            };
-        }
-        if (_.includes(['xrp', 'xlm', 'cspr'], this.baseCoin.getFamily()) && !_.isUndefined(params.rootPrivateKey)) {
-            walletParams.rootPrivateKey = params.rootPrivateKey;
+        if (params.keySignatures) {
+            walletParams.keySignatures = params.keySignatures;
         }
         const keychains = {
             userKeychain,
             backupKeychain,
             bitgoKeychain,
         };
+        if (_.includes(['xrp', 'xlm', 'cspr'], this.baseCoin.getFamily()) && !_.isUndefined(params.rootPrivateKey)) {
+            walletParams.rootPrivateKey = params.rootPrivateKey;
+        }
         const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);
         this.bitgo.setRequestTracer(reqId);
-        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();
-        const result = {
+        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();
+        return {
             wallet: new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet),
-            userKeychain: userKeychain,
-            backupKeychain: backupKeychain,
-            bitgoKeychain: bitgoKeychain,
+            userKeychain,
+            backupKeychain,
+            bitgoKeychain,
+            responseType: 'WalletWithKeychains',
         };
-        if (!_.isUndefined(backupKeychain.prv)) {
-            result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';
-        }
-        if (!_.isUndefined(derivationPath)) {
-            userKeychain.derivationPath = derivationPath;
-        }
-        return result;
     }
     /**
      * List the user's wallet shares
@@ -433,6 +778,13 @@ class Wallets {
     async listShares(params = {}) {
         return await this.bitgo.get(this.baseCoin.url('/walletshare')).result();
     }
+    /**
+     * List the user's wallet shares v2
+     * @returns {Promise<WalletShares>}
+     */
+    async listSharesV2() {
+        return await this.bitgo.get(this.bitgo.url('/walletshares', 2)).result();
+    }
     /**
      * Gets a wallet share information, including the encrypted sharing keychain. requires unlock if keychain is present.
      * @param params
@@ -455,6 +807,73 @@ class Wallets {
             .send(params)
             .result();
     }
+    /**
+     * Bulk accept wallet shares
+     * @param params AcceptShareOptionsRequest[]
+     * @returns {Promise<BulkAcceptShareResponse>}
+     */
+    async bulkAcceptShareRequest(params) {
+        return await this.bulkAcceptShareRequestWithRetry(params);
+    }
+    async bulkAcceptShareRequestWithRetry(params) {
+        // Server has a limit of approximately 1MB for payload size
+        let MAX_PAYLOAD_SIZE = 950000; // ~950KB to leave some buffer
+        // Function to calculate the size of a payload
+        const calculatePayloadSize = (items) => {
+            return Buffer.byteLength(JSON.stringify({ keysForWalletShares: items }), 'utf8');
+        };
+        const results = [];
+        const remainingParams = [...params];
+        while (remainingParams.length > 0) {
+            // Build optimal batch by adding items until we reach size limit
+            const batch = [];
+            // Start with empty batch
+            // Add items one by one while monitoring payload size
+            while (remainingParams.length > 0) {
+                // Test adding the next item
+                const testBatch = [...batch, remainingParams[0]];
+                const testSize = calculatePayloadSize(testBatch);
+                // If adding this item would exceed the size limit, stop adding
+                if (testSize > MAX_PAYLOAD_SIZE && batch.length > 0) {
+                    break;
+                }
+                // Otherwise, add the item to the batch
+                batch.push(remainingParams.shift());
+            }
+            // Handle case where even a single item is too large
+            if (batch.length === 0 && remainingParams.length > 0) {
+                // Send just the first item even if it's oversized
+                batch.push(remainingParams.shift());
+            }
+            const payloadObj = { keysForWalletShares: batch };
+            try {
+                const result = await this.bitgo.put(this.bitgo.url('/walletshares/accept', 2)).send(payloadObj).result();
+                if (result.acceptedWalletShares && Array.isArray(result.acceptedWalletShares)) {
+                    results.push(...result.acceptedWalletShares);
+                }
+            }
+            catch (error) {
+                if (error.status === 413 && batch.length > 1) {
+                    // If we still get 413 with multiple items, put them back and try with half the batch size
+                    remainingParams.unshift(...batch);
+                    MAX_PAYLOAD_SIZE = Math.floor(MAX_PAYLOAD_SIZE / 2); // Reduce size limit for next attempt
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return {
+            acceptedWalletShares: results,
+        };
+    }
+    async bulkUpdateWalletShareRequest(params) {
+        return await this.bitgo
+            .put(this.bitgo.url('/walletshares/update', 2))
+            .send({
+            shares: params,
+        })
+            .result();
+    }
     /**
      * Resend a wallet share invitation email
      * @param params
@@ -477,6 +896,40 @@ class Wallets {
             .send()
             .result();
     }
+    /**
+     * Re-share wallet with existing spenders of the wallet
+     * @param walletId
+     * @param userPassword
+     */
+    async reshareWalletWithSpenders(walletId, userPassword, encryptionVersion) {
+        const wallet = await this.get({ id: walletId });
+        if (!wallet?._wallet?.enterprise) {
+            throw new Error('Enterprise not found for the wallet');
+        }
+        const enterpriseUsersResponse = await this.bitgo
+            .get(this.bitgo.url(`/enterprise/${wallet?._wallet?.enterprise}/user`))
+            .result();
+        // create a map of users for easy lookup - we need the user email id to share the wallet
+        const usersMap = new Map([...enterpriseUsersResponse?.adminUsers, ...enterpriseUsersResponse?.nonAdminUsers].map((obj) => [obj.id, obj]));
+        if (wallet._wallet.users) {
+            for (const user of wallet._wallet.users) {
+                const userObject = usersMap.get(user.user);
+                if (user.permissions.includes('spend') && !user.permissions.includes('admin') && userObject) {
+                    const shareParams = {
+                        walletId: walletId,
+                        user: user.user,
+                        permissions: user.permissions.join(','),
+                        walletPassphrase: userPassword,
+                        email: userObject.email.email,
+                        reshare: true,
+                        skipKeychain: false,
+                        encryptionVersion,
+                    };
+                    await wallet.shareWallet(shareParams);
+                }
+            }
+        }
+    }
     /**
      * Accepts a wallet share, adding the wallet to the user's list
      * Needs a user's password to decrypt the shared key
@@ -492,7 +945,71 @@ class Wallets {
     async acceptShare(params = {}) {
         common.validateParams(params, ['walletShareId'], ['overrideEncryptedPrv', 'userPassword', 'newWalletPassphrase']);
         let encryptedPrv = params.overrideEncryptedPrv;
-        const walletShare = (await this.getShare({ walletShareId: params.walletShareId }));
+        const walletShare = await this.getShare({ walletShareId: params.walletShareId });
+        // Multi-user-key case: requires user to provide their own public key in addition to the encrypted private key
+        if (walletShare.userMultiKeyRotationRequired) {
+            if (_.isUndefined(params.userPassword)) {
+                throw new Error('userPassword param must be provided to generate user keychain');
+            }
+            const walletKeychain = this.baseCoin.keychains().create();
+            const encryptedPrv = await this.bitgo.encryptAsync({
+                password: params.newWalletPassphrase || params.userPassword,
+                input: walletKeychain.prv,
+                encryptionVersion: params.encryptionVersion,
+            });
+            const updateParams = {
+                walletShareId: params.walletShareId,
+                state: 'accepted',
+                encryptedPrv: encryptedPrv,
+                pub: walletKeychain.pub,
+            };
+            // Note: Unlike keychainOverrideRequired, we do NOT reshare the wallet with spenders
+            // This is a key difference - multi-key-user-key wallets don't require reshare
+            return this.updateShare(updateParams);
+        }
+        // Keychain override case: requires user keychain creation and signing
+        if (walletShare.keychainOverrideRequired &&
+            walletShare.permissions.indexOf('admin') !== -1 &&
+            walletShare.permissions.indexOf('spend') !== -1) {
+            if (_.isUndefined(params.userPassword)) {
+                throw new Error('userPassword param must be provided to decrypt shared key');
+            }
+            const walletKeychain = await this.baseCoin
+                .keychains()
+                .createUserKeychain(params.userPassword, params.encryptionVersion);
+            if (_.isUndefined(walletKeychain.encryptedPrv)) {
+                throw new Error('encryptedPrv was not found on wallet keychain');
+            }
+            const payload = {
+                tradingAccountId: walletShare.wallet,
+                pubkey: walletKeychain.pub,
+                timestamp: new Date().toISOString(),
+            };
+            const payloadString = JSON.stringify(payload);
+            const privateKey = await this.bitgo.decryptAsync({
+                password: params.userPassword,
+                input: walletKeychain.encryptedPrv,
+            });
+            const signature = await this.baseCoin.signMessage({ prv: privateKey }, payloadString);
+            const response = await this.updateShare({
+                walletShareId: params.walletShareId,
+                state: 'accepted',
+                keyId: walletKeychain.id,
+                signature: signature.toString('hex'),
+                payload: payloadString,
+            });
+            // If the wallet share was accepted successfully (changed=true), reshare the wallet with the spenders
+            if (response.changed && response.state === 'accepted') {
+                try {
+                    await this.reshareWalletWithSpenders(walletShare.wallet, params.userPassword, params.encryptionVersion);
+                }
+                catch (e) {
+                    // TODO: PX-3826
+                    // Do nothing
+                }
+            }
+            return response;
+        }
         // Return right away if there is no keychain to decrypt, or if explicit encryptedPrv was provided
         if (!walletShare.keychain || !walletShare.keychain.encryptedPrv || encryptedPrv) {
             return this.updateShare({
@@ -509,23 +1026,24 @@ class Wallets {
             throw new Error('encryptedXprv was not found on sharing keychain');
         }
         // Now we have the sharing keychain, we can work out the secret used for sharing the wallet with us
-        sharingKeychain.prv = this.bitgo.decrypt({
+        sharingKeychain.prv = await this.bitgo.decryptAsync({
             password: params.userPassword,
             input: sharingKeychain.encryptedXprv,
         });
-        const secret = ecdh_1.getSharedSecret(
+        const secret = (0, ecdh_1.getSharedSecret)(
         // Derive key by path (which is used between these 2 users only)
-        utxo_lib_1.bip32.fromBase58(sharingKeychain.prv).derivePath(api_1.sanitizeLegacyPath(walletShare.keychain.path)), Buffer.from(walletShare.keychain.fromPubKey, 'hex')).toString('hex');
+        utxo_lib_1.bip32.fromBase58(sharingKeychain.prv).derivePath((0, api_1.sanitizeLegacyPath)(walletShare.keychain.path)), Buffer.from(walletShare.keychain.fromPubKey, 'hex')).toString('hex');
         // Yes! We got the secret successfully here, now decrypt the shared wallet prv
-        const decryptedSharedWalletPrv = this.bitgo.decrypt({
+        const decryptedSharedWalletPrv = await this.bitgo.decryptAsync({
             password: secret,
             input: walletShare.keychain.encryptedPrv,
         });
         // We will now re-encrypt the wallet with our own password
         const newWalletPassphrase = params.newWalletPassphrase || params.userPassword;
-        encryptedPrv = this.bitgo.encrypt({
+        encryptedPrv = await this.bitgo.encryptAsync({
             password: newWalletPassphrase,
             input: decryptedSharedWalletPrv,
+            encryptionVersion: params.encryptionVersion,
         });
         const updateParams = {
             walletShareId: params.walletShareId,
@@ -536,6 +1054,341 @@ class Wallets {
         }
         return this.updateShare(updateParams);
     }
+    /**
+     * Bulk Accept wallet shares, adding the wallets to the user's list
+     * Needs a user's password to decrypt the shared key
+     *
+     * @param params BulkAcceptShareOptions
+     * @param params.walletShareId - array of the wallet shares to accept
+     * @param params.userPassword - user's password to decrypt the shared wallet key
+     * @param params.newWalletPassphrase - new wallet passphrase for saving the shared wallet prv.
+     *                                     If left blank then the user's login password is used.
+     *
+     *@returns {Promise<BulkAcceptShareResponse>}
+     */
+    async bulkAcceptShare(params) {
+        try {
+            common.validateParams(params, ['userLoginPassword'], ['newWalletPassphrase']);
+        }
+        catch (e) {
+            if ('newWalletPassphrase' in params) {
+                throw new Error('Please provide a valid wallet passphrase');
+            }
+            throw new Error('Please provide a valid user login password');
+        }
+        (0, assert_1.default)(params.walletShareIds.length > 0, 'Please provide at least one wallet share to accept');
+        const allWalletShares = await this.listSharesV2();
+        const walletShareMap = allWalletShares.incoming.reduce((map, share) => ({ ...map, [share.id]: share }), {});
+        const walletShares = params.walletShareIds
+            .map((walletShareId) => walletShareMap[walletShareId])
+            .filter((walletShare) => walletShare && (walletShare.keychain || walletShare.userMultiKeyRotationRequired));
+        if (!walletShares.length) {
+            throw new Error('No valid wallet shares found to accept');
+        }
+        const sharingKeychain = await this.bitgo.getECDHKeychain();
+        if (_.isUndefined(sharingKeychain.encryptedXprv)) {
+            throw new Error('encryptedXprv was not found on sharing keychain');
+        }
+        sharingKeychain.prv = await this.bitgo.decryptAsync({
+            password: params.userLoginPassword,
+            input: sharingKeychain.encryptedXprv,
+        });
+        const newWalletPassphrase = params.newWalletPassphrase || params.userLoginPassword;
+        const webauthnInfo = params.webauthnInfo;
+        const keysForWalletShares = (await Promise.all(walletShares.map(async (walletShare) => {
+            // Handle userMultiKeyRotationRequired case - these shares don't have keychains
+            if (walletShare.userMultiKeyRotationRequired) {
+                if (!params.userLoginPassword) {
+                    throw new Error('userLoginPassword param must be provided to generate user keychain');
+                }
+                const walletKeychain = this.baseCoin.keychains().create();
+                const encryptedPrv = await this.bitgo.encryptAsync({
+                    password: newWalletPassphrase,
+                    input: walletKeychain.prv,
+                    encryptionVersion: params.encryptionVersion,
+                });
+                return [
+                    {
+                        walletShareId: walletShare.id,
+                        encryptedPrv: encryptedPrv,
+                        pub: walletKeychain.pub,
+                    },
+                ];
+            }
+            // Standard case: shares with keychains
+            if (!walletShare.keychain) {
+                return [];
+            }
+            const secret = (0, ecdh_1.getSharedSecret)(utxo_lib_1.bip32.fromBase58(sharingKeychain.prv).derivePath((0, api_1.sanitizeLegacyPath)(walletShare.keychain.path)), Buffer.from(walletShare.keychain.fromPubKey, 'hex')).toString('hex');
+            const decryptedSharedWalletPrv = await this.bitgo.decryptAsync({
+                password: secret,
+                input: walletShare.keychain.encryptedPrv,
+            });
+            const newEncryptedPrv = await this.bitgo.encryptAsync({
+                password: newWalletPassphrase,
+                input: decryptedSharedWalletPrv,
+                encryptionVersion: params.encryptionVersion,
+            });
+            const entry = {
+                walletShareId: walletShare.id,
+                encryptedPrv: newEncryptedPrv,
+            };
+            if (webauthnInfo) {
+                entry.webauthnInfo = {
+                    otpDeviceId: webauthnInfo.otpDeviceId,
+                    prfSalt: webauthnInfo.prfSalt,
+                    encryptedPrv: await this.bitgo.encryptAsync({
+                        password: webauthnInfo.passphrase,
+                        input: decryptedSharedWalletPrv,
+                        encryptionVersion: params.encryptionVersion,
+                    }),
+                };
+            }
+            return [entry];
+        }))).flat();
+        return this.bulkAcceptShareRequest(keysForWalletShares);
+    }
+    /**
+     * Updates multiple wallet shares in bulk
+     * This method allows users to accept or reject multiple wallet shares in a single operation.
+     * It handles different types of wallet shares including those requiring special keychain overrides
+     * and those with encrypted private keys that need to be decrypted and re-encrypted.
+     * After processing, it also reshares accepted wallets with spenders for special override cases.
+     *
+     * @param params - Options for bulk updating wallet shares
+     * @param params.shares - Array of wallet shares to update with their status (accept/reject)
+     * @param params.userLoginPassword - User's login password for decryption operations
+     * @param params.newWalletPassphrase - New wallet passphrase for re-encryption
+     * @returns Array of responses for each wallet share update
+     */
+    async bulkUpdateWalletShare(params) {
+        if (!params.shares) {
+            throw new Error('Missing parameter: shares');
+        }
+        if (!Array.isArray(params.shares)) {
+            throw new Error('Expecting parameter array: shares but found ' + typeof params.shares);
+        }
+        // Validate each share in the array
+        for (const share of params.shares) {
+            if (!share.walletShareId) {
+                throw new Error('Missing walletShareId in share');
+            }
+            if (!share.status) {
+                throw new Error('Missing status in share');
+            }
+            if (share.status !== 'accept' && share.status !== 'reject') {
+                throw new Error('Invalid status in share: ' + share.status + '. Must be either "accept" or "reject"');
+            }
+            if (typeof share.walletShareId !== 'string') {
+                throw new Error('Expecting walletShareId to be a string but found ' + typeof share.walletShareId);
+            }
+        }
+        // Validate optional parameters if provided
+        if (params.userLoginPassword !== undefined && typeof params.userLoginPassword !== 'string') {
+            throw new Error('Expecting parameter string: userLoginPassword but found ' + typeof params.userLoginPassword);
+        }
+        if (params.newWalletPassphrase !== undefined && typeof params.newWalletPassphrase !== 'string') {
+            throw new Error('Expecting parameter string: newWalletPassphrase but found ' + typeof params.newWalletPassphrase);
+        }
+        (0, assert_1.default)(params.shares.length > 0, 'no shares are passed');
+        const { shares: inputShares, userLoginPassword, newWalletPassphrase, encryptionVersion } = params;
+        const allWalletShares = await this.listSharesV2();
+        // Only include shares that are in the input array for efficiency
+        const shareIds = new Set(inputShares.map((share) => share.walletShareId));
+        const walletShareMap = new Map();
+        allWalletShares.incoming
+            .filter((share) => shareIds.has(share.id))
+            .forEach((share) => walletShareMap.set(share.id, share));
+        allWalletShares.outgoing
+            .filter((share) => shareIds.has(share.id))
+            .forEach((share) => walletShareMap.set(share.id, share));
+        const resolvedShares = inputShares.map((share) => {
+            const walletShare = walletShareMap.get(share.walletShareId);
+            if (!walletShare) {
+                throw new Error(`invalid wallet share provided: ${share.walletShareId}`);
+            }
+            return { ...share, walletShare };
+        });
+        // Identify special override cases that need resharing after acceptance
+        const specialOverrideCases = new Map();
+        resolvedShares.forEach((share) => {
+            if (share.status === 'accept' &&
+                share.walletShare.keychainOverrideRequired &&
+                share.walletShare.permissions.includes('admin') &&
+                share.walletShare.permissions.includes('spend')) {
+                specialOverrideCases.set(share.walletShareId, share.walletShare.wallet);
+            }
+        });
+        // Decrypt sharing keychain if needed (only once)
+        let sharingKeychainPrv;
+        // Only decrypt if there are shares to accept that might need it
+        const hasSharesRequiringDecryption = specialOverrideCases.size > 0 ||
+            resolvedShares.some((share) => share.status === 'accept' && share.walletShare.keychain?.encryptedPrv);
+        if (userLoginPassword && hasSharesRequiringDecryption) {
+            const sharingKeychain = await this.bitgo.getECDHKeychain();
+            if (!sharingKeychain.encryptedXprv) {
+                throw new Error('encryptedXprv was not found on sharing keychain');
+            }
+            sharingKeychainPrv = await this.bitgo.decryptAsync({
+                password: userLoginPassword,
+                input: sharingKeychain.encryptedXprv,
+            });
+        }
+        const settledUpdates = await Promise.allSettled(resolvedShares.map(async (share) => {
+            const { walletShareId, status, walletShare } = share;
+            // Handle accept case
+            if (status === 'accept') {
+                return this.processAcceptShare(walletShareId, walletShare, userLoginPassword, newWalletPassphrase, sharingKeychainPrv, encryptionVersion);
+            }
+            // Handle reject case
+            return [
+                {
+                    walletShareId,
+                    status: 'reject',
+                },
+            ];
+        }));
+        // Extract successful updates
+        const successfulUpdates = settledUpdates.flatMap((result) => (result.status === 'fulfilled' ? result.value : []));
+        // Extract failed updates - only from rejected promises
+        const failedUpdates = settledUpdates.reduce((acc, result, index) => {
+            if (result.status === 'rejected') {
+                const rejectedResult = result;
+                acc.push({
+                    walletShareId: resolvedShares[index].walletShareId,
+                    reason: rejectedResult.reason?.message || String(rejectedResult.reason),
+                });
+            }
+            return acc;
+        }, []);
+        // Send successful updates to the server
+        const response = await this.bulkUpdateWalletShareRequest(successfulUpdates);
+        // Process accepted special override cases - reshare with spenders
+        if (response.acceptedWalletShares && response.acceptedWalletShares.length > 0 && userLoginPassword) {
+            // For each accepted wallet share that is a special override case, reshare with spenders
+            for (const walletShareId of response.acceptedWalletShares) {
+                if (specialOverrideCases.has(walletShareId)) {
+                    const walletId = specialOverrideCases.get(walletShareId);
+                    try {
+                        await this.reshareWalletWithSpenders(walletId, userLoginPassword, encryptionVersion);
+                    }
+                    catch (e) {
+                        // Log error but continue processing other shares
+                        console.error(`Error resharing wallet ${walletId} with spenders: ${e?.message}`);
+                    }
+                }
+            }
+        }
+        // Add information about failed updates to the response
+        if (failedUpdates.length > 0) {
+            response.walletShareUpdateErrors.push(...failedUpdates);
+        }
+        return response;
+    }
+    /**
+     * Process a wallet share that is being accepted
+     * This method handles the different cases for accepting a wallet share:
+     * 1. Special override case requiring user keychain and signing
+     * 2. Simple case with no keychain to decrypt
+     * 3. Standard case requiring decryption and re-encryption
+     *
+     * @param walletShareId - ID of the wallet share
+     * @param walletShare - Wallet share object
+     * @param userLoginPassword - User's login password
+     * @param newWalletPassphrase - New wallet passphrase
+     * @param sharingKeychainPrv - Decrypted sharing keychain private key
+     * @returns Array of wallet share update requests
+     */
+    async processAcceptShare(walletShareId, walletShare, userLoginPassword, newWalletPassphrase, sharingKeychainPrv, encryptionVersion) {
+        // Special override case: requires user keychain and signing
+        if (walletShare.keychainOverrideRequired &&
+            walletShare.permissions.includes('admin') &&
+            walletShare.permissions.includes('spend')) {
+            if (!userLoginPassword) {
+                throw new Error('userLoginPassword param must be provided to decrypt shared key');
+            }
+            const walletKeychain = await this.baseCoin
+                .keychains()
+                .createUserKeychain(newWalletPassphrase || userLoginPassword, encryptionVersion);
+            if (!walletKeychain.encryptedPrv) {
+                throw new Error('encryptedPrv was not found on wallet keychain');
+            }
+            const payload = JSON.stringify({
+                tradingAccountId: walletShare.wallet,
+                pubkey: walletKeychain.pub,
+                timestamp: new Date().toISOString(),
+            });
+            const prv = await this.bitgo.decryptAsync({
+                password: userLoginPassword,
+                input: walletKeychain.encryptedPrv,
+            });
+            const signature = await this.baseCoin.signMessage({ prv }, payload);
+            return [
+                {
+                    walletShareId,
+                    status: 'accept',
+                    keyId: walletKeychain.id,
+                    signature: signature.toString('hex'),
+                    payload,
+                },
+            ];
+        }
+        // Multi-user-key case: requires user to provide their own public key
+        if (walletShare.userMultiKeyRotationRequired) {
+            if (!(newWalletPassphrase || userLoginPassword)) {
+                throw new Error('userLoginPassword param must be provided to generate user keychain');
+            }
+            const walletKeychain = this.baseCoin.keychains().create();
+            const encryptedPrv = await this.bitgo.encryptAsync({
+                password: newWalletPassphrase || userLoginPassword,
+                input: walletKeychain.prv,
+                encryptionVersion,
+            });
+            return [
+                {
+                    walletShareId,
+                    status: 'accept',
+                    encryptedPrv: encryptedPrv,
+                    pub: walletKeychain.pub,
+                },
+            ];
+        }
+        // Return right away if there is no keychain to decrypt
+        if (!walletShare.keychain || !walletShare.keychain.encryptedPrv) {
+            return [
+                {
+                    walletShareId,
+                    status: 'accept',
+                },
+            ];
+        }
+        // More than viewing was requested, so we need to process the wallet keys using the shared ecdh scheme
+        if (!userLoginPassword) {
+            throw new Error('userLoginPassword param must be provided to decrypt shared key');
+        }
+        if (!sharingKeychainPrv) {
+            throw new Error('failed to retrieve and decrypt sharing keychain');
+        }
+        const derivedKey = utxo_lib_1.bip32.fromBase58(sharingKeychainPrv).derivePath((0, api_1.sanitizeLegacyPath)(walletShare.keychain.path));
+        const sharedSecret = (0, ecdh_1.getSharedSecret)(derivedKey, Buffer.from(walletShare.keychain.fromPubKey, 'hex')).toString('hex');
+        const decryptedPrv = await this.bitgo.decryptAsync({
+            password: sharedSecret,
+            input: walletShare.keychain.encryptedPrv,
+        });
+        // We will now re-encrypt the wallet with our own password
+        const encryptedPrv = await this.bitgo.encryptAsync({
+            password: newWalletPassphrase || userLoginPassword,
+            input: decryptedPrv,
+            encryptionVersion,
+        });
+        return [
+            {
+                walletShareId,
+                status: 'accept',
+                encryptedPrv,
+            },
+        ];
+    }
     /**
      * Get a wallet by its ID
      * @param params
@@ -551,6 +1404,9 @@ class Wallets {
             }
             query.allTokens = params.allTokens;
         }
+        if (params.includeBalance !== undefined) {
+            query.includeBalance = params.includeBalance;
+        }
         this.bitgo.setRequestTracer(params.reqId || new utils_1.RequestTracer());
         const wallet = await this.bitgo
             .get(this.baseCoin.url('/wallet/' + params.id))
@@ -584,7 +1440,14 @@ class Wallets {
      * @param params
      * @private
      */
-    async generateMpcWallet({ passphrase, label, multisigType, enterprise, walletVersion, originalPasscodeEncryptionCode, backupProvider, }) {
+    async generateMpcWallet({ passphrase, label, multisigType, enterprise, walletVersion, originalPasscodeEncryptionCode, webauthnInfo, encryptionVersion, }) {
+        if (multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa') {
+            const tssSettings = await this.bitgo
+                .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))
+                .result();
+            const multisigTypeVersion = tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.multiSigTypeVersion;
+            walletVersion = this.determineEcdsaMpcWalletVersion(walletVersion, multisigTypeVersion);
+        }
         const reqId = new utils_1.RequestTracer();
         this.bitgo.setRequestTracer(reqId);
         // Create MPC Keychains
@@ -593,7 +1456,8 @@ class Wallets {
             passphrase,
             enterprise,
             originalPasscodeEncryptionCode,
-            backupProvider,
+            webauthnInfo,
+            encryptionVersion,
         });
         // Create Wallet
         const { userKeychain, backupKeychain, bitgoKeychain } = keychains;
@@ -608,14 +1472,15 @@ class Wallets {
             walletVersion,
         };
         const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);
-        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();
+        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();
         const result = {
             wallet: new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet),
             userKeychain,
             backupKeychain,
             bitgoKeychain,
+            responseType: 'WalletWithKeychains',
         };
-        if (!_.isUndefined(backupKeychain.prv) && !_.isUndefined(backupProvider)) {
+        if (!_.isUndefined(backupKeychain.prv)) {
             result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';
         }
         return result;
@@ -628,11 +1493,23 @@ class Wallets {
     async generateSMCMpcWallet({ label, multisigType, enterprise, walletVersion, bitgoKeyId, commonKeychain, coldDerivationSeed, }) {
         const reqId = new utils_1.RequestTracer();
         this.bitgo.setRequestTracer(reqId);
+        let multisigTypeVersion;
+        if (multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa') {
+            const tssSettings = await this.bitgo
+                .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))
+                .result();
+            multisigTypeVersion =
+                tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.coldMultiSigTypeVersion;
+            walletVersion = this.determineEcdsaMpcWalletVersion(walletVersion, multisigTypeVersion);
+        }
         // Create MPC Keychains
         const bitgoKeychain = await this.baseCoin.keychains().get({ id: bitgoKeyId });
         if (!bitgoKeychain || !bitgoKeychain.commonKeychain) {
             throw new Error('BitGo keychain not found');
         }
+        if (bitgoKeychain.source !== 'bitgo') {
+            throw new Error('The provided bitgoKeyId is not a BitGo keychain');
+        }
         if (bitgoKeychain.commonKeychain !== commonKeychain) {
             throw new Error('The provided Common keychain mismatch with the provided Bitgo key');
         }
@@ -644,6 +1521,7 @@ class Wallets {
             keyType: 'tss',
             commonKeychain: commonKeychain,
             derivedFromParentWithSeed: coldDerivationSeed,
+            isMPCv2: multisigTypeVersion === 'MPCv2' ? true : undefined,
         };
         const userKeychain = await this.baseCoin.keychains().add(userKeychainParams);
         const backupKeyChainParams = {
@@ -651,6 +1529,7 @@ class Wallets {
             keyType: 'tss',
             commonKeychain: commonKeychain,
             derivedFromParentWithSeed: coldDerivationSeed,
+            isMPCv2: multisigTypeVersion === 'MPCv2' ? true : undefined,
         };
         const backupKeychain = await this.baseCoin.keychains().add(backupKeyChainParams);
         // Create Wallet
@@ -666,12 +1545,13 @@ class Wallets {
             walletVersion,
         };
         const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);
-        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();
+        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();
         const result = {
             wallet: new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet),
             userKeychain,
             backupKeychain,
             bitgoKeychain,
+            responseType: 'WalletWithKeychains',
         };
         return result;
     }
@@ -683,6 +1563,13 @@ class Wallets {
     async generateCustodialMpcWallet({ label, multisigType, enterprise, walletVersion, }) {
         const reqId = new utils_1.RequestTracer();
         this.bitgo.setRequestTracer(reqId);
+        if (multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa') {
+            const tssSettings = await this.bitgo
+                .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))
+                .result();
+            const multisigTypeVersion = tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.custodialMultiSigTypeVersion;
+            walletVersion = this.determineEcdsaMpcWalletVersion(walletVersion, multisigTypeVersion);
+        }
         const finalWalletParams = {
             label,
             multisigType,
@@ -691,17 +1578,26 @@ class Wallets {
             type: 'custodial',
         };
         // Create Wallet
-        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();
+        const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();
         const wallet = new wallet_1.Wallet(this.bitgo, this.baseCoin, newWallet);
         const keychains = wallet.keyIds();
         const result = {
             wallet,
-            userKeychain: { id: keychains[0], type: multisigType },
-            backupKeychain: { id: keychains[1], type: multisigType },
-            bitgoKeychain: { id: keychains[2], type: multisigType },
+            userKeychain: { id: keychains[0], type: multisigType, source: 'user' },
+            backupKeychain: { id: keychains[1], type: multisigType, source: 'backup' },
+            bitgoKeychain: { id: keychains[2], type: multisigType, source: 'bitgo' },
+            responseType: 'WalletWithKeychains',
         };
         return result;
     }
+    determineEcdsaMpcWalletVersion(walletVersion, multisigTypeVersion) {
+        if (this.baseCoin.isEVM() && multisigTypeVersion === 'MPCv2') {
+            if (!walletVersion || (walletVersion !== 5 && walletVersion !== 6)) {
+                return 5;
+            }
+        }
+        return walletVersion;
+    }
 }
 exports.Wallets = Wallets;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wallets.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/wallets.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,oDAA4B;AAC5B,+CAAyC;AACzC,mDAA6C;AAC7C,0CAA4B;AAC5B,mCAA+C;AAC/C,qDAAuC;AAGvC,kCAA0C;AAE1C,oCAAuD;AAevD,qCAAkC;AAElC,MAAa,OAAO;IAIlB,YAAY,KAAgB,EAAE,QAAmB;QAC/C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,GAAG,CAAC,SAA2B,EAAE;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,CAAC,SAA4B,EAAE;QACvC,MAAM,WAAW,GAAsB,EAAE,CAAC;QAE1C,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE;YAChC,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;SACxD;QAED,IAAI,MAAM,CAAC,WAAW,EAAE;YACtB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE;gBACpC,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;aACpE;YACD,WAAW,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;SAC9C;QACD,IAAI,MAAM,CAAC,MAAM,EAAE;YACjB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;gBAC9B,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;aAC9D;YACD,WAAW,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;SACpC;QACD,IAAI,MAAM,CAAC,KAAK,EAAE;YAChB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;gBAC7B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;aAC7D;YACD,WAAW,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;SAClC;QAED,IAAI,MAAM,CAAC,SAAS,EAAE;YACpB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE;gBAClC,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;aAClE;YACD,WAAW,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;SAC1C;QAED,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,MAAM,EAAE,CAAQ,CAAC;QACrG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;QACjF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,GAAG,CAAC,MAAwB;QAChC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QAEtB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;QAEnE,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,EAAE;YACpC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;SAC5D;QAED,sDAAsD;QACtD,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE;YAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;gBAC1F,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;aACrC;YAED,uCAAuC;YACvC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE;gBAC3C,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;aAC/C;SACF;QAED,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;YACnD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;SACpE;QAED,IAAI,MAAM,CAAC,aAAa,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE;YAC7D,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;SACzE;QAED,IAAI,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,KAAK,EAAE;YACvD,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;SAC/D;QAED,IAAI,MAAM,CAAC,WAAW,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,KAAK,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;SACtE;QAED,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;YAChD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;SACnE;QAED,IAAI,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE;YAC1D,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;SACxE;QAED,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE;YACpG,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;SACjF;QAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;QAC5F,OAAO;YACL,MAAM,EAAE,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;SACzD,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,KAAK,CAAC,cAAc,CAAC,SAAgC,EAAE;QACrD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;QAClF,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,EAAE;YACpC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;SAC5D;QAED,MAAM,EAAE,IAAI,GAAG,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,oBAAoB,EAAE,GAAG,MAAM,CAAC;QACrF,MAAM,KAAK,GAAG,MAAM,CAAC,YAAY,KAAK,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC3E,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,IAAI,OAAO,UAAU,KAAK,QAAQ,CAAC;QAElE,MAAM,YAAY,GAAoC;YACpD,KAAK,EAAE,KAAK;YACZ,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;YACJ,IAAI,EAAE,EAAE;YACR,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;SAC5E,CAAC;QAEF,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,sBAAsB,CAAC,EAAE;YACjD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,sBAAsB,CAAC,EAAE;gBAC9C,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;aAC5D;SACF;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE;YAC9B,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;gBAC3B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;aAClE;YACD,YAAY,CAAC,UAAU,GAAG,UAAU,CAAC;SACtC;QAED,4CAA4C;QAC5C,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,KAAK,CAAC,CAAC,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;SAC5E;QAED,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE;gBAChC,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,oCAAoC,CAAC,CAAC;aACxF;YACD,gBAAM,CAAC,UAAU,EAAE,uCAAuC,CAAC,CAAC;YAE5D,IAAI,IAAI,KAAK,MAAM,EAAE;gBACnB,WAAW;gBACX,gBAAM,CAAC,MAAM,CAAC,UAAU,EAAE,2CAA2C,CAAC,CAAC;gBACvE,gBAAM,CAAC,MAAM,CAAC,cAAc,EAAE,+CAA+C,CAAC,CAAC;gBAC/E,OAAO,IAAI,CAAC,oBAAoB,CAAC;oBAC/B,YAAY,EAAE,KAAK;oBACnB,KAAK;oBACL,UAAU;oBACV,aAAa,EAAE,MAAM,CAAC,aAAa;oBACnC,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,cAAc,EAAE,MAAM,CAAC,cAAc;oBACrC,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;iBAC9C,CAAC,CAAC;aACJ;YAED,IAAI,IAAI,KAAK,WAAW,EAAE;gBACxB,OAAO,IAAI,CAAC,0BAA0B,CAAC;oBACrC,YAAY,EAAE,KAAK;oBACnB,KAAK;oBACL,UAAU;oBACV,aAAa,EAAE,MAAM,CAAC,aAAa;iBACpC,CAAC,CAAC;aACJ;YAED,gBAAM,CAAC,UAAU,EAAE,6CAA6C,CAAC,CAAC;YAClE,OAAO,IAAI,CAAC,iBAAiB,CAAC;gBAC5B,YAAY,EAAE,KAAK;gBACnB,KAAK;gBACL,UAAU;gBACV,8BAA8B,EAAE,MAAM,CAAC,sBAAsB;gBAC7D,UAAU;gBACV,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,cAAc,EAAE,MAAM,CAAC,cAAc;aACtC,CAAC,CAAC;SACJ;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC;QACzG,IAAI,QAAQ,EAAE;YACZ,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,EAAE;gBACnC,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,wCAAwC,CAAC,CAAC;aAC5F;YACD,gBAAM,CAAC,UAAU,EAAE,2CAA2C,CAAC,CAAC;YAEhE,IAAI,IAAI,KAAK,MAAM,EAAE;gBACnB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;aACvE;YAED,IAAI,IAAI,KAAK,WAAW,EAAE;gBACxB,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;aAC7E;YAED,gBAAM,CAAC,UAAU,EAAE,iDAAiD,CAAC,CAAC;YACtE,OAAO,IAAI,CAAC,iBAAiB,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,CAAC;SAC1F;QAED,6BAA6B;QAC7B,IAAI,oBAAoB,EAAE;YACxB,IAAI,CAAC,UAAU,EAAE;gBACf,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;aACrF;YACD,IAAI,CAAC,IAAI,IAAI,IAAI,KAAK,MAAM,EAAE;gBAC5B,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;aACnE;SACF;QAED,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;QAC1C,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;QAC1D,IAAI,aAAa,IAAI,qBAAqB,EAAE;YAC1C,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;SACvF;QAED,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,OAAO,EAAE;YACrC,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;SACjE;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,+BAA+B,CAAC,EAAE;YAC1D,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,+BAA+B,CAAC,EAAE;gBACxD,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;aACxF;YACD,YAAY,CAAC,+BAA+B,GAAG,MAAM,CAAC,+BAA+B,CAAC;SACvF;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;YACnC,MAAM,UAAU,GAAG,IAAI,wBAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAClD,IAAI,UAAU,CAAC,KAAK,EAAE,EAAE;gBACtB,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;aACrF;YACD,YAAY,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC;SAC/C;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;YAChE,MAAM,cAAc,GAAG,IAAI,wBAAS,CAAC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAClE,IAAI,cAAc,CAAC,KAAK,EAAE,EAAE;gBAC1B,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;aACnF;YACD,MAAM,sBAAsB,GAAG,IAAI,wBAAS,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;YAClF,IAAI,sBAAsB,CAAC,KAAK,EAAE,EAAE;gBAClC,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;aACxF;YACD,YAAY,CAAC,OAAO,GAAG;gBACrB,YAAY,EAAE,cAAc,CAAC,QAAQ,EAAE;gBACvC,oBAAoB,EAAE,sBAAsB,CAAC,QAAQ,EAAE;aACxD,CAAC;SACH;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE;YAC1C,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE;gBACxC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;aACxE;YACD,YAAY,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;SACvD;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE;YACxC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE;gBACrC,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;aACrE;YACD,YAAY,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;SACnD;QAED,uEAAuE;QACvE,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC;QAC/B,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE;YAC/B,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;gBACvC,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;gBAC7B,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;oBAC7D,MAAM,IAAI,KAAK,CAAC,0FAA0F,CAAC,CAAC;iBAC7G;YACH,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,cAAc,GAAuB,SAAS,CAAC;QAEnD,MAAM,KAAK,GAAG,IAAI,qBAAa,EAAE,CAAC;QAElC,wBAAwB;QACxB,MAAM,mBAAmB,GAAG,KAAK,IAAuB,EAAE;YACxD,IAAI,kBAAkB,CAAC;YACvB,IAAI,YAAY,CAAC;YACjB,yBAAyB;YACzB,IAAI,MAAM,CAAC,OAAO,EAAE;gBAClB,YAAY,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;gBACvC,kBAAkB,GAAG,YAAY,CAAC;gBAClC,IAAI,MAAM,CAAC,kBAAkB,EAAE;oBAC7B,4DAA4D;oBAC5D,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;wBACjD,GAAG,EAAE,MAAM,CAAC,OAAO;wBACnB,IAAI,EAAE,MAAM,CAAC,kBAAkB;qBAChC,CAAC,CAAC;oBACH,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;oBAC3C,YAAY,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;oBAClC,YAAY,CAAC,yBAAyB,GAAG,MAAM,CAAC,kBAAkB,CAAC;iBACpE;aACF;iBAAM;gBACL,IAAI,CAAC,UAAU,EAAE;oBACf,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;iBACpE;gBACD,uBAAuB;gBACvB,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC;gBAClD,YAAY,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC;gBAClG,kBAAkB,GAAG;oBACnB,GAAG,EAAE,YAAY,CAAC,GAAG;oBACrB,YAAY,EAAE,YAAY,CAAC,YAAY;oBACvC,8BAA8B,EAAE,MAAM,CAAC,sBAAsB;iBAC9D,CAAC;aACH;YAED,kBAAkB,CAAC,KAAK,GAAG,KAAK,CAAC;YACjC,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YAChF,OAAO,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC;QACrD,CAAC,CAAC;QAEF,MAAM,qBAAqB,GAAG,KAAK,IAAuB,EAAE;YAC1D,IAAI,MAAM,CAAC,kBAAkB,EAAE;gBAC7B,iDAAiD;gBACjD,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,YAAY,CAAC;oBAC5C,QAAQ,EAAE,MAAM,CAAC,kBAAkB,IAAI,0BAA0B;oBACjE,eAAe,EAAE,MAAM,CAAC,eAAe;oBACvC,WAAW,EAAE,MAAM,CAAC,WAAW;oBAC/B,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;oBAC9B,KAAK;iBACN,CAAC,CAAC;aACJ;YAED,4BAA4B;YAC5B,IAAI,MAAM,CAAC,UAAU,EAAE;gBACrB,wCAAwC;gBACxC,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC;oBACnC,GAAG,EAAE,MAAM,CAAC,UAAU;oBACtB,MAAM,EAAE,QAAQ;oBAChB,KAAK;iBACN,CAAC,CAAC;aACJ;iBAAM;gBACL,IAAI,CAAC,UAAU,EAAE;oBACf,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;iBACtE;gBACD,sEAAsE;gBACtE,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;aAC1D;QACH,CAAC,CAAC;QAEF,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,GAAqB,MAAM,oBAAY,CAAC;YAC3F,YAAY,EAAE,mBAAmB,EAAE;YACnC,cAAc,EAAE,qBAAqB,EAAE;YACvC,aAAa,EAAE,IAAI,CAAC,QAAQ;iBACzB,SAAS,EAAE;iBACX,WAAW,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,CAAC,oBAAoB,EAAE,CAAC;SAC5G,CAAC,CAAC;QAEH,YAAY,CAAC,IAAI,GAAG,CAAC,YAAY,CAAC,EAAE,EAAE,cAAc,CAAC,EAAE,EAAE,aAAa,CAAC,EAAE,CAAC,CAAC;QAE3E,MAAM,EAAE,GAAG,EAAE,GAAG,YAAY,CAAC;QAC7B,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACnB,gBAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAC3B,gBAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YAC1B,YAAY,CAAC,aAAa,GAAG;gBAC3B,MAAM,EAAE,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;gBACtF,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;aACrF,CAAC;SACH;QAED,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE;YAC1G,YAAY,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;SACrD;QAED,MAAM,SAAS,GAAG;YAChB,YAAY;YACZ,cAAc;YACd,aAAa;SACd,CAAC;QACF,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;QAChG,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACnC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,CAAC;QAEvG,MAAM,MAAM,GAAwB;YAClC,MAAM,EAAE,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;YACxD,YAAY,EAAE,YAAY;YAC1B,cAAc,EAAE,cAAc;YAC9B,aAAa,EAAE,aAAa;SAC7B,CAAC;QAEF,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;YACtC,MAAM,CAAC,OAAO,GAAG,0EAA0E,CAAC;SAC7F;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE;YAClC,YAAY,CAAC,cAAc,GAAG,cAAc,CAAC;SAC9C;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CAAC,SAAkC,EAAE;QACnD,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1E,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,QAAQ,CAAC,SAAqC,EAAE;QACpD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,CAAC;QAErD,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAClG,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,WAAW,CAAC,SAA6B,EAAE;QAC/C,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,CAAC;QAErD,OAAO,MAAM,IAAI,CAAC,KAAK;aACpB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;aAC/D,IAAI,CAAC,MAAM,CAAC;aACZ,MAAM,EAAE,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iBAAiB,CAAC,SAAqC,EAAE;QAC7D,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,CAAC;QAErD,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,GAAG,cAAc,CAAC;QACvD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACjF,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,WAAW,CAAC,SAAqC,EAAE;QACvD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,CAAC;QAErD,OAAO,MAAM,IAAI,CAAC,KAAK;aACpB,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;aAC9D,IAAI,EAAE;aACN,MAAM,EAAE,CAAC;IACd,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,WAAW,CAAC,SAA6B,EAAE;QAC/C,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,sBAAsB,EAAE,cAAc,EAAE,qBAAqB,CAAC,CAAC,CAAC;QAElH,IAAI,YAAY,GAAG,MAAM,CAAC,oBAAoB,CAAC;QAE/C,MAAM,WAAW,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,EAAE,CAAC,CAAQ,CAAC;QAE1F,iGAAiG;QACjG,IAAI,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,YAAY,IAAI,YAAY,EAAE;YAC/E,OAAO,IAAI,CAAC,WAAW,CAAC;gBACtB,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,KAAK,EAAE,UAAU;aAClB,CAAC,CAAC;SACJ;QAED,sGAAsG;QACtG,IAAI,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;YACtC,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;SAC9E;QAED,MAAM,eAAe,GAAG,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAQ,CAAC;QACpE,IAAI,CAAC,CAAC,WAAW,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE;YAChD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;SACpE;QAED,mGAAmG;QACnG,eAAe,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YACvC,QAAQ,EAAE,MAAM,CAAC,YAAY;YAC7B,KAAK,EAAE,eAAe,CAAC,aAAa;SACrC,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,sBAAe;QAC5B,gEAAgE;QAChE,gBAAK,CAAC,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,wBAAkB,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAC/F,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,CACpD,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAElB,8EAA8E;QAC9E,MAAM,wBAAwB,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YAClD,QAAQ,EAAE,MAAM;YAChB,KAAK,EAAE,WAAW,CAAC,QAAQ,CAAC,YAAY;SACzC,CAAC,CAAC;QAEH,0DAA0D;QAC1D,MAAM,mBAAmB,GAAG,MAAM,CAAC,mBAAmB,IAAI,MAAM,CAAC,YAAY,CAAC;QAC9E,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YAChC,QAAQ,EAAE,mBAAmB;YAC7B,KAAK,EAAE,wBAAwB;SAChC,CAAC,CAAC;QACH,MAAM,YAAY,GAAuB;YACvC,aAAa,EAAE,MAAM,CAAC,aAAa;YACnC,KAAK,EAAE,UAAU;SAClB,CAAC;QAEF,IAAI,YAAY,EAAE;YAChB,YAAY,CAAC,YAAY,GAAG,YAAY,CAAC;SAC1C;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,SAAS,CAAC,SAA2B,EAAE;QAC3C,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;QAE1C,MAAM,KAAK,GAAqB,EAAE,CAAC;QACnC,IAAI,MAAM,CAAC,SAAS,EAAE;YACpB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE;gBAClC,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;aAClE;YACD,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;SACpC;QAED,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,IAAI,IAAI,qBAAa,EAAE,CAAC,CAAC;QAEjE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK;aAC5B,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;aAC9C,KAAK,CAAC,KAAK,CAAC;aACZ,MAAM,EAAE,CAAC;QACZ,OAAO,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,kBAAkB,CAAC,SAAoC,EAAE;QAC7D,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;QAE/C,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,IAAI,IAAI,qBAAa,EAAE,CAAC,CAAC;QAEjE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QACrG,OAAO,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,gBAAgB,CAAC,SAAgC,EAAE;QACvD,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9E,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,iBAAiB,CAAC,EAC9B,UAAU,EACV,KAAK,EACL,YAAY,EACZ,UAAU,EACV,aAAa,EACb,8BAA8B,EAC9B,cAAc,GACW;QACzB,MAAM,KAAK,GAAG,IAAI,qBAAa,EAAE,CAAC;QAClC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAEnC,uBAAuB;QACvB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,SAAS,CAAC;YAC1D,YAAY;YACZ,UAAU;YACV,UAAU;YACV,8BAA8B;YAC9B,cAAc;SACf,CAAC,CAAC;QAEH,gBAAgB;QAChB,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,GAAG,SAAS,CAAC;QAClE,MAAM,YAAY,GAAoC;YACpD,KAAK;YACL,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;YACJ,IAAI,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,cAAc,CAAC,EAAE,EAAE,aAAa,CAAC,EAAE,CAAC;YAC5D,IAAI,EAAE,KAAK;YACX,YAAY;YACZ,UAAU;YACV,aAAa;SACd,CAAC;QACF,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;QAChG,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,CAAC;QAEvG,MAAM,MAAM,GAAwB;YAClC,MAAM,EAAE,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;YACxD,YAAY;YACZ,cAAc;YACd,aAAa;SACd,CAAC;QAEF,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE;YACxE,MAAM,CAAC,OAAO,GAAG,0EAA0E,CAAC;SAC7F;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,oBAAoB,CAAC,EACjC,KAAK,EACL,YAAY,EACZ,UAAU,EACV,aAAa,EACb,UAAU,EACV,cAAc,EACd,kBAAkB,GACU;QAC5B,MAAM,KAAK,GAAG,IAAI,qBAAa,EAAE,CAAC;QAClC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAEnC,uBAAuB;QACvB,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;QAE9E,IAAI,CAAC,aAAa,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE;YACnD,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;SAC7C;QAED,IAAI,aAAa,CAAC,cAAc,KAAK,cAAc,EAAE;YACnD,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;SACtF;QAED,IAAI,CAAC,kBAAkB,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;SAC1D;QAED,MAAM,kBAAkB,GAAuB;YAC7C,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,KAAK;YACd,cAAc,EAAE,cAAc;YAC9B,yBAAyB,EAAE,kBAAkB;SAC9C,CAAC;QACF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAE7E,MAAM,oBAAoB,GAAuB;YAC/C,MAAM,EAAE,QAAQ;YAChB,OAAO,EAAE,KAAK;YACd,cAAc,EAAE,cAAc;YAC9B,yBAAyB,EAAE,kBAAkB;SAC9C,CAAC;QAEF,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QAEjF,gBAAgB;QAChB,MAAM,SAAS,GAAG,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;QAClE,MAAM,YAAY,GAAoC;YACpD,KAAK;YACL,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;YACJ,IAAI,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,cAAc,CAAC,EAAE,EAAE,aAAa,CAAC,EAAE,CAAC;YAC5D,IAAI,EAAE,MAAM;YACZ,YAAY;YACZ,UAAU;YACV,aAAa;SACd,CAAC;QAEF,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;QAChG,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,CAAC;QAEvG,MAAM,MAAM,GAAwB;YAClC,MAAM,EAAE,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;YACxD,YAAY;YACZ,cAAc;YACd,aAAa;SACd,CAAC;QAEF,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,0BAA0B,CAAC,EACvC,KAAK,EACL,YAAY,EACZ,UAAU,EACV,aAAa,GACgB;QAC7B,MAAM,KAAK,GAAG,IAAI,qBAAa,EAAE,CAAC;QAClC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAEnC,MAAM,iBAAiB,GAAG;YACxB,KAAK;YACL,YAAY;YACZ,UAAU;YACV,aAAa;YACb,IAAI,EAAE,WAAW;SAClB,CAAC;QAEF,gBAAgB;QAChB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,CAAC;QACvG,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QAChE,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;QAClC,MAAM,MAAM,GAAwB;YAClC,MAAM;YACN,YAAY,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE;YACtD,cAAc,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE;YACxD,aAAa,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE;SACxD,CAAC;QAEF,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA9xBD,0BA8xBC","sourcesContent":["/**\n * @prettier\n */\nimport assert from 'assert';\nimport { BigNumber } from 'bignumber.js';\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport * as _ from 'lodash';\nimport { sanitizeLegacyPath } from '../../api';\nimport * as common from '../../common';\nimport { IBaseCoin, KeychainsTriplet, SupplementGenerateWalletOptions } from '../baseCoin';\nimport { BitGoBase } from '../bitgoBase';\nimport { getSharedSecret } from '../ecdh';\nimport { AddKeychainOptions, Keychain } from '../keychain';\nimport { promiseProps, RequestTracer } from '../utils';\nimport {\n  AcceptShareOptions,\n  AddWalletOptions,\n  GenerateBaseMpcWalletOptions,\n  GenerateMpcWalletOptions,\n  GenerateSMCMpcWalletOptions,\n  GenerateWalletOptions,\n  GetWalletByAddressOptions,\n  GetWalletOptions,\n  IWallets,\n  ListWalletOptions,\n  UpdateShareOptions,\n  WalletWithKeychains,\n} from './iWallets';\nimport { Wallet } from './wallet';\n\nexport class Wallets implements IWallets {\n  private readonly bitgo: BitGoBase;\n  private readonly baseCoin: IBaseCoin;\n\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin) {\n    this.bitgo = bitgo;\n    this.baseCoin = baseCoin;\n  }\n\n  /**\n   * Get a wallet by ID (proxy for getWallet)\n   * @param params\n   */\n  async get(params: GetWalletOptions = {}): Promise<Wallet> {\n    return this.getWallet(params);\n  }\n\n  /**\n   * List a user's wallets\n   * @param params\n   * @returns {*}\n   */\n  async list(params: ListWalletOptions = {}): Promise<{ wallets: Wallet[] }> {\n    const queryObject: ListWalletOptions = {};\n\n    if (params.skip && params.prevId) {\n      throw new Error('cannot specify both skip and prevId');\n    }\n\n    if (params.getbalances) {\n      if (!_.isBoolean(params.getbalances)) {\n        throw new Error('invalid getbalances argument, expecting boolean');\n      }\n      queryObject.getbalances = params.getbalances;\n    }\n    if (params.prevId) {\n      if (!_.isString(params.prevId)) {\n        throw new Error('invalid prevId argument, expecting string');\n      }\n      queryObject.prevId = params.prevId;\n    }\n    if (params.limit) {\n      if (!_.isNumber(params.limit)) {\n        throw new Error('invalid limit argument, expecting number');\n      }\n      queryObject.limit = params.limit;\n    }\n\n    if (params.allTokens) {\n      if (!_.isBoolean(params.allTokens)) {\n        throw new Error('invalid allTokens argument, expecting boolean');\n      }\n      queryObject.allTokens = params.allTokens;\n    }\n\n    const body = (await this.bitgo.get(this.baseCoin.url('/wallet')).query(queryObject).result()) as any;\n    body.wallets = body.wallets.map((w) => new Wallet(this.bitgo, this.baseCoin, w));\n    return body;\n  }\n\n  /**\n   * add\n   * Add a new wallet (advanced mode).\n   * This allows you to manually submit the keys, type, m and n of the wallet\n   * Parameters include:\n   *    \"label\": label of the wallet to be shown in UI\n   *    \"m\": number of keys required to unlock wallet (2)\n   *    \"n\": number of keys available on the wallet (3)\n   *    \"keys\": array of keychain ids\n   */\n  async add(params: AddWalletOptions): Promise<any> {\n    params = params || {};\n\n    common.validateParams(params, [], ['label', 'enterprise', 'type']);\n\n    if (typeof params.label !== 'string') {\n      throw new Error('missing required string parameter label');\n    }\n\n    // no need to pass keys for (single) custodial wallets\n    if (params.type !== 'custodial') {\n      if (Array.isArray(params.keys) === false || !_.isNumber(params.m) || !_.isNumber(params.n)) {\n        throw new Error('invalid argument');\n      }\n\n      // TODO: support more types of multisig\n      if (!this.baseCoin.isValidMofNSetup(params)) {\n        throw new Error('unsupported multi-sig type');\n      }\n    }\n\n    if (params.gasPrice && !_.isNumber(params.gasPrice)) {\n      throw new Error('invalid argument for gasPrice - number expected');\n    }\n\n    if (params.walletVersion && !_.isNumber(params.walletVersion)) {\n      throw new Error('invalid argument for walletVersion - number expected');\n    }\n\n    if (params.tags && Array.isArray(params.tags) === false) {\n      throw new Error('invalid argument for tags - array expected');\n    }\n\n    if (params.clientFlags && Array.isArray(params.clientFlags) === false) {\n      throw new Error('invalid argument for clientFlags - array expected');\n    }\n\n    if (params.isCold && !_.isBoolean(params.isCold)) {\n      throw new Error('invalid argument for isCold - boolean expected');\n    }\n\n    if (params.isCustodial && !_.isBoolean(params.isCustodial)) {\n      throw new Error('invalid argument for isCustodial - boolean expected');\n    }\n\n    if (params.address && (!_.isString(params.address) || !this.baseCoin.isValidAddress(params.address))) {\n      throw new Error('invalid argument for address - valid address string expected');\n    }\n\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(params).result();\n    return {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n    };\n  }\n\n  /**\n   * Generate a new wallet\n   * 1. Creates the user keychain locally on the client, and encrypts it with the provided passphrase\n   * 2. If no pub was provided, creates the backup keychain locally on the client, and encrypts it with the provided passphrase\n   * 3. Uploads the encrypted user and backup keychains to BitGo\n   * 4. Creates the BitGo key on the service\n   * 5. Creates the wallet on BitGo with the 3 public keys above\n   * @param params\n   * @param params.label Label for the wallet\n   * @param params.passphrase Passphrase to be used to encrypt the user and backup keychains\n   * @param params.userKey User xpub\n   * @param params.backupXpub Backup xpub\n   * @param params.backupXpubProvider\n   * @param params.backupProvider Third party backup provider for TSS\n   * @param params.enterprise the enterpriseId\n   * @param params.disableTransactionNotifications\n   * @param params.passcodeEncryptionCode optional this is a recovery code that can be used to decrypt the original passphrase in a recovery case.\n   *                                      The user must generate and keep the encrypted original passphrase safe while this code is stored on BitGo\n   * @param params.coldDerivationSeed optional seed for SMC wallets\n   * @param params.gasPrice\n   * @param params.disableKRSEmail\n   * @param params.walletVersion\n   * @param params.multisigType optional multisig type, 'onchain' or 'tss' or 'blsdkg'; if absent, we will defer to the coin's default type\n   * @param params.isDistributedCustody optional parameter for creating bitgo key. This is only necessary if you want to create\n   *                                    a distributed custody wallet. If provided, you must have the enterprise license and pass in\n   *                                    `params.enterprise` into `generateWallet` as well.\n   * @param params.type optional wallet type, 'hot' or 'cold' or 'custodial'; if absent, we will defer to 'hot'\n   * @param params.bitgoKeyId optional bitgo key id for SMC TSS wallets\n   * @param params.commonKeychain optional common keychain for SMC TSS wallets\n   *\n   * @returns {*}\n   */\n  async generateWallet(params: GenerateWalletOptions = {}): Promise<WalletWithKeychains> {\n    common.validateParams(params, ['label'], ['passphrase', 'userKey', 'backupXpub']);\n    if (typeof params.label !== 'string') {\n      throw new Error('missing required string parameter label');\n    }\n\n    const { type = 'hot', label, passphrase, enterprise, isDistributedCustody } = params;\n    const isTss = params.multisigType === 'tss' && this.baseCoin.supportsTss();\n    const canEncrypt = !!passphrase && typeof passphrase === 'string';\n\n    const walletParams: SupplementGenerateWalletOptions = {\n      label: label,\n      m: 2,\n      n: 3,\n      keys: [],\n      type: !!params.userKey && params.multisigType !== 'onchain' ? 'cold' : type,\n    };\n\n    if (!_.isUndefined(params.passcodeEncryptionCode)) {\n      if (!_.isString(params.passcodeEncryptionCode)) {\n        throw new Error('passcodeEncryptionCode must be a string');\n      }\n    }\n\n    if (!_.isUndefined(enterprise)) {\n      if (!_.isString(enterprise)) {\n        throw new Error('invalid enterprise argument, expecting string');\n      }\n      walletParams.enterprise = enterprise;\n    }\n\n    // EVM TSS wallets must use wallet version 3\n    if ((isTss && this.baseCoin.isEVM()) !== (params.walletVersion === 3)) {\n      throw new Error('EVM TSS wallets are only supported for wallet version 3');\n    }\n\n    if (isTss) {\n      if (!this.baseCoin.supportsTss()) {\n        throw new Error(`coin ${this.baseCoin.getFamily()} does not support TSS at this time`);\n      }\n      assert(enterprise, 'enterprise is required for TSS wallet');\n\n      if (type === 'cold') {\n        // validate\n        assert(params.bitgoKeyId, 'bitgoKeyId is required for SMC TSS wallet');\n        assert(params.commonKeychain, 'commonKeychain is required for SMC TSS wallet');\n        return this.generateSMCMpcWallet({\n          multisigType: 'tss',\n          label,\n          enterprise,\n          walletVersion: params.walletVersion,\n          bitgoKeyId: params.bitgoKeyId,\n          commonKeychain: params.commonKeychain,\n          coldDerivationSeed: params.coldDerivationSeed,\n        });\n      }\n\n      if (type === 'custodial') {\n        return this.generateCustodialMpcWallet({\n          multisigType: 'tss',\n          label,\n          enterprise,\n          walletVersion: params.walletVersion,\n        });\n      }\n\n      assert(passphrase, 'cannot generate TSS keys without passphrase');\n      return this.generateMpcWallet({\n        multisigType: 'tss',\n        label,\n        passphrase,\n        originalPasscodeEncryptionCode: params.passcodeEncryptionCode,\n        enterprise,\n        walletVersion: params.walletVersion,\n        backupProvider: params.backupProvider,\n      });\n    }\n\n    const isBlsDkg = params.multisigType ? params.multisigType === 'blsdkg' : this.baseCoin.supportsBlsDkg();\n    if (isBlsDkg) {\n      if (!this.baseCoin.supportsBlsDkg()) {\n        throw new Error(`coin ${this.baseCoin.getFamily()} does not support BLS-DKG at this time`);\n      }\n      assert(enterprise, 'enterprise is required for BLS-DKG wallet');\n\n      if (type === 'cold') {\n        throw new Error('BLS-DKG SMC wallets are not supported at this time');\n      }\n\n      if (type === 'custodial') {\n        throw new Error('BLS-DKG custodial wallets are not supported at this time');\n      }\n\n      assert(passphrase, 'cannot generate BLS-DKG keys without passphrase');\n      return this.generateMpcWallet({ multisigType: 'blsdkg', label, passphrase, enterprise });\n    }\n\n    // Handle distributed custody\n    if (isDistributedCustody) {\n      if (!enterprise) {\n        throw new Error('must provide enterprise when creating distributed custody wallet');\n      }\n      if (!type || type !== 'cold') {\n        throw new Error('distributed custody wallets must be type: cold');\n      }\n    }\n\n    const hasBackupXpub = !!params.backupXpub;\n    const hasBackupXpubProvider = !!params.backupXpubProvider;\n    if (hasBackupXpub && hasBackupXpubProvider) {\n      throw new Error('Cannot provide more than one backupXpub or backupXpubProvider flag');\n    }\n\n    if (params.gasPrice && params.eip1559) {\n      throw new Error('can not use both eip1559 and gasPrice values');\n    }\n\n    if (!_.isUndefined(params.disableTransactionNotifications)) {\n      if (!_.isBoolean(params.disableTransactionNotifications)) {\n        throw new Error('invalid disableTransactionNotifications argument, expecting boolean');\n      }\n      walletParams.disableTransactionNotifications = params.disableTransactionNotifications;\n    }\n\n    if (!_.isUndefined(params.gasPrice)) {\n      const gasPriceBN = new BigNumber(params.gasPrice);\n      if (gasPriceBN.isNaN()) {\n        throw new Error('invalid gas price argument, expecting number or number as string');\n      }\n      walletParams.gasPrice = gasPriceBN.toString();\n    }\n\n    if (!_.isUndefined(params.eip1559) && !_.isEmpty(params.eip1559)) {\n      const maxFeePerGasBN = new BigNumber(params.eip1559.maxFeePerGas);\n      if (maxFeePerGasBN.isNaN()) {\n        throw new Error('invalid max fee argument, expecting number or number as string');\n      }\n      const maxPriorityFeePerGasBN = new BigNumber(params.eip1559.maxPriorityFeePerGas);\n      if (maxPriorityFeePerGasBN.isNaN()) {\n        throw new Error('invalid priority fee argument, expecting number or number as string');\n      }\n      walletParams.eip1559 = {\n        maxFeePerGas: maxFeePerGasBN.toString(),\n        maxPriorityFeePerGas: maxPriorityFeePerGasBN.toString(),\n      };\n    }\n\n    if (!_.isUndefined(params.disableKRSEmail)) {\n      if (!_.isBoolean(params.disableKRSEmail)) {\n        throw new Error('invalid disableKRSEmail argument, expecting boolean');\n      }\n      walletParams.disableKRSEmail = params.disableKRSEmail;\n    }\n\n    if (!_.isUndefined(params.walletVersion)) {\n      if (!_.isNumber(params.walletVersion)) {\n        throw new Error('invalid walletVersion provided, expecting number');\n      }\n      walletParams.walletVersion = params.walletVersion;\n    }\n\n    // Ensure each krsSpecific param is either a string, boolean, or number\n    const { krsSpecific } = params;\n    if (!_.isUndefined(krsSpecific)) {\n      Object.keys(krsSpecific).forEach((key) => {\n        const val = krsSpecific[key];\n        if (!_.isBoolean(val) && !_.isString(val) && !_.isNumber(val)) {\n          throw new Error('krsSpecific object contains illegal values. values must be strings, booleans, or numbers');\n        }\n      });\n    }\n\n    let derivationPath: string | undefined = undefined;\n\n    const reqId = new RequestTracer();\n\n    // Add the user keychain\n    const userKeychainPromise = async (): Promise<Keychain> => {\n      let userKeychainParams;\n      let userKeychain;\n      // User provided user key\n      if (params.userKey) {\n        userKeychain = { pub: params.userKey };\n        userKeychainParams = userKeychain;\n        if (params.coldDerivationSeed) {\n          // the derivation only makes sense when a key already exists\n          const derivation = this.baseCoin.deriveKeyWithSeed({\n            key: params.userKey,\n            seed: params.coldDerivationSeed,\n          });\n          derivationPath = derivation.derivationPath;\n          userKeychain.pub = derivation.key;\n          userKeychain.derivedFromParentWithSeed = params.coldDerivationSeed;\n        }\n      } else {\n        if (!canEncrypt) {\n          throw new Error('cannot generate user keypair without passphrase');\n        }\n        // Create the user key.\n        userKeychain = this.baseCoin.keychains().create();\n        userKeychain.encryptedPrv = this.bitgo.encrypt({ password: passphrase, input: userKeychain.prv });\n        userKeychainParams = {\n          pub: userKeychain.pub,\n          encryptedPrv: userKeychain.encryptedPrv,\n          originalPasscodeEncryptionCode: params.passcodeEncryptionCode,\n        };\n      }\n\n      userKeychainParams.reqId = reqId;\n      const newUserKeychain = await this.baseCoin.keychains().add(userKeychainParams);\n      return _.extend({}, newUserKeychain, userKeychain);\n    };\n\n    const backupKeychainPromise = async (): Promise<Keychain> => {\n      if (params.backupXpubProvider) {\n        // If requested, use a KRS or backup key provider\n        return this.baseCoin.keychains().createBackup({\n          provider: params.backupXpubProvider || 'defaultRMGBackupProvider',\n          disableKRSEmail: params.disableKRSEmail,\n          krsSpecific: params.krsSpecific,\n          type: this.baseCoin.getChain(),\n          reqId,\n        });\n      }\n\n      // User provided backup xpub\n      if (params.backupXpub) {\n        // user provided backup ethereum address\n        return this.baseCoin.keychains().add({\n          pub: params.backupXpub,\n          source: 'backup',\n          reqId,\n        });\n      } else {\n        if (!canEncrypt) {\n          throw new Error('cannot generate backup keypair without passphrase');\n        }\n        // No provided backup xpub or address, so default to creating one here\n        return this.baseCoin.keychains().createBackup({ reqId });\n      }\n    };\n\n    const { userKeychain, backupKeychain, bitgoKeychain }: KeychainsTriplet = await promiseProps({\n      userKeychain: userKeychainPromise(),\n      backupKeychain: backupKeychainPromise(),\n      bitgoKeychain: this.baseCoin\n        .keychains()\n        .createBitGo({ enterprise: params.enterprise, reqId, isDistributedCustody: params.isDistributedCustody }),\n    });\n\n    walletParams.keys = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];\n\n    const { prv } = userKeychain;\n    if (_.isString(prv)) {\n      assert(backupKeychain.pub);\n      assert(bitgoKeychain.pub);\n      walletParams.keySignatures = {\n        backup: (await this.baseCoin.signMessage({ prv }, backupKeychain.pub)).toString('hex'),\n        bitgo: (await this.baseCoin.signMessage({ prv }, bitgoKeychain.pub)).toString('hex'),\n      };\n    }\n\n    if (_.includes(['xrp', 'xlm', 'cspr'], this.baseCoin.getFamily()) && !_.isUndefined(params.rootPrivateKey)) {\n      walletParams.rootPrivateKey = params.rootPrivateKey;\n    }\n\n    const keychains = {\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n    };\n    const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);\n    this.bitgo.setRequestTracer(reqId);\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();\n\n    const result: WalletWithKeychains = {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n      userKeychain: userKeychain,\n      backupKeychain: backupKeychain,\n      bitgoKeychain: bitgoKeychain,\n    };\n\n    if (!_.isUndefined(backupKeychain.prv)) {\n      result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';\n    }\n\n    if (!_.isUndefined(derivationPath)) {\n      userKeychain.derivationPath = derivationPath;\n    }\n\n    return result;\n  }\n\n  /**\n   * List the user's wallet shares\n   * @param params\n   */\n  async listShares(params: Record<string, unknown> = {}): Promise<any> {\n    return await this.bitgo.get(this.baseCoin.url('/walletshare')).result();\n  }\n\n  /**\n   * Gets a wallet share information, including the encrypted sharing keychain. requires unlock if keychain is present.\n   * @param params\n   * @param params.walletShareId - the wallet share to get information on\n   */\n  async getShare(params: { walletShareId?: string } = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    return await this.bitgo.get(this.baseCoin.url('/walletshare/' + params.walletShareId)).result();\n  }\n\n  /**\n   * Update a wallet share\n   * @param params.walletShareId - the wallet share to update\n   * @param params.state - the new state of the wallet share\n   * @param params\n   */\n  async updateShare(params: UpdateShareOptions = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    return await this.bitgo\n      .post(this.baseCoin.url('/walletshare/' + params.walletShareId))\n      .send(params)\n      .result();\n  }\n\n  /**\n   * Resend a wallet share invitation email\n   * @param params\n   * @param params.walletShareId - the wallet share whose invitiation should be resent\n   */\n  async resendShareInvite(params: { walletShareId?: string } = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    const urlParts = params.walletShareId + '/resendemail';\n    return this.bitgo.post(this.baseCoin.url('/walletshare/' + urlParts)).result();\n  }\n\n  /**\n   * Cancel a wallet share\n   * @param params\n   * @param params.walletShareId - the wallet share to update\n   */\n  async cancelShare(params: { walletShareId?: string } = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    return await this.bitgo\n      .del(this.baseCoin.url('/walletshare/' + params.walletShareId))\n      .send()\n      .result();\n  }\n\n  /**\n   * Accepts a wallet share, adding the wallet to the user's list\n   * Needs a user's password to decrypt the shared key\n   *\n   * @param params\n   * @param params.walletShareId - the wallet share to accept\n   * @param params.userPassword - (required if more a keychain was shared) user's password to decrypt the shared wallet\n   * @param params.newWalletPassphrase - new wallet passphrase for saving the shared wallet prv.\n   *                                     If left blank and a wallet with more than view permissions was shared,\n   *                                     then the user's login password is used.\n   * @param params.overrideEncryptedPrv - set only if the prv was received out-of-band.\n   */\n  async acceptShare(params: AcceptShareOptions = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], ['overrideEncryptedPrv', 'userPassword', 'newWalletPassphrase']);\n\n    let encryptedPrv = params.overrideEncryptedPrv;\n\n    const walletShare = (await this.getShare({ walletShareId: params.walletShareId })) as any;\n\n    // Return right away if there is no keychain to decrypt, or if explicit encryptedPrv was provided\n    if (!walletShare.keychain || !walletShare.keychain.encryptedPrv || encryptedPrv) {\n      return this.updateShare({\n        walletShareId: params.walletShareId,\n        state: 'accepted',\n      });\n    }\n\n    // More than viewing was requested, so we need to process the wallet keys using the shared ecdh scheme\n    if (_.isUndefined(params.userPassword)) {\n      throw new Error('userPassword param must be provided to decrypt shared key');\n    }\n\n    const sharingKeychain = (await this.bitgo.getECDHKeychain()) as any;\n    if (_.isUndefined(sharingKeychain.encryptedXprv)) {\n      throw new Error('encryptedXprv was not found on sharing keychain');\n    }\n\n    // Now we have the sharing keychain, we can work out the secret used for sharing the wallet with us\n    sharingKeychain.prv = this.bitgo.decrypt({\n      password: params.userPassword,\n      input: sharingKeychain.encryptedXprv,\n    });\n    const secret = getSharedSecret(\n      // Derive key by path (which is used between these 2 users only)\n      bip32.fromBase58(sharingKeychain.prv).derivePath(sanitizeLegacyPath(walletShare.keychain.path)),\n      Buffer.from(walletShare.keychain.fromPubKey, 'hex')\n    ).toString('hex');\n\n    // Yes! We got the secret successfully here, now decrypt the shared wallet prv\n    const decryptedSharedWalletPrv = this.bitgo.decrypt({\n      password: secret,\n      input: walletShare.keychain.encryptedPrv,\n    });\n\n    // We will now re-encrypt the wallet with our own password\n    const newWalletPassphrase = params.newWalletPassphrase || params.userPassword;\n    encryptedPrv = this.bitgo.encrypt({\n      password: newWalletPassphrase,\n      input: decryptedSharedWalletPrv,\n    });\n    const updateParams: UpdateShareOptions = {\n      walletShareId: params.walletShareId,\n      state: 'accepted',\n    };\n\n    if (encryptedPrv) {\n      updateParams.encryptedPrv = encryptedPrv;\n    }\n\n    return this.updateShare(updateParams);\n  }\n\n  /**\n   * Get a wallet by its ID\n   * @param params\n   * @param params.id wallet id\n   * @returns {*}\n   */\n  async getWallet(params: GetWalletOptions = {}): Promise<Wallet> {\n    common.validateParams(params, ['id'], []);\n\n    const query: GetWalletOptions = {};\n    if (params.allTokens) {\n      if (!_.isBoolean(params.allTokens)) {\n        throw new Error('invalid allTokens argument, expecting boolean');\n      }\n      query.allTokens = params.allTokens;\n    }\n\n    this.bitgo.setRequestTracer(params.reqId || new RequestTracer());\n\n    const wallet = await this.bitgo\n      .get(this.baseCoin.url('/wallet/' + params.id))\n      .query(query)\n      .result();\n    return new Wallet(this.bitgo, this.baseCoin, wallet);\n  }\n\n  /**\n   * Get a wallet by its address\n   * @param params\n   * @param params.address wallet address\n   * @returns {*}\n   */\n  async getWalletByAddress(params: GetWalletByAddressOptions = {}): Promise<Wallet> {\n    common.validateParams(params, ['address'], []);\n\n    this.bitgo.setRequestTracer(params.reqId || new RequestTracer());\n\n    const wallet = await this.bitgo.get(this.baseCoin.url('/wallet/address/' + params.address)).result();\n    return new Wallet(this.bitgo, this.baseCoin, wallet);\n  }\n\n  /**\n   * For any given supported coin, get total balances for all wallets of that\n   * coin type on the account.\n   * @param params\n   * @returns {*}\n   */\n  async getTotalBalances(params: Record<string, never> = {}): Promise<any> {\n    return await this.bitgo.get(this.baseCoin.url('/wallet/balances')).result();\n  }\n\n  /**\n   * Generates a TSS or BLS-DKG Wallet.\n   * @param params\n   * @private\n   */\n  private async generateMpcWallet({\n    passphrase,\n    label,\n    multisigType,\n    enterprise,\n    walletVersion,\n    originalPasscodeEncryptionCode,\n    backupProvider,\n  }: GenerateMpcWalletOptions): Promise<WalletWithKeychains> {\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    // Create MPC Keychains\n    const keychains = await this.baseCoin.keychains().createMpc({\n      multisigType,\n      passphrase,\n      enterprise,\n      originalPasscodeEncryptionCode,\n      backupProvider,\n    });\n\n    // Create Wallet\n    const { userKeychain, backupKeychain, bitgoKeychain } = keychains;\n    const walletParams: SupplementGenerateWalletOptions = {\n      label,\n      m: 2,\n      n: 3,\n      keys: [userKeychain.id, backupKeychain.id, bitgoKeychain.id],\n      type: 'hot',\n      multisigType,\n      enterprise,\n      walletVersion,\n    };\n    const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();\n\n    const result: WalletWithKeychains = {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n    };\n\n    if (!_.isUndefined(backupKeychain.prv) && !_.isUndefined(backupProvider)) {\n      result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';\n    }\n\n    return result;\n  }\n\n  /**\n   * Generates a Self-Managed Cold TSS Wallet.\n   * @param params\n   * @private\n   */\n  private async generateSMCMpcWallet({\n    label,\n    multisigType,\n    enterprise,\n    walletVersion,\n    bitgoKeyId,\n    commonKeychain,\n    coldDerivationSeed,\n  }: GenerateSMCMpcWalletOptions): Promise<WalletWithKeychains> {\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    // Create MPC Keychains\n    const bitgoKeychain = await this.baseCoin.keychains().get({ id: bitgoKeyId });\n\n    if (!bitgoKeychain || !bitgoKeychain.commonKeychain) {\n      throw new Error('BitGo keychain not found');\n    }\n\n    if (bitgoKeychain.commonKeychain !== commonKeychain) {\n      throw new Error('The provided Common keychain mismatch with the provided Bitgo key');\n    }\n\n    if (!coldDerivationSeed) {\n      throw new Error('derivedFromParentWithSeed is required');\n    }\n\n    const userKeychainParams: AddKeychainOptions = {\n      source: 'user',\n      keyType: 'tss',\n      commonKeychain: commonKeychain,\n      derivedFromParentWithSeed: coldDerivationSeed,\n    };\n    const userKeychain = await this.baseCoin.keychains().add(userKeychainParams);\n\n    const backupKeyChainParams: AddKeychainOptions = {\n      source: 'backup',\n      keyType: 'tss',\n      commonKeychain: commonKeychain,\n      derivedFromParentWithSeed: coldDerivationSeed,\n    };\n\n    const backupKeychain = await this.baseCoin.keychains().add(backupKeyChainParams);\n\n    // Create Wallet\n    const keychains = { userKeychain, backupKeychain, bitgoKeychain };\n    const walletParams: SupplementGenerateWalletOptions = {\n      label,\n      m: 2,\n      n: 3,\n      keys: [userKeychain.id, backupKeychain.id, bitgoKeychain.id],\n      type: 'cold',\n      multisigType,\n      enterprise,\n      walletVersion,\n    };\n\n    const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();\n\n    const result: WalletWithKeychains = {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n    };\n\n    return result;\n  }\n\n  /**\n   * Generates a Custodial TSS Wallet.\n   * @param params\n   * @private\n   */\n  private async generateCustodialMpcWallet({\n    label,\n    multisigType,\n    enterprise,\n    walletVersion,\n  }: GenerateBaseMpcWalletOptions): Promise<WalletWithKeychains> {\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    const finalWalletParams = {\n      label,\n      multisigType,\n      enterprise,\n      walletVersion,\n      type: 'custodial',\n    };\n\n    // Create Wallet\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet')).send(finalWalletParams).result();\n    const wallet = new Wallet(this.bitgo, this.baseCoin, newWallet);\n    const keychains = wallet.keyIds();\n    const result: WalletWithKeychains = {\n      wallet,\n      userKeychain: { id: keychains[0], type: multisigType },\n      backupKeychain: { id: keychains[1], type: multisigType },\n      bitgoKeychain: { id: keychains[2], type: multisigType },\n    };\n\n    return result;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wallets.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/wallets.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport assert from 'assert';\nimport { BigNumber } from 'bignumber.js';\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport * as _ from 'lodash';\nimport { CoinFeature } from '@bitgo-beta/statics';\n\nimport { EncryptionVersion, sanitizeLegacyPath } from '../../api';\nimport * as common from '../../common';\nimport { IBaseCoin, KeychainsTriplet, SupplementGenerateWalletOptions } from '../baseCoin';\nimport { BitGoBase } from '../bitgoBase';\nimport { getSharedSecret } from '../ecdh';\nimport { AddKeychainOptions, Keychain, KeyIndices } from '../keychain';\nimport { decodeOrElse, promiseProps, RequestTracer } from '../utils';\nimport {\n  AcceptShareOptions,\n  AcceptShareOptionsRequest,\n  AddWalletOptions,\n  BulkAcceptShareOptions,\n  BulkAcceptShareResponse,\n  BulkUpdateWalletShareOptions,\n  BulkUpdateWalletShareOptionsRequest,\n  BulkUpdateWalletShareResponse,\n  GenerateBaseMpcWalletOptions,\n  GenerateGoAccountWalletOptions,\n  GenerateGoAccountWalletOptionsCodec,\n  GenerateLightningWalletOptions,\n  GenerateLightningWalletOptionsCodec,\n  GenerateMpcWalletOptions,\n  GenerateSMCMpcWalletOptions,\n  GenerateWalletOptions,\n  GenerateWalletWithExternalSignerOptions,\n  GetWalletByAddressOptions,\n  GetWalletOptions,\n  GoAccountWalletWithUserKeychain,\n  IWallets,\n  LightningWalletWithKeychains,\n  ListWalletOptions,\n  UpdateShareOptions,\n  WalletShares,\n  WalletWithKeychains,\n} from './iWallets';\nimport { WalletShare } from './iWallet';\nimport { Wallet } from './wallet';\nimport { TssSettings } from '@bitgo/public-types';\nimport { createEvmKeyRingWallet, validateEvmKeyRingWalletParams } from '../evm/evmUtils';\n\n/**\n * Check if a wallet is a WalletWithKeychains\n */\nexport function isWalletWithKeychains(\n  wallet: WalletWithKeychains | LightningWalletWithKeychains | GoAccountWalletWithUserKeychain\n): wallet is WalletWithKeychains {\n  return wallet.responseType === 'WalletWithKeychains';\n}\n\nexport class Wallets implements IWallets {\n  private readonly bitgo: BitGoBase;\n  private readonly baseCoin: IBaseCoin;\n\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin) {\n    this.bitgo = bitgo;\n    this.baseCoin = baseCoin;\n  }\n\n  /**\n   * Get a wallet by ID (proxy for getWallet)\n   * @param params\n   */\n  async get(params: GetWalletOptions = {}): Promise<Wallet> {\n    return this.getWallet(params);\n  }\n\n  /**\n   * List a user's wallets\n   * @param params\n   * @returns {*}\n   */\n  async list(params: ListWalletOptions & { enterprise?: string } = {}): Promise<{ wallets: Wallet[] }> {\n    if (params.skip && params.prevId) {\n      throw new Error('cannot specify both skip and prevId');\n    }\n    const body = (await this.bitgo.get(this.baseCoin.url('/wallet')).query(params).result()) as any;\n    body.wallets = body.wallets.map((w) => new Wallet(this.bitgo, this.baseCoin, w));\n    return body;\n  }\n\n  /**\n   * add\n   * Add a new wallet (advanced mode).\n   * This allows you to manually submit the keys, type, m and n of the wallet\n   * Parameters include:\n   *    \"label\": label of the wallet to be shown in UI\n   *    \"m\": number of keys required to unlock wallet (2)\n   *    \"n\": number of keys available on the wallet (3)\n   *    \"keys\": array of keychain ids\n   */\n  async add(params: AddWalletOptions): Promise<any> {\n    params = params || {};\n\n    common.validateParams(params, [], ['label', 'enterprise', 'type']);\n\n    if (typeof params.label !== 'string') {\n      throw new Error('missing required string parameter label');\n    }\n\n    validateEvmKeyRingWalletParams(params, this.baseCoin);\n\n    if (!params.evmKeyRingReferenceWalletId && params.type !== 'custodial') {\n      // no need to pass keys for (single) custodial wallets\n      if (Array.isArray(params.keys) === false || !_.isNumber(params.m) || !_.isNumber(params.n)) {\n        throw new Error('invalid argument');\n      }\n\n      // TODO: support more types of multisig\n      if (!this.baseCoin.isValidMofNSetup(params)) {\n        throw new Error('unsupported multi-sig type');\n      }\n    }\n\n    if (params.gasPrice && !_.isNumber(params.gasPrice)) {\n      throw new Error('invalid argument for gasPrice - number expected');\n    }\n\n    if (params.walletVersion) {\n      if (!_.isNumber(params.walletVersion)) {\n        throw new Error('invalid argument for walletVersion - number expected');\n      }\n      if (params.multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa' && params.walletVersion === 3) {\n        const tssSettings: TssSettings = await this.bitgo\n          .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))\n          .result();\n        const multisigTypeVersion =\n          tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.multiSigTypeVersion;\n        if (multisigTypeVersion === 'MPCv2') {\n          params.walletVersion = 5;\n        }\n      }\n    }\n\n    if (params.tags && Array.isArray(params.tags) === false) {\n      throw new Error('invalid argument for tags - array expected');\n    }\n\n    if (params.clientFlags && Array.isArray(params.clientFlags) === false) {\n      throw new Error('invalid argument for clientFlags - array expected');\n    }\n\n    if (params.isCold && !_.isBoolean(params.isCold)) {\n      throw new Error('invalid argument for isCold - boolean expected');\n    }\n\n    if (params.isCustodial && !_.isBoolean(params.isCustodial)) {\n      throw new Error('invalid argument for isCustodial - boolean expected');\n    }\n\n    if (params.address && (!_.isString(params.address) || !this.baseCoin.isValidAddress(params.address))) {\n      throw new Error('invalid argument for address - valid address string expected');\n    }\n\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(params).result();\n    return {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n    };\n  }\n\n  private async generateLightningWallet(params: GenerateLightningWalletOptions): Promise<LightningWalletWithKeychains> {\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    const { label, passphrase, enterprise, passcodeEncryptionCode, subType, lightningProvider, encryptionVersion } =\n      params;\n\n    // TODO BTC-1899: only userAuth key is required for custodial lightning wallet. all 3 keys are required for self custodial lightning.\n    // to avoid changing the platform for custodial flow, let us all 3 keys both wallet types.\n    const keychainPromises = ([undefined, 'userAuth', 'nodeAuth'] as const).map((purpose) => {\n      return async (): Promise<Keychain> => {\n        const keychain = this.baseCoin.keychains().create();\n        const keychainParams: AddKeychainOptions = {\n          pub: keychain.pub,\n          encryptedPrv: await this.bitgo.encryptAsync({\n            password: passphrase,\n            input: keychain.prv,\n            encryptionVersion,\n          }),\n          originalPasscodeEncryptionCode: purpose === undefined ? passcodeEncryptionCode : undefined,\n          coinSpecific: purpose === undefined ? undefined : { [this.baseCoin.getChain()]: { purpose } },\n          keyType: 'independent',\n          source: 'user',\n        };\n        return await this.baseCoin.keychains().add(keychainParams);\n      };\n    });\n\n    const { userKeychain, userAuthKeychain, nodeAuthKeychain } = await promiseProps({\n      userKeychain: keychainPromises[0](),\n      userAuthKeychain: keychainPromises[1](),\n      nodeAuthKeychain: keychainPromises[2](),\n    });\n\n    const walletParams: SupplementGenerateWalletOptions = {\n      label,\n      m: 1,\n      n: 1,\n      type: 'hot',\n      subType,\n      enterprise,\n      keys: [userKeychain.id],\n      coinSpecific: { [this.baseCoin.getChain()]: { keys: [userAuthKeychain.id, nodeAuthKeychain.id] } },\n      lightningProvider,\n    };\n\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(walletParams).result();\n    const wallet = new Wallet(this.bitgo, this.baseCoin, newWallet);\n    return {\n      wallet,\n      userKeychain,\n      userAuthKeychain,\n      nodeAuthKeychain,\n      responseType: 'LightningWalletWithKeychains',\n    };\n  }\n\n  /**\n   * Generate a Go Account wallet\n   * @param params GenerateGoAccountWalletOptions\n   * @returns Promise<GoAccountWalletWithUserKeychain>\n   */\n  private async generateGoAccountWallet(\n    params: GenerateGoAccountWalletOptions\n  ): Promise<GoAccountWalletWithUserKeychain> {\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    const { label, passphrase, enterprise, passcodeEncryptionCode, encryptionVersion } = params;\n\n    const keychain = this.baseCoin.keychains().create();\n\n    const keychainParams: AddKeychainOptions = {\n      pub: keychain.pub,\n      encryptedPrv: await this.bitgo.encryptAsync({\n        password: passphrase,\n        input: keychain.prv,\n        encryptionVersion,\n      }),\n      originalPasscodeEncryptionCode: passcodeEncryptionCode,\n      keyType: 'independent',\n      source: 'user',\n    };\n\n    const userKeychain = await this.baseCoin.keychains().add(keychainParams);\n\n    const walletParams: SupplementGenerateWalletOptions = {\n      label,\n      m: 1,\n      n: 1,\n      type: 'trading',\n      enterprise,\n      keys: [userKeychain.id],\n    };\n\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(walletParams).result();\n    const wallet = new Wallet(this.bitgo, this.baseCoin, newWallet);\n\n    const result: GoAccountWalletWithUserKeychain = {\n      wallet,\n      userKeychain,\n      responseType: 'GoAccountWalletWithUserKeychain',\n    };\n\n    // Add warning if the user keychain has an encrypted private key\n    if (!_.isUndefined(userKeychain.encryptedPrv)) {\n      result.warning = 'Be sure to backup the user keychain -- it is not stored anywhere else!';\n    }\n\n    return result;\n  }\n\n  /**\n   * Generate a new wallet\n   * 1. Creates the user keychain locally on the client, and encrypts it with the provided passphrase\n   * 2. If no pub was provided, creates the backup keychain locally on the client, and encrypts it with the provided passphrase\n   * 3. Uploads the encrypted user and backup keychains to BitGo\n   * 4. Creates the BitGo key on the service\n   * 5. Creates the wallet on BitGo with the 3 public keys above\n   * @param params\n   * @param params.label Label for the wallet\n   * @param params.passphrase Passphrase to be used to encrypt the user and backup keychains\n   * @param params.userKey User xpub\n   * @param params.backupXpub Backup xpub\n   * @param params.backupXpubProvider\n   * @param params.enterprise the enterpriseId\n   * @param params.disableTransactionNotifications\n   * @param params.passcodeEncryptionCode optional this is a recovery code that can be used to decrypt the original passphrase in a recovery case.\n   *                                      The user must generate and keep the encrypted original passphrase safe while this code is stored on BitGo\n   * @param params.coldDerivationSeed optional seed for SMC wallets\n   * @param params.gasPrice\n   * @param params.disableKRSEmail\n   * @param params.walletVersion\n   * @param params.multisigType optional multisig type, 'onchain' or 'tss' or 'blsdkg'; if absent, we will defer to the coin's default type\n   * @param params.isDistributedCustody optional parameter for creating bitgo key. This is only necessary if you want to create\n   *                                    a distributed custody wallet. If provided, you must have the enterprise license and pass in\n   *                                    `params.enterprise` into `generateWallet` as well.\n   * @param params.type optional wallet type, 'hot' or 'cold' or 'custodial'; if absent, we will defer to 'hot'\n   * @param params.bitgoKeyId optional bitgo key id for SMC TSS wallets\n   * @param params.commonKeychain optional common keychain for SMC TSS wallets\n   *\n   * @returns {*}\n   */\n  async generateWallet(\n    params: GenerateWalletOptions = {}\n  ): Promise<WalletWithKeychains | LightningWalletWithKeychains | GoAccountWalletWithUserKeychain> {\n    // Assign the default multiSig type value based on the coin\n    if (!params.multisigType) {\n      params.multisigType = this.baseCoin.getDefaultMultisigType();\n    }\n\n    if (this.baseCoin.getFamily() === 'lnbtc') {\n      const options = decodeOrElse(\n        GenerateLightningWalletOptionsCodec.name,\n        GenerateLightningWalletOptionsCodec,\n        params,\n        (errors) => {\n          throw new Error(`error(s) parsing generate lightning wallet request params: ${errors}`);\n        }\n      );\n\n      const walletData = await this.generateLightningWallet(options);\n      walletData.encryptedWalletPassphrase = await this.bitgo.encryptAsync({\n        input: options.passphrase,\n        password: options.passcodeEncryptionCode,\n        encryptionVersion: options.encryptionVersion,\n      });\n      return walletData;\n    }\n\n    // Go Account wallet generation\n    if (this.baseCoin.getFamily() === 'ofc' && params.type === 'trading') {\n      const options = decodeOrElse(\n        GenerateGoAccountWalletOptionsCodec.name,\n        GenerateGoAccountWalletOptionsCodec,\n        params,\n        (errors) => {\n          throw new Error(`error(s) parsing generate go account request params: ${errors}`);\n        }\n      );\n\n      const walletData = await this.generateGoAccountWallet(options);\n      walletData.encryptedWalletPassphrase = await this.bitgo.encryptAsync({\n        input: options.passphrase,\n        password: options.passcodeEncryptionCode,\n        encryptionVersion: options.encryptionVersion,\n      });\n      return walletData;\n    }\n\n    common.validateParams(params, ['label'], ['passphrase', 'userKey', 'backupXpub']);\n    if (typeof params.label !== 'string') {\n      throw new Error('missing required string parameter label');\n    }\n\n    if (params.createKeychainCallback) {\n      return this.generateWalletWithExternalSigner(params as GenerateWalletWithExternalSignerOptions);\n    }\n\n    const { type = 'hot', label, passphrase, enterprise, isDistributedCustody, evmKeyRingReferenceWalletId } = params;\n    const isTss = params.multisigType === 'tss' && this.baseCoin.supportsTss();\n    const canEncrypt = !!passphrase && typeof passphrase === 'string';\n\n    if (validateEvmKeyRingWalletParams(params, this.baseCoin)) {\n      return await createEvmKeyRingWallet({\n        label,\n        evmKeyRingReferenceWalletId: evmKeyRingReferenceWalletId!,\n        bitgo: this.bitgo,\n        baseCoin: this.baseCoin,\n      });\n    }\n\n    const walletParams: SupplementGenerateWalletOptions = {\n      label: label,\n      m: 2,\n      n: 3,\n      keys: [],\n      type: !!params.userKey && params.multisigType !== 'onchain' ? 'cold' : type,\n    };\n\n    if (!_.isUndefined(params.passcodeEncryptionCode)) {\n      if (!_.isString(params.passcodeEncryptionCode)) {\n        throw new Error('passcodeEncryptionCode must be a string');\n      }\n    }\n\n    if (!_.isUndefined(enterprise)) {\n      if (!_.isString(enterprise)) {\n        throw new Error('invalid enterprise argument, expecting string');\n      }\n      walletParams.enterprise = enterprise;\n    }\n\n    // EVM TSS wallets must use wallet version 3, 5 and 6\n    if (\n      isTss &&\n      this.baseCoin.isEVM() &&\n      !evmKeyRingReferenceWalletId &&\n      !(params.walletVersion === 3 || params.walletVersion === 5 || params.walletVersion === 6)\n    ) {\n      throw new Error('EVM TSS wallets are only supported for wallet version 3, 5 and 6');\n    }\n\n    if (isTss) {\n      if (!this.baseCoin.supportsTss()) {\n        throw new Error(`coin ${this.baseCoin.getFamily()} does not support TSS at this time`);\n      }\n      if (\n        (params.walletVersion === 5 || params.walletVersion === 6) &&\n        !this.baseCoin.getConfig().features.includes(CoinFeature.MPCV2)\n      ) {\n        throw new Error(`coin ${this.baseCoin.getFamily()} does not support TSS MPCv2 at this time`);\n      }\n      assert(enterprise, 'enterprise is required for TSS wallet');\n\n      if (type === 'cold') {\n        // validate\n        assert(params.bitgoKeyId, 'bitgoKeyId is required for SMC TSS wallet');\n        assert(params.commonKeychain, 'commonKeychain is required for SMC TSS wallet');\n        return this.generateSMCMpcWallet({\n          multisigType: 'tss',\n          label,\n          enterprise,\n          walletVersion: params.walletVersion,\n          bitgoKeyId: params.bitgoKeyId,\n          commonKeychain: params.commonKeychain,\n          coldDerivationSeed: params.coldDerivationSeed,\n        });\n      }\n\n      if (type === 'custodial') {\n        return this.generateCustodialMpcWallet({\n          multisigType: 'tss',\n          label,\n          enterprise,\n          walletVersion: params.walletVersion,\n        });\n      }\n\n      assert(passphrase, 'cannot generate TSS keys without passphrase');\n      const walletData = await this.generateMpcWallet({\n        multisigType: 'tss',\n        label,\n        passphrase,\n        originalPasscodeEncryptionCode: params.passcodeEncryptionCode,\n        enterprise,\n        walletVersion: params.walletVersion,\n        webauthnInfo: params.webauthnInfo,\n        encryptionVersion: params.encryptionVersion,\n      });\n      if (params.passcodeEncryptionCode) {\n        walletData.encryptedWalletPassphrase = await this.bitgo.encryptAsync({\n          input: passphrase,\n          password: params.passcodeEncryptionCode,\n          encryptionVersion: params.encryptionVersion,\n        });\n      }\n      return walletData;\n    }\n\n    // Handle distributed custody\n    if (isDistributedCustody) {\n      if (!enterprise) {\n        throw new Error('must provide enterprise when creating distributed custody wallet');\n      }\n      if (!type || type !== 'cold') {\n        throw new Error('distributed custody wallets must be type: cold');\n      }\n    }\n\n    const hasBackupXpub = !!params.backupXpub;\n    const hasBackupXpubProvider = !!params.backupXpubProvider;\n    if (hasBackupXpub && hasBackupXpubProvider) {\n      throw new Error('Cannot provide more than one backupXpub or backupXpubProvider flag');\n    }\n\n    if (params.gasPrice && params.eip1559) {\n      throw new Error('can not use both eip1559 and gasPrice values');\n    }\n\n    if (!_.isUndefined(params.disableTransactionNotifications)) {\n      if (!_.isBoolean(params.disableTransactionNotifications)) {\n        throw new Error('invalid disableTransactionNotifications argument, expecting boolean');\n      }\n      walletParams.disableTransactionNotifications = params.disableTransactionNotifications;\n    }\n\n    if (!_.isUndefined(params.gasPrice)) {\n      const gasPriceBN = new BigNumber(params.gasPrice);\n      if (gasPriceBN.isNaN()) {\n        throw new Error('invalid gas price argument, expecting number or number as string');\n      }\n      walletParams.gasPrice = gasPriceBN.toString();\n    }\n\n    if (!_.isUndefined(params.eip1559) && !_.isEmpty(params.eip1559)) {\n      const maxFeePerGasBN = new BigNumber(params.eip1559.maxFeePerGas);\n      if (maxFeePerGasBN.isNaN()) {\n        throw new Error('invalid max fee argument, expecting number or number as string');\n      }\n      const maxPriorityFeePerGasBN = new BigNumber(params.eip1559.maxPriorityFeePerGas);\n      if (maxPriorityFeePerGasBN.isNaN()) {\n        throw new Error('invalid priority fee argument, expecting number or number as string');\n      }\n      walletParams.eip1559 = {\n        maxFeePerGas: maxFeePerGasBN.toString(),\n        maxPriorityFeePerGas: maxPriorityFeePerGasBN.toString(),\n      };\n    }\n\n    if (!_.isUndefined(params.disableKRSEmail)) {\n      if (!_.isBoolean(params.disableKRSEmail)) {\n        throw new Error('invalid disableKRSEmail argument, expecting boolean');\n      }\n      walletParams.disableKRSEmail = params.disableKRSEmail;\n    }\n\n    if (!_.isUndefined(params.walletVersion)) {\n      if (!_.isNumber(params.walletVersion)) {\n        throw new Error('invalid walletVersion provided, expecting number');\n      }\n      walletParams.walletVersion = params.walletVersion;\n    }\n\n    // Ensure each krsSpecific param is either a string, boolean, or number\n    const { krsSpecific } = params;\n    if (!_.isUndefined(krsSpecific)) {\n      Object.keys(krsSpecific).forEach((key) => {\n        const val = krsSpecific[key];\n        if (!_.isBoolean(val) && !_.isString(val) && !_.isNumber(val)) {\n          throw new Error('krsSpecific object contains illegal values. values must be strings, booleans, or numbers');\n        }\n      });\n    }\n\n    let derivationPath: string | undefined = undefined;\n\n    const reqId = new RequestTracer();\n\n    if (params.type === 'custodial' && (params.multisigType ?? 'onchain') === 'onchain') {\n      // for custodial multisig, when the wallet is created on the platfor side, the keys are not needed\n      walletParams.n = undefined;\n      walletParams.m = undefined;\n      walletParams.keys = undefined;\n      walletParams.keySignatures = undefined;\n\n      const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(walletParams).result(); // returns the ids\n\n      const userKeychain = this.baseCoin.keychains().get({ id: newWallet.keys[KeyIndices.USER], reqId });\n      const backupKeychain = this.baseCoin.keychains().get({ id: newWallet.keys[KeyIndices.BACKUP], reqId });\n      const bitgoKeychain = this.baseCoin.keychains().get({ id: newWallet.keys[KeyIndices.BITGO], reqId });\n\n      const [userKey, bitgoKey, backupKey] = await Promise.all([userKeychain, bitgoKeychain, backupKeychain]);\n\n      const result: WalletWithKeychains = {\n        wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n        userKeychain: userKey,\n        backupKeychain: bitgoKey,\n        bitgoKeychain: backupKey,\n        responseType: 'WalletWithKeychains',\n      };\n\n      return result;\n    } else {\n      const userKeychainPromise = async (): Promise<Keychain> => {\n        let userKeychainParams;\n        let userKeychain;\n        // User provided user key\n        if (params.userKey) {\n          userKeychain = { pub: params.userKey };\n          userKeychainParams = userKeychain;\n          if (params.coldDerivationSeed) {\n            // the derivation only makes sense when a key already exists\n            const derivation = this.baseCoin.deriveKeyWithSeed({\n              key: params.userKey,\n              seed: params.coldDerivationSeed,\n            });\n            derivationPath = derivation.derivationPath;\n            userKeychain.pub = derivation.key;\n            userKeychain.derivedFromParentWithSeed = params.coldDerivationSeed;\n          }\n        } else {\n          if (!canEncrypt) {\n            throw new Error('cannot generate user keypair without passphrase');\n          }\n          // Create the user key.\n          userKeychain = this.baseCoin.keychains().create();\n          userKeychain.encryptedPrv = await this.bitgo.encryptAsync({\n            password: passphrase,\n            input: userKeychain.prv,\n            encryptionVersion: params.encryptionVersion,\n          });\n          userKeychainParams = {\n            pub: userKeychain.pub,\n            encryptedPrv: userKeychain.encryptedPrv,\n            originalPasscodeEncryptionCode: params.passcodeEncryptionCode,\n          };\n\n          // If WebAuthn info is provided, store an additional copy of the private key encrypted\n          // with the PRF-derived passphrase so the authenticator can later decrypt it.\n          // Send it as `webauthnInfo` (single object, with enterpriseId) so the atomic\n          // POST /key persists the passkey — the backend ignores the deprecated `webauthnDevices`.\n          if (params.webauthnInfo && userKeychain.prv) {\n            userKeychainParams.webauthnInfo = {\n              otpDeviceId: params.webauthnInfo.otpDeviceId,\n              prfSalt: params.webauthnInfo.prfSalt,\n              enterpriseId: params.enterprise,\n              encryptedPrv: await this.bitgo.encryptAsync({\n                password: params.webauthnInfo.passphrase,\n                input: userKeychain.prv,\n                encryptionVersion: params.encryptionVersion,\n              }),\n            };\n          }\n        }\n\n        userKeychainParams.reqId = reqId;\n        const newUserKeychain = await this.baseCoin.keychains().add(userKeychainParams);\n        return _.extend({}, newUserKeychain, userKeychain);\n      };\n\n      const backupKeychainPromise = async (): Promise<Keychain> => {\n        if (params.backupXpubProvider) {\n          // If requested, use a KRS or backup key provider\n          return this.baseCoin.keychains().createBackup({\n            provider: params.backupXpubProvider || 'defaultRMGBackupProvider',\n            disableKRSEmail: params.disableKRSEmail,\n            krsSpecific: params.krsSpecific,\n            type: this.baseCoin.getChain(),\n            passphrase: params.passphrase,\n            encryptionVersion: params.encryptionVersion,\n            reqId,\n          });\n        }\n\n        // User provided backup xpub\n        if (params.backupXpub) {\n          // user provided backup ethereum address\n          return this.baseCoin.keychains().add({\n            pub: params.backupXpub,\n            source: 'backup',\n            reqId,\n          });\n        } else {\n          if (!canEncrypt) {\n            throw new Error('cannot generate backup keypair without passphrase');\n          }\n          // No provided backup xpub or address, so default to creating one here\n          return this.baseCoin.keychains().createBackup({\n            reqId,\n            passphrase: params.passphrase,\n            encryptionVersion: params.encryptionVersion,\n          });\n        }\n      };\n      const { userKeychain, backupKeychain, bitgoKeychain }: KeychainsTriplet = await promiseProps({\n        userKeychain: userKeychainPromise(),\n        backupKeychain: backupKeychainPromise(),\n        bitgoKeychain: this.baseCoin\n          .keychains()\n          .createBitGo({ enterprise: params.enterprise, reqId, isDistributedCustody: params.isDistributedCustody }),\n      });\n\n      walletParams.keys = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];\n\n      const { prv } = userKeychain;\n      if (_.isString(prv)) {\n        assert(backupKeychain.pub);\n        assert(bitgoKeychain.pub);\n        walletParams.keySignatures = {\n          backup: (await this.baseCoin.signMessage({ prv }, backupKeychain.pub)).toString('hex'),\n          bitgo: (await this.baseCoin.signMessage({ prv }, bitgoKeychain.pub)).toString('hex'),\n        };\n      }\n\n      const keychains = {\n        userKeychain,\n        backupKeychain,\n        bitgoKeychain,\n      };\n\n      const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);\n\n      if (_.includes(['xrp', 'xlm', 'cspr'], this.baseCoin.getFamily()) && !_.isUndefined(params.rootPrivateKey)) {\n        walletParams.rootPrivateKey = params.rootPrivateKey;\n      }\n\n      this.bitgo.setRequestTracer(reqId);\n      const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();\n\n      const result: WalletWithKeychains = {\n        wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n        userKeychain: userKeychain,\n        backupKeychain: backupKeychain,\n        bitgoKeychain: bitgoKeychain,\n        responseType: 'WalletWithKeychains',\n      };\n\n      if (!_.isUndefined(backupKeychain.prv)) {\n        result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';\n      }\n\n      if (!_.isUndefined(derivationPath)) {\n        userKeychain.derivationPath = derivationPath;\n      }\n\n      if (canEncrypt && params.passcodeEncryptionCode) {\n        result.encryptedWalletPassphrase = await this.bitgo.encryptAsync({\n          input: passphrase,\n          password: params.passcodeEncryptionCode,\n          encryptionVersion: params.encryptionVersion,\n        });\n      }\n\n      return result;\n    }\n  }\n\n  /**\n   * Generate an onchain multisig wallet using an external signer for user and backup key creation.\n   * 1. Calls createKeychainCallback for user and backup keys\n   * 2. Uploads keychains via keychains().add()\n   * 3. Creates the BitGo key on the service\n   * 4. Creates the wallet on BitGo with the 3 public keys\n   * @param params\n   */\n  async generateWalletWithExternalSigner(\n    params: GenerateWalletWithExternalSignerOptions\n  ): Promise<WalletWithKeychains> {\n    if (!_.isFunction(params.createKeychainCallback)) {\n      throw new Error('missing required function parameter createKeychainCallback');\n    }\n\n    const multisigType = params.multisigType ?? this.baseCoin.getDefaultMultisigType();\n    if (multisigType !== 'onchain') {\n      throw new Error('external signer wallet generation is only supported for onchain multisig wallets');\n    }\n\n    // these belong to the passphrase-based path and are incompatible with createKeychainCallback\n    const passphrasePathParams = ['passphrase', 'userKey', 'backupXpub', 'backupXpubProvider'] as const;\n    for (const key of passphrasePathParams) {\n      if (!_.isUndefined(params[key])) {\n        throw new Error(`createKeychainCallback cannot be used with ${key}`);\n      }\n    }\n\n    const { label, createKeychainCallback, type = 'hot', enterprise, isDistributedCustody } = params;\n\n    if (type === 'custodial') {\n      throw new Error('external signer wallet generation is not supported for custodial onchain wallets');\n    }\n\n    if (!_.isUndefined(params.webauthnInfo)) {\n      throw new Error('webauthnInfo is not supported for external signer wallet generation');\n    }\n\n    if (!_.isUndefined(params.passcodeEncryptionCode)) {\n      throw new Error('passcodeEncryptionCode is not supported for external signer wallet generation');\n    }\n\n    if (isDistributedCustody) {\n      if (!enterprise) {\n        throw new Error('must provide enterprise when creating distributed custody wallet');\n      }\n      if (type !== 'cold') {\n        throw new Error('distributed custody wallets must be type: cold');\n      }\n    }\n\n    if (params.gasPrice && params.eip1559) {\n      throw new Error('can not use both eip1559 and gasPrice values');\n    }\n\n    const walletParams: SupplementGenerateWalletOptions = {\n      label,\n      m: 2,\n      n: 3,\n      keys: [],\n      type,\n    };\n\n    if (!_.isUndefined(enterprise)) {\n      if (!_.isString(enterprise)) {\n        throw new Error('invalid enterprise argument, expecting string');\n      }\n      walletParams.enterprise = enterprise;\n    }\n\n    if (!_.isUndefined(params.disableTransactionNotifications)) {\n      if (!_.isBoolean(params.disableTransactionNotifications)) {\n        throw new Error('invalid disableTransactionNotifications argument, expecting boolean');\n      }\n      walletParams.disableTransactionNotifications = params.disableTransactionNotifications;\n    }\n\n    if (!_.isUndefined(params.gasPrice)) {\n      const gasPriceBN = new BigNumber(params.gasPrice);\n      if (gasPriceBN.isNaN()) {\n        throw new Error('invalid gas price argument, expecting number or number as string');\n      }\n      walletParams.gasPrice = gasPriceBN.toString();\n    }\n\n    if (!_.isUndefined(params.eip1559) && !_.isEmpty(params.eip1559)) {\n      const maxFeePerGasBN = new BigNumber(params.eip1559.maxFeePerGas);\n      if (maxFeePerGasBN.isNaN()) {\n        throw new Error('invalid max fee argument, expecting number or number as string');\n      }\n      const maxPriorityFeePerGasBN = new BigNumber(params.eip1559.maxPriorityFeePerGas);\n      if (maxPriorityFeePerGasBN.isNaN()) {\n        throw new Error('invalid priority fee argument, expecting number or number as string');\n      }\n      walletParams.eip1559 = {\n        maxFeePerGas: maxFeePerGasBN.toString(),\n        maxPriorityFeePerGas: maxPriorityFeePerGasBN.toString(),\n      };\n    }\n\n    if (!_.isUndefined(params.walletVersion)) {\n      if (!_.isNumber(params.walletVersion)) {\n        throw new Error('invalid walletVersion provided, expecting number');\n      }\n      walletParams.walletVersion = params.walletVersion;\n    }\n\n    const reqId = new RequestTracer();\n    const coin = this.baseCoin.getChain();\n\n    const createAndUploadKeychain = async (source: 'user' | 'backup'): Promise<Keychain> => {\n      try {\n        const keychainFromCallback = await createKeychainCallback({ source, coin });\n        if (keychainFromCallback.source !== source) {\n          throw new Error(`createKeychainCallback returned source ${keychainFromCallback.source}, expected ${source}`);\n        }\n        if (keychainFromCallback.type !== 'independent') {\n          throw new Error(\n            `createKeychainCallback returned invalid type ${keychainFromCallback.type}, expected 'independent' for onchain multisig`\n          );\n        }\n        if (!this.baseCoin.isValidPub(keychainFromCallback.pub)) {\n          throw new Error(`createKeychainCallback returned invalid pub for ${source} key on ${coin}`);\n        }\n        return this.baseCoin.keychains().add({\n          pub: keychainFromCallback.pub,\n          keyType: keychainFromCallback.type,\n          source: keychainFromCallback.source,\n          reqId,\n        });\n      } catch (error) {\n        throw new Error(\n          `Failed to create ${source} keychain: ${error instanceof Error ? error.message : String(error)}`\n        );\n      }\n    };\n\n    const { userKeychain, backupKeychain, bitgoKeychain }: KeychainsTriplet = await promiseProps({\n      userKeychain: createAndUploadKeychain('user'),\n      backupKeychain: createAndUploadKeychain('backup'),\n      bitgoKeychain: this.baseCoin\n        .keychains()\n        .createBitGo({ enterprise, reqId, isDistributedCustody: params.isDistributedCustody }),\n    });\n\n    walletParams.keys = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];\n\n    if (params.keySignatures) {\n      walletParams.keySignatures = params.keySignatures;\n    }\n\n    const keychains = {\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n    };\n\n    if (_.includes(['xrp', 'xlm', 'cspr'], this.baseCoin.getFamily()) && !_.isUndefined(params.rootPrivateKey)) {\n      walletParams.rootPrivateKey = params.rootPrivateKey;\n    }\n\n    const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);\n\n    this.bitgo.setRequestTracer(reqId);\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();\n\n    return {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n      responseType: 'WalletWithKeychains',\n    };\n  }\n\n  /**\n   * List the user's wallet shares\n   * @param params\n   */\n  async listShares(params: Record<string, unknown> = {}): Promise<any> {\n    return await this.bitgo.get(this.baseCoin.url('/walletshare')).result();\n  }\n\n  /**\n   * List the user's wallet shares v2\n   * @returns {Promise<WalletShares>}\n   */\n  async listSharesV2(): Promise<WalletShares> {\n    return await this.bitgo.get(this.bitgo.url('/walletshares', 2)).result();\n  }\n\n  /**\n   * Gets a wallet share information, including the encrypted sharing keychain. requires unlock if keychain is present.\n   * @param params\n   * @param params.walletShareId - the wallet share to get information on\n   */\n  async getShare(params: { walletShareId?: string } = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    return await this.bitgo.get(this.baseCoin.url('/walletshare/' + params.walletShareId)).result();\n  }\n\n  /**\n   * Update a wallet share\n   * @param params.walletShareId - the wallet share to update\n   * @param params.state - the new state of the wallet share\n   * @param params\n   */\n  async updateShare(params: UpdateShareOptions = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    return await this.bitgo\n      .post(this.baseCoin.url('/walletshare/' + params.walletShareId))\n      .send(params)\n      .result();\n  }\n\n  /**\n   * Bulk accept wallet shares\n   * @param params AcceptShareOptionsRequest[]\n   * @returns {Promise<BulkAcceptShareResponse>}\n   */\n  async bulkAcceptShareRequest(params: AcceptShareOptionsRequest[]): Promise<BulkAcceptShareResponse> {\n    return await this.bulkAcceptShareRequestWithRetry(params);\n  }\n\n  private async bulkAcceptShareRequestWithRetry(params: AcceptShareOptionsRequest[]): Promise<BulkAcceptShareResponse> {\n    // Server has a limit of approximately 1MB for payload size\n    let MAX_PAYLOAD_SIZE = 950000; // ~950KB to leave some buffer\n\n    // Function to calculate the size of a payload\n    const calculatePayloadSize = (items: AcceptShareOptionsRequest[]): number => {\n      return Buffer.byteLength(JSON.stringify({ keysForWalletShares: items }), 'utf8');\n    };\n\n    const results: any[] = [];\n    const remainingParams = [...params];\n\n    while (remainingParams.length > 0) {\n      // Build optimal batch by adding items until we reach size limit\n      const batch: AcceptShareOptionsRequest[] = [];\n      // Start with empty batch\n\n      // Add items one by one while monitoring payload size\n      while (remainingParams.length > 0) {\n        // Test adding the next item\n        const testBatch = [...batch, remainingParams[0]];\n        const testSize = calculatePayloadSize(testBatch);\n\n        // If adding this item would exceed the size limit, stop adding\n        if (testSize > MAX_PAYLOAD_SIZE && batch.length > 0) {\n          break;\n        }\n\n        // Otherwise, add the item to the batch\n        batch.push(remainingParams.shift()!);\n      }\n\n      // Handle case where even a single item is too large\n      if (batch.length === 0 && remainingParams.length > 0) {\n        // Send just the first item even if it's oversized\n        batch.push(remainingParams.shift()!);\n      }\n\n      const payloadObj = { keysForWalletShares: batch };\n\n      try {\n        const result = await this.bitgo.put(this.bitgo.url('/walletshares/accept', 2)).send(payloadObj).result();\n\n        if (result.acceptedWalletShares && Array.isArray(result.acceptedWalletShares)) {\n          results.push(...result.acceptedWalletShares);\n        }\n      } catch (error: any) {\n        if (error.status === 413 && batch.length > 1) {\n          // If we still get 413 with multiple items, put them back and try with half the batch size\n          remainingParams.unshift(...batch);\n          MAX_PAYLOAD_SIZE = Math.floor(MAX_PAYLOAD_SIZE / 2); // Reduce size limit for next attempt\n          continue;\n        }\n        throw error;\n      }\n    }\n\n    return {\n      acceptedWalletShares: results,\n    };\n  }\n\n  async bulkUpdateWalletShareRequest(\n    params: BulkUpdateWalletShareOptionsRequest[]\n  ): Promise<BulkUpdateWalletShareResponse> {\n    return await this.bitgo\n      .put(this.bitgo.url('/walletshares/update', 2))\n      .send({\n        shares: params,\n      })\n      .result();\n  }\n\n  /**\n   * Resend a wallet share invitation email\n   * @param params\n   * @param params.walletShareId - the wallet share whose invitiation should be resent\n   */\n  async resendShareInvite(params: { walletShareId?: string } = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    const urlParts = params.walletShareId + '/resendemail';\n    return this.bitgo.post(this.baseCoin.url('/walletshare/' + urlParts)).result();\n  }\n\n  /**\n   * Cancel a wallet share\n   * @param params\n   * @param params.walletShareId - the wallet share to update\n   */\n  async cancelShare(params: { walletShareId?: string } = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], []);\n\n    return await this.bitgo\n      .del(this.baseCoin.url('/walletshare/' + params.walletShareId))\n      .send()\n      .result();\n  }\n\n  /**\n   * Re-share wallet with existing spenders of the wallet\n   * @param walletId\n   * @param userPassword\n   */\n  async reshareWalletWithSpenders(\n    walletId: string,\n    userPassword: string,\n    encryptionVersion?: EncryptionVersion\n  ): Promise<void> {\n    const wallet = await this.get({ id: walletId });\n    if (!wallet?._wallet?.enterprise) {\n      throw new Error('Enterprise not found for the wallet');\n    }\n\n    const enterpriseUsersResponse = await this.bitgo\n      .get(this.bitgo.url(`/enterprise/${wallet?._wallet?.enterprise}/user`))\n      .result();\n    // create a map of users for easy lookup - we need the user email id to share the wallet\n    const usersMap = new Map(\n      [...enterpriseUsersResponse?.adminUsers, ...enterpriseUsersResponse?.nonAdminUsers].map((obj) => [obj.id, obj])\n    );\n\n    if (wallet._wallet.users) {\n      for (const user of wallet._wallet.users) {\n        const userObject = usersMap.get(user.user);\n        if (user.permissions.includes('spend') && !user.permissions.includes('admin') && userObject) {\n          const shareParams = {\n            walletId: walletId,\n            user: user.user,\n            permissions: user.permissions.join(','),\n            walletPassphrase: userPassword,\n            email: userObject.email.email,\n            reshare: true,\n            skipKeychain: false,\n            encryptionVersion,\n          };\n          await wallet.shareWallet(shareParams);\n        }\n      }\n    }\n  }\n\n  /**\n   * Accepts a wallet share, adding the wallet to the user's list\n   * Needs a user's password to decrypt the shared key\n   *\n   * @param params\n   * @param params.walletShareId - the wallet share to accept\n   * @param params.userPassword - (required if more a keychain was shared) user's password to decrypt the shared wallet\n   * @param params.newWalletPassphrase - new wallet passphrase for saving the shared wallet prv.\n   *                                     If left blank and a wallet with more than view permissions was shared,\n   *                                     then the user's login password is used.\n   * @param params.overrideEncryptedPrv - set only if the prv was received out-of-band.\n   */\n  async acceptShare(params: AcceptShareOptions = {}): Promise<any> {\n    common.validateParams(params, ['walletShareId'], ['overrideEncryptedPrv', 'userPassword', 'newWalletPassphrase']);\n\n    let encryptedPrv = params.overrideEncryptedPrv;\n    const walletShare = await this.getShare({ walletShareId: params.walletShareId });\n\n    // Multi-user-key case: requires user to provide their own public key in addition to the encrypted private key\n    if (walletShare.userMultiKeyRotationRequired) {\n      if (_.isUndefined(params.userPassword)) {\n        throw new Error('userPassword param must be provided to generate user keychain');\n      }\n\n      const walletKeychain = this.baseCoin.keychains().create();\n      const encryptedPrv = await this.bitgo.encryptAsync({\n        password: params.newWalletPassphrase || params.userPassword,\n        input: walletKeychain.prv,\n        encryptionVersion: params.encryptionVersion,\n      });\n\n      const updateParams: UpdateShareOptions = {\n        walletShareId: params.walletShareId,\n        state: 'accepted',\n        encryptedPrv: encryptedPrv,\n        pub: walletKeychain.pub,\n      };\n\n      // Note: Unlike keychainOverrideRequired, we do NOT reshare the wallet with spenders\n      // This is a key difference - multi-key-user-key wallets don't require reshare\n      return this.updateShare(updateParams);\n    }\n\n    // Keychain override case: requires user keychain creation and signing\n    if (\n      walletShare.keychainOverrideRequired &&\n      walletShare.permissions.indexOf('admin') !== -1 &&\n      walletShare.permissions.indexOf('spend') !== -1\n    ) {\n      if (_.isUndefined(params.userPassword)) {\n        throw new Error('userPassword param must be provided to decrypt shared key');\n      }\n\n      const walletKeychain = await this.baseCoin\n        .keychains()\n        .createUserKeychain(params.userPassword, params.encryptionVersion);\n      if (_.isUndefined(walletKeychain.encryptedPrv)) {\n        throw new Error('encryptedPrv was not found on wallet keychain');\n      }\n\n      const payload = {\n        tradingAccountId: walletShare.wallet,\n        pubkey: walletKeychain.pub,\n        timestamp: new Date().toISOString(),\n      };\n      const payloadString = JSON.stringify(payload);\n\n      const privateKey = await this.bitgo.decryptAsync({\n        password: params.userPassword,\n        input: walletKeychain.encryptedPrv,\n      });\n      const signature = await this.baseCoin.signMessage({ prv: privateKey }, payloadString);\n\n      const response = await this.updateShare({\n        walletShareId: params.walletShareId,\n        state: 'accepted',\n        keyId: walletKeychain.id,\n        signature: signature.toString('hex'),\n        payload: payloadString,\n      });\n      // If the wallet share was accepted successfully (changed=true), reshare the wallet with the spenders\n      if (response.changed && response.state === 'accepted') {\n        try {\n          await this.reshareWalletWithSpenders(walletShare.wallet, params.userPassword, params.encryptionVersion);\n        } catch (e) {\n          // TODO: PX-3826\n          // Do nothing\n        }\n      }\n      return response;\n    }\n\n    // Return right away if there is no keychain to decrypt, or if explicit encryptedPrv was provided\n    if (!walletShare.keychain || !walletShare.keychain.encryptedPrv || encryptedPrv) {\n      return this.updateShare({\n        walletShareId: params.walletShareId,\n        state: 'accepted',\n      });\n    }\n\n    // More than viewing was requested, so we need to process the wallet keys using the shared ecdh scheme\n    if (_.isUndefined(params.userPassword)) {\n      throw new Error('userPassword param must be provided to decrypt shared key');\n    }\n\n    const sharingKeychain = (await this.bitgo.getECDHKeychain()) as any;\n    if (_.isUndefined(sharingKeychain.encryptedXprv)) {\n      throw new Error('encryptedXprv was not found on sharing keychain');\n    }\n\n    // Now we have the sharing keychain, we can work out the secret used for sharing the wallet with us\n    sharingKeychain.prv = await this.bitgo.decryptAsync({\n      password: params.userPassword,\n      input: sharingKeychain.encryptedXprv,\n    });\n    const secret = getSharedSecret(\n      // Derive key by path (which is used between these 2 users only)\n      bip32.fromBase58(sharingKeychain.prv).derivePath(sanitizeLegacyPath(walletShare.keychain.path)),\n      Buffer.from(walletShare.keychain.fromPubKey, 'hex')\n    ).toString('hex');\n\n    // Yes! We got the secret successfully here, now decrypt the shared wallet prv\n    const decryptedSharedWalletPrv = await this.bitgo.decryptAsync({\n      password: secret,\n      input: walletShare.keychain.encryptedPrv,\n    });\n\n    // We will now re-encrypt the wallet with our own password\n    const newWalletPassphrase = params.newWalletPassphrase || params.userPassword;\n    encryptedPrv = await this.bitgo.encryptAsync({\n      password: newWalletPassphrase,\n      input: decryptedSharedWalletPrv,\n      encryptionVersion: params.encryptionVersion,\n    });\n    const updateParams: UpdateShareOptions = {\n      walletShareId: params.walletShareId,\n      state: 'accepted',\n    };\n\n    if (encryptedPrv) {\n      updateParams.encryptedPrv = encryptedPrv;\n    }\n    return this.updateShare(updateParams);\n  }\n\n  /**\n   * Bulk Accept wallet shares, adding the wallets to the user's list\n   * Needs a user's password to decrypt the shared key\n   *\n   * @param params BulkAcceptShareOptions\n   * @param params.walletShareId - array of the wallet shares to accept\n   * @param params.userPassword - user's password to decrypt the shared wallet key\n   * @param params.newWalletPassphrase - new wallet passphrase for saving the shared wallet prv.\n   *                                     If left blank then the user's login password is used.\n   *\n   *@returns {Promise<BulkAcceptShareResponse>}\n   */\n  async bulkAcceptShare(params: BulkAcceptShareOptions): Promise<BulkAcceptShareResponse> {\n    try {\n      common.validateParams(params, ['userLoginPassword'], ['newWalletPassphrase']);\n    } catch (e) {\n      if ('newWalletPassphrase' in params) {\n        throw new Error('Please provide a valid wallet passphrase');\n      }\n      throw new Error('Please provide a valid user login password');\n    }\n\n    assert(params.walletShareIds.length > 0, 'Please provide at least one wallet share to accept');\n\n    const allWalletShares = await this.listSharesV2();\n    const walletShareMap = allWalletShares.incoming.reduce(\n      (map: { [key: string]: WalletShare }, share) => ({ ...map, [share.id]: share }),\n      {}\n    );\n\n    const walletShares = params.walletShareIds\n      .map((walletShareId) => walletShareMap[walletShareId])\n      .filter((walletShare) => walletShare && (walletShare.keychain || walletShare.userMultiKeyRotationRequired));\n\n    if (!walletShares.length) {\n      throw new Error('No valid wallet shares found to accept');\n    }\n\n    const sharingKeychain = await this.bitgo.getECDHKeychain();\n    if (_.isUndefined(sharingKeychain.encryptedXprv)) {\n      throw new Error('encryptedXprv was not found on sharing keychain');\n    }\n\n    sharingKeychain.prv = await this.bitgo.decryptAsync({\n      password: params.userLoginPassword,\n      input: sharingKeychain.encryptedXprv,\n    });\n    const newWalletPassphrase = params.newWalletPassphrase || params.userLoginPassword;\n    const webauthnInfo = params.webauthnInfo;\n    const keysForWalletShares = (\n      await Promise.all(\n        walletShares.map(async (walletShare) => {\n          // Handle userMultiKeyRotationRequired case - these shares don't have keychains\n          if (walletShare.userMultiKeyRotationRequired) {\n            if (!params.userLoginPassword) {\n              throw new Error('userLoginPassword param must be provided to generate user keychain');\n            }\n            const walletKeychain = this.baseCoin.keychains().create();\n            const encryptedPrv = await this.bitgo.encryptAsync({\n              password: newWalletPassphrase,\n              input: walletKeychain.prv,\n              encryptionVersion: params.encryptionVersion,\n            });\n            return [\n              {\n                walletShareId: walletShare.id,\n                encryptedPrv: encryptedPrv,\n                pub: walletKeychain.pub,\n              },\n            ];\n          }\n\n          // Standard case: shares with keychains\n          if (!walletShare.keychain) {\n            return [];\n          }\n          const secret = getSharedSecret(\n            bip32.fromBase58(sharingKeychain.prv).derivePath(sanitizeLegacyPath(walletShare.keychain.path)),\n            Buffer.from(walletShare.keychain.fromPubKey, 'hex')\n          ).toString('hex');\n\n          const decryptedSharedWalletPrv = await this.bitgo.decryptAsync({\n            password: secret,\n            input: walletShare.keychain.encryptedPrv,\n          });\n          const newEncryptedPrv = await this.bitgo.encryptAsync({\n            password: newWalletPassphrase,\n            input: decryptedSharedWalletPrv,\n            encryptionVersion: params.encryptionVersion,\n          });\n          const entry: AcceptShareOptionsRequest = {\n            walletShareId: walletShare.id,\n            encryptedPrv: newEncryptedPrv,\n          };\n          if (webauthnInfo) {\n            entry.webauthnInfo = {\n              otpDeviceId: webauthnInfo.otpDeviceId,\n              prfSalt: webauthnInfo.prfSalt,\n              encryptedPrv: await this.bitgo.encryptAsync({\n                password: webauthnInfo.passphrase,\n                input: decryptedSharedWalletPrv,\n                encryptionVersion: params.encryptionVersion,\n              }),\n            };\n          }\n          return [entry];\n        })\n      )\n    ).flat();\n\n    return this.bulkAcceptShareRequest(keysForWalletShares);\n  }\n\n  /**\n   * Updates multiple wallet shares in bulk\n   * This method allows users to accept or reject multiple wallet shares in a single operation.\n   * It handles different types of wallet shares including those requiring special keychain overrides\n   * and those with encrypted private keys that need to be decrypted and re-encrypted.\n   * After processing, it also reshares accepted wallets with spenders for special override cases.\n   *\n   * @param params - Options for bulk updating wallet shares\n   * @param params.shares - Array of wallet shares to update with their status (accept/reject)\n   * @param params.userLoginPassword - User's login password for decryption operations\n   * @param params.newWalletPassphrase - New wallet passphrase for re-encryption\n   * @returns Array of responses for each wallet share update\n   */\n  async bulkUpdateWalletShare(params: BulkUpdateWalletShareOptions): Promise<BulkUpdateWalletShareResponse> {\n    if (!params.shares) {\n      throw new Error('Missing parameter: shares');\n    }\n\n    if (!Array.isArray(params.shares)) {\n      throw new Error('Expecting parameter array: shares but found ' + typeof params.shares);\n    }\n\n    // Validate each share in the array\n    for (const share of params.shares) {\n      if (!share.walletShareId) {\n        throw new Error('Missing walletShareId in share');\n      }\n\n      if (!share.status) {\n        throw new Error('Missing status in share');\n      }\n\n      if (share.status !== 'accept' && share.status !== 'reject') {\n        throw new Error('Invalid status in share: ' + share.status + '. Must be either \"accept\" or \"reject\"');\n      }\n\n      if (typeof share.walletShareId !== 'string') {\n        throw new Error('Expecting walletShareId to be a string but found ' + typeof share.walletShareId);\n      }\n    }\n\n    // Validate optional parameters if provided\n    if (params.userLoginPassword !== undefined && typeof params.userLoginPassword !== 'string') {\n      throw new Error('Expecting parameter string: userLoginPassword but found ' + typeof params.userLoginPassword);\n    }\n\n    if (params.newWalletPassphrase !== undefined && typeof params.newWalletPassphrase !== 'string') {\n      throw new Error('Expecting parameter string: newWalletPassphrase but found ' + typeof params.newWalletPassphrase);\n    }\n    assert(params.shares.length > 0, 'no shares are passed');\n\n    const { shares: inputShares, userLoginPassword, newWalletPassphrase, encryptionVersion } = params;\n\n    const allWalletShares = await this.listSharesV2();\n\n    // Only include shares that are in the input array for efficiency\n    const shareIds = new Set(inputShares.map((share) => share.walletShareId));\n    const walletShareMap = new Map();\n\n    allWalletShares.incoming\n      .filter((share) => shareIds.has(share.id))\n      .forEach((share) => walletShareMap.set(share.id, share));\n\n    allWalletShares.outgoing\n      .filter((share) => shareIds.has(share.id))\n      .forEach((share) => walletShareMap.set(share.id, share));\n\n    const resolvedShares = inputShares.map((share) => {\n      const walletShare = walletShareMap.get(share.walletShareId);\n      if (!walletShare) {\n        throw new Error(`invalid wallet share provided: ${share.walletShareId}`);\n      }\n      return { ...share, walletShare };\n    });\n\n    // Identify special override cases that need resharing after acceptance\n    const specialOverrideCases = new Map();\n    resolvedShares.forEach((share) => {\n      if (\n        share.status === 'accept' &&\n        share.walletShare.keychainOverrideRequired &&\n        share.walletShare.permissions.includes('admin') &&\n        share.walletShare.permissions.includes('spend')\n      ) {\n        specialOverrideCases.set(share.walletShareId, share.walletShare.wallet);\n      }\n    });\n\n    // Decrypt sharing keychain if needed (only once)\n    let sharingKeychainPrv: string | undefined;\n\n    // Only decrypt if there are shares to accept that might need it\n    const hasSharesRequiringDecryption =\n      specialOverrideCases.size > 0 ||\n      resolvedShares.some((share) => share.status === 'accept' && share.walletShare.keychain?.encryptedPrv);\n\n    if (userLoginPassword && hasSharesRequiringDecryption) {\n      const sharingKeychain = await this.bitgo.getECDHKeychain();\n      if (!sharingKeychain.encryptedXprv) {\n        throw new Error('encryptedXprv was not found on sharing keychain');\n      }\n      sharingKeychainPrv = await this.bitgo.decryptAsync({\n        password: userLoginPassword,\n        input: sharingKeychain.encryptedXprv,\n      });\n    }\n\n    const settledUpdates = await Promise.allSettled(\n      resolvedShares.map(async (share) => {\n        const { walletShareId, status, walletShare } = share;\n\n        // Handle accept case\n        if (status === 'accept') {\n          return this.processAcceptShare(\n            walletShareId,\n            walletShare,\n            userLoginPassword,\n            newWalletPassphrase,\n            sharingKeychainPrv,\n            encryptionVersion\n          );\n        }\n\n        // Handle reject case\n        return [\n          {\n            walletShareId,\n            status: 'reject' as const,\n          },\n        ];\n      })\n    );\n\n    // Extract successful updates\n    const successfulUpdates = settledUpdates.flatMap((result) => (result.status === 'fulfilled' ? result.value : []));\n\n    // Extract failed updates - only from rejected promises\n    const failedUpdates = settledUpdates.reduce<Array<{ walletShareId: string; reason: string }>>(\n      (acc, result, index) => {\n        if (result.status === 'rejected') {\n          const rejectedResult = result;\n          acc.push({\n            walletShareId: resolvedShares[index].walletShareId,\n            reason: rejectedResult.reason?.message || String(rejectedResult.reason),\n          });\n        }\n        return acc;\n      },\n      []\n    );\n\n    // Send successful updates to the server\n    const response = await this.bulkUpdateWalletShareRequest(successfulUpdates);\n\n    // Process accepted special override cases - reshare with spenders\n    if (response.acceptedWalletShares && response.acceptedWalletShares.length > 0 && userLoginPassword) {\n      // For each accepted wallet share that is a special override case, reshare with spenders\n      for (const walletShareId of response.acceptedWalletShares) {\n        if (specialOverrideCases.has(walletShareId)) {\n          const walletId = specialOverrideCases.get(walletShareId);\n          try {\n            await this.reshareWalletWithSpenders(walletId, userLoginPassword, encryptionVersion);\n          } catch (e) {\n            // Log error but continue processing other shares\n            console.error(`Error resharing wallet ${walletId} with spenders: ${e?.message}`);\n          }\n        }\n      }\n    }\n\n    // Add information about failed updates to the response\n    if (failedUpdates.length > 0) {\n      response.walletShareUpdateErrors.push(...failedUpdates);\n    }\n\n    return response;\n  }\n\n  /**\n   * Process a wallet share that is being accepted\n   * This method handles the different cases for accepting a wallet share:\n   * 1. Special override case requiring user keychain and signing\n   * 2. Simple case with no keychain to decrypt\n   * 3. Standard case requiring decryption and re-encryption\n   *\n   * @param walletShareId - ID of the wallet share\n   * @param walletShare - Wallet share object\n   * @param userLoginPassword - User's login password\n   * @param newWalletPassphrase - New wallet passphrase\n   * @param sharingKeychainPrv - Decrypted sharing keychain private key\n   * @returns Array of wallet share update requests\n   */\n  private async processAcceptShare(\n    walletShareId: string,\n    walletShare: WalletShare,\n    userLoginPassword?: string,\n    newWalletPassphrase?: string,\n    sharingKeychainPrv?: string,\n    encryptionVersion?: EncryptionVersion\n  ): Promise<BulkUpdateWalletShareOptionsRequest[]> {\n    // Special override case: requires user keychain and signing\n    if (\n      walletShare.keychainOverrideRequired &&\n      walletShare.permissions.includes('admin') &&\n      walletShare.permissions.includes('spend')\n    ) {\n      if (!userLoginPassword) {\n        throw new Error('userLoginPassword param must be provided to decrypt shared key');\n      }\n\n      const walletKeychain = await this.baseCoin\n        .keychains()\n        .createUserKeychain(newWalletPassphrase || userLoginPassword, encryptionVersion);\n      if (!walletKeychain.encryptedPrv) {\n        throw new Error('encryptedPrv was not found on wallet keychain');\n      }\n\n      const payload = JSON.stringify({\n        tradingAccountId: walletShare.wallet,\n        pubkey: walletKeychain.pub,\n        timestamp: new Date().toISOString(),\n      });\n\n      const prv = await this.bitgo.decryptAsync({\n        password: userLoginPassword,\n        input: walletKeychain.encryptedPrv,\n      });\n\n      const signature = await this.baseCoin.signMessage({ prv }, payload);\n\n      return [\n        {\n          walletShareId,\n          status: 'accept' as const,\n          keyId: walletKeychain.id,\n          signature: signature.toString('hex'),\n          payload,\n        },\n      ];\n    }\n\n    // Multi-user-key case: requires user to provide their own public key\n    if (walletShare.userMultiKeyRotationRequired) {\n      if (!(newWalletPassphrase || userLoginPassword)) {\n        throw new Error('userLoginPassword param must be provided to generate user keychain');\n      }\n\n      const walletKeychain = this.baseCoin.keychains().create();\n      const encryptedPrv = await this.bitgo.encryptAsync({\n        password: newWalletPassphrase || userLoginPassword,\n        input: walletKeychain.prv,\n        encryptionVersion,\n      });\n\n      return [\n        {\n          walletShareId,\n          status: 'accept' as const,\n          encryptedPrv: encryptedPrv,\n          pub: walletKeychain.pub,\n        },\n      ];\n    }\n\n    // Return right away if there is no keychain to decrypt\n    if (!walletShare.keychain || !walletShare.keychain.encryptedPrv) {\n      return [\n        {\n          walletShareId,\n          status: 'accept' as const,\n        },\n      ];\n    }\n\n    // More than viewing was requested, so we need to process the wallet keys using the shared ecdh scheme\n    if (!userLoginPassword) {\n      throw new Error('userLoginPassword param must be provided to decrypt shared key');\n    }\n    if (!sharingKeychainPrv) {\n      throw new Error('failed to retrieve and decrypt sharing keychain');\n    }\n\n    const derivedKey = bip32.fromBase58(sharingKeychainPrv).derivePath(sanitizeLegacyPath(walletShare.keychain.path));\n\n    const sharedSecret = getSharedSecret(derivedKey, Buffer.from(walletShare.keychain.fromPubKey, 'hex')).toString(\n      'hex'\n    );\n\n    const decryptedPrv = await this.bitgo.decryptAsync({\n      password: sharedSecret,\n      input: walletShare.keychain.encryptedPrv,\n    });\n\n    // We will now re-encrypt the wallet with our own password\n    const encryptedPrv = await this.bitgo.encryptAsync({\n      password: newWalletPassphrase || userLoginPassword,\n      input: decryptedPrv,\n      encryptionVersion,\n    });\n\n    return [\n      {\n        walletShareId,\n        status: 'accept' as const,\n        encryptedPrv,\n      },\n    ];\n  }\n\n  /**\n   * Get a wallet by its ID\n   * @param params\n   * @param params.id wallet id\n   * @returns {*}\n   */\n  async getWallet(params: GetWalletOptions = {}): Promise<Wallet> {\n    common.validateParams(params, ['id'], []);\n\n    const query: GetWalletOptions = {};\n    if (params.allTokens) {\n      if (!_.isBoolean(params.allTokens)) {\n        throw new Error('invalid allTokens argument, expecting boolean');\n      }\n      query.allTokens = params.allTokens;\n    }\n\n    if (params.includeBalance !== undefined) {\n      query.includeBalance = params.includeBalance;\n    }\n\n    this.bitgo.setRequestTracer(params.reqId || new RequestTracer());\n\n    const wallet = await this.bitgo\n      .get(this.baseCoin.url('/wallet/' + params.id))\n      .query(query)\n      .result();\n    return new Wallet(this.bitgo, this.baseCoin, wallet);\n  }\n\n  /**\n   * Get a wallet by its address\n   * @param params\n   * @param params.address wallet address\n   * @returns {*}\n   */\n  async getWalletByAddress(params: GetWalletByAddressOptions = {}): Promise<Wallet> {\n    common.validateParams(params, ['address'], []);\n\n    this.bitgo.setRequestTracer(params.reqId || new RequestTracer());\n\n    const wallet = await this.bitgo.get(this.baseCoin.url('/wallet/address/' + params.address)).result();\n    return new Wallet(this.bitgo, this.baseCoin, wallet);\n  }\n\n  /**\n   * For any given supported coin, get total balances for all wallets of that\n   * coin type on the account.\n   * @param params\n   * @returns {*}\n   */\n  async getTotalBalances(params: Record<string, never> = {}): Promise<any> {\n    return await this.bitgo.get(this.baseCoin.url('/wallet/balances')).result();\n  }\n\n  /**\n   * Generates a TSS or BLS-DKG Wallet.\n   * @param params\n   * @private\n   */\n  private async generateMpcWallet({\n    passphrase,\n    label,\n    multisigType,\n    enterprise,\n    walletVersion,\n    originalPasscodeEncryptionCode,\n    webauthnInfo,\n    encryptionVersion,\n  }: GenerateMpcWalletOptions): Promise<WalletWithKeychains> {\n    if (multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa') {\n      const tssSettings: TssSettings = await this.bitgo\n        .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))\n        .result();\n      const multisigTypeVersion =\n        tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.multiSigTypeVersion;\n      walletVersion = this.determineEcdsaMpcWalletVersion(walletVersion, multisigTypeVersion);\n    }\n\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    // Create MPC Keychains\n    const keychains = await this.baseCoin.keychains().createMpc({\n      multisigType,\n      passphrase,\n      enterprise,\n      originalPasscodeEncryptionCode,\n      webauthnInfo,\n      encryptionVersion,\n    });\n\n    // Create Wallet\n    const { userKeychain, backupKeychain, bitgoKeychain } = keychains;\n    const walletParams: SupplementGenerateWalletOptions = {\n      label,\n      m: 2,\n      n: 3,\n      keys: [userKeychain.id, backupKeychain.id, bitgoKeychain.id],\n      type: 'hot',\n      multisigType,\n      enterprise,\n      walletVersion,\n    };\n    const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();\n\n    const result: WalletWithKeychains = {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n      responseType: 'WalletWithKeychains',\n    };\n\n    if (!_.isUndefined(backupKeychain.prv)) {\n      result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';\n    }\n\n    return result;\n  }\n\n  /**\n   * Generates a Self-Managed Cold TSS Wallet.\n   * @param params\n   * @private\n   */\n  private async generateSMCMpcWallet({\n    label,\n    multisigType,\n    enterprise,\n    walletVersion,\n    bitgoKeyId,\n    commonKeychain,\n    coldDerivationSeed,\n  }: GenerateSMCMpcWalletOptions): Promise<WalletWithKeychains> {\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    let multisigTypeVersion: 'MPCv2' | undefined;\n    if (multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa') {\n      const tssSettings: TssSettings = await this.bitgo\n        .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))\n        .result();\n      multisigTypeVersion =\n        tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.coldMultiSigTypeVersion;\n      walletVersion = this.determineEcdsaMpcWalletVersion(walletVersion, multisigTypeVersion);\n    }\n\n    // Create MPC Keychains\n    const bitgoKeychain = await this.baseCoin.keychains().get({ id: bitgoKeyId });\n\n    if (!bitgoKeychain || !bitgoKeychain.commonKeychain) {\n      throw new Error('BitGo keychain not found');\n    }\n\n    if (bitgoKeychain.source !== 'bitgo') {\n      throw new Error('The provided bitgoKeyId is not a BitGo keychain');\n    }\n\n    if (bitgoKeychain.commonKeychain !== commonKeychain) {\n      throw new Error('The provided Common keychain mismatch with the provided Bitgo key');\n    }\n\n    if (!coldDerivationSeed) {\n      throw new Error('derivedFromParentWithSeed is required');\n    }\n\n    const userKeychainParams: AddKeychainOptions = {\n      source: 'user',\n      keyType: 'tss',\n      commonKeychain: commonKeychain,\n      derivedFromParentWithSeed: coldDerivationSeed,\n      isMPCv2: multisigTypeVersion === 'MPCv2' ? true : undefined,\n    };\n    const userKeychain = await this.baseCoin.keychains().add(userKeychainParams);\n\n    const backupKeyChainParams: AddKeychainOptions = {\n      source: 'backup',\n      keyType: 'tss',\n      commonKeychain: commonKeychain,\n      derivedFromParentWithSeed: coldDerivationSeed,\n      isMPCv2: multisigTypeVersion === 'MPCv2' ? true : undefined,\n    };\n\n    const backupKeychain = await this.baseCoin.keychains().add(backupKeyChainParams);\n\n    // Create Wallet\n    const keychains = { userKeychain, backupKeychain, bitgoKeychain };\n    const walletParams: SupplementGenerateWalletOptions = {\n      label,\n      m: 2,\n      n: 3,\n      keys: [userKeychain.id, backupKeychain.id, bitgoKeychain.id],\n      type: 'cold',\n      multisigType,\n      enterprise,\n      walletVersion,\n    };\n\n    const finalWalletParams = await this.baseCoin.supplementGenerateWallet(walletParams, keychains);\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();\n\n    const result: WalletWithKeychains = {\n      wallet: new Wallet(this.bitgo, this.baseCoin, newWallet),\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n      responseType: 'WalletWithKeychains',\n    };\n\n    return result;\n  }\n\n  /**\n   * Generates a Custodial TSS Wallet.\n   * @param params\n   * @private\n   */\n  private async generateCustodialMpcWallet({\n    label,\n    multisigType,\n    enterprise,\n    walletVersion,\n  }: GenerateBaseMpcWalletOptions): Promise<WalletWithKeychains> {\n    const reqId = new RequestTracer();\n    this.bitgo.setRequestTracer(reqId);\n\n    if (multisigType === 'tss' && this.baseCoin.getMPCAlgorithm() === 'ecdsa') {\n      const tssSettings: TssSettings = await this.bitgo\n        .get(this.bitgo.microservicesUrl('/api/v2/tss/settings'))\n        .result();\n      const multisigTypeVersion =\n        tssSettings.coinSettings[this.baseCoin.getFamily()]?.walletCreationSettings?.custodialMultiSigTypeVersion;\n      walletVersion = this.determineEcdsaMpcWalletVersion(walletVersion, multisigTypeVersion);\n    }\n\n    const finalWalletParams = {\n      label,\n      multisigType,\n      enterprise,\n      walletVersion,\n      type: 'custodial',\n    };\n\n    // Create Wallet\n    const newWallet = await this.bitgo.post(this.baseCoin.url('/wallet/add')).send(finalWalletParams).result();\n    const wallet = new Wallet(this.bitgo, this.baseCoin, newWallet);\n    const keychains = wallet.keyIds();\n    const result: WalletWithKeychains = {\n      wallet,\n      userKeychain: { id: keychains[0], type: multisigType, source: 'user' },\n      backupKeychain: { id: keychains[1], type: multisigType, source: 'backup' },\n      bitgoKeychain: { id: keychains[2], type: multisigType, source: 'bitgo' },\n      responseType: 'WalletWithKeychains',\n    };\n\n    return result;\n  }\n\n  private determineEcdsaMpcWalletVersion(walletVersion?: number, multisigTypeVersion?: string): number | undefined {\n    if (this.baseCoin.isEVM() && multisigTypeVersion === 'MPCv2') {\n      if (!walletVersion || (walletVersion !== 5 && walletVersion !== 6)) {\n        return 5;\n      }\n    }\n    return walletVersion;\n  }\n}\n"]}