@bitgo-beta/sdk-api 1.10.1-beta.18 → 1.10.1-beta.1800

package/dist/src/bitgoAPI.js

@@ -1,24 +1,59 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitGoAPI = void 0;
-const _ = require("lodash");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdkHmac = __importStar(require("@bitgo-beta/sdk-hmac"));
+const sdk_hmac_1 = require("@bitgo-beta/sdk-hmac");
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
 const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
-const secp256k1 = require("secp256k1");
-const bs58 = require("bs58");
-const bitcoinMessage = require("bitcoinjs-message");
+const bitcoinMessage = __importStar(require("bitcoinjs-message"));
+const debug_1 = __importDefault(require("debug"));
+const _ = __importStar(require("lodash"));
+const secp256k1 = __importStar(require("secp256k1"));
+const superagent = __importStar(require("superagent"));
 const api_1 = require("./api");
-const debug_1 = require("debug");
-const superagent = require("superagent");
-const urlLib = require("url");
-const crypto_1 = require("crypto");
-const utxolib = require("@bitgo-beta/utxo-lib");
-const sdk_core_1 = require("@bitgo-beta/sdk-core");
-const sjcl = require("@bitgo-beta/sjcl");
+const encrypt_1 = require("./encrypt");
+const encryptionSession_1 = require("./encryptionSession");
+const verifyAddress_1 = require("./v1/verifyAddress");
 const shamir = require("secrets.js-grempe");
 const pjson = require("../package.json");
-const encrypt_1 = require("./encrypt");
-const browser_or_node_1 = require("browser-or-node");
-const debug = debug_1.default('bitgo:api');
+const debug = (0, debug_1.default)('bitgo:api');
 const Blockchain = require('./v1/blockchain');
 const Keychains = require('./v1/keychains');
 const Wallet = require("./v1/wallet");
@@ -27,16 +62,120 @@ const Markets = require('./v1/markets');
 const PendingApprovals = require('./v1/pendingapprovals');
 const TravelRule = require('./v1/travelRule');
 const TransactionBuilder = require('./v1/transactionBuilder');
-if (!browser_or_node_1.isBrowser && !browser_or_node_1.isWebWorker) {
-    debug('enabling superagent-proxy wrapper');
-    require('superagent-proxy')(superagent);
+function validateDecryptKeysParams(params) {
+    params = params || {};
+    if (!params.walletIdEncryptedKeyPairs) {
+        throw new Error('Missing parameter: walletIdEncryptedKeyPairs');
+    }
+    if (!params.password) {
+        throw new Error('Missing parameter: password');
+    }
+    if (!Array.isArray(params.walletIdEncryptedKeyPairs)) {
+        throw new Error('walletIdEncryptedKeyPairs must be an array');
+    }
+    return params;
+}
+function validateSplitSecretInputs({ passwords, m }) {
+    if (!Array.isArray(passwords)) {
+        throw new Error('passwords must be an array');
+    }
+    if (!_.isInteger(m) || m < 2) {
+        throw new Error('m must be a positive integer greater than or equal to 2');
+    }
+    if (passwords.length < m) {
+        throw new Error('passwords array length cannot be less than m');
+    }
+    return passwords.length;
+}
+function validateReconstituteInputs({ shards, passwords }) {
+    if (!Array.isArray(shards)) {
+        throw new Error('shards must be an array');
+    }
+    if (!Array.isArray(passwords)) {
+        throw new Error('passwords must be an array');
+    }
+    if (shards.length !== passwords.length) {
+        throw new Error('shards and passwords arrays must have same length');
+    }
+}
+function buildSplitSecretResult(seed, shards, m, n) {
+    const node = utxo_lib_1.bip32.fromSeed(Buffer.from(seed, 'hex'));
+    return {
+        xpub: node.neutered().toBase58(),
+        m,
+        n,
+        seedShares: shards,
+    };
+}
+function buildReconstitutedSecret(seed) {
+    const node = utxo_lib_1.bip32.fromSeed(Buffer.from(seed, 'hex'));
+    return {
+        xpub: node.neutered().toBase58(),
+        xprv: node.toBase58(),
+        seed,
+    };
+}
+function verifyShardSecrets(secrets, m, xpub) {
+    const generateCombinations = (array, combinationSize, entryIndices = []) => {
+        let combinations = [];
+        if (entryIndices.length === combinationSize) {
+            const currentCombination = _.at(array, entryIndices);
+            return [currentCombination];
+        }
+        let entryIndex = _.last(entryIndices);
+        if (_.isUndefined(entryIndex)) {
+            entryIndex = -1;
+        }
+        for (let i = entryIndex + 1; i < array.length; i++) {
+            const currentEntryIndices = [...entryIndices, i];
+            const newCombinations = generateCombinations(array, combinationSize, currentEntryIndices);
+            combinations = [...combinations, ...newCombinations];
+        }
+        return combinations;
+    };
+    const secretCombinations = generateCombinations(secrets, m);
+    const seeds = secretCombinations.map((currentCombination) => {
+        return shamir.combine(currentCombination);
+    });
+    const uniqueSeeds = _.uniq(seeds);
+    if (uniqueSeeds.length !== 1) {
+        return false;
+    }
+    const seed = _.first(uniqueSeeds);
+    const node = utxo_lib_1.bip32.fromSeed(Buffer.from(seed, 'hex'));
+    const restoredXpub = node.neutered().toBase58();
+    if (!_.isUndefined(xpub)) {
+        if (!_.isString(xpub)) {
+            throw new Error('xpub must be a string');
+        }
+        if (restoredXpub !== xpub) {
+            return false;
+        }
+    }
+    return true;
+}
+function deriveTokenIssuanceEcdhSecret(ecdhXprv, derivationPath, serverXpub) {
+    const clientHDNode = utxo_lib_1.bip32.fromBase58(ecdhXprv);
+    const serverHDNode = utxo_lib_1.bip32.fromBase58(serverXpub);
+    const sanitizedPath = (0, sdk_core_1.sanitizeLegacyPath)(derivationPath);
+    const clientDerivedNode = clientHDNode.derivePath(sanitizedPath);
+    const serverDerivedNode = serverHDNode.derivePath(sanitizedPath);
+    const secretKey = clientDerivedNode.privateKey;
+    if (!secretKey) {
+        throw new Error('no client private Key');
+    }
+    return Buffer.from(
+    // FIXME(BG-34386): we should use `secp256k1.ecdh()` in the future
+    //                  see discussion here https://github.com/bitcoin-core/secp256k1/issues/352
+    secp256k1.publicKeyTweakMul(serverDerivedNode.publicKey, secretKey)).toString('hex');
 }
-const patchedRequestMethods = ['get', 'post', 'put', 'del', 'patch'];
 class BitGoAPI {
     constructor(params = {}) {
         this._authVersion = 2;
         this._hmacVerification = true;
         this._version = pjson.version;
+        this.getAdditionalHeadersCb = params.getAdditionalHeadersCb;
+        this._requestIdPrefix = params.requestIdPrefix;
         this.cookiesPropagationEnabled = false;
         if (!sdk_core_1.common.validateParams(params, [], [
             'accessToken',
@@ -120,16 +259,47 @@ class BitGoAPI {
             this._baseUrl = sdk_core_1.common.Environments[env].uri;
         }
         this._env = this.env = env;
-        const supportedApiTokens = ['etherscanApiToken', 'polygonscanApiToken'];
+        const supportedApiTokens = [
+            'etherscanApiToken',
+            'polygonscanApiToken',
+            'arbiscanApiToken',
+            'optimisticEtherscanApiToken',
+            'zksyncExplorerApiToken',
+            'bscscanApiToken',
+            'coredaoExplorerApiToken',
+            'oasExplorerApiToken',
+            'baseethApiToken',
+            'sgbExplorerApiToken',
+            'flrExplorerApiToken',
+            'xdcExplorerApiToken',
+            'wemixExplorerApiToken',
+            'monExplorerApiToken',
+            'worldExplorerApiToken',
+            'somniaExplorerApiToken',
+            'soneiumExplorerApiToken',
+        ];
         Object.keys(params).forEach((key) => {
             if (supportedApiTokens.includes(key)) {
                 sdk_core_1.common.Environments[env][key] = params[key];
             }
         });
+        if (params.evm) {
+            const evmConfig = sdk_core_1.common.Environments[env]['evm'] || {};
+            Object.keys(params.evm).forEach((key) => {
+                if (params.evm?.[key] && params.evm[key]['apiToken']) {
+                    evmConfig[key] = evmConfig[key] || {};
+                    evmConfig[key]['apiToken'] = params.evm[key]['apiToken'];
+                }
+            });
+            sdk_core_1.common.Environments[env]['evm'] = evmConfig;
+        }
         sdk_core_1.common.setNetwork(sdk_core_1.common.Environments[env].network);
         this._baseApiUrl = this._baseUrl + '/api/v1';
         this._baseApiUrlV2 = this._baseUrl + '/api/v2';
+        this._baseApiUrlV3 = this._baseUrl + '/api/v3';
         this._token = params.accessToken;
+        const clientConstants = params.clientConstants;
+        this._initializeClientConstants(clientConstants);
         this._userAgent = params.userAgent || 'BitGoJS-api/' + this.version();
         this._reqId = undefined;
         this._refreshToken = params.refreshToken;
@@ -149,23 +319,37 @@ class BitGoAPI {
             debug('HMAC verification explicitly disabled by constructor option');
             this._hmacVerification = params.hmacVerification;
         }
-        if (!params.proxy && process.env.BITGO_USE_PROXY) {
-            params.proxy = process.env.BITGO_USE_PROXY;
-        }
-        if (process.browser && params.proxy) {
-            throw new Error('cannot use https proxy params while in browser');
+        if (process.browser && params.customProxyAgent) {
+            throw new Error('should not use https proxy while in browser');
+        }
+        this._customProxyAgent = params.customProxyAgent;
+        this._hmacAuthStrategy = params.hmacAuthStrategy ?? new sdk_hmac_1.DefaultHmacAuthStrategy();
+        // Only fetch constants from constructor if clientConstants was not provided
+        if (!clientConstants) {
+            // capture outer stack so we have useful debug information if fetch constants fails
+            const e = new Error();
+            // Kick off first load of constants
+            this.fetchConstants().catch((err) => {
+                if (err) {
+                    // make sure an error does not terminate the entire script
+                    console.error('failed to fetch initial client constants from BitGo');
+                    debug(e.stack);
+                }
+            });
         }
-        this._proxy = params.proxy;
-        // capture outer stack so we have useful debug information if fetch constants fails
-        const e = new Error();
-        // Kick off first load of constants
-        this.fetchConstants().catch((err) => {
-            if (err) {
-                // make sure an error does not terminate the entire script
-                console.error('failed to fetch initial client constants from BitGo');
-                debug(e.stack);
+    }
+    /**
+     * Initialize client constants if provided.
+     * @param clientConstants - The client constants from params
+     * @private
+     */
+    _initializeClientConstants(clientConstants) {
+        if (clientConstants) {
+            if (!BitGoAPI._constants) {
+                BitGoAPI._constants = {};
             }
-        });
+            BitGoAPI._constants[this.env] = 'constants' in clientConstants ? clientConstants.constants : clientConstants;
+        }
     }
     /**
      * Get a superagent request for specified http method and URL configured to the SDK configuration
@@ -198,27 +382,73 @@ class BitGoAPI {
     getAuthVersion() {
         return this._authVersion;
     }
+    /**
+     * Signs and sends a v2-authenticated request, then verifies the response HMAC.
+     * Extracted from the req.then override in requestPatch to keep that method readable.
+     */
+    async _sendRequestWithHmac({ req, method, url, data, strategyAuthenticated, onfulfilled, originalThen, }) {
+        if (this._token || strategyAuthenticated) {
+            (0, api_1.setRequestQueryString)(req);
+            const requestProperties = await this._hmacAuthStrategy.calculateRequestHeaders({
+                url: req.url,
+                token: this._token ?? '',
+                method,
+                text: data || '',
+                authVersion: this._authVersion,
+            });
+            req.set('Auth-Timestamp', requestProperties.timestamp.toString());
+            req.set('Authorization', 'Bearer ' + requestProperties.tokenHash);
+            debug('sending v%d %s request to %s with token %s', this._authVersion, method, url, this._token?.substr(0, 8) ?? '(strategy-managed)');
+            req.set('HMAC', requestProperties.hmac);
+        }
+        if (this.getAdditionalHeadersCb) {
+            const additionalHeaders = this.getAdditionalHeadersCb(method, url, data);
+            for (const { key, value } of additionalHeaders) {
+                req.set(key, value);
+            }
+        }
+        /**
+         * Verify the response before calling the original onfulfilled handler,
+         * and make sure onrejected is called if a verification error is encountered
+         */
+        const newOnFulfilled = onfulfilled
+            ? async (response) => {
+                // HMAC verification is only allowed to be skipped in certain environments.
+                // This is checked in the constructor, but checking it again at request time
+                // will help prevent against tampering of this property after the object is created
+                if (!this._hmacVerification && !sdk_core_1.common.Environments[this.getEnv()].hmacVerificationEnforced) {
+                    return onfulfilled(response);
+                }
+                const verifiedResponse = await (0, api_1.verifyResponseAsync)(this, this._token, method, req, response, this._authVersion);
+                return onfulfilled(verifiedResponse);
+            }
+            : null;
+        return originalThen(newOnFulfilled);
+    }
     /**
      * This is a patching function which can apply our authorization
      * headers to any outbound request.
      * @param method
      */
     requestPatch(method, url) {
-        let req = this.getAgentRequest(method, url);
-        if (this._proxy) {
-            debug('proxying request through %s', this._proxy);
-            req = req.proxy(this._proxy);
+        const req = this.getAgentRequest(method, url);
+        if (this._customProxyAgent) {
+            debug('using custom proxy agent');
+            if (this._customProxyAgent) {
+                req.agent(this._customProxyAgent);
+            }
         }
         const originalThen = req.then.bind(req);
         req.then = (onfulfilled, onrejected) => {
-            var _a, _b;
             // intercept a request before it's submitted to the server for v2 authentication (based on token)
             if (this._version) {
                 // TODO - decide where to get version
                 req.set('BitGo-SDK-Version', this._version);
             }
             if (!_.isUndefined(this._reqId)) {
-                req.set('Request-ID', this._reqId.toString());
+                const reqId = this._reqId.toString();
+                const requestId = this._requestIdPrefix ? `${this._requestIdPrefix}${reqId}` : reqId;
+                req.set('Request-ID', requestId);
                 // increment after setting the header so the sequence numbers start at 0
                 this._reqId.inc();
                 // request ids must be set before each request instead of being kept
@@ -228,7 +458,7 @@ class BitGoAPI {
             }
             // prevent IE from caching requests
             req.set('If-Modified-Since', 'Mon, 26 Jul 1997 05:00:00 GMT');
-            if (!process.browser && this._userAgent) {
+            if (typeof window === 'undefined' && this._userAgent) {
                 // If not in the browser, set the User-Agent. Browsers don't allow
                 // setting of User-Agent, so we must disable this when run in the
                 // browser (browserify sets process.browser).
@@ -236,53 +466,32 @@ class BitGoAPI {
             }
             // Set the request timeout to just above 5 minutes by default
             req.timeout(process.env.BITGO_TIMEOUT * 1000 || 305 * 1000);
-            // if there is no token, and we're not logged in, the request cannot be v2 authenticated
+            // The strategy may have its own signing material (e.g. a CryptoKey
+            // restored from IndexedDB) independent of this._token.
+            const strategyAuthenticated = this._hmacAuthStrategy.isAuthenticated?.() ?? false;
             req.isV2Authenticated = true;
-            req.authenticationToken = this._token;
+            req.authenticationToken = this._token ?? (strategyAuthenticated ? 'strategy-authenticated' : undefined);
             // some of the older tokens appear to be only 40 characters long
             if ((this._token && this._token.length !== 67 && this._token.indexOf('v2x') !== 0) || req.forceV1Auth) {
                 // use the old method
                 req.isV2Authenticated = false;
                 req.set('Authorization', 'Bearer ' + this._token);
-                debug('sending v1 %s request to %s with token %s', method, url, (_a = this._token) === null || _a === void 0 ? void 0 : _a.substr(0, 8));
+                debug('sending v1 %s request to %s with token %s', method, url, this._token?.substr(0, 8));
                 return originalThen(onfulfilled).catch(onrejected);
             }
             req.set('BitGo-Auth-Version', this._authVersion === 3 ? '3.0' : '2.0');
-            if (this._token) {
-                const data = api_1.serializeRequestData(req);
-                api_1.setRequestQueryString(req);
-                const requestProperties = this.calculateRequestHeaders({
-                    url: req.url,
-                    token: this._token,
-                    method,
-                    text: data || '',
-                });
-                req.set('Auth-Timestamp', requestProperties.timestamp.toString());
-                // we're not sending the actual token, but only its hash
-                req.set('Authorization', 'Bearer ' + requestProperties.tokenHash);
-                debug('sending v2 %s request to %s with token %s', method, url, (_b = this._token) === null || _b === void 0 ? void 0 : _b.substr(0, 8));
-                // set the HMAC
-                req.set('HMAC', requestProperties.hmac);
-            }
-            /**
-             * Verify the response before calling the original onfulfilled handler,
-             * and make sure onrejected is called if a verification error is encountered
-             */
-            const newOnFulfilled = onfulfilled
-                ? (response) => {
-                    // HMAC verification is only allowed to be skipped in certain environments.
-                    // This is checked in the constructor, but checking it again at request time
-                    // will help prevent against tampering of this property after the object is created
-                    if (!this._hmacVerification && !sdk_core_1.common.Environments[this.getEnv()].hmacVerificationEnforced) {
-                        return onfulfilled(response);
-                    }
-                    const verifiedResponse = api_1.verifyResponse(this, this._token, method, req, response);
-                    return onfulfilled(verifiedResponse);
-                }
-                : null;
-            return originalThen(newOnFulfilled).catch(onrejected);
+            const data = (0, api_1.serializeRequestData)(req);
+            return this._sendRequestWithHmac({
+                req,
+                method,
+                url,
+                data,
+                strategyAuthenticated,
+                onfulfilled,
+                originalThen,
+            }).catch(onrejected);
         };
-        return api_1.toBitgoRequest(req);
+        return (0, api_1.toBitgoRequest)(req);
     }
     get(url) {
         return this.requestPatch('get', url);
@@ -299,6 +508,9 @@ class BitGoAPI {
     patch(url) {
         return this.requestPatch('patch', url);
     }
+    options(url) {
+        return this.requestPatch('options', url);
+    }
     /**
      * Calculate the HMAC for the given key and message
      * @param key {String} - the key to use for the HMAC
@@ -306,7 +518,7 @@ class BitGoAPI {
      * @returns {*} - the result of the HMAC operation
      */
     calculateHMAC(key, message) {
-        return crypto_1.createHmac('sha256', key).update(message).digest('hex');
+        return sdkHmac.calculateHMAC(key, message);
     }
     /**
      * Calculate the subject string that is to be HMAC'ed for a HTTP request or response
@@ -315,69 +527,36 @@ class BitGoAPI {
      * @param timestamp request timestamp from `Date.now()`
      * @param statusCode Only set for HTTP responses, leave blank for requests
      * @param method request method
-     * @returns {string}
+     * @returns {string | Buffer}
      */
-    calculateHMACSubject({ urlPath, text, timestamp, statusCode, method }) {
-        const urlDetails = urlLib.parse(urlPath);
-        const queryPath = urlDetails.query && urlDetails.query.length > 0 ? urlDetails.path : urlDetails.pathname;
-        if (!_.isUndefined(statusCode) && _.isInteger(statusCode) && _.isFinite(statusCode)) {
-            if (this._authVersion === 3) {
-                return [method.toUpperCase(), timestamp, queryPath, statusCode, text].join('|');
-            }
-            return [timestamp, queryPath, statusCode, text].join('|');
-        }
-        if (this._authVersion === 3) {
-            return [method.toUpperCase(), timestamp, '3.0', queryPath, text].join('|');
-        }
-        return [timestamp, queryPath, text].join('|');
+    calculateHMACSubject(params) {
+        return sdkHmac.calculateHMACSubject({ ...params, authVersion: this._authVersion });
     }
     /**
      * Calculate the HMAC for an HTTP request
      */
-    calculateRequestHMAC({ url: urlPath, text, timestamp, token, method }) {
-        const signatureSubject = this.calculateHMACSubject({ urlPath, text, timestamp, method });
-        // calculate the HMAC
-        return this.calculateHMAC(token, signatureSubject);
+    calculateRequestHMAC(params) {
+        return sdkHmac.calculateRequestHMAC({ ...params, authVersion: this._authVersion });
     }
     /**
      * Calculate request headers with HMAC
      */
-    calculateRequestHeaders({ url, text, token, method }) {
-        const timestamp = Date.now();
-        const hmac = this.calculateRequestHMAC({ url, text, timestamp, token, method });
-        // calculate the SHA256 hash of the token
-        const hashDigest = sjcl.hash.sha256.hash(token);
-        const tokenHash = sjcl.codec.hex.fromBits(hashDigest);
-        return {
-            hmac,
-            timestamp,
-            tokenHash,
-        };
+    calculateRequestHeaders(params) {
+        return sdkHmac.calculateRequestHeaders({ ...params, authVersion: this._authVersion });
     }
     /**
-     * Verify the HMAC for an HTTP response
+     * Verify the HMAC for an HTTP response (synchronous, uses sdk-hmac directly).
+     * Kept for backward compatibility with external callers.
      */
-    verifyResponse({ url: urlPath, statusCode, text, timestamp, token, hmac, method, }) {
-        const signatureSubject = this.calculateHMACSubject({
-            urlPath,
-            text,
-            timestamp,
-            statusCode,
-            method,
-        });
-        // calculate the HMAC
-        const expectedHmac = this.calculateHMAC(token, signatureSubject);
-        // determine if the response is still within the validity window (5 minute window)
-        const now = Date.now();
-        const isInResponseValidityWindow = timestamp >= now - 1000 * 60 * 5 && timestamp <= now;
-        // verify the HMAC and timestamp
-        return {
-            isValid: expectedHmac === hmac,
-            expectedHmac,
-            signatureSubject,
-            isInResponseValidityWindow,
-            verificationTime: now,
-        };
+    verifyResponse(params) {
+        return sdkHmac.verifyResponse({ ...params, authVersion: this._authVersion });
+    }
+    /**
+     * Verify the HMAC for an HTTP response via the configured strategy (async).
+     * Used internally by the request pipeline.
+     */
+    verifyResponseAsync(params) {
+        return this._hmacAuthStrategy.verifyResponse({ ...params, authVersion: this._authVersion });
     }
     /**
      * Fetch useful constant values from the BitGo server.
@@ -386,15 +565,11 @@ class BitGoAPI {
      * so they can safely cached.
      */
     async fetchConstants() {
-        var _a, _b;
         const env = this.getEnv();
-        if (!BitGoAPI._constants) {
-            BitGoAPI._constants = {};
-        }
-        if (!BitGoAPI._constantsExpire) {
-            BitGoAPI._constantsExpire = {};
-        }
-        if (BitGoAPI._constants[env] && BitGoAPI._constantsExpire[env] && new Date() < BitGoAPI._constantsExpire[env]) {
+        // Check if we have cached constants that haven't expired
+        if (BitGoAPI._constants &&
+            BitGoAPI._constants[env] &&
+            (!BitGoAPI._constantsExpire || !BitGoAPI._constantsExpire[env] || new Date() < BitGoAPI._constantsExpire[env])) {
             return BitGoAPI._constants[env];
         }
         // client constants call cannot be authenticated using the normal HMAC validation
@@ -402,9 +577,24 @@ class BitGoAPI {
         // Proxy settings must still be respected however
         const resultPromise = this.getAgentRequest('get', this.url('/client/constants'));
         resultPromise.set('BitGo-SDK-Version', this._version);
-        const result = await (this._proxy ? resultPromise.proxy(this._proxy) : resultPromise);
+        if (this._customProxyAgent) {
+            resultPromise.agent(this._customProxyAgent);
+        }
+        if (this.getAdditionalHeadersCb) {
+            const additionalHeaders = this.getAdditionalHeadersCb('get', this.url('/client/constants'));
+            for (const { key, value } of additionalHeaders) {
+                resultPromise.set(key, value);
+            }
+        }
+        const result = await resultPromise;
+        if (!BitGoAPI._constants) {
+            BitGoAPI._constants = {};
+        }
         BitGoAPI._constants[env] = result.body.constants;
-        if (((_a = result.body) === null || _a === void 0 ? void 0 : _a.ttl) && typeof ((_b = result.body) === null || _b === void 0 ? void 0 : _b.ttl) === 'number') {
+        if (result.body?.ttl && typeof result.body?.ttl === 'number') {
+            if (!BitGoAPI._constantsExpire) {
+                BitGoAPI._constantsExpire = {};
+            }
             BitGoAPI._constantsExpire[env] = new Date(new Date().getTime() + result.body.ttl * 1000);
         }
         return BitGoAPI._constants[env];
@@ -415,7 +605,7 @@ class BitGoAPI {
      * @param version
      */
     url(path, version = 1) {
-        const baseUrl = version === 2 ? this._baseApiUrlV2 : this._baseApiUrl;
+        const baseUrl = version === 3 ? this._baseApiUrlV3 : version === 2 ? this._baseApiUrlV2 : this._baseApiUrl;
         return baseUrl + path;
     }
     /**
@@ -452,11 +642,32 @@ class BitGoAPI {
      * Utility function to encrypt locally.
      */
     encrypt(params) {
-        sdk_core_1.common.validateParams(params, ['input', 'password'], []);
+        sdk_core_1.common.validateParams(params, ['input', 'password'], ['adata']);
         if (!params.password) {
             throw new Error(`cannot encrypt without password`);
         }
-        return encrypt_1.encrypt(params.password, params.input);
+        return (0, encrypt_1.encrypt)(params.password, params.input, { adata: params.adata });
+    }
+    /**
+     * Async encrypt that dispatches to v1 (SJCL) or v2 (Argon2id + AES-256-GCM)
+     * based on `encryptionVersion`.
+     */
+    async encryptAsync(params) {
+        sdk_core_1.common.validateParams(params, ['input', 'password'], []);
+        if (!params.password) {
+            throw new Error('cannot encrypt without password');
+        }
+        return await (0, encrypt_1.encryptAsync)(params.password, params.input, {
+            adata: params.adata,
+            encryptionVersion: params.encryptionVersion,
+        });
+    }
+    /**
+     * Create an encryption session for multi-call operations.
+     * Runs Argon2id once; all subsequent calls derive keys via HKDF.
+     */
+    async createEncryptionSession(password) {
+        return (0, encryptionSession_1.createEncryptionSession)(password);
     }
     /**
      * Decrypt an encrypted string locally.
@@ -468,7 +679,7 @@ class BitGoAPI {
             throw new Error(`cannot decrypt without password`);
         }
         try {
-            return encrypt_1.decrypt(params.password, params.input);
+            return (0, encrypt_1.decrypt)(params.password, params.input);
         }
         catch (error) {
             if (error.message.includes("ccm: tag doesn't match")) {
@@ -477,6 +688,91 @@ class BitGoAPI {
             throw error;
         }
     }
+    /**
+     * Async decrypt that auto-detects v1 (SJCL) or v2 (Argon2id).
+     * Migration path from sync decrypt() -- use this before the breaking release.
+     */
+    async decryptAsync(params) {
+        params = params || {};
+        sdk_core_1.common.validateParams(params, ['input', 'password'], []);
+        if (!params.password) {
+            throw new Error(`cannot decrypt without password`);
+        }
+        try {
+            return await (0, encrypt_1.decryptAsync)(params.password, params.input);
+        }
+        catch (error) {
+            if (error.message.includes("ccm: tag doesn't match") ||
+                error.message.includes('The operation failed for an operation-specific reason')) {
+                throw new Error('incorrect password');
+            }
+            throw error;
+        }
+    }
+    /**
+     * TODO: deprecate this function in favor of decryptKeysAsync once v2 encryption is default
+     * Attempt to decrypt multiple wallet keys with the provided passphrase
+     * @param {DecryptKeysOptions} params - Parameters object containing wallet key pairs and password
+     * @param {Array<{walletId: string, encryptedPrv: string}>} params.walletIdEncryptedKeyPairs - Array of wallet ID and encrypted private key pairs
+     * @param {string} params.password - The passphrase to attempt decryption with
+     * @returns {string[]} - Array of wallet IDs for which decryption failed
+     */
+    decryptKeys(params) {
+        const validatedParams = validateDecryptKeysParams(params);
+        if (validatedParams.walletIdEncryptedKeyPairs.length === 0) {
+            return [];
+        }
+        const failedWalletIds = [];
+        for (const keyPair of validatedParams.walletIdEncryptedKeyPairs) {
+            if (!keyPair.walletId || typeof keyPair.walletId !== 'string') {
+                throw new Error('each key pair must have a string walletId');
+            }
+            if (!keyPair.encryptedPrv || typeof keyPair.encryptedPrv !== 'string') {
+                throw new Error('each key pair must have a string encryptedPrv');
+            }
+            try {
+                this.decrypt({
+                    input: keyPair.encryptedPrv,
+                    password: validatedParams.password,
+                });
+                // If no error was thrown, decryption was successful
+            }
+            catch (error) {
+                // If decryption fails, add the walletId to the failed list
+                failedWalletIds.push(keyPair.walletId);
+            }
+        }
+        return failedWalletIds;
+    }
+    /**
+     * Async version of decryptKeys with v2 encrypt/decrypt support.
+     * @param params
+     */
+    async decryptKeysAsync(params) {
+        const validatedParams = validateDecryptKeysParams(params);
+        if (validatedParams.walletIdEncryptedKeyPairs.length === 0) {
+            return [];
+        }
+        const failedWalletIds = [];
+        for (const keyPair of validatedParams.walletIdEncryptedKeyPairs) {
+            if (!keyPair.walletId || typeof keyPair.walletId !== 'string') {
+                throw new Error('each key pair must have a string walletId');
+            }
+            if (!keyPair.encryptedPrv || typeof keyPair.encryptedPrv !== 'string') {
+                throw new Error('each key pair must have a string encryptedPrv');
+            }
+            try {
+                await this.decryptAsync({
+                    input: keyPair.encryptedPrv,
+                    password: validatedParams.password,
+                });
+            }
+            catch (error) {
+                failedWalletIds.push(keyPair.walletId);
+            }
+        }
+        return failedWalletIds;
+    }
     /**
      * Serialize this BitGo object to a JSON object.
      *
@@ -517,7 +813,7 @@ class BitGoAPI {
      * Process the username, password and otp into an object containing the username and hashed password, ready to
      * send to bitgo for authentication.
      */
-    preprocessAuthenticationParams({ username, password, otp, forceSMS, extensible, trust, }) {
+    async preprocessAuthenticationParams({ username, password, otp, forceSMS, extensible, trust, forReset2FA, initialHash, fingerprintHash, }) {
         if (!_.isString(username)) {
             throw new Error('expected string username');
         }
@@ -526,7 +822,7 @@ class BitGoAPI {
         }
         const lowerName = username.toLowerCase();
         // Calculate the password HMAC so we don't send clear-text passwords
-        const hmacPassword = this.calculateHMAC(lowerName, password);
+        const hmacPassword = await this._hmacAuthStrategy.calculateHMAC(lowerName, password);
         const authParams = {
             email: lowerName,
             password: hmacPassword,
@@ -539,12 +835,46 @@ class BitGoAPI {
             }
         }
         if (extensible) {
-            this._extensionKey = sdk_core_1.makeRandomKey();
+            this._extensionKey = (0, sdk_core_1.makeRandomKey)();
             authParams.extensible = true;
-            authParams.extensionAddress = sdk_core_1.getAddressP2PKH(this._extensionKey);
+            authParams.extensionAddress = (0, sdk_core_1.getAddressP2PKH)(this._extensionKey);
+        }
+        if (forReset2FA) {
+            authParams.forReset2FA = true;
+        }
+        if (initialHash) {
+            authParams.initialHash = initialHash;
+        }
+        if (fingerprintHash) {
+            authParams.fingerprintHash = fingerprintHash;
         }
         return authParams;
     }
+    /**
+     * Validate the passkey response is in the expected format
+     * Should be as is returned from navigator.credentials.get()
+     */
+    validatePasskeyResponse(passkeyResponse) {
+        const parsedPasskeyResponse = JSON.parse(passkeyResponse);
+        if (!parsedPasskeyResponse && !parsedPasskeyResponse.response) {
+            throw new Error('unexpected webauthnResponse');
+        }
+        if (!_.isString(parsedPasskeyResponse.id)) {
+            throw new Error('id is missing');
+        }
+        if (!_.isString(parsedPasskeyResponse.response.authenticatorData)) {
+            throw new Error('authenticatorData is missing');
+        }
+        if (!_.isString(parsedPasskeyResponse.response.clientDataJSON)) {
+            throw new Error('clientDataJSON is missing');
+        }
+        if (!_.isString(parsedPasskeyResponse.response.signature)) {
+            throw new Error('signature is missing');
+        }
+        if (!_.isString(parsedPasskeyResponse.response.userHandle)) {
+            throw new Error('userHandle is missing');
+        }
+    }
     /**
      * Synchronous method for activating an access token.
      */
@@ -552,6 +882,69 @@ class BitGoAPI {
         debug('now authenticating with access token %s', accessToken.substring(0, 8));
         this._token = accessToken;
     }
+    /**
+     * Creates a new ECDH keychain for the user.
+     * @param {string} loginPassword - The user's login password.
+     * @returns {Promise<any>} - A promise that resolves with the new ECDH keychain data.
+     * @throws {Error} - Throws an error if there is an issue creating the keychain.
+     */
+    async createUserEcdhKeychain(loginPassword) {
+        const keyData = this.keychains().create();
+        const hdNode = sdk_core_1.bitcoin.HDNode.fromBase58(keyData.xprv);
+        /**
+         * Add the new ECDH keychain to the user's account.
+         * @type {Promise<any>} - A promise that resolves with the new ECDH keychain.
+         */
+        return await this.keychains().add({
+            source: 'ecdh',
+            xpub: hdNode.neutered().toBase58(),
+            encryptedXprv: await this.encryptAsync({
+                password: loginPassword,
+                input: hdNode.toBase58(),
+            }),
+        });
+    }
+    /**
+     * Updates the user's settings with the provided parameters.
+     * @param {Object} params - The parameters to update the user's settings with.
+     * @returns {Promise<any>}
+     * @throws {Error} - Throws an error if there is an issue updating the user's settings.
+     */
+    async updateUserSettings(params) {
+        return this.put(this.url('/user/settings', 2)).send(params).result();
+    }
+    /**
+     * Ensures that the user's ECDH keychain is created for wallet sharing and TSS wallets.
+     * If the keychain does not exist, it will be created and the user's settings will be updated.
+     * @param {string} loginPassword - The user's login password.
+     * @returns {Promise<any>} - A promise that resolves with the user's settings ensuring we have the ecdhKeychain in there.
+     * @throws {Error} - Throws an error if there is an issue creating the keychain or updating the user's settings.
+     */
+    async ensureUserEcdhKeychainIsCreated(loginPassword) {
+        /**
+         * Get the user's current settings.
+         */
+        const userSettings = await this.get(this.url('/user/settings')).result();
+        /**
+         * If the user's ECDH keychain does not exist, create a new keychain and update the user's settings.
+         */
+        if (!userSettings.settings.ecdhKeychain) {
+            const newKeychain = await this.createUserEcdhKeychain(loginPassword);
+            await this.updateUserSettings({
+                settings: {
+                    ecdhKeychain: newKeychain.xpub,
+                },
+            });
+            /**
+             * Update the user's settings object with the new ECDH keychain.
+             */
+            userSettings.settings.ecdhKeychain = newKeychain.xpub;
+        }
+        /**
+         * Return the user's ECDH keychain settings.
+         */
+        return userSettings.settings;
+    }
     /**
      * Login to the bitgo platform.
      */
@@ -564,7 +957,7 @@ class BitGoAPI {
                 throw new Error('expected string password');
             }
             const forceV1Auth = !!params.forceV1Auth;
-            const authParams = this.preprocessAuthenticationParams(params);
+            const authParams = await this.preprocessAuthenticationParams(params);
             const password = params.password;
             if (this._token) {
                 return new Error('already logged in');
@@ -592,22 +985,68 @@ class BitGoAPI {
                 if (!encryptedXprv) {
                     throw new Error('Keychain needs encryptedXprv property');
                 }
-                const responseDetails = this.handleTokenIssuance(response.body, password);
+                const responseDetails = await this.handleTokenIssuanceAsync(response.body, password);
                 this._token = responseDetails.token;
                 this._ecdhXprv = responseDetails.ecdhXprv;
                 // verify the response's authenticity
-                api_1.verifyResponse(this, responseDetails.token, 'post', request, response);
+                await (0, api_1.verifyResponseAsync)(this, responseDetails.token, 'post', request, response, this._authVersion);
                 // add the remaining component for easier access
                 response.body.access_token = this._token;
             }
-            return api_1.handleResponseResult()(response);
+            // Sync the token into the strategy so that strategies which manage their
+            // own key material (e.g. WebCryptoHmacStrategy) can sign the subsequent
+            // ensureUserEcdhKeychainIsCreated requests.  Must be awaited — the call
+            // may perform async key derivation (crypto.subtle.importKey).
+            if (this._token) {
+                await this._hmacAuthStrategy.setToken?.(this._token);
+            }
+            const userSettings = params.ensureEcdhKeychain ? await this.ensureUserEcdhKeychainIsCreated(password) : undefined;
+            if (userSettings?.ecdhKeychain) {
+                response.body.user.ecdhKeychain = userSettings.ecdhKeychain;
+            }
+            return (0, api_1.handleResponseResult)()(response);
         }
         catch (e) {
-            api_1.handleResponseError(e);
+            (0, api_1.handleResponseError)(e);
         }
     }
     /**
-     *
+     * Login to the bitgo platform with passkey.
+     */
+    async authenticateWithPasskey(passkey, initialHash, fingerprintHash) {
+        try {
+            if (this._token) {
+                return new Error('already logged in');
+            }
+            const authUrl = this.microservicesUrl('/api/auth/v1/session');
+            const request = this.post(authUrl);
+            this.validatePasskeyResponse(passkey);
+            const userId = JSON.parse(passkey).response.userHandle;
+            const response = await request.send({
+                passkey: passkey,
+                userId: userId,
+                initialHash,
+                fingerprintHash,
+            });
+            // extract body and user information
+            const body = response.body;
+            this._user = body.user;
+            if (body.access_token) {
+                this._token = body.access_token;
+                response.body.access_token = body.access_token;
+                await this._hmacAuthStrategy.setToken?.(body.access_token);
+            }
+            else {
+                throw new Error('Failed to login. Please contact support@bitgo.com');
+            }
+            return (0, api_1.handleResponseResult)()(response);
+        }
+        catch (e) {
+            (0, api_1.handleResponseError)(e);
+        }
+    }
+    /**
+     * TODO: Deprecate this function in favor of handleTokenIssuanceAsync once v2 encryption is default.
      * @param responseBody Response body object
      * @param password Password for the symmetric decryption
      */
@@ -634,52 +1073,80 @@ class BitGoAPI {
                 throw e;
             }
         }
-        // construct HDNode objects for client's xprv and server's xpub
-        const clientHDNode = utxo_lib_1.bip32.fromBase58(ecdhXprv);
-        const serverHDNode = utxo_lib_1.bip32.fromBase58(serverXpub);
-        // BIP32 derivation path is applied to both client and server master keys
-        const derivationPath = sdk_core_1.sanitizeLegacyPath(responseBody.derivationPath);
-        const clientDerivedNode = clientHDNode.derivePath(derivationPath);
-        const serverDerivedNode = serverHDNode.derivePath(derivationPath);
-        const publicKey = serverDerivedNode.publicKey;
-        const secretKey = clientDerivedNode.privateKey;
-        if (!secretKey) {
-            throw new Error('no client private Key');
-        }
-        const secret = Buffer.from(
-        // FIXME(BG-34386): we should use `secp256k1.ecdh()` in the future
-        //                  see discussion here https://github.com/bitcoin-core/secp256k1/issues/352
-        secp256k1.publicKeyTweakMul(publicKey, secretKey)).toString('hex');
-        // decrypt token with symmetric ECDH key
-        let response;
+        const secret = deriveTokenIssuanceEcdhSecret(ecdhXprv, responseBody.derivationPath, serverXpub);
         try {
-            response = {
-                token: this.decrypt({
-                    input: responseBody.encryptedToken,
-                    password: secret,
-                }),
-            };
+            const token = this.decrypt({
+                input: responseBody.encryptedToken,
+                password: secret,
+            });
+            const response = { token };
+            if (!this._ecdhXprv) {
+                response.ecdhXprv = ecdhXprv;
+            }
+            return response;
         }
         catch (e) {
             e.errorCode = 'token_decryption_failure';
             console.error('Failed to decrypt token.');
             throw e;
         }
-        if (!this._ecdhXprv) {
-            response.ecdhXprv = ecdhXprv;
+    }
+    /**
+     * Async version of handleTokenIssuance with v2 encrypt/decrypt support.
+     * @param responseBody Response body object
+     * @param password Password for the symmetric decryption
+     */
+    async handleTokenIssuanceAsync(responseBody, password) {
+        // make sure the response body contains the necessary properties
+        sdk_core_1.common.validateParams(responseBody, ['derivationPath'], ['encryptedECDHXprv']);
+        const environment = this._env;
+        const environmentConfig = sdk_core_1.common.Environments[environment];
+        const serverXpub = environmentConfig.serverXpub;
+        let ecdhXprv = this._ecdhXprv;
+        if (!ecdhXprv) {
+            if (!password || !responseBody.encryptedECDHXprv) {
+                throw new Error('ecdhXprv property must be set or password and encrypted encryptedECDHXprv must be provided');
+            }
+            try {
+                ecdhXprv = await this.decryptAsync({
+                    input: responseBody.encryptedECDHXprv,
+                    password: password,
+                });
+            }
+            catch (e) {
+                e.errorCode = 'ecdh_xprv_decryption_failure';
+                console.error('Failed to decrypt encryptedECDHXprv.');
+                throw e;
+            }
+        }
+        const secret = deriveTokenIssuanceEcdhSecret(ecdhXprv, responseBody.derivationPath, serverXpub);
+        try {
+            const token = await this.decryptAsync({
+                input: responseBody.encryptedToken,
+                password: secret,
+            });
+            const response = { token };
+            if (!this._ecdhXprv) {
+                response.ecdhXprv = ecdhXprv;
+            }
+            return response;
+        }
+        catch (e) {
+            e.errorCode = 'token_decryption_failure';
+            console.error('Failed to decrypt token.');
+            throw e;
         }
-        return response;
     }
     /**
      */
-    verifyPassword(params = {}) {
+    async verifyPassword(params = {}) {
         if (!_.isString(params.password)) {
             throw new Error('missing required string password');
         }
         if (!this._user || !this._user.username) {
             throw new Error('no current user');
         }
-        const hmacPassword = this.calculateHMAC(this._user.username, params.password);
+        const hmacPassword = await this._hmacAuthStrategy.calculateHMAC(this._user.username, params.password);
         return this.post(this.url('/user/verifypassword')).send({ password: hmacPassword }).result('valid');
     }
     /**
@@ -692,6 +1159,10 @@ class BitGoAPI {
         this._refreshToken = undefined;
         this._ecdhXprv = undefined;
     }
+    async clearAsync() {
+        this.clear();
+        await this._hmacAuthStrategy.clearToken?.();
+    }
     /**
      * Use refresh token to get new access token.
      * If the refresh token is null/defined, then we use the stored token from auth
@@ -715,6 +1186,7 @@ class BitGoAPI {
             .result();
         this._token = body.access_token;
         this._refreshToken = body.refresh_token;
+        await this._hmacAuthStrategy?.setToken?.(body.access_token);
         return body;
     }
     /**
@@ -767,7 +1239,6 @@ class BitGoAPI {
      * }
      */
     async addAccessToken(params) {
-        var _a;
         try {
             if (!_.isString(params.label)) {
                 throw new Error('required string label');
@@ -809,21 +1280,21 @@ class BitGoAPI {
             if (!this._ecdhXprv) {
                 // without a private key, the user cannot decrypt the new access token the server will send
                 request.forceV1Auth = true;
-                debug('forcing v1 auth for adding access token using token %s', (_a = this._token) === null || _a === void 0 ? void 0 : _a.substr(0, 8));
+                debug('forcing v1 auth for adding access token using token %s', this._token?.substr(0, 8));
             }
             const response = await request.send(params);
             if (request.forceV1Auth) {
                 response.body.warning = 'A protocol downgrade has occurred because this is a legacy account.';
-                return api_1.handleResponseResult()(response);
+                return (0, api_1.handleResponseResult)()(response);
             }
             // verify the authenticity of the server's response before proceeding any further
-            api_1.verifyResponse(this, this._token, 'post', request, response);
-            const responseDetails = this.handleTokenIssuance(response.body);
+            await (0, api_1.verifyResponseAsync)(this, this._token, 'post', request, response, this._authVersion);
+            const responseDetails = await this.handleTokenIssuanceAsync(response.body);
             response.body.token = responseDetails.token;
-            return api_1.handleResponseResult()(response);
+            return (0, api_1.handleResponseResult)()(response);
         }
         catch (e) {
-            api_1.handleResponseError(e);
+            (0, api_1.handleResponseError)(e);
         }
     }
     /**
@@ -878,8 +1349,7 @@ class BitGoAPI {
      * @returns {String}          base58 random password
      */
     generateRandomPassword(numWords = 5) {
-        const bytes = sjcl.codec.bytes.fromBits(sjcl.random.randomWords(numWords));
-        return bs58.encode(bytes);
+        return (0, sdk_core_1.generateRandomPassword)(numWords);
     }
     /**
      * Logout of BitGo
@@ -982,7 +1452,7 @@ class BitGoAPI {
      * @param userId
      */
     async getSigningKeyForUser(enterpriseId, userId) {
-        const user = userId !== null && userId !== void 0 ? userId : 'me';
+        const user = userId ?? 'me';
         return this.get(this.url(`/enterprise/${enterpriseId}/user/${user}/signingkey`, 2))
             .query({})
             .result();
@@ -1122,137 +1592,85 @@ class BitGoAPI {
         }
         const networkName = sdk_core_1.common.Environments[this.getEnv()].network;
         const network = utxolib.networks[networkName];
-        let address;
-        try {
-            address = utxolib.address.fromBase58Check(params.address, network);
-        }
-        catch (e) {
-            return false;
-        }
-        return address.version === network.pubKeyHash || address.version === network.scriptHash;
+        return (0, verifyAddress_1.verifyAddress)(params.address, network);
     }
     /**
+     * TODO: deprecate this function in favor of splitSecretAsync when v2 encryption is the default
      * Split a secret into shards using Shamir Secret Sharing.
      * @param seed A hexadecimal secret to split
      * @param passwords An array of the passwords used to encrypt each share
      * @param m The threshold number of shards necessary to reconstitute the secret
      */
     splitSecret({ seed, passwords, m }) {
-        if (!Array.isArray(passwords)) {
-            throw new Error('passwords must be an array');
-        }
-        if (!_.isInteger(m) || m < 2) {
-            throw new Error('m must be a positive integer greater than or equal to 2');
-        }
-        if (passwords.length < m) {
-            throw new Error('passwords array length cannot be less than m');
-        }
-        const n = passwords.length;
+        const n = validateSplitSecretInputs({ seed, passwords, m });
         const secrets = shamir.share(seed, n, m);
         const shards = _.zipWith(secrets, passwords, (shard, password) => {
             return this.encrypt({ input: shard, password });
         });
-        const node = utxo_lib_1.bip32.fromSeed(Buffer.from(seed, 'hex'));
-        return {
-            xpub: node.neutered().toBase58(),
-            m,
-            n,
-            seedShares: shards,
-        };
+        return buildSplitSecretResult(seed, shards, m, n);
     }
     /**
+     * Async version of splitSecret with v2 encrypt/decrypt support.
+     * @param seed
+     * @param passwords
+     * @param m
+     */
+    async splitSecretAsync({ seed, passwords, m }) {
+        const n = validateSplitSecretInputs({ seed, passwords, m });
+        const secrets = shamir.share(seed, n, m);
+        const shards = await Promise.all(secrets.map((shard, i) => this.encryptAsync({ input: shard, password: passwords[i] })));
+        return buildSplitSecretResult(seed, shards, m, n);
+    }
+    /**
+     * TODO: deprecate this function in favor of reconstituteSecretAsync when v2 encryption is the default
      * Reconstitute a secret which was sharded with `splitSecret`.
      * @param shards
      * @param passwords
      */
     reconstituteSecret({ shards, passwords }) {
-        if (!Array.isArray(shards)) {
-            throw new Error('shards must be an array');
-        }
-        if (!Array.isArray(passwords)) {
-            throw new Error('passwords must be an array');
-        }
-        if (shards.length !== passwords.length) {
-            throw new Error('shards and passwords arrays must have same length');
-        }
+        validateReconstituteInputs({ shards, passwords });
         const secrets = _.zipWith(shards, passwords, (shard, password) => {
             return this.decrypt({ input: shard, password });
         });
         const seed = shamir.combine(secrets);
-        const node = utxo_lib_1.bip32.fromSeed(Buffer.from(seed, 'hex'));
-        return {
-            xpub: node.neutered().toBase58(),
-            xprv: node.toBase58(),
-            seed,
-        };
+        return buildReconstitutedSecret(seed);
     }
     /**
-     *
+     * Async version of reconstituteSecret with v2 encrypt/decrypt support.
+     * @param shards
+     * @param passwords
+     */
+    async reconstituteSecretAsync({ shards, passwords }) {
+        validateReconstituteInputs({ shards, passwords });
+        const secrets = await Promise.all(shards.map((shard, i) => this.decryptAsync({ input: shard, password: passwords[i] })));
+        const seed = shamir.combine(secrets);
+        return buildReconstitutedSecret(seed);
+    }
+    /**
+     * TODO: Deprecate this function in favour of verifyShardsAsync when v2 encryption is the default.
      * @param shards
      * @param passwords
      * @param m
      * @param xpub Optional xpub to verify the results against
      */
     verifyShards({ shards, passwords, m, xpub }) {
-        /**
-         * Generate all possible combinations of a given array's values given subset size m
-         * @param array The array whose values are to be arranged in all combinations
-         * @param m The size of each subset
-         * @param entryIndices Recursively trailing set of currently chosen array indices for the combination subset under construction
-         * @returns {Array}
-         */
-        const generateCombinations = (array, m, entryIndices = []) => {
-            let combinations = [];
-            if (entryIndices.length === m) {
-                const currentCombination = _.at(array, entryIndices);
-                return [currentCombination];
-            }
-            // The highest index
-            let entryIndex = _.last(entryIndices);
-            // If there are currently no indices, assume -1
-            if (_.isUndefined(entryIndex)) {
-                entryIndex = -1;
-            }
-            for (let i = entryIndex + 1; i < array.length; i++) {
-                // append the current index to the trailing indices
-                const currentEntryIndices = [...entryIndices, i];
-                const newCombinations = generateCombinations(array, m, currentEntryIndices);
-                combinations = [...combinations, ...newCombinations];
-            }
-            return combinations;
-        };
-        if (!Array.isArray(shards)) {
-            throw new Error('shards must be an array');
-        }
-        if (!Array.isArray(passwords)) {
-            throw new Error('passwords must be an array');
-        }
-        if (shards.length !== passwords.length) {
-            throw new Error('shards and passwords arrays must have same length');
-        }
+        validateReconstituteInputs({ shards, passwords });
         const secrets = _.zipWith(shards, passwords, (shard, password) => {
             return this.decrypt({ input: shard, password });
         });
-        const secretCombinations = generateCombinations(secrets, m);
-        const seeds = secretCombinations.map((currentCombination) => {
-            return shamir.combine(currentCombination);
-        });
-        const uniqueSeeds = _.uniq(seeds);
-        if (uniqueSeeds.length !== 1) {
-            return false;
-        }
-        const seed = _.first(uniqueSeeds);
-        const node = utxo_lib_1.bip32.fromSeed(Buffer.from(seed, 'hex'));
-        const restoredXpub = node.neutered().toBase58();
-        if (!_.isUndefined(xpub)) {
-            if (!_.isString(xpub)) {
-                throw new Error('xpub must be a string');
-            }
-            if (restoredXpub !== xpub) {
-                return false;
-            }
-        }
-        return true;
+        return verifyShardSecrets(secrets, m, xpub);
+    }
+    /**
+     * Async version of verifyShards with v2 encrypt/decrypt support.
+     * @param shards
+     * @param passwords
+     * @param m
+     * @param xpub
+     */
+    async verifyShardsAsync({ shards, passwords, m, xpub }) {
+        validateReconstituteInputs({ shards, passwords });
+        const secrets = await Promise.all(shards.map((shard, i) => this.decryptAsync({ input: shard, password: passwords[i] })));
+        return verifyShardSecrets(secrets, m, xpub);
     }
     /**
      * @deprecated - use `getSharedSecret()`
@@ -1264,7 +1682,7 @@ class BitGoAPI {
         if (!_.isObject(eckey)) {
             throw new Error('eckey object required');
         }
-        return sdk_core_1.getSharedSecret(eckey, Buffer.from(otherPubKeyHex, 'hex')).toString('hex');
+        return (0, sdk_core_1.getSharedSecret)(eckey, Buffer.from(otherPubKeyHex, 'hex')).toString('hex');
     }
     /**
      * Gets the user's private ECDH keychain
@@ -1279,6 +1697,34 @@ class BitGoAPI {
         }
         return this.keychains().get({ xpub: ecdhKeychainPub });
     }
+    /**
+     * Returns the user derived public and private ECDH keypair
+     * @param password password to decrypt the user's ECDH encrypted private key
+     * @param entId? optional enterprise id to check for permissions
+     */
+    async getEcdhKeypairPrivate(password, entId) {
+        const userSigningKey = await this.getSigningKeyForUser(entId);
+        const pubkeyOfAdminEcdhKeyHex = userSigningKey.derivedPubkey;
+        if (!userSigningKey.ecdhKeychain || !userSigningKey.derivationPath) {
+            throw new Error('Something went wrong with the user keychain. Please contact support@bitgo.com.');
+        }
+        const userEcdhKeychain = await this.getECDHKeychain(userSigningKey.ecdhKeychain);
+        let xprv;
+        try {
+            xprv = await this.decryptAsync({
+                password: password,
+                input: userEcdhKeychain.encryptedXprv,
+            });
+        }
+        catch (e) {
+            throw new Error('Incorrect password. Please try again.');
+        }
+        return {
+            derivedPubKey: pubkeyOfAdminEcdhKeyHex,
+            derivationPath: userSigningKey.derivationPath,
+            xprv,
+        };
+    }
     /**
      * @param params
      * - operatingSystem: one of ios, android
@@ -1344,6 +1790,7 @@ class BitGoAPI {
             .result();
         this._token = body.access_token;
         this._refreshToken = body.refresh_token;
+        await this._hmacAuthStrategy?.setToken?.(body.access_token);
         this._user = await this.me();
         return body;
     }
@@ -1375,13 +1822,40 @@ class BitGoAPI {
         const updateKeychainPasswordParams = { oldPassword, newPassword };
         const v1KeychainUpdatePWResult = await this.keychains().updatePassword(updateKeychainPasswordParams);
         const v2Keychains = await this.coin(coin).keychains().updatePassword(updateKeychainPasswordParams);
+        const [hmacOldPassword, hmacNewPassword] = await Promise.all([
+            this._hmacAuthStrategy.calculateHMAC(user.username, oldPassword),
+            this._hmacAuthStrategy.calculateHMAC(user.username, newPassword),
+        ]);
         const updatePasswordParams = {
             keychains: v1KeychainUpdatePWResult.keychains,
             v2_keychains: v2Keychains,
             version: v1KeychainUpdatePWResult.version,
-            oldPassword: this.calculateHMAC(user.username, oldPassword),
-            password: this.calculateHMAC(user.username, newPassword),
+            oldPassword: hmacOldPassword,
+            password: hmacNewPassword,
         };
+        // Calculate payload size in KB
+        const payloadSizeBytes = JSON.stringify(updatePasswordParams).length;
+        const payloadSizeKB = Math.ceil(payloadSizeBytes / 1024);
+        // Check if batching flow is enabled
+        try {
+            const batchingFlowCheck = await this.get(this.url('/user/checkBatchingPasswordFlow', 2))
+                .query({ payloadSize: payloadSizeKB.toString() })
+                .result();
+            if (batchingFlowCheck.isBatchingFlowEnabled) {
+                await this.processKeychainPasswordUpdatesInBatches(updatePasswordParams.keychains, updatePasswordParams.v2_keychains, batchingFlowCheck.maxBatchSizeKB, 3);
+                // Call changepassword API without keychains for batching flow
+                return this.post(this.url('/user/changepassword'))
+                    .send({
+                    version: updatePasswordParams.version,
+                    oldPassword: updatePasswordParams.oldPassword,
+                    password: updatePasswordParams.password,
+                })
+                    .result();
+            }
+        }
+        catch (error) {
+            // batching flow check failed
+        }
         return this.post(this.url('/user/changepassword')).send(updatePasswordParams).result();
     }
     /**
@@ -1576,10 +2050,121 @@ class BitGoAPI {
                 console.trace(err);
             }
         });
-        // use defaultConstants as the backup for keys that are not set in this._constants
-        return _.merge({}, sdk_core_1.defaultConstants(this.getEnv()), BitGoAPI._constants[this.getEnv()]);
+        // use defaultConstants as the backup for keys that are not set in BitGoAPI._constants
+        return _.merge({}, (0, sdk_core_1.defaultConstants)(this.getEnv()), BitGoAPI._constants?.[this.getEnv()] || {});
+    }
+    /**
+     * Execute an asset request which does not need HMAC validation
+     * @param url The URL for the asset request
+     * @returns {Promise<any>} The response body
+     */
+    async executeAssetRequest(url) {
+        const req = this.getAgentRequest('get', url);
+        req.set('BitGo-SDK-Version', this._version);
+        if (this._customProxyAgent) {
+            req.agent(this._customProxyAgent);
+        }
+        // Set the request timeout to just above 5 minutes by default
+        req.timeout(process.env.BITGO_TIMEOUT * 1000 || 305 * 1000);
+        if (this.getAdditionalHeadersCb) {
+            const additionalHeaders = this.getAdditionalHeadersCb('get', url);
+            for (const { key, value } of additionalHeaders) {
+                req.set(key, value);
+            }
+        }
+        const result = await req;
+        return result.body;
+    }
+    /**
+     * Pack keychains into batches using First Fit Decreasing (FFD) algorithm.
+     *
+     * @param keychains - V1 keychains
+     * @param v2Keychains - V2 keychains
+     * @param maxBatchSizeBytes - Maximum byte size per batch
+     * @private
+     */
+    packKeychainsFFD(keychains, v2Keychains, maxBatchSizeBytes) {
+        const entrySize = (id, value) => Buffer.byteLength(id, 'utf8') + Buffer.byteLength(value, 'utf8');
+        const items = [
+            ...Object.entries(keychains).map(([id, value]) => ({ id, value, sizeBytes: entrySize(id, value), isV2: false })),
+            ...Object.entries(v2Keychains).map(([id, value]) => ({ id, value, sizeBytes: entrySize(id, value), isV2: true })),
+        ].sort((a, b) => b.sizeBytes - a.sizeBytes);
+        const bins = [];
+        for (const item of items) {
+            if (item.sizeBytes > maxBatchSizeBytes) {
+                throw new Error(`Keychain with id ${item.id} exceeds the maximum batch size and cannot be processed`);
+            }
+            const target = bins.find((bin) => bin.sizeBytes + item.sizeBytes <= maxBatchSizeBytes);
+            if (target) {
+                if (item.isV2) {
+                    target.v2Batch[item.id] = item.value;
+                }
+                else {
+                    target.v1Batch[item.id] = item.value;
+                }
+                target.sizeBytes += item.sizeBytes;
+            }
+            else {
+                const newBin = {
+                    v1Batch: {},
+                    v2Batch: {},
+                    sizeBytes: item.sizeBytes,
+                };
+                if (item.isV2) {
+                    newBin.v2Batch[item.id] = item.value;
+                }
+                else {
+                    newBin.v1Batch[item.id] = item.value;
+                }
+                bins.push(newBin);
+            }
+        }
+        return bins;
+    }
+    /**
+     * Process keychain password updates in batches with retry logic.
+     * Uses First Fit Decreasing (FFD) bin packing to ensure no batch exceeds
+     * maxBatchSizeKB
+     *
+     * @param keychains - The v1 keychains to update
+     * @param v2Keychains - The v2 keychains to update
+     * @param maxBatchSizeKB - Maximum payload size per batch in kilobytes
+     * @param maxRetries - Maximum number of retries per batch
+     * @private
+     */
+    async processKeychainPasswordUpdatesInBatches(keychains, v2Keychains, maxBatchSizeKB, maxRetries) {
+        const maxBatchSizeBytes = maxBatchSizeKB * 1024;
+        const bins = this.packKeychainsFFD(keychains, v2Keychains, maxBatchSizeBytes);
+        for (let i = 0; i < bins.length; i++) {
+            const { v1Batch, v2Batch } = bins[i];
+            let retryCount = 0;
+            let success = false;
+            while (retryCount < maxRetries && !success) {
+                try {
+                    const response = await this.put(this.url('/user/keychains', 2))
+                        .send({
+                        keychains: v1Batch,
+                        v2_keychains: v2Batch,
+                    })
+                        .result();
+                    // Check if there are any failed keychains in the response
+                    const hasFailed = (response.failed?.v1 && Object.keys(response.failed.v1).length > 0) ||
+                        (response.failed?.v2 && Object.keys(response.failed.v2).length > 0);
+                    if (hasFailed) {
+                        throw new Error(`Batch ${i + 1} had failed keychains: ${JSON.stringify(response.failed)}`);
+                    }
+                    success = true;
+                }
+                catch (error) {
+                    retryCount++;
+                    if (retryCount >= maxRetries) {
+                        throw new Error(`Batch ${i + 1} failed after ${maxRetries} retries: ${error.message}`);
+                    }
+                }
+            }
+        }
     }
 }
 exports.BitGoAPI = BitGoAPI;
 BitGoAPI._testnetWarningMessage = false;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bitgoAPI.js","sourceRoot":"","sources":["../../src/bitgoAPI.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _ from 'lodash';\nimport { bip32, ECPairInterface } from '@bitgo-beta/utxo-lib';\nimport * as secp256k1 from 'secp256k1';\nimport * as bs58 from 'bs58';\nimport * as bitcoinMessage from 'bitcoinjs-message';\nimport {\n  handleResponseError,\n  handleResponseResult,\n  serializeRequestData,\n  setRequestQueryString,\n  toBitgoRequest,\n  verifyResponse,\n} from './api';\nimport debugLib from 'debug';\nimport * as superagent from 'superagent';\nimport * as urlLib from 'url';\nimport { createHmac } from 'crypto';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport {\n  AliasEnvironments,\n  BaseCoin,\n  BitGoBase,\n  BitGoRequest,\n  CoinConstructor,\n  common,\n  DecryptOptions,\n  defaultConstants,\n  EncryptOptions,\n  EnvironmentName,\n  getAddressP2PKH,\n  getSharedSecret,\n  GetSharingKeyOptions,\n  GetSigningKeyApi,\n  GlobalCoinFactory,\n  IRequestTracer,\n  makeRandomKey,\n  sanitizeLegacyPath,\n} from '@bitgo-beta/sdk-core';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport {\n  AccessTokenOptions,\n  AddAccessTokenResponse,\n  AddAccessTokenOptions,\n  AuthenticateOptions,\n  AuthenticateWithAuthCodeOptions,\n  BitGoAPIOptions,\n  BitGoJson,\n  BitGoSimulateWebhookOptions,\n  CalculateHmacSubjectOptions,\n  CalculateRequestHeadersOptions,\n  CalculateRequestHmacOptions,\n  ChangePasswordOptions,\n  DeprecatedVerifyAddressOptions,\n  EstimateFeeOptions,\n  ExtendTokenOptions,\n  GetEcdhSecretOptions,\n  GetUserOptions,\n  ListWebhookNotificationsOptions,\n  PingOptions,\n  ProcessedAuthenticationOptions,\n  ReconstitutedSecret,\n  ReconstituteSecretOptions,\n  RegisterPushTokenOptions,\n  RemoveAccessTokenOptions,\n  RequestHeaders,\n  SplitSecret,\n  SplitSecretOptions,\n  TokenIssuance,\n  TokenIssuanceResponse,\n  UnlockOptions,\n  User,\n  VerifyPasswordOptions,\n  VerifyPushTokenOptions,\n  VerifyResponseInfo,\n  VerifyResponseOptions,\n  VerifyShardsOptions,\n  WebhookOptions,\n} from './types';\nimport shamir = require('secrets.js-grempe');\nimport pjson = require('../package.json');\nimport { decrypt, encrypt } from './encrypt';\nimport { isBrowser, isWebWorker } from 'browser-or-node';\nconst debug = debugLib('bitgo:api');\n\nconst Blockchain = require('./v1/blockchain');\nconst Keychains = require('./v1/keychains');\nimport Wallet = require('./v1/wallet');\nconst Wallets = require('./v1/wallets');\nconst Markets = require('./v1/markets');\nconst PendingApprovals = require('./v1/pendingapprovals');\nconst TravelRule = require('./v1/travelRule');\nconst TransactionBuilder = require('./v1/transactionBuilder');\n\nif (!isBrowser && !isWebWorker) {\n  debug('enabling superagent-proxy wrapper');\n  require('superagent-proxy')(superagent);\n}\n\nconst patchedRequestMethods = ['get', 'post', 'put', 'del', 'patch'] as const;\n\nexport class BitGoAPI implements BitGoBase {\n  // v1 types\n  protected _keychains: any;\n  protected _wallets: any;\n  protected _markets?: any;\n  protected _blockchain?: any;\n  protected _travelRule?: any;\n  protected _pendingApprovals?: any;\n\n  protected static _constants: any;\n  protected static _constantsExpire: any;\n  protected static _testnetWarningMessage = false;\n  public readonly env: EnvironmentName;\n  protected readonly _baseUrl: string;\n  protected readonly _baseApiUrl: string;\n  protected readonly _baseApiUrlV2: string;\n  protected readonly _env: EnvironmentName;\n  protected readonly _authVersion: Exclude<BitGoAPIOptions['authVersion'], undefined> = 2;\n  protected _hmacVerification = true;\n  protected readonly _proxy?: string;\n  protected _user?: User;\n  protected _extensionKey?: ECPairInterface;\n  protected _reqId?: IRequestTracer;\n  protected _token?: string;\n  protected _version = pjson.version;\n  protected _userAgent?: string;\n  protected _ecdhXprv?: string;\n  protected _refreshToken?: string;\n  protected readonly _clientId?: string;\n  protected readonly _clientSecret?: string;\n  protected _validate: boolean;\n  public readonly cookiesPropagationEnabled: boolean;\n\n  constructor(params: BitGoAPIOptions = {}) {\n    this.cookiesPropagationEnabled = false;\n    if (\n      !common.validateParams(\n        params,\n        [],\n        [\n          'accessToken',\n          'userAgent',\n          'customRootURI',\n          'customBitcoinNetwork',\n          'serverXpub',\n          'stellarFederationServerUrl',\n        ]\n      ) ||\n      (params.useProduction && !_.isBoolean(params.useProduction))\n    ) {\n      throw new Error('invalid argument');\n    }\n\n    // By default, we operate on the test server.\n    // Deprecate useProduction in the future\n    let env: EnvironmentName;\n\n    if (params.useProduction) {\n      if (params.env && params.env !== 'prod') {\n        throw new Error('cannot use useProduction when env=' + params.env);\n      }\n      env = 'prod';\n    } else if (\n      params.customRootURI ||\n      params.customBitcoinNetwork ||\n      params.customSigningAddress ||\n      params.serverXpub ||\n      process.env.BITGO_CUSTOM_ROOT_URI ||\n      process.env.BITGO_CUSTOM_BITCOIN_NETWORK\n    ) {\n      // for branch deploys, we want to be able to specify custom endpoints while still\n      // maintaining the name of specified the environment\n      env = params.env === 'branch' ? 'branch' : 'custom';\n      if (params.customRootURI) {\n        common.Environments[env].uri = params.customRootURI;\n      }\n      if (params.customBitcoinNetwork) {\n        common.Environments[env].network = params.customBitcoinNetwork;\n      }\n      if (params.customSigningAddress) {\n        (common.Environments[env] as any).customSigningAddress = params.customSigningAddress;\n      }\n      if (params.serverXpub) {\n        common.Environments[env].serverXpub = params.serverXpub;\n      }\n      if (params.stellarFederationServerUrl) {\n        common.Environments[env].stellarFederationServerUrl = params.stellarFederationServerUrl;\n      }\n      if (params.cookiesPropagationEnabled) {\n        this.cookiesPropagationEnabled = true;\n      }\n    } else {\n      env = params.env || (process.env.BITGO_ENV as EnvironmentName);\n    }\n\n    // if this hasn't been set to true already some conditions are not met\n    if (params.cookiesPropagationEnabled && !this.cookiesPropagationEnabled) {\n      throw new Error('Cookies are only allowed when custom URIs are in use');\n    }\n\n    if (params.authVersion !== undefined) {\n      this._authVersion = params.authVersion;\n    }\n\n    // if this env is an alias, swap it out with the equivalent supported environment\n    if (env in AliasEnvironments) {\n      env = AliasEnvironments[env];\n    }\n\n    if (env === 'custom' && _.isUndefined(common.Environments[env].uri)) {\n      throw new Error(\n        'must use --customrooturi or set the BITGO_CUSTOM_ROOT_URI environment variable when using the custom environment'\n      );\n    }\n\n    if (env) {\n      if (common.Environments[env]) {\n        this._baseUrl = common.Environments[env].uri;\n      } else {\n        throw new Error('invalid environment ' + env + '. Supported environments: prod, test, dev, latest');\n      }\n    } else {\n      env = 'test';\n      if (!BitGoAPI._testnetWarningMessage) {\n        BitGoAPI._testnetWarningMessage = true;\n        console.log('BitGo SDK env not set - defaulting to test at test.bitgo.com.');\n      }\n      this._baseUrl = common.Environments[env].uri;\n    }\n    this._env = this.env = env;\n\n    const supportedApiTokens = ['etherscanApiToken', 'polygonscanApiToken'];\n\n    Object.keys(params).forEach((key) => {\n      if (supportedApiTokens.includes(key)) {\n        common.Environments[env][key] = params[key];\n      }\n    });\n\n    common.setNetwork(common.Environments[env].network);\n\n    this._baseApiUrl = this._baseUrl + '/api/v1';\n    this._baseApiUrlV2 = this._baseUrl + '/api/v2';\n    this._token = params.accessToken;\n    this._userAgent = params.userAgent || 'BitGoJS-api/' + this.version();\n    this._reqId = undefined;\n    this._refreshToken = params.refreshToken;\n    this._clientId = params.clientId;\n    this._clientSecret = params.clientSecret;\n    this._keychains = null;\n    this._wallets = null;\n\n    // whether to perform extra client-side validation for some things, such as\n    // address validation or signature validation. defaults to true, but can be\n    // turned off by setting to false. can also be overridden individually in the\n    // functions that use it.\n    this._validate = params.validate === undefined ? true : params.validate;\n\n    if (!params.hmacVerification && params.hmacVerification !== undefined) {\n      if ((env == 'prod' || env == 'adminProd') && common.Environments[env].hmacVerificationEnforced) {\n        throw new Error(`Cannot disable request HMAC verification in environment ${this.getEnv()}`);\n      }\n      debug('HMAC verification explicitly disabled by constructor option');\n      this._hmacVerification = params.hmacVerification;\n    }\n    if (!params.proxy && process.env.BITGO_USE_PROXY) {\n      params.proxy = process.env.BITGO_USE_PROXY;\n    }\n\n    if ((process as any).browser && params.proxy) {\n      throw new Error('cannot use https proxy params while in browser');\n    }\n\n    this._proxy = params.proxy;\n\n    // capture outer stack so we have useful debug information if fetch constants fails\n    const e = new Error();\n\n    // Kick off first load of constants\n    this.fetchConstants().catch((err) => {\n      if (err) {\n        // make sure an error does not terminate the entire script\n        console.error('failed to fetch initial client constants from BitGo');\n        debug(e.stack);\n      }\n    });\n  }\n\n  /**\n   * Get a superagent request for specified http method and URL configured to the SDK configuration\n   * @param method - http method for the new request\n   * @param url - URL for the new request\n   */\n  protected getAgentRequest(method: (typeof patchedRequestMethods)[number], url: string): superagent.SuperAgentRequest {\n    let req: superagent.SuperAgentRequest = superagent[method](url);\n    if (this.cookiesPropagationEnabled) {\n      req = req.withCredentials();\n    }\n    return req;\n  }\n  /**\n   * Create a basecoin object\n   * @param name\n   */\n  public coin(name: string): BaseCoin {\n    return GlobalCoinFactory.getInstance(this, name);\n  }\n\n  /**\n   * Return the current BitGo environment\n   */\n  getEnv(): EnvironmentName {\n    return this._env;\n  }\n\n  /**\n   * Return the current auth version used for requests to the BitGo server\n   */\n  getAuthVersion(): number {\n    return this._authVersion;\n  }\n\n  /**\n   * This is a patching function which can apply our authorization\n   * headers to any outbound request.\n   * @param method\n   */\n  private requestPatch(method: (typeof patchedRequestMethods)[number], url: string) {\n    let req = this.getAgentRequest(method, url);\n    if (this._proxy) {\n      debug('proxying request through %s', this._proxy);\n      req = req.proxy(this._proxy);\n    }\n\n    const originalThen = req.then.bind(req);\n    req.then = (onfulfilled, onrejected) => {\n      // intercept a request before it's submitted to the server for v2 authentication (based on token)\n      if (this._version) {\n        // TODO - decide where to get version\n        req.set('BitGo-SDK-Version', this._version);\n      }\n\n      if (!_.isUndefined(this._reqId)) {\n        req.set('Request-ID', this._reqId.toString());\n\n        // increment after setting the header so the sequence numbers start at 0\n        this._reqId.inc();\n\n        // request ids must be set before each request instead of being kept\n        // inside the bitgo object. This is to prevent reentrancy issues where\n        // multiple simultaneous requests could cause incorrect reqIds to be used\n        delete this._reqId;\n      }\n\n      // prevent IE from caching requests\n      req.set('If-Modified-Since', 'Mon, 26 Jul 1997 05:00:00 GMT');\n\n      if (!(process as any).browser && this._userAgent) {\n        // If not in the browser, set the User-Agent. Browsers don't allow\n        // setting of User-Agent, so we must disable this when run in the\n        // browser (browserify sets process.browser).\n        req.set('User-Agent', this._userAgent);\n      }\n\n      // Set the request timeout to just above 5 minutes by default\n      req.timeout((process.env.BITGO_TIMEOUT as any) * 1000 || 305 * 1000);\n\n      // if there is no token, and we're not logged in, the request cannot be v2 authenticated\n      req.isV2Authenticated = true;\n      req.authenticationToken = this._token;\n      // some of the older tokens appear to be only 40 characters long\n      if ((this._token && this._token.length !== 67 && this._token.indexOf('v2x') !== 0) || req.forceV1Auth) {\n        // use the old method\n        req.isV2Authenticated = false;\n\n        req.set('Authorization', 'Bearer ' + this._token);\n        debug('sending v1 %s request to %s with token %s', method, url, this._token?.substr(0, 8));\n        return originalThen(onfulfilled).catch(onrejected);\n      }\n\n      req.set('BitGo-Auth-Version', this._authVersion === 3 ? '3.0' : '2.0');\n\n      if (this._token) {\n        const data = serializeRequestData(req);\n        setRequestQueryString(req);\n\n        const requestProperties = this.calculateRequestHeaders({\n          url: req.url,\n          token: this._token,\n          method,\n          text: data || '',\n        });\n        req.set('Auth-Timestamp', requestProperties.timestamp.toString());\n\n        // we're not sending the actual token, but only its hash\n        req.set('Authorization', 'Bearer ' + requestProperties.tokenHash);\n        debug('sending v2 %s request to %s with token %s', method, url, this._token?.substr(0, 8));\n\n        // set the HMAC\n        req.set('HMAC', requestProperties.hmac);\n      }\n\n      /**\n       * Verify the response before calling the original onfulfilled handler,\n       * and make sure onrejected is called if a verification error is encountered\n       */\n      const newOnFulfilled = onfulfilled\n        ? (response: superagent.Response) => {\n            // HMAC verification is only allowed to be skipped in certain environments.\n            // This is checked in the constructor, but checking it again at request time\n            // will help prevent against tampering of this property after the object is created\n            if (!this._hmacVerification && !common.Environments[this.getEnv()].hmacVerificationEnforced) {\n              return onfulfilled(response);\n            }\n\n            const verifiedResponse = verifyResponse(this, this._token, method, req, response);\n            return onfulfilled(verifiedResponse);\n          }\n        : null;\n      return originalThen(newOnFulfilled).catch(onrejected);\n    };\n    return toBitgoRequest(req);\n  }\n\n  get(url: string): BitGoRequest {\n    return this.requestPatch('get', url);\n  }\n  post(url: string): BitGoRequest {\n    return this.requestPatch('post', url);\n  }\n  put(url: string): BitGoRequest {\n    return this.requestPatch('put', url);\n  }\n  del(url: string): BitGoRequest {\n    return this.requestPatch('del', url);\n  }\n  patch(url: string): BitGoRequest {\n    return this.requestPatch('patch', url);\n  }\n\n  /**\n   * Calculate the HMAC for the given key and message\n   * @param key {String} - the key to use for the HMAC\n   * @param message {String} - the actual message to HMAC\n   * @returns {*} - the result of the HMAC operation\n   */\n  calculateHMAC(key: string, message: string): string {\n    return createHmac('sha256', key).update(message).digest('hex');\n  }\n\n  /**\n   * Calculate the subject string that is to be HMAC'ed for a HTTP request or response\n   * @param urlPath request url, including query params\n   * @param text request body text\n   * @param timestamp request timestamp from `Date.now()`\n   * @param statusCode Only set for HTTP responses, leave blank for requests\n   * @param method request method\n   * @returns {string}\n   */\n  calculateHMACSubject({ urlPath, text, timestamp, statusCode, method }: CalculateHmacSubjectOptions): string {\n    const urlDetails = urlLib.parse(urlPath);\n    const queryPath = urlDetails.query && urlDetails.query.length > 0 ? urlDetails.path : urlDetails.pathname;\n    if (!_.isUndefined(statusCode) && _.isInteger(statusCode) && _.isFinite(statusCode)) {\n      if (this._authVersion === 3) {\n        return [method.toUpperCase(), timestamp, queryPath, statusCode, text].join('|');\n      }\n      return [timestamp, queryPath, statusCode, text].join('|');\n    }\n    if (this._authVersion === 3) {\n      return [method.toUpperCase(), timestamp, '3.0', queryPath, text].join('|');\n    }\n    return [timestamp, queryPath, text].join('|');\n  }\n\n  /**\n   * Calculate the HMAC for an HTTP request\n   */\n  calculateRequestHMAC({ url: urlPath, text, timestamp, token, method }: CalculateRequestHmacOptions): string {\n    const signatureSubject = this.calculateHMACSubject({ urlPath, text, timestamp, method });\n\n    // calculate the HMAC\n    return this.calculateHMAC(token, signatureSubject);\n  }\n\n  /**\n   * Calculate request headers with HMAC\n   */\n  calculateRequestHeaders({ url, text, token, method }: CalculateRequestHeadersOptions): RequestHeaders {\n    const timestamp = Date.now();\n    const hmac = this.calculateRequestHMAC({ url, text, timestamp, token, method });\n\n    // calculate the SHA256 hash of the token\n    const hashDigest = sjcl.hash.sha256.hash(token);\n    const tokenHash = sjcl.codec.hex.fromBits(hashDigest);\n    return {\n      hmac,\n      timestamp,\n      tokenHash,\n    };\n  }\n\n  /**\n   * Verify the HMAC for an HTTP response\n   */\n  verifyResponse({\n    url: urlPath,\n    statusCode,\n    text,\n    timestamp,\n    token,\n    hmac,\n    method,\n  }: VerifyResponseOptions): VerifyResponseInfo {\n    const signatureSubject = this.calculateHMACSubject({\n      urlPath,\n      text,\n      timestamp,\n      statusCode,\n      method,\n    });\n\n    // calculate the HMAC\n    const expectedHmac = this.calculateHMAC(token, signatureSubject);\n\n    // determine if the response is still within the validity window (5 minute window)\n    const now = Date.now();\n    const isInResponseValidityWindow = timestamp >= now - 1000 * 60 * 5 && timestamp <= now;\n\n    // verify the HMAC and timestamp\n    return {\n      isValid: expectedHmac === hmac,\n      expectedHmac,\n      signatureSubject,\n      isInResponseValidityWindow,\n      verificationTime: now,\n    };\n  }\n\n  /**\n   * Fetch useful constant values from the BitGo server.\n   * These values do change infrequently, so they need to be fetched,\n   * but are unlikely to change during the lifetime of a BitGo object,\n   * so they can safely cached.\n   */\n  async fetchConstants(): Promise<any> {\n    const env = this.getEnv();\n\n    if (!BitGoAPI._constants) {\n      BitGoAPI._constants = {};\n    }\n    if (!BitGoAPI._constantsExpire) {\n      BitGoAPI._constantsExpire = {};\n    }\n\n    if (BitGoAPI._constants[env] && BitGoAPI._constantsExpire[env] && new Date() < BitGoAPI._constantsExpire[env]) {\n      return BitGoAPI._constants[env];\n    }\n\n    // client constants call cannot be authenticated using the normal HMAC validation\n    // scheme, so we need to use a raw superagent instance to do this request.\n    // Proxy settings must still be respected however\n    const resultPromise = this.getAgentRequest('get', this.url('/client/constants'));\n    resultPromise.set('BitGo-SDK-Version', this._version);\n    const result = await (this._proxy ? resultPromise.proxy(this._proxy) : resultPromise);\n    BitGoAPI._constants[env] = result.body.constants;\n\n    if (result.body?.ttl && typeof result.body?.ttl === 'number') {\n      BitGoAPI._constantsExpire[env] = new Date(new Date().getTime() + (result.body.ttl as number) * 1000);\n    }\n\n    return BitGoAPI._constants[env];\n  }\n\n  /**\n   * Create a url for calling BitGo platform APIs\n   * @param path\n   * @param version\n   */\n  url(path: string, version = 1): string {\n    const baseUrl = version === 2 ? this._baseApiUrlV2 : this._baseApiUrl;\n    return baseUrl + path;\n  }\n\n  /**\n   * Create a url for calling BitGo microservice APIs\n   */\n  microservicesUrl(path: string): string {\n    return this._baseUrl + path;\n  }\n\n  /**\n   * Gets the version of the BitGoJS package\n   */\n  version(): string {\n    return this._version;\n  }\n\n  /**\n   * Test connectivity to the server\n   * @param params\n   */\n  ping({ reqId }: PingOptions = {}): Promise<any> {\n    if (reqId) {\n      this._reqId = reqId;\n    }\n\n    return this.get(this.url('/ping')).result();\n  }\n\n  /**\n   * Set a request tracer to provide request IDs during multi-request workflows\n   */\n  setRequestTracer(reqTracer: IRequestTracer): void {\n    if (reqTracer) {\n      this._reqId = reqTracer;\n    }\n  }\n\n  /**\n   * Utility function to encrypt locally.\n   */\n  encrypt(params: EncryptOptions): string {\n    common.validateParams(params, ['input', 'password'], []);\n    if (!params.password) {\n      throw new Error(`cannot encrypt without password`);\n    }\n    return encrypt(params.password, params.input);\n  }\n\n  /**\n   * Decrypt an encrypted string locally.\n   */\n  decrypt(params: DecryptOptions): string {\n    params = params || {};\n    common.validateParams(params, ['input', 'password'], []);\n    if (!params.password) {\n      throw new Error(`cannot decrypt without password`);\n    }\n    try {\n      return decrypt(params.password, params.input);\n    } catch (error) {\n      if (error.message.includes(\"ccm: tag doesn't match\")) {\n        error.message = 'password error - ' + error.message;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Serialize this BitGo object to a JSON object.\n   *\n   * Caution: contains sensitive data\n   */\n  toJSON(): BitGoJson {\n    return {\n      user: this._user,\n      token: this._token,\n      extensionKey: this._extensionKey ? this._extensionKey.toWIF() : undefined,\n      ecdhXprv: this._ecdhXprv,\n    };\n  }\n\n  /**\n   * Get the current user\n   */\n  user(): User | undefined {\n    return this._user;\n  }\n\n  /**\n   * Deserialize a JSON serialized BitGo object.\n   *\n   * Overwrites the properties on the current BitGo object with\n   * those of the deserialzed object.\n   *\n   * @param json\n   */\n  fromJSON(json: BitGoJson): void {\n    this._user = json.user;\n    this._token = json.token;\n    this._ecdhXprv = json.ecdhXprv;\n    if (json.extensionKey) {\n      const network = common.Environments[this.getEnv()].network;\n      this._extensionKey = utxolib.ECPair.fromWIF(\n        json.extensionKey,\n        utxolib.networks[network] as utxolib.BitcoinJSNetwork\n      );\n    }\n  }\n\n  /**\n   * Process the username, password and otp into an object containing the username and hashed password, ready to\n   * send to bitgo for authentication.\n   */\n  preprocessAuthenticationParams({\n    username,\n    password,\n    otp,\n    forceSMS,\n    extensible,\n    trust,\n  }: AuthenticateOptions): ProcessedAuthenticationOptions {\n    if (!_.isString(username)) {\n      throw new Error('expected string username');\n    }\n\n    if (!_.isString(password)) {\n      throw new Error('expected string password');\n    }\n\n    const lowerName = username.toLowerCase();\n    // Calculate the password HMAC so we don't send clear-text passwords\n    const hmacPassword = this.calculateHMAC(lowerName, password);\n\n    const authParams: ProcessedAuthenticationOptions = {\n      email: lowerName,\n      password: hmacPassword,\n      forceSMS: !!forceSMS,\n    };\n\n    if (otp) {\n      authParams.otp = otp;\n      if (trust) {\n        authParams.trust = 1;\n      }\n    }\n\n    if (extensible) {\n      this._extensionKey = makeRandomKey();\n      authParams.extensible = true;\n      authParams.extensionAddress = getAddressP2PKH(this._extensionKey);\n    }\n\n    return authParams;\n  }\n\n  /**\n   * Synchronous method for activating an access token.\n   */\n  authenticateWithAccessToken({ accessToken }: AccessTokenOptions): void {\n    debug('now authenticating with access token %s', accessToken.substring(0, 8));\n    this._token = accessToken;\n  }\n\n  /**\n   * Login to the bitgo platform.\n   */\n  async authenticate(params: AuthenticateOptions): Promise<any> {\n    try {\n      if (!_.isObject(params)) {\n        throw new Error('required object params');\n      }\n\n      if (!_.isString(params.password)) {\n        throw new Error('expected string password');\n      }\n\n      const forceV1Auth = !!params.forceV1Auth;\n      const authParams = this.preprocessAuthenticationParams(params);\n      const password = params.password;\n\n      if (this._token) {\n        return new Error('already logged in');\n      }\n\n      const authUrl = this.microservicesUrl('/api/auth/v1/session');\n      const request = this.post(authUrl);\n\n      if (forceV1Auth) {\n        request.forceV1Auth = true;\n        // tell the server that the client was forced to downgrade the authentication protocol\n        authParams.forceV1Auth = true;\n        debug('forcing v1 auth for call to authenticate');\n      }\n      const response: superagent.Response = await request.send(authParams);\n      // extract body and user information\n      const body = response.body;\n      this._user = body.user;\n\n      if (body.access_token) {\n        this._token = body.access_token;\n        // if the downgrade was forced, adding a warning message might be prudent\n      } else {\n        // check the presence of an encrypted ECDH xprv\n        // if not present, legacy account\n        const encryptedXprv = body.encryptedECDHXprv;\n        if (!encryptedXprv) {\n          throw new Error('Keychain needs encryptedXprv property');\n        }\n\n        const responseDetails = this.handleTokenIssuance(response.body, password);\n        this._token = responseDetails.token;\n        this._ecdhXprv = responseDetails.ecdhXprv;\n\n        // verify the response's authenticity\n        verifyResponse(this, responseDetails.token, 'post', request, response);\n\n        // add the remaining component for easier access\n        response.body.access_token = this._token;\n      }\n\n      return handleResponseResult<any>()(response);\n    } catch (e) {\n      handleResponseError(e);\n    }\n  }\n\n  /**\n   *\n   * @param responseBody Response body object\n   * @param password Password for the symmetric decryption\n   */\n  handleTokenIssuance(responseBody: TokenIssuanceResponse, password?: string): TokenIssuance {\n    // make sure the response body contains the necessary properties\n    common.validateParams(responseBody, ['derivationPath'], ['encryptedECDHXprv']);\n\n    const environment = this._env;\n    const environmentConfig = common.Environments[environment];\n    const serverXpub = environmentConfig.serverXpub;\n    let ecdhXprv = this._ecdhXprv;\n    if (!ecdhXprv) {\n      if (!password || !responseBody.encryptedECDHXprv) {\n        throw new Error('ecdhXprv property must be set or password and encrypted encryptedECDHXprv must be provided');\n      }\n      try {\n        ecdhXprv = this.decrypt({\n          input: responseBody.encryptedECDHXprv,\n          password: password,\n        });\n      } catch (e) {\n        e.errorCode = 'ecdh_xprv_decryption_failure';\n        console.error('Failed to decrypt encryptedECDHXprv.');\n        throw e;\n      }\n    }\n\n    // construct HDNode objects for client's xprv and server's xpub\n    const clientHDNode = bip32.fromBase58(ecdhXprv);\n    const serverHDNode = bip32.fromBase58(serverXpub);\n\n    // BIP32 derivation path is applied to both client and server master keys\n    const derivationPath = sanitizeLegacyPath(responseBody.derivationPath);\n    const clientDerivedNode = clientHDNode.derivePath(derivationPath);\n    const serverDerivedNode = serverHDNode.derivePath(derivationPath);\n\n    const publicKey = serverDerivedNode.publicKey;\n    const secretKey = clientDerivedNode.privateKey;\n    if (!secretKey) {\n      throw new Error('no client private Key');\n    }\n    const secret = Buffer.from(\n      // FIXME(BG-34386): we should use `secp256k1.ecdh()` in the future\n      //                  see discussion here https://github.com/bitcoin-core/secp256k1/issues/352\n      secp256k1.publicKeyTweakMul(publicKey, secretKey)\n    ).toString('hex');\n\n    // decrypt token with symmetric ECDH key\n    let response: TokenIssuance;\n    try {\n      response = {\n        token: this.decrypt({\n          input: responseBody.encryptedToken,\n          password: secret,\n        }),\n      };\n    } catch (e) {\n      e.errorCode = 'token_decryption_failure';\n      console.error('Failed to decrypt token.');\n      throw e;\n    }\n    if (!this._ecdhXprv) {\n      response.ecdhXprv = ecdhXprv;\n    }\n    return response;\n  }\n\n  /**\n   */\n  verifyPassword(params: VerifyPasswordOptions = {}): Promise<any> {\n    if (!_.isString(params.password)) {\n      throw new Error('missing required string password');\n    }\n\n    if (!this._user || !this._user.username) {\n      throw new Error('no current user');\n    }\n    const hmacPassword = this.calculateHMAC(this._user.username, params.password);\n\n    return this.post(this.url('/user/verifypassword')).send({ password: hmacPassword }).result('valid');\n  }\n\n  /**\n   * Clear out all state from this BitGo object, effectively logging out the current user.\n   */\n  clear(): void {\n    // TODO: are there any other fields which should be cleared?\n    this._user = undefined;\n    this._token = undefined;\n    this._refreshToken = undefined;\n    this._ecdhXprv = undefined;\n  }\n\n  /**\n   * Use refresh token to get new access token.\n   * If the refresh token is null/defined, then we use the stored token from auth\n   */\n  async refreshToken(params: { refreshToken?: string } = {}): Promise<any> {\n    common.validateParams(params, [], ['refreshToken']);\n\n    const refreshToken = params.refreshToken || this._refreshToken;\n\n    if (!refreshToken) {\n      throw new Error('Must provide refresh token or have authenticated with Oauth before');\n    }\n\n    if (!this._clientId || !this._clientSecret) {\n      throw new Error('Need client id and secret set first to use this');\n    }\n\n    const body = await this.post(this._baseUrl + '/oauth/token')\n      .send({\n        grant_type: 'refresh_token',\n        refresh_token: refreshToken,\n        client_id: this._clientId,\n        client_secret: this._clientSecret,\n      })\n      .result();\n    this._token = body.access_token;\n    this._refreshToken = body.refresh_token;\n    return body;\n  }\n\n  /**\n   *\n   * listAccessTokens\n   * Get information on all of the BitGo access tokens on the user\n   * @return {\n   *  id: <id of the token>\n   *  label: <the user-provided label for this token>\n   *  user: <id of the user on the token>\n   *  enterprise <id of the enterprise this token is valid for>\n   *  client: <the auth client that this token belongs to>\n   *  scope: <list of allowed OAuth scope values>\n   *  created: <date the token was created>\n   *  expires: <date the token will expire>\n   *  origin: <the origin for which this token is valid>\n   *  isExtensible: <flag indicating if the token can be extended>\n   *  extensionAddress: <address whose private key's signature is necessary for extensions>\n   *  unlock: <info for actions that require an unlock before firing>\n   * }\n   */\n  async listAccessTokens(): Promise<any> {\n    return this.get(this.url('/user/accesstoken')).send().result('accessTokens');\n  }\n\n  /**\n   * addAccessToken\n   * Add a BitGo API Access Token to the current user account\n   * @param params {\n   *    otp: (required) <valid otp code>\n   *    label: (required) <label for the token>\n   *    duration: <length of time in seconds the token will be valid for>\n   *    ipRestrict: <array of IP address strings to whitelist>\n   *    txValueLimit: <number of outgoing satoshis allowed on this token>\n   *    scope: (required) <authorization scope of the requested token>\n   * }\n   * @return {\n   *    id: <id of the token>\n   *    token: <access token hex string to be used for BitGo API request verification>\n   *    label: <user-provided label for this token>\n   *    user: <id of the user on the token>\n   *    enterprise <id of the enterprise this token is valid for>\n   *    client: <the auth client that this token belongs to>\n   *    scope: <list of allowed OAuth scope values>\n   *    created: <date the token was created>\n   *    expires: <date the token will expire>\n   *    origin: <the origin for which this token is valid>\n   *    isExtensible: <flag indicating if the token can be extended>\n   *    extensionAddress: <address whose private key's signature is necessary for extensions>\n   *    unlock: <info for actions that require an unlock before firing>\n   * }\n   */\n  async addAccessToken(params: AddAccessTokenOptions): Promise<AddAccessTokenResponse> {\n    try {\n      if (!_.isString(params.label)) {\n        throw new Error('required string label');\n      }\n\n      // check non-string params\n      if (params.duration) {\n        if (!_.isNumber(params.duration) || params.duration < 0) {\n          throw new Error('duration must be a non-negative number');\n        }\n      }\n      if (params.ipRestrict) {\n        if (!_.isArray(params.ipRestrict)) {\n          throw new Error('ipRestrict must be an array');\n        }\n        _.forEach(params.ipRestrict, (ipAddr) => {\n          if (!_.isString(ipAddr)) {\n            throw new Error('ipRestrict must be an array of IP address strings');\n          }\n        });\n      }\n      if (params.txValueLimit) {\n        if (!_.isNumber(params.txValueLimit)) {\n          throw new Error('txValueLimit must be a number');\n        }\n        if (params.txValueLimit < 0) {\n          throw new Error('txValueLimit must be a non-negative number');\n        }\n      }\n      if (params.scope && params.scope.length > 0) {\n        if (!_.isArray(params.scope)) {\n          throw new Error('scope must be an array');\n        }\n      } else {\n        throw new Error('must specify scope for token');\n      }\n\n      const authUrl = this.microservicesUrl('/api/auth/v1/accesstoken');\n      const request = this.post(authUrl);\n\n      if (!this._ecdhXprv) {\n        // without a private key, the user cannot decrypt the new access token the server will send\n        request.forceV1Auth = true;\n        debug('forcing v1 auth for adding access token using token %s', this._token?.substr(0, 8));\n      }\n\n      const response = await request.send(params);\n      if (request.forceV1Auth) {\n        (response as any).body.warning = 'A protocol downgrade has occurred because this is a legacy account.';\n        return handleResponseResult<AddAccessTokenResponse>()(response);\n      }\n\n      // verify the authenticity of the server's response before proceeding any further\n      verifyResponse(this, this._token, 'post', request, response);\n\n      const responseDetails = this.handleTokenIssuance(response.body);\n      response.body.token = responseDetails.token;\n\n      return handleResponseResult<AddAccessTokenResponse>()(response);\n    } catch (e) {\n      handleResponseError(e);\n    }\n  }\n\n  /**\n   * Sets the expire time of an access token matching either the id or label to the current date, effectively deleting it\n   *\n   * Params:\n   * id: <id of the access token to be deleted>\n   * label: <label of the access token to be deleted>\n   *\n   * Returns:\n   * id: <id of the token>\n   * label: <user-provided label for this token>\n   * user: <id of the user on the token>\n   * enterprise <id of the enterprise this token is valid for>\n   * client: <the auth client that this token belongs to>\n   * scope: <list of allowed OAuth scope values>\n   * created: <date the token was created>\n   * expires: <date the token will expire>\n   * origin: <the origin for which this token is valid>\n   * isExtensible: <flag indicating if the token can be extended>\n   * extensionAddress: <address whose private key's signature is ne*cessary for extensions>\n   * unlock: <info for actions that require an unlock before firing>\n   * @param params\n   */\n  async removeAccessToken({ id, label }: RemoveAccessTokenOptions): Promise<any> {\n    if ((!id && !label) || (id && label)) {\n      throw new Error('must provide exactly one of id or label');\n    }\n    if (id) {\n      return this.del(this.url(`/user/accesstoken/${id}`))\n        .send()\n        .result();\n    }\n\n    const tokens = await this.listAccessTokens();\n\n    if (!tokens) {\n      throw new Error('token with this label does not exist');\n    }\n\n    const matchingTokens = _.filter(tokens, { label });\n    if (matchingTokens.length > 1) {\n      throw new Error('ambiguous call: multiple tokens matching this label');\n    }\n    if (matchingTokens.length === 0) {\n      throw new Error('token with this label does not exist');\n    }\n\n    return this.del(this.url(`/user/accesstoken/${matchingTokens[0].id}`))\n      .send()\n      .result();\n  }\n\n  /**\n   * Generate a random password\n   * @param   {Number} numWords     Number of 32-bit words\n   * @returns {String}          base58 random password\n   */\n  generateRandomPassword(numWords = 5): string {\n    const bytes = sjcl.codec.bytes.fromBits(sjcl.random.randomWords(numWords));\n    return bs58.encode(bytes);\n  }\n\n  /**\n   * Logout of BitGo\n   */\n  async logout(): Promise<any> {\n    const result = await this.get(this.url('/user/logout')).result();\n    this.clear();\n    return result;\n  }\n\n  /**\n   * Get a user by ID (name/email only)\n   * @param id\n   *\n   * @deprecated\n   */\n  async getUser({ id }: GetUserOptions): Promise<any> {\n    if (!_.isString(id)) {\n      throw new Error('expected string id');\n    }\n    return this.get(this.url(`/user/${id}`)).result('user');\n  }\n  /**\n   * Get the current logged in user\n   */\n  async me(): Promise<any> {\n    return this.getUser({ id: 'me' });\n  }\n\n  /**\n   * Unlock the session by providing OTP\n   * @param {string} otp Required OTP code for the account.\n   * @param {number} duration Desired duration of the unlock in seconds (default=600, max=3600).\n   */\n  async unlock({ otp, duration }: UnlockOptions): Promise<any> {\n    if (otp && !_.isString(otp)) {\n      throw new Error('expected string or undefined otp');\n    }\n    return this.post(this.url('/user/unlock')).send({ otp, duration }).result();\n  }\n\n  /**\n   * Lock the session\n   */\n  async lock(): Promise<any> {\n    return this.post(this.url('/user/lock')).result();\n  }\n\n  /**\n   * Get the current session\n   */\n  async session(): Promise<any> {\n    return this.get(this.url('/user/session')).result('session');\n  }\n\n  /**\n   * Trigger a push/sms for the OTP code\n   * @param {boolean} params.forceSMS If set to true, will use SMS to send the OTP to the user even if they have other 2FA method set up.\n   * @deprecated\n   */\n  async sendOTP(params: { forceSMS?: boolean } = {}): Promise<any> {\n    return this.post(this.url('/user/sendotp')).send(params).result();\n  }\n\n  /**\n   * Extend token, provided the current token is extendable\n   * @param params\n   * - duration: duration in seconds by which to extend the token, starting at the current time\n   */\n  async extendToken(params: ExtendTokenOptions = {}): Promise<any> {\n    if (!this._extensionKey) {\n      throw new Error('missing required property _extensionKey');\n    }\n\n    const timestamp = Date.now();\n    const duration = params.duration;\n    const message = timestamp + '|' + this._token + '|' + duration;\n    const privateKey = this._extensionKey.privateKey;\n    if (!privateKey) {\n      throw new Error('no privateKey on extensionKey');\n    }\n    const isCompressed = this._extensionKey.compressed;\n    const prefix = utxolib.networks.bitcoin.messagePrefix;\n    const signature = bitcoinMessage.sign(message, privateKey, isCompressed, prefix).toString('hex');\n\n    return this.post(this.url('/user/extendtoken'))\n      .send(params)\n      .set('timestamp', timestamp.toString())\n      .set('signature', signature)\n      .result();\n  }\n\n  /**\n   * Get a key for sharing a wallet with a user\n   * @param email email of user to share wallet with\n   */\n  async getSharingKey({ email }: GetSharingKeyOptions): Promise<any> {\n    if (!_.isString(email)) {\n      throw new Error('required string email');\n    }\n\n    return this.post(this.url('/user/sharingkey')).send({ email }).result();\n  }\n\n  /**\n   * Users that want to sign with a key will use this api to fetch the keychain and the path.\n   * Users that want to verify a signature will use this api to fetch another users ecdh pubkey.\n   * Note: If the user id is not provided, it will default to getting the current user's keychain.\n   * @param bitgo\n   * @param enterpriseId\n   * @param userId\n   */\n  async getSigningKeyForUser(enterpriseId: string, userId?: string): Promise<GetSigningKeyApi> {\n    const user = userId ?? 'me';\n    return this.get(this.url(`/enterprise/${enterpriseId}/user/${user}/signingkey`, 2))\n      .query({})\n      .result();\n  }\n\n  /**\n   *\n   */\n  getValidate(): boolean {\n    return this._validate;\n  }\n\n  /**\n   *\n   */\n  setValidate(validate: boolean): void {\n    if (!_.isBoolean(validate)) {\n      throw new Error('invalid argument');\n    }\n    this._validate = validate;\n  }\n\n  /**\n   * Register a new coin instance with its builder factory\n   * @param {string} name coin name as it was registered in @bitgo-beta/statics\n   * @param {CoinConstructor} coin the builder factory class for that coin\n   * @returns {void}\n   */\n  public register(name: string, coin: CoinConstructor): void {\n    GlobalCoinFactory.register(name, coin);\n  }\n\n  /**\n   * Get bitcoin market data\n   *\n   * @deprecated\n   */\n  markets(): any {\n    if (!this._markets) {\n      this._markets = new Markets(this);\n    }\n    return this._markets;\n  }\n\n  /**\n   * Get the latest bitcoin prices\n   * (Deprecated: Will be removed in the future) use `bitgo.markets().latest()`\n   * @deprecated\n   */\n  // cb-compat\n  async market(): Promise<any> {\n    return this.get(this.url('/market/latest')).result();\n  }\n\n  /**\n   * Get market data from yesterday\n   * (Deprecated: Will be removed in the future) use bitgo.markets().yesterday()\n   * @deprecated\n   */\n  async yesterday(): Promise<any> {\n    return this.get(this.url('/market/yesterday')).result();\n  }\n\n  /**\n   * Get the blockchain object.\n   * @deprecated\n   */\n  blockchain(): any {\n    if (!this._blockchain) {\n      this._blockchain = new Blockchain(this);\n    }\n    return this._blockchain;\n  }\n\n  /**\n   * Get the user's keychains object.\n   * @deprecated\n   */\n  keychains(): any {\n    if (!this._keychains) {\n      this._keychains = new Keychains(this);\n    }\n    return this._keychains;\n  }\n\n  /**\n   * Get the travel rule object\n   * @deprecated\n   */\n  travelRule(): any {\n    if (!this._travelRule) {\n      this._travelRule = new TravelRule(this);\n    }\n    return this._travelRule;\n  }\n\n  /**\n   * Get the user's wallets object.\n   * @deprecated\n   */\n  wallets(): any {\n    if (!this._wallets) {\n      this._wallets = new Wallets(this);\n    }\n    return this._wallets;\n  }\n\n  /**\n   * Get pending approvals that can be approved/ or rejected\n   * @deprecated\n   */\n  pendingApprovals(): any {\n    if (!this._pendingApprovals) {\n      this._pendingApprovals = new PendingApprovals(this);\n    }\n    return this._pendingApprovals;\n  }\n\n  /**\n   * A factory method to create a new Wallet object, initialized with the wallet params\n   * Can be used to reconstitute a wallet from cached data\n   * @param walletParams\n   * @deprecated\n   */\n  newWalletObject(walletParams): any {\n    return new Wallet(this, walletParams);\n  }\n\n  /**\n   * V1 method for calculating miner fee amounts, given the number and\n   * type of transaction inputs, along with a fee rate in satoshis per vkB.\n   *\n   * This method should not be used for new code.\n   *\n   * @deprecated\n   * @param params\n   * @return {any}\n   */\n  async calculateMinerFeeInfo(params: any): Promise<any> {\n    return TransactionBuilder.calculateMinerFeeInfo(params);\n  }\n\n  /**\n   * Verify a Bitcoin address is a valid base58 address\n   * @deprecated\n   */\n  verifyAddress(params: DeprecatedVerifyAddressOptions = {}): boolean {\n    common.validateParams(params, ['address'], []);\n\n    if (!_.isString(params.address)) {\n      throw new Error('missing required string address');\n    }\n\n    const networkName = common.Environments[this.getEnv()].network;\n    const network = utxolib.networks[networkName];\n\n    let address;\n    try {\n      address = utxolib.address.fromBase58Check(params.address, network);\n    } catch (e) {\n      return false;\n    }\n\n    return address.version === network.pubKeyHash || address.version === network.scriptHash;\n  }\n\n  /**\n   * Split a secret into shards using Shamir Secret Sharing.\n   * @param seed A hexadecimal secret to split\n   * @param passwords An array of the passwords used to encrypt each share\n   * @param m The threshold number of shards necessary to reconstitute the secret\n   */\n  splitSecret({ seed, passwords, m }: SplitSecretOptions): SplitSecret {\n    if (!Array.isArray(passwords)) {\n      throw new Error('passwords must be an array');\n    }\n    if (!_.isInteger(m) || m < 2) {\n      throw new Error('m must be a positive integer greater than or equal to 2');\n    }\n\n    if (passwords.length < m) {\n      throw new Error('passwords array length cannot be less than m');\n    }\n\n    const n = passwords.length;\n    const secrets: string[] = shamir.share(seed, n, m);\n    const shards = _.zipWith(secrets, passwords, (shard, password) => {\n      return this.encrypt({ input: shard, password });\n    });\n    const node = bip32.fromSeed(Buffer.from(seed, 'hex'));\n    return {\n      xpub: node.neutered().toBase58(),\n      m,\n      n,\n      seedShares: shards,\n    };\n  }\n\n  /**\n   * Reconstitute a secret which was sharded with `splitSecret`.\n   * @param shards\n   * @param passwords\n   */\n  reconstituteSecret({ shards, passwords }: ReconstituteSecretOptions): ReconstitutedSecret {\n    if (!Array.isArray(shards)) {\n      throw new Error('shards must be an array');\n    }\n    if (!Array.isArray(passwords)) {\n      throw new Error('passwords must be an array');\n    }\n\n    if (shards.length !== passwords.length) {\n      throw new Error('shards and passwords arrays must have same length');\n    }\n\n    const secrets = _.zipWith(shards, passwords, (shard, password) => {\n      return this.decrypt({ input: shard, password });\n    });\n    const seed: string = shamir.combine(secrets);\n    const node = bip32.fromSeed(Buffer.from(seed, 'hex'));\n    return {\n      xpub: node.neutered().toBase58() as string,\n      xprv: node.toBase58() as string,\n      seed,\n    };\n  }\n\n  /**\n   *\n   * @param shards\n   * @param passwords\n   * @param m\n   * @param xpub Optional xpub to verify the results against\n   */\n  verifyShards({ shards, passwords, m, xpub }: VerifyShardsOptions): boolean {\n    /**\n     * Generate all possible combinations of a given array's values given subset size m\n     * @param array The array whose values are to be arranged in all combinations\n     * @param m The size of each subset\n     * @param entryIndices Recursively trailing set of currently chosen array indices for the combination subset under construction\n     * @returns {Array}\n     */\n    const generateCombinations = (array: string[], m: number, entryIndices: number[] = []): string[][] => {\n      let combinations: string[][] = [];\n\n      if (entryIndices.length === m) {\n        const currentCombination = _.at(array, entryIndices);\n        return [currentCombination];\n      }\n\n      // The highest index\n      let entryIndex = _.last(entryIndices);\n      // If there are currently no indices, assume -1\n      if (_.isUndefined(entryIndex)) {\n        entryIndex = -1;\n      }\n      for (let i = entryIndex + 1; i < array.length; i++) {\n        // append the current index to the trailing indices\n        const currentEntryIndices = [...entryIndices, i];\n        const newCombinations = generateCombinations(array, m, currentEntryIndices);\n        combinations = [...combinations, ...newCombinations];\n      }\n\n      return combinations;\n    };\n\n    if (!Array.isArray(shards)) {\n      throw new Error('shards must be an array');\n    }\n    if (!Array.isArray(passwords)) {\n      throw new Error('passwords must be an array');\n    }\n\n    if (shards.length !== passwords.length) {\n      throw new Error('shards and passwords arrays must have same length');\n    }\n\n    const secrets = _.zipWith(shards, passwords, (shard, password) => {\n      return this.decrypt({ input: shard, password });\n    });\n    const secretCombinations = generateCombinations(secrets, m);\n    const seeds = secretCombinations.map((currentCombination) => {\n      return shamir.combine(currentCombination);\n    });\n    const uniqueSeeds = _.uniq(seeds);\n    if (uniqueSeeds.length !== 1) {\n      return false;\n    }\n    const seed = _.first(uniqueSeeds);\n    const node = bip32.fromSeed(Buffer.from(seed, 'hex'));\n    const restoredXpub = node.neutered().toBase58();\n\n    if (!_.isUndefined(xpub)) {\n      if (!_.isString(xpub)) {\n        throw new Error('xpub must be a string');\n      }\n      if (restoredXpub !== xpub) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * @deprecated - use `getSharedSecret()`\n   */\n  getECDHSecret({ otherPubKeyHex, eckey }: GetEcdhSecretOptions): string {\n    if (!_.isString(otherPubKeyHex)) {\n      throw new Error('otherPubKeyHex string required');\n    }\n    if (!_.isObject(eckey)) {\n      throw new Error('eckey object required');\n    }\n\n    return getSharedSecret(eckey, Buffer.from(otherPubKeyHex, 'hex')).toString('hex');\n  }\n\n  /**\n   * Gets the user's private ECDH keychain\n   */\n  async getECDHKeychain(ecdhKeychainPub?: string): Promise<any> {\n    if (!ecdhKeychainPub) {\n      const result = await this.get(this.url('/user/settings')).result();\n      if (!result.settings.ecdhKeychain) {\n        return new Error('ecdh keychain not found for user');\n      }\n      ecdhKeychainPub = result.settings.ecdhKeychain;\n    }\n    return this.keychains().get({ xpub: ecdhKeychainPub });\n  }\n\n  /**\n   * @param params\n   * - operatingSystem: one of ios, android\n   * - pushToken: hex-formatted token for the respective native push notification service\n   * @returns {*}\n   * @deprecated\n   */\n  async registerPushToken(params: RegisterPushTokenOptions): Promise<any> {\n    params = params || {};\n    common.validateParams(params, ['pushToken', 'operatingSystem'], []);\n\n    if (!this._token) {\n      // this device has to be registered to an extensible session\n      throw new Error('not logged in');\n    }\n\n    const postParams = _.pick(params, ['pushToken', 'operatingSystem']);\n\n    return this.post(this.url('/devices')).send(postParams).result();\n  }\n\n  /**\n   * @param params\n   * - pushVerificationToken: the token received via push notification to confirm the device's mobility\n   * @deprecated\n   */\n  verifyPushToken(params: VerifyPushTokenOptions): Promise<any> {\n    if (!_.isObject(params)) {\n      throw new Error('required object params');\n    }\n\n    if (!_.isString(params.pushVerificationToken)) {\n      throw new Error('required string pushVerificationToken');\n    }\n\n    if (!this._token) {\n      // this device has to be registered to an extensible session\n      throw new Error('not logged in');\n    }\n\n    const postParams = _.pick(params, 'pushVerificationToken');\n\n    return this.post(this.url('/devices/verify')).send(postParams).result();\n  }\n\n  /**\n   * Login to the bitgo system using an authcode generated via Oauth\n   */\n  async authenticateWithAuthCode(params: AuthenticateWithAuthCodeOptions): Promise<any> {\n    if (!_.isObject(params)) {\n      throw new Error('required object params');\n    }\n\n    if (!_.isString(params.authCode)) {\n      throw new Error('required string authCode');\n    }\n\n    if (!this._clientId || !this._clientSecret) {\n      throw new Error('Need client id and secret set first to use this');\n    }\n\n    const authCode = params.authCode;\n\n    if (this._token) {\n      throw new Error('already logged in');\n    }\n\n    const request = this.post(this._baseUrl + '/oauth/token');\n    request.forceV1Auth = true; // OAuth currently only supports v1 authentication\n    const body = await request\n      .send({\n        grant_type: 'authorization_code',\n        code: authCode,\n        client_id: this._clientId,\n        client_secret: this._clientSecret,\n      })\n      .result();\n\n    this._token = body.access_token;\n    this._refreshToken = body.refresh_token;\n    this._user = await this.me();\n    return body;\n  }\n\n  /**\n   * Change the password of the currently logged in user.\n   * Also change all v1 and v2 keychain passwords if they match the\n   * given oldPassword. Returns nothing on success.\n   * @param oldPassword {String} - the current password\n   * @param newPassword {String} - the new password\n   */\n  async changePassword({ oldPassword, newPassword }: ChangePasswordOptions): Promise<any> {\n    if (!_.isString(oldPassword)) {\n      throw new Error('expected string oldPassword');\n    }\n\n    if (!_.isString(newPassword)) {\n      throw new Error('expected string newPassword');\n    }\n\n    const user = this.user();\n    if (typeof user !== 'object' || !user.username) {\n      throw new Error('missing required object user');\n    }\n\n    const validation = await this.verifyPassword({ password: oldPassword });\n    if (!validation) {\n      throw new Error('the provided oldPassword is incorrect');\n    }\n\n    // it doesn't matter which coin we choose because the v2 updatePassword functions updates all v2 keychains\n    // we just need to choose a coin that exists in the current environment\n    const coin = common.Environments[this.getEnv()].network === 'bitcoin' ? 'btc' : 'tbtc';\n\n    const updateKeychainPasswordParams = { oldPassword, newPassword };\n    const v1KeychainUpdatePWResult = await this.keychains().updatePassword(updateKeychainPasswordParams);\n    const v2Keychains = await this.coin(coin).keychains().updatePassword(updateKeychainPasswordParams);\n\n    const updatePasswordParams = {\n      keychains: v1KeychainUpdatePWResult.keychains,\n      v2_keychains: v2Keychains,\n      version: v1KeychainUpdatePWResult.version,\n      oldPassword: this.calculateHMAC(user.username, oldPassword),\n      password: this.calculateHMAC(user.username, newPassword),\n    };\n\n    return this.post(this.url('/user/changepassword')).send(updatePasswordParams).result();\n  }\n\n  /**\n   * Get all the address labels on all of the user's wallets\n   *\n   * @deprecated\n   */\n  async labels(): Promise<any> {\n    return this.get(this.url('/labels')).result('labels');\n  }\n\n  /**\n   * Estimates approximate fee per kb needed for a tx to get into a block\n   * @param {number} params.numBlocks target blocks for the transaction to be confirmed\n   * @param {number} params.maxFee maximum fee willing to be paid (for safety)\n   * @param {array[string]} params.inputs list of unconfirmed txIds from which this transaction uses inputs\n   * @param {number} params.txSize estimated transaction size in bytes, optional parameter used for CPFP estimation.\n   * @param {boolean} params.cpfpAware flag indicating fee should take into account CPFP\n   * @deprecated\n   */\n  async estimateFee(params: EstimateFeeOptions = {}): Promise<any> {\n    const queryParams: any = { version: 12 };\n    if (params.numBlocks) {\n      if (!_.isNumber(params.numBlocks)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.numBlocks = params.numBlocks;\n    }\n    if (params.maxFee) {\n      if (!_.isNumber(params.maxFee)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.maxFee = params.maxFee;\n    }\n    if (params.inputs) {\n      if (!Array.isArray(params.inputs)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.inputs = params.inputs;\n    }\n    if (params.txSize) {\n      if (!_.isNumber(params.txSize)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.txSize = params.txSize;\n    }\n    if (params.cpfpAware) {\n      if (!_.isBoolean(params.cpfpAware)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.cpfpAware = params.cpfpAware;\n    }\n\n    return this.get(this.url('/tx/fee')).query(queryParams).result();\n  }\n\n  /**\n   * Get BitGo's guarantee using an instant id\n   * @param params\n   * @deprecated\n   */\n  async instantGuarantee(params: { id: string }): Promise<any> {\n    if (!_.isString(params.id)) {\n      throw new Error('required string id');\n    }\n\n    const body = await this.get(this.url('/instant/' + params.id)).result();\n    if (!body.guarantee) {\n      throw new Error('no guarantee found in response body');\n    }\n    if (!body.signature) {\n      throw new Error('no signature found in guarantee response body');\n    }\n    const signingAddress = common.Environments[this.getEnv()].signingAddress;\n    const signatureBuffer = Buffer.from(body.signature, 'hex');\n    const prefix = utxolib.networks[common.Environments[this.getEnv()].network].messagePrefix;\n    const isValidSignature = bitcoinMessage.verify(body.guarantee, signingAddress, signatureBuffer, prefix);\n    if (!isValidSignature) {\n      throw new Error('incorrect signature');\n    }\n    return body;\n  }\n\n  /**\n   * Get a target address for payment of a BitGo fee\n   * @deprecated\n   */\n  async getBitGoFeeAddress(): Promise<any> {\n    return this.post(this.url('/billing/address')).send({}).result();\n  }\n\n  /**\n   * Gets an address object (including the wallet id) for a given address.\n   * @param {string} params.address The address to look up.\n   * @deprecated\n   */\n  async getWalletAddress({ address }: { address: string }): Promise<any> {\n    return this.get(this.url(`/walletaddress/${address}`)).result();\n  }\n\n  /**\n   * Fetch list of user webhooks\n   *\n   * @returns {*}\n   * @deprecated\n   */\n  async listWebhooks(): Promise<any> {\n    return this.get(this.url('/webhooks')).result();\n  }\n\n  /**\n   * Add new user webhook\n   *\n   * @param params\n   * @returns {*}\n   * @deprecated\n   */\n  async addWebhook(params: WebhookOptions): Promise<any> {\n    if (!_.isString(params.url)) {\n      throw new Error('required string url');\n    }\n\n    if (!_.isString(params.type)) {\n      throw new Error('required string type');\n    }\n\n    return this.post(this.url('/webhooks')).send(params).result();\n  }\n\n  /**\n   * Remove user webhook\n   *\n   * @param params\n   * @returns {*}\n   * @deprecated\n   */\n  async removeWebhook(params: WebhookOptions): Promise<any> {\n    if (!_.isString(params.url)) {\n      throw new Error('required string url');\n    }\n\n    if (!_.isString(params.type)) {\n      throw new Error('required string type');\n    }\n\n    return this.del(this.url('/webhooks')).send(params).result();\n  }\n\n  /**\n   * Fetch list of webhook notifications for the user\n   *\n   * @param params\n   * @returns {*}\n   */\n  async listWebhookNotifications(params: ListWebhookNotificationsOptions = {}): Promise<any> {\n    const query: any = {};\n    if (params.prevId) {\n      if (!_.isString(params.prevId)) {\n        throw new Error('invalid prevId argument, expecting string');\n      }\n      query.prevId = params.prevId;\n    }\n    if (params.limit) {\n      if (!_.isNumber(params.limit)) {\n        throw new Error('invalid limit argument, expecting number');\n      }\n      query.limit = params.limit;\n    }\n\n    return this.get(this.url('/webhooks/notifications')).query(query).result();\n  }\n\n  /**\n   * Simulate a user webhook\n   *\n   * @param params\n   * @returns {*}\n   */\n  async simulateWebhook(params: BitGoSimulateWebhookOptions): Promise<any> {\n    common.validateParams(params, ['webhookId', 'blockId'], []);\n    if (!_.isString(params.webhookId)) {\n      throw new Error('required string webhookId');\n    }\n\n    if (!_.isString(params.blockId)) {\n      throw new Error('required string blockId');\n    }\n\n    return this.post(this.url(`/webhooks/${params.webhookId}/simulate`))\n      .send(params)\n      .result();\n  }\n\n  /**\n   * Synchronously get constants which are relevant to the client.\n   *\n   * Note: This function has a known race condition. It may return different values over time,\n   * especially if called shortly after creation of the BitGo object.\n   *\n   * New code should call fetchConstants() directly instead.\n   *\n   * @deprecated\n   * @return {Object} The client constants object\n   */\n  getConstants(): any {\n    // kick off a fresh request for the client constants\n    this.fetchConstants().catch(function (err) {\n      if (err) {\n        // make sure an error does not terminate the entire script\n        console.error('failed to fetch client constants from BitGo');\n        console.trace(err);\n      }\n    });\n\n    // use defaultConstants as the backup for keys that are not set in this._constants\n    return _.merge({}, defaultConstants(this.getEnv()), BitGoAPI._constants[this.getEnv()]);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bitgoAPI.js","sourceRoot":"","sources":["../../src/bitgoAPI.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AliasEnvironments,\n  BaseCoin,\n  bitcoin,\n  BitGoBase,\n  BitGoRequest,\n  CoinConstructor,\n  common,\n  DecryptKeysOptions,\n  DecryptOptions,\n  defaultConstants,\n  EcdhDerivedKeypair,\n  EncryptOptions,\n  EnvironmentName,\n  generateRandomPassword,\n  getAddressP2PKH,\n  getSharedSecret,\n  GetSharingKeyOptions,\n  GetSigningKeyApi,\n  GlobalCoinFactory,\n  IRequestTracer,\n  makeRandomKey,\n  sanitizeLegacyPath,\n} from '@bitgo-beta/sdk-core';\nimport * as sdkHmac from '@bitgo-beta/sdk-hmac';\nimport { DefaultHmacAuthStrategy, type IHmacAuthStrategy } from '@bitgo-beta/sdk-hmac';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { bip32, ECPairInterface } from '@bitgo-beta/utxo-lib';\nimport * as bitcoinMessage from 'bitcoinjs-message';\nimport { type Agent } from 'http';\nimport debugLib from 'debug';\nimport * as _ from 'lodash';\nimport * as secp256k1 from 'secp256k1';\nimport * as superagent from 'superagent';\nimport {\n  handleResponseError,\n  handleResponseResult,\n  serializeRequestData,\n  setRequestQueryString,\n  toBitgoRequest,\n  verifyResponseAsync,\n} from './api';\nimport { decrypt, decryptAsync, encrypt, encryptAsync } from './encrypt';\nimport { createEncryptionSession } from './encryptionSession';\nimport { verifyAddress } from './v1/verifyAddress';\nimport {\n  AccessTokenOptions,\n  AddAccessTokenOptions,\n  AddAccessTokenResponse,\n  AdditionalHeadersCallback,\n  AuthenticateOptions,\n  AuthenticateWithAuthCodeOptions,\n  BitGoAPIOptions,\n  BitGoJson,\n  BitGoSimulateWebhookOptions,\n  CalculateHmacSubjectOptions,\n  CalculateRequestHeadersOptions,\n  CalculateRequestHmacOptions,\n  ChangePasswordOptions,\n  Constants,\n  DeprecatedVerifyAddressOptions,\n  EstimateFeeOptions,\n  ExtendTokenOptions,\n  GetEcdhSecretOptions,\n  GetUserOptions,\n  ListWebhookNotificationsOptions,\n  LoginResponse,\n  PingOptions,\n  ProcessedAuthenticationOptions,\n  ReconstitutedSecret,\n  ReconstituteSecretOptions,\n  RegisterPushTokenOptions,\n  RemoveAccessTokenOptions,\n  RequestHeaders,\n  RequestMethods,\n  SplitSecret,\n  SplitSecretOptions,\n  TokenIssuance,\n  TokenIssuanceResponse,\n  UnlockOptions,\n  User,\n  VerifyPasswordOptions,\n  VerifyPushTokenOptions,\n  VerifyResponseInfo,\n  VerifyResponseOptions,\n  VerifyShardsOptions,\n  WebhookOptions,\n} from './types';\nimport shamir = require('secrets.js-grempe');\nimport pjson = require('../package.json');\nconst debug = debugLib('bitgo:api');\n\nconst Blockchain = require('./v1/blockchain');\nconst Keychains = require('./v1/keychains');\nimport Wallet = require('./v1/wallet');\n\nconst Wallets = require('./v1/wallets');\nconst Markets = require('./v1/markets');\nconst PendingApprovals = require('./v1/pendingapprovals');\nconst TravelRule = require('./v1/travelRule');\nconst TransactionBuilder = require('./v1/transactionBuilder');\n\nfunction validateDecryptKeysParams(params: DecryptKeysOptions): DecryptKeysOptions {\n  params = params || {};\n  if (!params.walletIdEncryptedKeyPairs) {\n    throw new Error('Missing parameter: walletIdEncryptedKeyPairs');\n  }\n\n  if (!params.password) {\n    throw new Error('Missing parameter: password');\n  }\n\n  if (!Array.isArray(params.walletIdEncryptedKeyPairs)) {\n    throw new Error('walletIdEncryptedKeyPairs must be an array');\n  }\n\n  return params;\n}\n\nfunction validateSplitSecretInputs({ passwords, m }: SplitSecretOptions): number {\n  if (!Array.isArray(passwords)) {\n    throw new Error('passwords must be an array');\n  }\n  if (!_.isInteger(m) || m < 2) {\n    throw new Error('m must be a positive integer greater than or equal to 2');\n  }\n\n  if (passwords.length < m) {\n    throw new Error('passwords array length cannot be less than m');\n  }\n\n  return passwords.length;\n}\n\nfunction validateReconstituteInputs({ shards, passwords }: ReconstituteSecretOptions): void {\n  if (!Array.isArray(shards)) {\n    throw new Error('shards must be an array');\n  }\n  if (!Array.isArray(passwords)) {\n    throw new Error('passwords must be an array');\n  }\n\n  if (shards.length !== passwords.length) {\n    throw new Error('shards and passwords arrays must have same length');\n  }\n}\n\nfunction buildSplitSecretResult(seed: string, shards: string[], m: number, n: number): SplitSecret {\n  const node = bip32.fromSeed(Buffer.from(seed, 'hex'));\n  return {\n    xpub: node.neutered().toBase58(),\n    m,\n    n,\n    seedShares: shards,\n  };\n}\n\nfunction buildReconstitutedSecret(seed: string): ReconstitutedSecret {\n  const node = bip32.fromSeed(Buffer.from(seed, 'hex'));\n  return {\n    xpub: node.neutered().toBase58() as string,\n    xprv: node.toBase58() as string,\n    seed,\n  };\n}\n\nfunction verifyShardSecrets(secrets: string[], m: number, xpub?: string): boolean {\n  const generateCombinations = (array: string[], combinationSize: number, entryIndices: number[] = []): string[][] => {\n    let combinations: string[][] = [];\n\n    if (entryIndices.length === combinationSize) {\n      const currentCombination = _.at(array, entryIndices);\n      return [currentCombination];\n    }\n\n    let entryIndex = _.last(entryIndices);\n    if (_.isUndefined(entryIndex)) {\n      entryIndex = -1;\n    }\n    for (let i = entryIndex + 1; i < array.length; i++) {\n      const currentEntryIndices = [...entryIndices, i];\n      const newCombinations = generateCombinations(array, combinationSize, currentEntryIndices);\n      combinations = [...combinations, ...newCombinations];\n    }\n\n    return combinations;\n  };\n\n  const secretCombinations = generateCombinations(secrets, m);\n  const seeds = secretCombinations.map((currentCombination) => {\n    return shamir.combine(currentCombination);\n  });\n  const uniqueSeeds = _.uniq(seeds);\n  if (uniqueSeeds.length !== 1) {\n    return false;\n  }\n  const seed = _.first(uniqueSeeds);\n  const node = bip32.fromSeed(Buffer.from(seed, 'hex'));\n  const restoredXpub = node.neutered().toBase58();\n\n  if (!_.isUndefined(xpub)) {\n    if (!_.isString(xpub)) {\n      throw new Error('xpub must be a string');\n    }\n    if (restoredXpub !== xpub) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction deriveTokenIssuanceEcdhSecret(ecdhXprv: string, derivationPath: string, serverXpub: string): string {\n  const clientHDNode = bip32.fromBase58(ecdhXprv);\n  const serverHDNode = bip32.fromBase58(serverXpub);\n  const sanitizedPath = sanitizeLegacyPath(derivationPath);\n  const clientDerivedNode = clientHDNode.derivePath(sanitizedPath);\n  const serverDerivedNode = serverHDNode.derivePath(sanitizedPath);\n  const secretKey = clientDerivedNode.privateKey;\n  if (!secretKey) {\n    throw new Error('no client private Key');\n  }\n  return Buffer.from(\n    // FIXME(BG-34386): we should use `secp256k1.ecdh()` in the future\n    //                  see discussion here https://github.com/bitcoin-core/secp256k1/issues/352\n    secp256k1.publicKeyTweakMul(serverDerivedNode.publicKey, secretKey)\n  ).toString('hex');\n}\n\nexport class BitGoAPI implements BitGoBase {\n  // v1 types\n  protected _keychains: any;\n  protected _wallets: any;\n  protected _markets?: any;\n  protected _blockchain?: any;\n  protected _travelRule?: any;\n  protected _pendingApprovals?: any;\n\n  protected static _constants: any;\n  protected static _constantsExpire: any;\n  protected static _testnetWarningMessage = false;\n  public readonly env: EnvironmentName;\n  protected readonly _baseUrl: string;\n  protected readonly _baseApiUrl: string;\n  protected readonly _baseApiUrlV2: string;\n  protected readonly _baseApiUrlV3: string;\n  protected readonly _env: EnvironmentName;\n  protected readonly _authVersion: Exclude<BitGoAPIOptions['authVersion'], undefined> = 2;\n  protected _hmacVerification = true;\n  protected readonly _proxy?: string;\n  protected _user?: User;\n  protected _extensionKey?: ECPairInterface;\n  protected _reqId?: IRequestTracer;\n  protected _token?: string;\n  protected _version = pjson.version;\n  protected _userAgent?: string;\n  protected _ecdhXprv?: string;\n  protected _refreshToken?: string;\n  protected readonly _clientId?: string;\n  protected readonly _clientSecret?: string;\n  protected _validate: boolean;\n  public readonly cookiesPropagationEnabled: boolean;\n  private _customProxyAgent?: Agent;\n  private _requestIdPrefix?: string;\n  private getAdditionalHeadersCb?: AdditionalHeadersCallback;\n  protected _hmacAuthStrategy: IHmacAuthStrategy;\n\n  constructor(params: BitGoAPIOptions = {}) {\n    this.getAdditionalHeadersCb = params.getAdditionalHeadersCb;\n    this._requestIdPrefix = params.requestIdPrefix;\n    this.cookiesPropagationEnabled = false;\n    if (\n      !common.validateParams(\n        params,\n        [],\n        [\n          'accessToken',\n          'userAgent',\n          'customRootURI',\n          'customBitcoinNetwork',\n          'serverXpub',\n          'stellarFederationServerUrl',\n        ]\n      ) ||\n      (params.useProduction && !_.isBoolean(params.useProduction))\n    ) {\n      throw new Error('invalid argument');\n    }\n\n    // By default, we operate on the test server.\n    // Deprecate useProduction in the future\n    let env: EnvironmentName;\n\n    if (params.useProduction) {\n      if (params.env && params.env !== 'prod') {\n        throw new Error('cannot use useProduction when env=' + params.env);\n      }\n      env = 'prod';\n    } else if (\n      params.customRootURI ||\n      params.customBitcoinNetwork ||\n      params.customSigningAddress ||\n      params.serverXpub ||\n      process.env.BITGO_CUSTOM_ROOT_URI ||\n      process.env.BITGO_CUSTOM_BITCOIN_NETWORK\n    ) {\n      // for branch deploys, we want to be able to specify custom endpoints while still\n      // maintaining the name of specified the environment\n      env = params.env === 'branch' ? 'branch' : 'custom';\n      if (params.customRootURI) {\n        common.Environments[env].uri = params.customRootURI;\n      }\n      if (params.customBitcoinNetwork) {\n        common.Environments[env].network = params.customBitcoinNetwork;\n      }\n      if (params.customSigningAddress) {\n        (common.Environments[env] as any).customSigningAddress = params.customSigningAddress;\n      }\n      if (params.serverXpub) {\n        common.Environments[env].serverXpub = params.serverXpub;\n      }\n      if (params.stellarFederationServerUrl) {\n        common.Environments[env].stellarFederationServerUrl = params.stellarFederationServerUrl;\n      }\n      if (params.cookiesPropagationEnabled) {\n        this.cookiesPropagationEnabled = true;\n      }\n    } else {\n      env = params.env || (process.env.BITGO_ENV as EnvironmentName);\n    }\n\n    // if this hasn't been set to true already some conditions are not met\n    if (params.cookiesPropagationEnabled && !this.cookiesPropagationEnabled) {\n      throw new Error('Cookies are only allowed when custom URIs are in use');\n    }\n\n    if (params.authVersion !== undefined) {\n      this._authVersion = params.authVersion;\n    }\n\n    // if this env is an alias, swap it out with the equivalent supported environment\n    if (env in AliasEnvironments) {\n      env = AliasEnvironments[env];\n    }\n\n    if (env === 'custom' && _.isUndefined(common.Environments[env].uri)) {\n      throw new Error(\n        'must use --customrooturi or set the BITGO_CUSTOM_ROOT_URI environment variable when using the custom environment'\n      );\n    }\n\n    if (env) {\n      if (common.Environments[env]) {\n        this._baseUrl = common.Environments[env].uri;\n      } else {\n        throw new Error('invalid environment ' + env + '. Supported environments: prod, test, dev, latest');\n      }\n    } else {\n      env = 'test';\n      if (!BitGoAPI._testnetWarningMessage) {\n        BitGoAPI._testnetWarningMessage = true;\n        console.log('BitGo SDK env not set - defaulting to test at test.bitgo.com.');\n      }\n      this._baseUrl = common.Environments[env].uri;\n    }\n    this._env = this.env = env;\n\n    const supportedApiTokens = [\n      'etherscanApiToken',\n      'polygonscanApiToken',\n      'arbiscanApiToken',\n      'optimisticEtherscanApiToken',\n      'zksyncExplorerApiToken',\n      'bscscanApiToken',\n      'coredaoExplorerApiToken',\n      'oasExplorerApiToken',\n      'baseethApiToken',\n      'sgbExplorerApiToken',\n      'flrExplorerApiToken',\n      'xdcExplorerApiToken',\n      'wemixExplorerApiToken',\n      'monExplorerApiToken',\n      'worldExplorerApiToken',\n      'somniaExplorerApiToken',\n      'soneiumExplorerApiToken',\n    ];\n\n    Object.keys(params).forEach((key) => {\n      if (supportedApiTokens.includes(key)) {\n        common.Environments[env][key] = params[key];\n      }\n    });\n\n    if (params.evm) {\n      const evmConfig = common.Environments[env]['evm'] || {};\n      Object.keys(params.evm).forEach((key) => {\n        if (params.evm?.[key] && params.evm[key]['apiToken']) {\n          evmConfig[key] = evmConfig[key] || {};\n          evmConfig[key]['apiToken'] = params.evm[key]['apiToken'];\n        }\n      });\n      common.Environments[env]['evm'] = evmConfig;\n    }\n\n    common.setNetwork(common.Environments[env].network);\n\n    this._baseApiUrl = this._baseUrl + '/api/v1';\n    this._baseApiUrlV2 = this._baseUrl + '/api/v2';\n    this._baseApiUrlV3 = this._baseUrl + '/api/v3';\n    this._token = params.accessToken;\n\n    const clientConstants = params.clientConstants;\n    this._initializeClientConstants(clientConstants);\n\n    this._userAgent = params.userAgent || 'BitGoJS-api/' + this.version();\n    this._reqId = undefined;\n    this._refreshToken = params.refreshToken;\n    this._clientId = params.clientId;\n    this._clientSecret = params.clientSecret;\n    this._keychains = null;\n    this._wallets = null;\n\n    // whether to perform extra client-side validation for some things, such as\n    // address validation or signature validation. defaults to true, but can be\n    // turned off by setting to false. can also be overridden individually in the\n    // functions that use it.\n    this._validate = params.validate === undefined ? true : params.validate;\n\n    if (!params.hmacVerification && params.hmacVerification !== undefined) {\n      if ((env == 'prod' || env == 'adminProd') && common.Environments[env].hmacVerificationEnforced) {\n        throw new Error(`Cannot disable request HMAC verification in environment ${this.getEnv()}`);\n      }\n      debug('HMAC verification explicitly disabled by constructor option');\n      this._hmacVerification = params.hmacVerification;\n    }\n\n    if ((process as any).browser && params.customProxyAgent) {\n      throw new Error('should not use https proxy while in browser');\n    }\n\n    this._customProxyAgent = params.customProxyAgent;\n    this._hmacAuthStrategy = params.hmacAuthStrategy ?? new DefaultHmacAuthStrategy();\n\n    // Only fetch constants from constructor if clientConstants was not provided\n    if (!clientConstants) {\n      // capture outer stack so we have useful debug information if fetch constants fails\n      const e = new Error();\n\n      // Kick off first load of constants\n      this.fetchConstants().catch((err) => {\n        if (err) {\n          // make sure an error does not terminate the entire script\n          console.error('failed to fetch initial client constants from BitGo');\n          debug(e.stack);\n        }\n      });\n    }\n  }\n\n  /**\n   * Initialize client constants if provided.\n   * @param clientConstants - The client constants from params\n   * @private\n   */\n  private _initializeClientConstants(clientConstants: any): void {\n    if (clientConstants) {\n      if (!BitGoAPI._constants) {\n        BitGoAPI._constants = {};\n      }\n      BitGoAPI._constants[this.env] = 'constants' in clientConstants ? clientConstants.constants : clientConstants;\n    }\n  }\n\n  /**\n   * Get a superagent request for specified http method and URL configured to the SDK configuration\n   * @param method - http method for the new request\n   * @param url - URL for the new request\n   */\n  protected getAgentRequest(method: RequestMethods, url: string): superagent.SuperAgentRequest {\n    let req: superagent.SuperAgentRequest = superagent[method](url);\n    if (this.cookiesPropagationEnabled) {\n      req = req.withCredentials();\n    }\n    return req;\n  }\n  /**\n   * Create a basecoin object\n   * @param name\n   */\n  public coin(name: string): BaseCoin {\n    return GlobalCoinFactory.getInstance(this, name);\n  }\n\n  /**\n   * Return the current BitGo environment\n   */\n  getEnv(): EnvironmentName {\n    return this._env;\n  }\n\n  /**\n   * Return the current auth version used for requests to the BitGo server\n   */\n  getAuthVersion(): number {\n    return this._authVersion;\n  }\n\n  /**\n   * Signs and sends a v2-authenticated request, then verifies the response HMAC.\n   * Extracted from the req.then override in requestPatch to keep that method readable.\n   */\n  private async _sendRequestWithHmac({\n    req,\n    method,\n    url,\n    data,\n    strategyAuthenticated,\n    onfulfilled,\n    originalThen,\n  }: {\n    req: superagent.SuperAgentRequest;\n    method: RequestMethods;\n    url: string;\n    data: string | undefined;\n    strategyAuthenticated: boolean;\n    onfulfilled: ((response: superagent.Response) => any) | null | undefined;\n    originalThen: (onfulfilled: any, onrejected?: any) => Promise<any>;\n  }): Promise<any> {\n    if (this._token || strategyAuthenticated) {\n      setRequestQueryString(req);\n\n      const requestProperties = await this._hmacAuthStrategy.calculateRequestHeaders({\n        url: req.url,\n        token: this._token ?? '',\n        method,\n        text: data || '',\n        authVersion: this._authVersion,\n      });\n      req.set('Auth-Timestamp', requestProperties.timestamp.toString());\n\n      req.set('Authorization', 'Bearer ' + requestProperties.tokenHash);\n      debug(\n        'sending v%d %s request to %s with token %s',\n        this._authVersion,\n        method,\n        url,\n        this._token?.substr(0, 8) ?? '(strategy-managed)'\n      );\n\n      req.set('HMAC', requestProperties.hmac);\n    }\n\n    if (this.getAdditionalHeadersCb) {\n      const additionalHeaders = this.getAdditionalHeadersCb(method, url, data);\n      for (const { key, value } of additionalHeaders) {\n        req.set(key, value);\n      }\n    }\n\n    /**\n     * Verify the response before calling the original onfulfilled handler,\n     * and make sure onrejected is called if a verification error is encountered\n     */\n    const newOnFulfilled = onfulfilled\n      ? async (response: superagent.Response) => {\n          // HMAC verification is only allowed to be skipped in certain environments.\n          // This is checked in the constructor, but checking it again at request time\n          // will help prevent against tampering of this property after the object is created\n          if (!this._hmacVerification && !common.Environments[this.getEnv()].hmacVerificationEnforced) {\n            return onfulfilled(response);\n          }\n\n          const verifiedResponse = await verifyResponseAsync(\n            this,\n            this._token,\n            method,\n            req,\n            response,\n            this._authVersion\n          );\n          return onfulfilled(verifiedResponse);\n        }\n      : null;\n    return originalThen(newOnFulfilled);\n  }\n\n  /**\n   * This is a patching function which can apply our authorization\n   * headers to any outbound request.\n   * @param method\n   */\n  private requestPatch(method: RequestMethods, url: string) {\n    const req = this.getAgentRequest(method, url);\n    if (this._customProxyAgent) {\n      debug('using custom proxy agent');\n      if (this._customProxyAgent) {\n        req.agent(this._customProxyAgent);\n      }\n    }\n\n    const originalThen = req.then.bind(req);\n    req.then = (onfulfilled, onrejected) => {\n      // intercept a request before it's submitted to the server for v2 authentication (based on token)\n      if (this._version) {\n        // TODO - decide where to get version\n        req.set('BitGo-SDK-Version', this._version);\n      }\n\n      if (!_.isUndefined(this._reqId)) {\n        const reqId = this._reqId.toString();\n        const requestId = this._requestIdPrefix ? `${this._requestIdPrefix}${reqId}` : reqId;\n        req.set('Request-ID', requestId);\n\n        // increment after setting the header so the sequence numbers start at 0\n        this._reqId.inc();\n\n        // request ids must be set before each request instead of being kept\n        // inside the bitgo object. This is to prevent reentrancy issues where\n        // multiple simultaneous requests could cause incorrect reqIds to be used\n        delete this._reqId;\n      }\n\n      // prevent IE from caching requests\n      req.set('If-Modified-Since', 'Mon, 26 Jul 1997 05:00:00 GMT');\n\n      if (typeof window === 'undefined' && this._userAgent) {\n        // If not in the browser, set the User-Agent. Browsers don't allow\n        // setting of User-Agent, so we must disable this when run in the\n        // browser (browserify sets process.browser).\n        req.set('User-Agent', this._userAgent);\n      }\n\n      // Set the request timeout to just above 5 minutes by default\n      req.timeout((process.env.BITGO_TIMEOUT as any) * 1000 || 305 * 1000);\n\n      // The strategy may have its own signing material (e.g. a CryptoKey\n      // restored from IndexedDB) independent of this._token.\n      const strategyAuthenticated = this._hmacAuthStrategy.isAuthenticated?.() ?? false;\n\n      req.isV2Authenticated = true;\n      req.authenticationToken = this._token ?? (strategyAuthenticated ? 'strategy-authenticated' : undefined);\n      // some of the older tokens appear to be only 40 characters long\n      if ((this._token && this._token.length !== 67 && this._token.indexOf('v2x') !== 0) || req.forceV1Auth) {\n        // use the old method\n        req.isV2Authenticated = false;\n\n        req.set('Authorization', 'Bearer ' + this._token);\n        debug('sending v1 %s request to %s with token %s', method, url, this._token?.substr(0, 8));\n        return originalThen(onfulfilled).catch(onrejected);\n      }\n\n      req.set('BitGo-Auth-Version', this._authVersion === 3 ? '3.0' : '2.0');\n\n      const data = serializeRequestData(req);\n\n      return this._sendRequestWithHmac({\n        req,\n        method,\n        url,\n        data,\n        strategyAuthenticated,\n        onfulfilled,\n        originalThen,\n      }).catch(onrejected);\n    };\n    return toBitgoRequest(req);\n  }\n\n  get(url: string): BitGoRequest {\n    return this.requestPatch('get', url);\n  }\n  post(url: string): BitGoRequest {\n    return this.requestPatch('post', url);\n  }\n  put(url: string): BitGoRequest {\n    return this.requestPatch('put', url);\n  }\n  del(url: string): BitGoRequest {\n    return this.requestPatch('del', url);\n  }\n  patch(url: string): BitGoRequest {\n    return this.requestPatch('patch', url);\n  }\n  options(url: string): BitGoRequest {\n    return this.requestPatch('options', url);\n  }\n\n  /**\n   * Calculate the HMAC for the given key and message\n   * @param key {String} - the key to use for the HMAC\n   * @param message {String} - the actual message to HMAC\n   * @returns {*} - the result of the HMAC operation\n   */\n  calculateHMAC(key: string, message: string): string {\n    return sdkHmac.calculateHMAC(key, message);\n  }\n\n  /**\n   * Calculate the subject string that is to be HMAC'ed for a HTTP request or response\n   * @param urlPath request url, including query params\n   * @param text request body text\n   * @param timestamp request timestamp from `Date.now()`\n   * @param statusCode Only set for HTTP responses, leave blank for requests\n   * @param method request method\n   * @returns {string | Buffer}\n   */\n  calculateHMACSubject<T extends string | Buffer = string>(params: CalculateHmacSubjectOptions<T>): T {\n    return sdkHmac.calculateHMACSubject({ ...params, authVersion: this._authVersion });\n  }\n\n  /**\n   * Calculate the HMAC for an HTTP request\n   */\n  calculateRequestHMAC(params: CalculateRequestHmacOptions): string {\n    return sdkHmac.calculateRequestHMAC({ ...params, authVersion: this._authVersion });\n  }\n\n  /**\n   * Calculate request headers with HMAC\n   */\n  calculateRequestHeaders(params: CalculateRequestHeadersOptions): RequestHeaders {\n    return sdkHmac.calculateRequestHeaders({ ...params, authVersion: this._authVersion });\n  }\n\n  /**\n   * Verify the HMAC for an HTTP response (synchronous, uses sdk-hmac directly).\n   * Kept for backward compatibility with external callers.\n   */\n  verifyResponse(params: VerifyResponseOptions): VerifyResponseInfo {\n    return sdkHmac.verifyResponse({ ...params, authVersion: this._authVersion });\n  }\n\n  /**\n   * Verify the HMAC for an HTTP response via the configured strategy (async).\n   * Used internally by the request pipeline.\n   */\n  verifyResponseAsync(params: VerifyResponseOptions): Promise<VerifyResponseInfo> {\n    return this._hmacAuthStrategy.verifyResponse({ ...params, authVersion: this._authVersion });\n  }\n\n  /**\n   * Fetch useful constant values from the BitGo server.\n   * These values do change infrequently, so they need to be fetched,\n   * but are unlikely to change during the lifetime of a BitGo object,\n   * so they can safely cached.\n   */\n  async fetchConstants(): Promise<Constants> {\n    const env = this.getEnv();\n\n    // Check if we have cached constants that haven't expired\n    if (\n      BitGoAPI._constants &&\n      BitGoAPI._constants[env] &&\n      (!BitGoAPI._constantsExpire || !BitGoAPI._constantsExpire[env] || new Date() < BitGoAPI._constantsExpire[env])\n    ) {\n      return BitGoAPI._constants[env];\n    }\n\n    // client constants call cannot be authenticated using the normal HMAC validation\n    // scheme, so we need to use a raw superagent instance to do this request.\n    // Proxy settings must still be respected however\n    const resultPromise = this.getAgentRequest('get', this.url('/client/constants'));\n    resultPromise.set('BitGo-SDK-Version', this._version);\n    if (this._customProxyAgent) {\n      resultPromise.agent(this._customProxyAgent);\n    }\n    if (this.getAdditionalHeadersCb) {\n      const additionalHeaders = this.getAdditionalHeadersCb('get', this.url('/client/constants'));\n      for (const { key, value } of additionalHeaders) {\n        resultPromise.set(key, value);\n      }\n    }\n    const result = await resultPromise;\n\n    if (!BitGoAPI._constants) {\n      BitGoAPI._constants = {};\n    }\n    BitGoAPI._constants[env] = result.body.constants;\n\n    if (result.body?.ttl && typeof result.body?.ttl === 'number') {\n      if (!BitGoAPI._constantsExpire) {\n        BitGoAPI._constantsExpire = {};\n      }\n      BitGoAPI._constantsExpire[env] = new Date(new Date().getTime() + (result.body.ttl as number) * 1000);\n    }\n\n    return BitGoAPI._constants[env];\n  }\n\n  /**\n   * Create a url for calling BitGo platform APIs\n   * @param path\n   * @param version\n   */\n  url(path: string, version = 1): string {\n    const baseUrl = version === 3 ? this._baseApiUrlV3 : version === 2 ? this._baseApiUrlV2 : this._baseApiUrl;\n    return baseUrl + path;\n  }\n\n  /**\n   * Create a url for calling BitGo microservice APIs\n   */\n  microservicesUrl(path: string): string {\n    return this._baseUrl + path;\n  }\n\n  /**\n   * Gets the version of the BitGoJS package\n   */\n  version(): string {\n    return this._version;\n  }\n\n  /**\n   * Test connectivity to the server\n   * @param params\n   */\n  ping({ reqId }: PingOptions = {}): Promise<any> {\n    if (reqId) {\n      this._reqId = reqId;\n    }\n\n    return this.get(this.url('/ping')).result();\n  }\n\n  /**\n   * Set a request tracer to provide request IDs during multi-request workflows\n   */\n  setRequestTracer(reqTracer: IRequestTracer): void {\n    if (reqTracer) {\n      this._reqId = reqTracer;\n    }\n  }\n\n  /**\n   * Utility function to encrypt locally.\n   */\n  encrypt(params: EncryptOptions): string {\n    common.validateParams(params, ['input', 'password'], ['adata']);\n    if (!params.password) {\n      throw new Error(`cannot encrypt without password`);\n    }\n    return encrypt(params.password, params.input, { adata: params.adata });\n  }\n\n  /**\n   * Async encrypt that dispatches to v1 (SJCL) or v2 (Argon2id + AES-256-GCM)\n   * based on `encryptionVersion`.\n   */\n  async encryptAsync(params: EncryptOptions): Promise<string> {\n    common.validateParams(params, ['input', 'password'], []);\n    if (!params.password) {\n      throw new Error('cannot encrypt without password');\n    }\n    return await encryptAsync(params.password, params.input, {\n      adata: params.adata,\n      encryptionVersion: params.encryptionVersion,\n    });\n  }\n\n  /**\n   * Create an encryption session for multi-call operations.\n   * Runs Argon2id once; all subsequent calls derive keys via HKDF.\n   */\n  async createEncryptionSession(password: string) {\n    return createEncryptionSession(password);\n  }\n\n  /**\n   * Decrypt an encrypted string locally.\n   */\n  decrypt(params: DecryptOptions): string {\n    params = params || {};\n    common.validateParams(params, ['input', 'password'], []);\n    if (!params.password) {\n      throw new Error(`cannot decrypt without password`);\n    }\n    try {\n      return decrypt(params.password, params.input);\n    } catch (error) {\n      if (error.message.includes(\"ccm: tag doesn't match\")) {\n        error.message = 'password error - ' + error.message;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Async decrypt that auto-detects v1 (SJCL) or v2 (Argon2id).\n   * Migration path from sync decrypt() -- use this before the breaking release.\n   */\n  async decryptAsync(params: DecryptOptions): Promise<string> {\n    params = params || {};\n    common.validateParams(params, ['input', 'password'], []);\n    if (!params.password) {\n      throw new Error(`cannot decrypt without password`);\n    }\n    try {\n      return await decryptAsync(params.password, params.input);\n    } catch (error) {\n      if (\n        error.message.includes(\"ccm: tag doesn't match\") ||\n        error.message.includes('The operation failed for an operation-specific reason')\n      ) {\n        throw new Error('incorrect password');\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * TODO: deprecate this function in favor of decryptKeysAsync once v2 encryption is default\n   * Attempt to decrypt multiple wallet keys with the provided passphrase\n   * @param {DecryptKeysOptions} params - Parameters object containing wallet key pairs and password\n   * @param {Array<{walletId: string, encryptedPrv: string}>} params.walletIdEncryptedKeyPairs - Array of wallet ID and encrypted private key pairs\n   * @param {string} params.password - The passphrase to attempt decryption with\n   * @returns {string[]} - Array of wallet IDs for which decryption failed\n   */\n  decryptKeys(params: DecryptKeysOptions): string[] {\n    const validatedParams = validateDecryptKeysParams(params);\n    if (validatedParams.walletIdEncryptedKeyPairs.length === 0) {\n      return [];\n    }\n\n    const failedWalletIds: string[] = [];\n\n    for (const keyPair of validatedParams.walletIdEncryptedKeyPairs) {\n      if (!keyPair.walletId || typeof keyPair.walletId !== 'string') {\n        throw new Error('each key pair must have a string walletId');\n      }\n\n      if (!keyPair.encryptedPrv || typeof keyPair.encryptedPrv !== 'string') {\n        throw new Error('each key pair must have a string encryptedPrv');\n      }\n\n      try {\n        this.decrypt({\n          input: keyPair.encryptedPrv,\n          password: validatedParams.password,\n        });\n        // If no error was thrown, decryption was successful\n      } catch (error) {\n        // If decryption fails, add the walletId to the failed list\n        failedWalletIds.push(keyPair.walletId);\n      }\n    }\n\n    return failedWalletIds;\n  }\n\n  /**\n   * Async version of decryptKeys with v2 encrypt/decrypt support.\n   * @param params\n   */\n  async decryptKeysAsync(params: DecryptKeysOptions): Promise<string[]> {\n    const validatedParams = validateDecryptKeysParams(params);\n    if (validatedParams.walletIdEncryptedKeyPairs.length === 0) {\n      return [];\n    }\n\n    const failedWalletIds: string[] = [];\n\n    for (const keyPair of validatedParams.walletIdEncryptedKeyPairs) {\n      if (!keyPair.walletId || typeof keyPair.walletId !== 'string') {\n        throw new Error('each key pair must have a string walletId');\n      }\n\n      if (!keyPair.encryptedPrv || typeof keyPair.encryptedPrv !== 'string') {\n        throw new Error('each key pair must have a string encryptedPrv');\n      }\n\n      try {\n        await this.decryptAsync({\n          input: keyPair.encryptedPrv,\n          password: validatedParams.password,\n        });\n      } catch (error) {\n        failedWalletIds.push(keyPair.walletId);\n      }\n    }\n\n    return failedWalletIds;\n  }\n\n  /**\n   * Serialize this BitGo object to a JSON object.\n   *\n   * Caution: contains sensitive data\n   */\n  toJSON(): BitGoJson {\n    return {\n      user: this._user,\n      token: this._token,\n      extensionKey: this._extensionKey ? this._extensionKey.toWIF() : undefined,\n      ecdhXprv: this._ecdhXprv,\n    };\n  }\n\n  /**\n   * Get the current user\n   */\n  user(): User | undefined {\n    return this._user;\n  }\n\n  /**\n   * Deserialize a JSON serialized BitGo object.\n   *\n   * Overwrites the properties on the current BitGo object with\n   * those of the deserialzed object.\n   *\n   * @param json\n   */\n  fromJSON(json: BitGoJson): void {\n    this._user = json.user;\n    this._token = json.token;\n    this._ecdhXprv = json.ecdhXprv;\n    if (json.extensionKey) {\n      const network = common.Environments[this.getEnv()].network;\n      this._extensionKey = utxolib.ECPair.fromWIF(\n        json.extensionKey,\n        utxolib.networks[network] as utxolib.BitcoinJSNetwork\n      );\n    }\n  }\n\n  /**\n   * Process the username, password and otp into an object containing the username and hashed password, ready to\n   * send to bitgo for authentication.\n   */\n  async preprocessAuthenticationParams({\n    username,\n    password,\n    otp,\n    forceSMS,\n    extensible,\n    trust,\n    forReset2FA,\n    initialHash,\n    fingerprintHash,\n  }: AuthenticateOptions): Promise<ProcessedAuthenticationOptions> {\n    if (!_.isString(username)) {\n      throw new Error('expected string username');\n    }\n\n    if (!_.isString(password)) {\n      throw new Error('expected string password');\n    }\n\n    const lowerName = username.toLowerCase();\n    // Calculate the password HMAC so we don't send clear-text passwords\n    const hmacPassword = await this._hmacAuthStrategy.calculateHMAC(lowerName, password);\n\n    const authParams: ProcessedAuthenticationOptions = {\n      email: lowerName,\n      password: hmacPassword,\n      forceSMS: !!forceSMS,\n    };\n\n    if (otp) {\n      authParams.otp = otp;\n      if (trust) {\n        authParams.trust = 1;\n      }\n    }\n\n    if (extensible) {\n      this._extensionKey = makeRandomKey();\n      authParams.extensible = true;\n      authParams.extensionAddress = getAddressP2PKH(this._extensionKey);\n    }\n\n    if (forReset2FA) {\n      authParams.forReset2FA = true;\n    }\n\n    if (initialHash) {\n      authParams.initialHash = initialHash;\n    }\n\n    if (fingerprintHash) {\n      authParams.fingerprintHash = fingerprintHash;\n    }\n\n    return authParams;\n  }\n\n  /**\n   * Validate the passkey response is in the expected format\n   * Should be as is returned from navigator.credentials.get()\n   */\n  validatePasskeyResponse(passkeyResponse: string): void {\n    const parsedPasskeyResponse = JSON.parse(passkeyResponse);\n    if (!parsedPasskeyResponse && !parsedPasskeyResponse.response) {\n      throw new Error('unexpected webauthnResponse');\n    }\n    if (!_.isString(parsedPasskeyResponse.id)) {\n      throw new Error('id is missing');\n    }\n    if (!_.isString(parsedPasskeyResponse.response.authenticatorData)) {\n      throw new Error('authenticatorData is missing');\n    }\n    if (!_.isString(parsedPasskeyResponse.response.clientDataJSON)) {\n      throw new Error('clientDataJSON is missing');\n    }\n    if (!_.isString(parsedPasskeyResponse.response.signature)) {\n      throw new Error('signature is missing');\n    }\n    if (!_.isString(parsedPasskeyResponse.response.userHandle)) {\n      throw new Error('userHandle is missing');\n    }\n  }\n\n  /**\n   * Synchronous method for activating an access token.\n   */\n  authenticateWithAccessToken({ accessToken }: AccessTokenOptions): void {\n    debug('now authenticating with access token %s', accessToken.substring(0, 8));\n    this._token = accessToken;\n  }\n\n  /**\n   * Creates a new ECDH keychain for the user.\n   * @param {string} loginPassword - The user's login password.\n   * @returns {Promise<any>} - A promise that resolves with the new ECDH keychain data.\n   * @throws {Error} - Throws an error if there is an issue creating the keychain.\n   */\n  public async createUserEcdhKeychain(loginPassword: string): Promise<any> {\n    const keyData = this.keychains().create();\n    const hdNode = bitcoin.HDNode.fromBase58(keyData.xprv);\n\n    /**\n     * Add the new ECDH keychain to the user's account.\n     * @type {Promise<any>} - A promise that resolves with the new ECDH keychain.\n     */\n    return await this.keychains().add({\n      source: 'ecdh',\n      xpub: hdNode.neutered().toBase58(),\n      encryptedXprv: await this.encryptAsync({\n        password: loginPassword,\n        input: hdNode.toBase58(),\n      }),\n    });\n  }\n\n  /**\n   * Updates the user's settings with the provided parameters.\n   * @param {Object} params - The parameters to update the user's settings with.\n   * @returns {Promise<any>}\n   * @throws {Error} - Throws an error if there is an issue updating the user's settings.\n   */\n  private async updateUserSettings(params: any): Promise<any> {\n    return this.put(this.url('/user/settings', 2)).send(params).result();\n  }\n\n  /**\n   * Ensures that the user's ECDH keychain is created for wallet sharing and TSS wallets.\n   * If the keychain does not exist, it will be created and the user's settings will be updated.\n   * @param {string} loginPassword - The user's login password.\n   * @returns {Promise<any>} - A promise that resolves with the user's settings ensuring we have the ecdhKeychain in there.\n   * @throws {Error} - Throws an error if there is an issue creating the keychain or updating the user's settings.\n   */\n  private async ensureUserEcdhKeychainIsCreated(loginPassword: string): Promise<any> {\n    /**\n     * Get the user's current settings.\n     */\n    const userSettings = await this.get(this.url('/user/settings')).result();\n    /**\n     * If the user's ECDH keychain does not exist, create a new keychain and update the user's settings.\n     */\n    if (!userSettings.settings.ecdhKeychain) {\n      const newKeychain = await this.createUserEcdhKeychain(loginPassword);\n      await this.updateUserSettings({\n        settings: {\n          ecdhKeychain: newKeychain.xpub,\n        },\n      });\n      /**\n       * Update the user's settings object with the new ECDH keychain.\n       */\n      userSettings.settings.ecdhKeychain = newKeychain.xpub;\n    }\n    /**\n     * Return the user's ECDH keychain settings.\n     */\n    return userSettings.settings;\n  }\n\n  /**\n   * Login to the bitgo platform.\n   */\n  async authenticate(params: AuthenticateOptions): Promise<LoginResponse | any> {\n    try {\n      if (!_.isObject(params)) {\n        throw new Error('required object params');\n      }\n\n      if (!_.isString(params.password)) {\n        throw new Error('expected string password');\n      }\n\n      const forceV1Auth = !!params.forceV1Auth;\n      const authParams = await this.preprocessAuthenticationParams(params);\n      const password = params.password;\n\n      if (this._token) {\n        return new Error('already logged in');\n      }\n\n      const authUrl = this.microservicesUrl('/api/auth/v1/session');\n      const request = this.post(authUrl);\n\n      if (forceV1Auth) {\n        request.forceV1Auth = true;\n        // tell the server that the client was forced to downgrade the authentication protocol\n        authParams.forceV1Auth = true;\n        debug('forcing v1 auth for call to authenticate');\n      }\n      const response: superagent.Response = await request.send(authParams);\n      // extract body and user information\n      const body = response.body;\n      this._user = body.user;\n\n      if (body.access_token) {\n        this._token = body.access_token;\n        // if the downgrade was forced, adding a warning message might be prudent\n      } else {\n        // check the presence of an encrypted ECDH xprv\n        // if not present, legacy account\n        const encryptedXprv = body.encryptedECDHXprv;\n        if (!encryptedXprv) {\n          throw new Error('Keychain needs encryptedXprv property');\n        }\n\n        const responseDetails = await this.handleTokenIssuanceAsync(response.body, password);\n        this._token = responseDetails.token;\n        this._ecdhXprv = responseDetails.ecdhXprv;\n\n        // verify the response's authenticity\n        await verifyResponseAsync(this, responseDetails.token, 'post', request, response, this._authVersion);\n\n        // add the remaining component for easier access\n        response.body.access_token = this._token;\n      }\n\n      // Sync the token into the strategy so that strategies which manage their\n      // own key material (e.g. WebCryptoHmacStrategy) can sign the subsequent\n      // ensureUserEcdhKeychainIsCreated requests.  Must be awaited — the call\n      // may perform async key derivation (crypto.subtle.importKey).\n      if (this._token) {\n        await this._hmacAuthStrategy.setToken?.(this._token);\n      }\n\n      const userSettings = params.ensureEcdhKeychain ? await this.ensureUserEcdhKeychainIsCreated(password) : undefined;\n      if (userSettings?.ecdhKeychain) {\n        response.body.user.ecdhKeychain = userSettings.ecdhKeychain;\n      }\n\n      return handleResponseResult<LoginResponse>()(response);\n    } catch (e) {\n      handleResponseError(e);\n    }\n  }\n\n  /**\n   * Login to the bitgo platform with passkey.\n   */\n  async authenticateWithPasskey(\n    passkey: string,\n    initialHash?: string,\n    fingerprintHash?: string\n  ): Promise<LoginResponse | any> {\n    try {\n      if (this._token) {\n        return new Error('already logged in');\n      }\n\n      const authUrl = this.microservicesUrl('/api/auth/v1/session');\n      const request = this.post(authUrl);\n\n      this.validatePasskeyResponse(passkey);\n      const userId = JSON.parse(passkey).response.userHandle;\n\n      const response: superagent.Response = await request.send({\n        passkey: passkey,\n        userId: userId,\n        initialHash,\n        fingerprintHash,\n      });\n      // extract body and user information\n      const body = response.body;\n      this._user = body.user;\n\n      if (body.access_token) {\n        this._token = body.access_token;\n        response.body.access_token = body.access_token;\n        await this._hmacAuthStrategy.setToken?.(body.access_token);\n      } else {\n        throw new Error('Failed to login. Please contact support@bitgo.com');\n      }\n\n      return handleResponseResult<LoginResponse>()(response);\n    } catch (e) {\n      handleResponseError(e);\n    }\n  }\n\n  /**\n   * TODO: Deprecate this function in favor of handleTokenIssuanceAsync once v2 encryption is default.\n   * @param responseBody Response body object\n   * @param password Password for the symmetric decryption\n   */\n  handleTokenIssuance(responseBody: TokenIssuanceResponse, password?: string): TokenIssuance {\n    // make sure the response body contains the necessary properties\n    common.validateParams(responseBody, ['derivationPath'], ['encryptedECDHXprv']);\n\n    const environment = this._env;\n    const environmentConfig = common.Environments[environment];\n    const serverXpub = environmentConfig.serverXpub;\n    let ecdhXprv = this._ecdhXprv;\n    if (!ecdhXprv) {\n      if (!password || !responseBody.encryptedECDHXprv) {\n        throw new Error('ecdhXprv property must be set or password and encrypted encryptedECDHXprv must be provided');\n      }\n      try {\n        ecdhXprv = this.decrypt({\n          input: responseBody.encryptedECDHXprv,\n          password: password,\n        });\n      } catch (e) {\n        e.errorCode = 'ecdh_xprv_decryption_failure';\n        console.error('Failed to decrypt encryptedECDHXprv.');\n        throw e;\n      }\n    }\n\n    const secret = deriveTokenIssuanceEcdhSecret(ecdhXprv, responseBody.derivationPath, serverXpub);\n\n    try {\n      const token = this.decrypt({\n        input: responseBody.encryptedToken,\n        password: secret,\n      });\n      const response: TokenIssuance = { token };\n      if (!this._ecdhXprv) {\n        response.ecdhXprv = ecdhXprv;\n      }\n      return response;\n    } catch (e) {\n      e.errorCode = 'token_decryption_failure';\n      console.error('Failed to decrypt token.');\n      throw e;\n    }\n  }\n\n  /**\n   * Async version of handleTokenIssuance with v2 encrypt/decrypt support.\n   * @param responseBody Response body object\n   * @param password Password for the symmetric decryption\n   */\n  async handleTokenIssuanceAsync(responseBody: TokenIssuanceResponse, password?: string): Promise<TokenIssuance> {\n    // make sure the response body contains the necessary properties\n    common.validateParams(responseBody, ['derivationPath'], ['encryptedECDHXprv']);\n\n    const environment = this._env;\n    const environmentConfig = common.Environments[environment];\n    const serverXpub = environmentConfig.serverXpub;\n    let ecdhXprv = this._ecdhXprv;\n    if (!ecdhXprv) {\n      if (!password || !responseBody.encryptedECDHXprv) {\n        throw new Error('ecdhXprv property must be set or password and encrypted encryptedECDHXprv must be provided');\n      }\n      try {\n        ecdhXprv = await this.decryptAsync({\n          input: responseBody.encryptedECDHXprv,\n          password: password,\n        });\n      } catch (e) {\n        e.errorCode = 'ecdh_xprv_decryption_failure';\n        console.error('Failed to decrypt encryptedECDHXprv.');\n        throw e;\n      }\n    }\n\n    const secret = deriveTokenIssuanceEcdhSecret(ecdhXprv, responseBody.derivationPath, serverXpub);\n\n    try {\n      const token = await this.decryptAsync({\n        input: responseBody.encryptedToken,\n        password: secret,\n      });\n      const response: TokenIssuance = { token };\n      if (!this._ecdhXprv) {\n        response.ecdhXprv = ecdhXprv;\n      }\n      return response;\n    } catch (e) {\n      e.errorCode = 'token_decryption_failure';\n      console.error('Failed to decrypt token.');\n      throw e;\n    }\n  }\n\n  /**\n   */\n  async verifyPassword(params: VerifyPasswordOptions = {}): Promise<any> {\n    if (!_.isString(params.password)) {\n      throw new Error('missing required string password');\n    }\n\n    if (!this._user || !this._user.username) {\n      throw new Error('no current user');\n    }\n    const hmacPassword = await this._hmacAuthStrategy.calculateHMAC(this._user.username, params.password);\n\n    return this.post(this.url('/user/verifypassword')).send({ password: hmacPassword }).result('valid');\n  }\n\n  /**\n   * Clear out all state from this BitGo object, effectively logging out the current user.\n   */\n  clear(): void {\n    // TODO: are there any other fields which should be cleared?\n    this._user = undefined;\n    this._token = undefined;\n    this._refreshToken = undefined;\n    this._ecdhXprv = undefined;\n  }\n\n  async clearAsync(): Promise<void> {\n    this.clear();\n    await this._hmacAuthStrategy.clearToken?.();\n  }\n\n  /**\n   * Use refresh token to get new access token.\n   * If the refresh token is null/defined, then we use the stored token from auth\n   */\n  async refreshToken(params: { refreshToken?: string } = {}): Promise<any> {\n    common.validateParams(params, [], ['refreshToken']);\n\n    const refreshToken = params.refreshToken || this._refreshToken;\n\n    if (!refreshToken) {\n      throw new Error('Must provide refresh token or have authenticated with Oauth before');\n    }\n\n    if (!this._clientId || !this._clientSecret) {\n      throw new Error('Need client id and secret set first to use this');\n    }\n\n    const body = await this.post(this._baseUrl + '/oauth/token')\n      .send({\n        grant_type: 'refresh_token',\n        refresh_token: refreshToken,\n        client_id: this._clientId,\n        client_secret: this._clientSecret,\n      })\n      .result();\n    this._token = body.access_token;\n    this._refreshToken = body.refresh_token;\n    await this._hmacAuthStrategy?.setToken?.(body.access_token);\n    return body;\n  }\n\n  /**\n   *\n   * listAccessTokens\n   * Get information on all of the BitGo access tokens on the user\n   * @return {\n   *  id: <id of the token>\n   *  label: <the user-provided label for this token>\n   *  user: <id of the user on the token>\n   *  enterprise <id of the enterprise this token is valid for>\n   *  client: <the auth client that this token belongs to>\n   *  scope: <list of allowed OAuth scope values>\n   *  created: <date the token was created>\n   *  expires: <date the token will expire>\n   *  origin: <the origin for which this token is valid>\n   *  isExtensible: <flag indicating if the token can be extended>\n   *  extensionAddress: <address whose private key's signature is necessary for extensions>\n   *  unlock: <info for actions that require an unlock before firing>\n   * }\n   */\n  async listAccessTokens(): Promise<any> {\n    return this.get(this.url('/user/accesstoken')).send().result('accessTokens');\n  }\n\n  /**\n   * addAccessToken\n   * Add a BitGo API Access Token to the current user account\n   * @param params {\n   *    otp: (required) <valid otp code>\n   *    label: (required) <label for the token>\n   *    duration: <length of time in seconds the token will be valid for>\n   *    ipRestrict: <array of IP address strings to whitelist>\n   *    txValueLimit: <number of outgoing satoshis allowed on this token>\n   *    scope: (required) <authorization scope of the requested token>\n   * }\n   * @return {\n   *    id: <id of the token>\n   *    token: <access token hex string to be used for BitGo API request verification>\n   *    label: <user-provided label for this token>\n   *    user: <id of the user on the token>\n   *    enterprise <id of the enterprise this token is valid for>\n   *    client: <the auth client that this token belongs to>\n   *    scope: <list of allowed OAuth scope values>\n   *    created: <date the token was created>\n   *    expires: <date the token will expire>\n   *    origin: <the origin for which this token is valid>\n   *    isExtensible: <flag indicating if the token can be extended>\n   *    extensionAddress: <address whose private key's signature is necessary for extensions>\n   *    unlock: <info for actions that require an unlock before firing>\n   * }\n   */\n  async addAccessToken(params: AddAccessTokenOptions): Promise<AddAccessTokenResponse> {\n    try {\n      if (!_.isString(params.label)) {\n        throw new Error('required string label');\n      }\n\n      // check non-string params\n      if (params.duration) {\n        if (!_.isNumber(params.duration) || params.duration < 0) {\n          throw new Error('duration must be a non-negative number');\n        }\n      }\n      if (params.ipRestrict) {\n        if (!_.isArray(params.ipRestrict)) {\n          throw new Error('ipRestrict must be an array');\n        }\n        _.forEach(params.ipRestrict, (ipAddr) => {\n          if (!_.isString(ipAddr)) {\n            throw new Error('ipRestrict must be an array of IP address strings');\n          }\n        });\n      }\n      if (params.txValueLimit) {\n        if (!_.isNumber(params.txValueLimit)) {\n          throw new Error('txValueLimit must be a number');\n        }\n        if (params.txValueLimit < 0) {\n          throw new Error('txValueLimit must be a non-negative number');\n        }\n      }\n      if (params.scope && params.scope.length > 0) {\n        if (!_.isArray(params.scope)) {\n          throw new Error('scope must be an array');\n        }\n      } else {\n        throw new Error('must specify scope for token');\n      }\n\n      const authUrl = this.microservicesUrl('/api/auth/v1/accesstoken');\n      const request = this.post(authUrl);\n\n      if (!this._ecdhXprv) {\n        // without a private key, the user cannot decrypt the new access token the server will send\n        request.forceV1Auth = true;\n        debug('forcing v1 auth for adding access token using token %s', this._token?.substr(0, 8));\n      }\n\n      const response = await request.send(params);\n      if (request.forceV1Auth) {\n        (response as any).body.warning = 'A protocol downgrade has occurred because this is a legacy account.';\n        return handleResponseResult<AddAccessTokenResponse>()(response);\n      }\n\n      // verify the authenticity of the server's response before proceeding any further\n      await verifyResponseAsync(this, this._token, 'post', request, response, this._authVersion);\n\n      const responseDetails = await this.handleTokenIssuanceAsync(response.body);\n      response.body.token = responseDetails.token;\n\n      return handleResponseResult<AddAccessTokenResponse>()(response);\n    } catch (e) {\n      handleResponseError(e);\n    }\n  }\n\n  /**\n   * Sets the expire time of an access token matching either the id or label to the current date, effectively deleting it\n   *\n   * Params:\n   * id: <id of the access token to be deleted>\n   * label: <label of the access token to be deleted>\n   *\n   * Returns:\n   * id: <id of the token>\n   * label: <user-provided label for this token>\n   * user: <id of the user on the token>\n   * enterprise <id of the enterprise this token is valid for>\n   * client: <the auth client that this token belongs to>\n   * scope: <list of allowed OAuth scope values>\n   * created: <date the token was created>\n   * expires: <date the token will expire>\n   * origin: <the origin for which this token is valid>\n   * isExtensible: <flag indicating if the token can be extended>\n   * extensionAddress: <address whose private key's signature is ne*cessary for extensions>\n   * unlock: <info for actions that require an unlock before firing>\n   * @param params\n   */\n  async removeAccessToken({ id, label }: RemoveAccessTokenOptions): Promise<any> {\n    if ((!id && !label) || (id && label)) {\n      throw new Error('must provide exactly one of id or label');\n    }\n    if (id) {\n      return this.del(this.url(`/user/accesstoken/${id}`))\n        .send()\n        .result();\n    }\n\n    const tokens = await this.listAccessTokens();\n\n    if (!tokens) {\n      throw new Error('token with this label does not exist');\n    }\n\n    const matchingTokens = _.filter(tokens, { label });\n    if (matchingTokens.length > 1) {\n      throw new Error('ambiguous call: multiple tokens matching this label');\n    }\n    if (matchingTokens.length === 0) {\n      throw new Error('token with this label does not exist');\n    }\n\n    return this.del(this.url(`/user/accesstoken/${matchingTokens[0].id}`))\n      .send()\n      .result();\n  }\n\n  /**\n   * Generate a random password\n   * @param   {Number} numWords     Number of 32-bit words\n   * @returns {String}          base58 random password\n   */\n  generateRandomPassword(numWords = 5): string {\n    return generateRandomPassword(numWords);\n  }\n\n  /**\n   * Logout of BitGo\n   */\n  async logout(): Promise<any> {\n    const result = await this.get(this.url('/user/logout')).result();\n    this.clear();\n    return result;\n  }\n\n  /**\n   * Get a user by ID (name/email only)\n   * @param id\n   *\n   * @deprecated\n   */\n  async getUser({ id }: GetUserOptions): Promise<any> {\n    if (!_.isString(id)) {\n      throw new Error('expected string id');\n    }\n    return this.get(this.url(`/user/${id}`)).result('user');\n  }\n  /**\n   * Get the current logged in user\n   */\n  async me(): Promise<any> {\n    return this.getUser({ id: 'me' });\n  }\n\n  /**\n   * Unlock the session by providing OTP\n   * @param {string} otp Required OTP code for the account.\n   * @param {number} duration Desired duration of the unlock in seconds (default=600, max=3600).\n   */\n  async unlock({ otp, duration }: UnlockOptions): Promise<any> {\n    if (otp && !_.isString(otp)) {\n      throw new Error('expected string or undefined otp');\n    }\n    return this.post(this.url('/user/unlock')).send({ otp, duration }).result();\n  }\n\n  /**\n   * Lock the session\n   */\n  async lock(): Promise<any> {\n    return this.post(this.url('/user/lock')).result();\n  }\n\n  /**\n   * Get the current session\n   */\n  async session(): Promise<any> {\n    return this.get(this.url('/user/session')).result('session');\n  }\n\n  /**\n   * Trigger a push/sms for the OTP code\n   * @param {boolean} params.forceSMS If set to true, will use SMS to send the OTP to the user even if they have other 2FA method set up.\n   * @deprecated\n   */\n  async sendOTP(params: { forceSMS?: boolean } = {}): Promise<any> {\n    return this.post(this.url('/user/sendotp')).send(params).result();\n  }\n\n  /**\n   * Extend token, provided the current token is extendable\n   * @param params\n   * - duration: duration in seconds by which to extend the token, starting at the current time\n   */\n  async extendToken(params: ExtendTokenOptions = {}): Promise<any> {\n    if (!this._extensionKey) {\n      throw new Error('missing required property _extensionKey');\n    }\n\n    const timestamp = Date.now();\n    const duration = params.duration;\n    const message = timestamp + '|' + this._token + '|' + duration;\n    const privateKey = this._extensionKey.privateKey;\n    if (!privateKey) {\n      throw new Error('no privateKey on extensionKey');\n    }\n    const isCompressed = this._extensionKey.compressed;\n    const prefix = utxolib.networks.bitcoin.messagePrefix;\n    const signature = bitcoinMessage.sign(message, privateKey, isCompressed, prefix).toString('hex');\n\n    return this.post(this.url('/user/extendtoken'))\n      .send(params)\n      .set('timestamp', timestamp.toString())\n      .set('signature', signature)\n      .result();\n  }\n\n  /**\n   * Get a key for sharing a wallet with a user\n   * @param email email of user to share wallet with\n   */\n  async getSharingKey({ email }: GetSharingKeyOptions): Promise<any> {\n    if (!_.isString(email)) {\n      throw new Error('required string email');\n    }\n\n    return this.post(this.url('/user/sharingkey')).send({ email }).result();\n  }\n\n  /**\n   * Users that want to sign with a key will use this api to fetch the keychain and the path.\n   * Users that want to verify a signature will use this api to fetch another users ecdh pubkey.\n   * Note: If the user id is not provided, it will default to getting the current user's keychain.\n   * @param bitgo\n   * @param enterpriseId\n   * @param userId\n   */\n  async getSigningKeyForUser(enterpriseId: string, userId?: string): Promise<GetSigningKeyApi> {\n    const user = userId ?? 'me';\n    return this.get(this.url(`/enterprise/${enterpriseId}/user/${user}/signingkey`, 2))\n      .query({})\n      .result();\n  }\n\n  /**\n   *\n   */\n  getValidate(): boolean {\n    return this._validate;\n  }\n\n  /**\n   *\n   */\n  setValidate(validate: boolean): void {\n    if (!_.isBoolean(validate)) {\n      throw new Error('invalid argument');\n    }\n    this._validate = validate;\n  }\n\n  /**\n   * Register a new coin instance with its builder factory\n   * @param {string} name coin name as it was registered in @bitgo-beta/statics\n   * @param {CoinConstructor} coin the builder factory class for that coin\n   * @returns {void}\n   */\n  public register(name: string, coin: CoinConstructor): void {\n    GlobalCoinFactory.register(name, coin);\n  }\n\n  /**\n   * Get bitcoin market data\n   *\n   * @deprecated\n   */\n  markets(): any {\n    if (!this._markets) {\n      this._markets = new Markets(this);\n    }\n    return this._markets;\n  }\n\n  /**\n   * Get the latest bitcoin prices\n   * (Deprecated: Will be removed in the future) use `bitgo.markets().latest()`\n   * @deprecated\n   */\n  // cb-compat\n  async market(): Promise<any> {\n    return this.get(this.url('/market/latest')).result();\n  }\n\n  /**\n   * Get market data from yesterday\n   * (Deprecated: Will be removed in the future) use bitgo.markets().yesterday()\n   * @deprecated\n   */\n  async yesterday(): Promise<any> {\n    return this.get(this.url('/market/yesterday')).result();\n  }\n\n  /**\n   * Get the blockchain object.\n   * @deprecated\n   */\n  blockchain(): any {\n    if (!this._blockchain) {\n      this._blockchain = new Blockchain(this);\n    }\n    return this._blockchain;\n  }\n\n  /**\n   * Get the user's keychains object.\n   * @deprecated\n   */\n  keychains(): any {\n    if (!this._keychains) {\n      this._keychains = new Keychains(this);\n    }\n    return this._keychains;\n  }\n\n  /**\n   * Get the travel rule object\n   * @deprecated\n   */\n  travelRule(): any {\n    if (!this._travelRule) {\n      this._travelRule = new TravelRule(this);\n    }\n    return this._travelRule;\n  }\n\n  /**\n   * Get the user's wallets object.\n   * @deprecated\n   */\n  wallets(): any {\n    if (!this._wallets) {\n      this._wallets = new Wallets(this);\n    }\n    return this._wallets;\n  }\n\n  /**\n   * Get pending approvals that can be approved/ or rejected\n   * @deprecated\n   */\n  pendingApprovals(): any {\n    if (!this._pendingApprovals) {\n      this._pendingApprovals = new PendingApprovals(this);\n    }\n    return this._pendingApprovals;\n  }\n\n  /**\n   * A factory method to create a new Wallet object, initialized with the wallet params\n   * Can be used to reconstitute a wallet from cached data\n   * @param walletParams\n   * @deprecated\n   */\n  newWalletObject(walletParams): any {\n    return new Wallet(this, walletParams);\n  }\n\n  /**\n   * V1 method for calculating miner fee amounts, given the number and\n   * type of transaction inputs, along with a fee rate in satoshis per vkB.\n   *\n   * This method should not be used for new code.\n   *\n   * @deprecated\n   * @param params\n   * @return {any}\n   */\n  async calculateMinerFeeInfo(params: any): Promise<any> {\n    return TransactionBuilder.calculateMinerFeeInfo(params);\n  }\n\n  /**\n   * Verify a Bitcoin address is a valid base58 address\n   * @deprecated\n   */\n  verifyAddress(params: DeprecatedVerifyAddressOptions = {}): boolean {\n    common.validateParams(params, ['address'], []);\n\n    if (!_.isString(params.address)) {\n      throw new Error('missing required string address');\n    }\n\n    const networkName = common.Environments[this.getEnv()].network;\n    const network = utxolib.networks[networkName];\n\n    return verifyAddress(params.address, network);\n  }\n\n  /**\n   * TODO: deprecate this function in favor of splitSecretAsync when v2 encryption is the default\n   * Split a secret into shards using Shamir Secret Sharing.\n   * @param seed A hexadecimal secret to split\n   * @param passwords An array of the passwords used to encrypt each share\n   * @param m The threshold number of shards necessary to reconstitute the secret\n   */\n  splitSecret({ seed, passwords, m }: SplitSecretOptions): SplitSecret {\n    const n = validateSplitSecretInputs({ seed, passwords, m });\n    const secrets: string[] = shamir.share(seed, n, m);\n    const shards = _.zipWith(secrets, passwords, (shard, password) => {\n      return this.encrypt({ input: shard, password });\n    });\n    return buildSplitSecretResult(seed, shards, m, n);\n  }\n\n  /**\n   * Async version of splitSecret with v2 encrypt/decrypt support.\n   * @param seed\n   * @param passwords\n   * @param m\n   */\n  async splitSecretAsync({ seed, passwords, m }: SplitSecretOptions): Promise<SplitSecret> {\n    const n = validateSplitSecretInputs({ seed, passwords, m });\n    const secrets: string[] = shamir.share(seed, n, m);\n    const shards = await Promise.all(\n      secrets.map((shard, i) => this.encryptAsync({ input: shard, password: passwords[i] }))\n    );\n    return buildSplitSecretResult(seed, shards, m, n);\n  }\n\n  /**\n   * TODO: deprecate this function in favor of reconstituteSecretAsync when v2 encryption is the default\n   * Reconstitute a secret which was sharded with `splitSecret`.\n   * @param shards\n   * @param passwords\n   */\n  reconstituteSecret({ shards, passwords }: ReconstituteSecretOptions): ReconstitutedSecret {\n    validateReconstituteInputs({ shards, passwords });\n    const secrets = _.zipWith(shards, passwords, (shard, password) => {\n      return this.decrypt({ input: shard, password });\n    });\n    const seed: string = shamir.combine(secrets);\n    return buildReconstitutedSecret(seed);\n  }\n\n  /**\n   * Async version of reconstituteSecret with v2 encrypt/decrypt support.\n   * @param shards\n   * @param passwords\n   */\n  async reconstituteSecretAsync({ shards, passwords }: ReconstituteSecretOptions): Promise<ReconstitutedSecret> {\n    validateReconstituteInputs({ shards, passwords });\n    const secrets = await Promise.all(\n      shards.map((shard, i) => this.decryptAsync({ input: shard, password: passwords[i] }))\n    );\n    const seed: string = shamir.combine(secrets);\n    return buildReconstitutedSecret(seed);\n  }\n\n  /**\n   * TODO: Deprecate this function in favour of verifyShardsAsync when v2 encryption is the default.\n   * @param shards\n   * @param passwords\n   * @param m\n   * @param xpub Optional xpub to verify the results against\n   */\n  verifyShards({ shards, passwords, m, xpub }: VerifyShardsOptions): boolean {\n    validateReconstituteInputs({ shards, passwords });\n    const secrets = _.zipWith(shards, passwords, (shard, password) => {\n      return this.decrypt({ input: shard, password });\n    });\n    return verifyShardSecrets(secrets, m, xpub);\n  }\n\n  /**\n   * Async version of verifyShards with v2 encrypt/decrypt support.\n   * @param shards\n   * @param passwords\n   * @param m\n   * @param xpub\n   */\n  async verifyShardsAsync({ shards, passwords, m, xpub }: VerifyShardsOptions): Promise<boolean> {\n    validateReconstituteInputs({ shards, passwords });\n    const secrets = await Promise.all(\n      shards.map((shard, i) => this.decryptAsync({ input: shard, password: passwords[i] }))\n    );\n    return verifyShardSecrets(secrets, m, xpub);\n  }\n\n  /**\n   * @deprecated - use `getSharedSecret()`\n   */\n  getECDHSecret({ otherPubKeyHex, eckey }: GetEcdhSecretOptions): string {\n    if (!_.isString(otherPubKeyHex)) {\n      throw new Error('otherPubKeyHex string required');\n    }\n    if (!_.isObject(eckey)) {\n      throw new Error('eckey object required');\n    }\n\n    return getSharedSecret(eckey, Buffer.from(otherPubKeyHex, 'hex')).toString('hex');\n  }\n\n  /**\n   * Gets the user's private ECDH keychain\n   */\n  async getECDHKeychain(ecdhKeychainPub?: string): Promise<any> {\n    if (!ecdhKeychainPub) {\n      const result = await this.get(this.url('/user/settings')).result();\n      if (!result.settings.ecdhKeychain) {\n        return new Error('ecdh keychain not found for user');\n      }\n      ecdhKeychainPub = result.settings.ecdhKeychain;\n    }\n    return this.keychains().get({ xpub: ecdhKeychainPub });\n  }\n\n  /**\n   * Returns the user derived public and private ECDH keypair\n   * @param password password to decrypt the user's ECDH encrypted private key\n   * @param entId? optional enterprise id to check for permissions\n   */\n  async getEcdhKeypairPrivate(password: string, entId: string): Promise<EcdhDerivedKeypair> {\n    const userSigningKey = await this.getSigningKeyForUser(entId);\n    const pubkeyOfAdminEcdhKeyHex = userSigningKey.derivedPubkey;\n    if (!userSigningKey.ecdhKeychain || !userSigningKey.derivationPath) {\n      throw new Error('Something went wrong with the user keychain. Please contact support@bitgo.com.');\n    }\n    const userEcdhKeychain = await this.getECDHKeychain(userSigningKey.ecdhKeychain);\n    let xprv;\n    try {\n      xprv = await this.decryptAsync({\n        password: password,\n        input: userEcdhKeychain.encryptedXprv,\n      });\n    } catch (e) {\n      throw new Error('Incorrect password. Please try again.');\n    }\n    return {\n      derivedPubKey: pubkeyOfAdminEcdhKeyHex,\n      derivationPath: userSigningKey.derivationPath,\n      xprv,\n    };\n  }\n\n  /**\n   * @param params\n   * - operatingSystem: one of ios, android\n   * - pushToken: hex-formatted token for the respective native push notification service\n   * @returns {*}\n   * @deprecated\n   */\n  async registerPushToken(params: RegisterPushTokenOptions): Promise<any> {\n    params = params || {};\n    common.validateParams(params, ['pushToken', 'operatingSystem'], []);\n\n    if (!this._token) {\n      // this device has to be registered to an extensible session\n      throw new Error('not logged in');\n    }\n\n    const postParams = _.pick(params, ['pushToken', 'operatingSystem']);\n\n    return this.post(this.url('/devices')).send(postParams).result();\n  }\n\n  /**\n   * @param params\n   * - pushVerificationToken: the token received via push notification to confirm the device's mobility\n   * @deprecated\n   */\n  verifyPushToken(params: VerifyPushTokenOptions): Promise<any> {\n    if (!_.isObject(params)) {\n      throw new Error('required object params');\n    }\n\n    if (!_.isString(params.pushVerificationToken)) {\n      throw new Error('required string pushVerificationToken');\n    }\n\n    if (!this._token) {\n      // this device has to be registered to an extensible session\n      throw new Error('not logged in');\n    }\n\n    const postParams = _.pick(params, 'pushVerificationToken');\n\n    return this.post(this.url('/devices/verify')).send(postParams).result();\n  }\n\n  /**\n   * Login to the bitgo system using an authcode generated via Oauth\n   */\n  async authenticateWithAuthCode(params: AuthenticateWithAuthCodeOptions): Promise<any> {\n    if (!_.isObject(params)) {\n      throw new Error('required object params');\n    }\n\n    if (!_.isString(params.authCode)) {\n      throw new Error('required string authCode');\n    }\n\n    if (!this._clientId || !this._clientSecret) {\n      throw new Error('Need client id and secret set first to use this');\n    }\n\n    const authCode = params.authCode;\n\n    if (this._token) {\n      throw new Error('already logged in');\n    }\n\n    const request = this.post(this._baseUrl + '/oauth/token');\n    request.forceV1Auth = true; // OAuth currently only supports v1 authentication\n    const body = await request\n      .send({\n        grant_type: 'authorization_code',\n        code: authCode,\n        client_id: this._clientId,\n        client_secret: this._clientSecret,\n      })\n      .result();\n\n    this._token = body.access_token;\n    this._refreshToken = body.refresh_token;\n\n    await this._hmacAuthStrategy?.setToken?.(body.access_token);\n\n    this._user = await this.me();\n    return body;\n  }\n\n  /**\n   * Change the password of the currently logged in user.\n   * Also change all v1 and v2 keychain passwords if they match the\n   * given oldPassword. Returns nothing on success.\n   * @param oldPassword {String} - the current password\n   * @param newPassword {String} - the new password\n   */\n  async changePassword({ oldPassword, newPassword }: ChangePasswordOptions): Promise<any> {\n    if (!_.isString(oldPassword)) {\n      throw new Error('expected string oldPassword');\n    }\n\n    if (!_.isString(newPassword)) {\n      throw new Error('expected string newPassword');\n    }\n\n    const user = this.user();\n    if (typeof user !== 'object' || !user.username) {\n      throw new Error('missing required object user');\n    }\n\n    const validation = await this.verifyPassword({ password: oldPassword });\n    if (!validation) {\n      throw new Error('the provided oldPassword is incorrect');\n    }\n\n    // it doesn't matter which coin we choose because the v2 updatePassword functions updates all v2 keychains\n    // we just need to choose a coin that exists in the current environment\n    const coin = common.Environments[this.getEnv()].network === 'bitcoin' ? 'btc' : 'tbtc';\n\n    const updateKeychainPasswordParams = { oldPassword, newPassword };\n    const v1KeychainUpdatePWResult = await this.keychains().updatePassword(updateKeychainPasswordParams);\n    const v2Keychains = await this.coin(coin).keychains().updatePassword(updateKeychainPasswordParams);\n\n    const [hmacOldPassword, hmacNewPassword] = await Promise.all([\n      this._hmacAuthStrategy.calculateHMAC(user.username, oldPassword),\n      this._hmacAuthStrategy.calculateHMAC(user.username, newPassword),\n    ]);\n\n    const updatePasswordParams = {\n      keychains: v1KeychainUpdatePWResult.keychains,\n      v2_keychains: v2Keychains,\n      version: v1KeychainUpdatePWResult.version,\n      oldPassword: hmacOldPassword,\n      password: hmacNewPassword,\n    };\n\n    // Calculate payload size in KB\n    const payloadSizeBytes = JSON.stringify(updatePasswordParams).length;\n    const payloadSizeKB = Math.ceil(payloadSizeBytes / 1024);\n\n    // Check if batching flow is enabled\n    try {\n      const batchingFlowCheck = await this.get(this.url('/user/checkBatchingPasswordFlow', 2))\n        .query({ payloadSize: payloadSizeKB.toString() })\n        .result();\n\n      if (batchingFlowCheck.isBatchingFlowEnabled) {\n        await this.processKeychainPasswordUpdatesInBatches(\n          updatePasswordParams.keychains,\n          updatePasswordParams.v2_keychains,\n          batchingFlowCheck.maxBatchSizeKB,\n          3\n        );\n        // Call changepassword API without keychains for batching flow\n        return this.post(this.url('/user/changepassword'))\n          .send({\n            version: updatePasswordParams.version,\n            oldPassword: updatePasswordParams.oldPassword,\n            password: updatePasswordParams.password,\n          })\n          .result();\n      }\n    } catch (error) {\n      // batching flow check failed\n    }\n\n    return this.post(this.url('/user/changepassword')).send(updatePasswordParams).result();\n  }\n\n  /**\n   * Get all the address labels on all of the user's wallets\n   *\n   * @deprecated\n   */\n  async labels(): Promise<any> {\n    return this.get(this.url('/labels')).result('labels');\n  }\n\n  /**\n   * Estimates approximate fee per kb needed for a tx to get into a block\n   * @param {number} params.numBlocks target blocks for the transaction to be confirmed\n   * @param {number} params.maxFee maximum fee willing to be paid (for safety)\n   * @param {array[string]} params.inputs list of unconfirmed txIds from which this transaction uses inputs\n   * @param {number} params.txSize estimated transaction size in bytes, optional parameter used for CPFP estimation.\n   * @param {boolean} params.cpfpAware flag indicating fee should take into account CPFP\n   * @deprecated\n   */\n  async estimateFee(params: EstimateFeeOptions = {}): Promise<any> {\n    const queryParams: any = { version: 12 };\n    if (params.numBlocks) {\n      if (!_.isNumber(params.numBlocks)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.numBlocks = params.numBlocks;\n    }\n    if (params.maxFee) {\n      if (!_.isNumber(params.maxFee)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.maxFee = params.maxFee;\n    }\n    if (params.inputs) {\n      if (!Array.isArray(params.inputs)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.inputs = params.inputs;\n    }\n    if (params.txSize) {\n      if (!_.isNumber(params.txSize)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.txSize = params.txSize;\n    }\n    if (params.cpfpAware) {\n      if (!_.isBoolean(params.cpfpAware)) {\n        throw new Error('invalid argument');\n      }\n      queryParams.cpfpAware = params.cpfpAware;\n    }\n\n    return this.get(this.url('/tx/fee')).query(queryParams).result();\n  }\n\n  /**\n   * Get BitGo's guarantee using an instant id\n   * @param params\n   * @deprecated\n   */\n  async instantGuarantee(params: { id: string }): Promise<any> {\n    if (!_.isString(params.id)) {\n      throw new Error('required string id');\n    }\n\n    const body = await this.get(this.url('/instant/' + params.id)).result();\n    if (!body.guarantee) {\n      throw new Error('no guarantee found in response body');\n    }\n    if (!body.signature) {\n      throw new Error('no signature found in guarantee response body');\n    }\n    const signingAddress = common.Environments[this.getEnv()].signingAddress;\n    const signatureBuffer = Buffer.from(body.signature, 'hex');\n    const prefix = utxolib.networks[common.Environments[this.getEnv()].network].messagePrefix;\n    const isValidSignature = bitcoinMessage.verify(body.guarantee, signingAddress, signatureBuffer, prefix);\n    if (!isValidSignature) {\n      throw new Error('incorrect signature');\n    }\n    return body;\n  }\n\n  /**\n   * Get a target address for payment of a BitGo fee\n   * @deprecated\n   */\n  async getBitGoFeeAddress(): Promise<any> {\n    return this.post(this.url('/billing/address')).send({}).result();\n  }\n\n  /**\n   * Gets an address object (including the wallet id) for a given address.\n   * @param {string} params.address The address to look up.\n   * @deprecated\n   */\n  async getWalletAddress({ address }: { address: string }): Promise<any> {\n    return this.get(this.url(`/walletaddress/${address}`)).result();\n  }\n\n  /**\n   * Fetch list of user webhooks\n   *\n   * @returns {*}\n   * @deprecated\n   */\n  async listWebhooks(): Promise<any> {\n    return this.get(this.url('/webhooks')).result();\n  }\n\n  /**\n   * Add new user webhook\n   *\n   * @param params\n   * @returns {*}\n   * @deprecated\n   */\n  async addWebhook(params: WebhookOptions): Promise<any> {\n    if (!_.isString(params.url)) {\n      throw new Error('required string url');\n    }\n\n    if (!_.isString(params.type)) {\n      throw new Error('required string type');\n    }\n\n    return this.post(this.url('/webhooks')).send(params).result();\n  }\n\n  /**\n   * Remove user webhook\n   *\n   * @param params\n   * @returns {*}\n   * @deprecated\n   */\n  async removeWebhook(params: WebhookOptions): Promise<any> {\n    if (!_.isString(params.url)) {\n      throw new Error('required string url');\n    }\n\n    if (!_.isString(params.type)) {\n      throw new Error('required string type');\n    }\n\n    return this.del(this.url('/webhooks')).send(params).result();\n  }\n\n  /**\n   * Fetch list of webhook notifications for the user\n   *\n   * @param params\n   * @returns {*}\n   */\n  async listWebhookNotifications(params: ListWebhookNotificationsOptions = {}): Promise<any> {\n    const query: any = {};\n    if (params.prevId) {\n      if (!_.isString(params.prevId)) {\n        throw new Error('invalid prevId argument, expecting string');\n      }\n      query.prevId = params.prevId;\n    }\n    if (params.limit) {\n      if (!_.isNumber(params.limit)) {\n        throw new Error('invalid limit argument, expecting number');\n      }\n      query.limit = params.limit;\n    }\n\n    return this.get(this.url('/webhooks/notifications')).query(query).result();\n  }\n\n  /**\n   * Simulate a user webhook\n   *\n   * @param params\n   * @returns {*}\n   */\n  async simulateWebhook(params: BitGoSimulateWebhookOptions): Promise<any> {\n    common.validateParams(params, ['webhookId', 'blockId'], []);\n    if (!_.isString(params.webhookId)) {\n      throw new Error('required string webhookId');\n    }\n\n    if (!_.isString(params.blockId)) {\n      throw new Error('required string blockId');\n    }\n\n    return this.post(this.url(`/webhooks/${params.webhookId}/simulate`))\n      .send(params)\n      .result();\n  }\n\n  /**\n   * Synchronously get constants which are relevant to the client.\n   *\n   * Note: This function has a known race condition. It may return different values over time,\n   * especially if called shortly after creation of the BitGo object.\n   *\n   * New code should call fetchConstants() directly instead.\n   *\n   * @deprecated\n   * @return {Object} The client constants object\n   */\n  getConstants(): any {\n    // kick off a fresh request for the client constants\n    this.fetchConstants().catch(function (err) {\n      if (err) {\n        // make sure an error does not terminate the entire script\n        console.error('failed to fetch client constants from BitGo');\n        console.trace(err);\n      }\n    });\n\n    // use defaultConstants as the backup for keys that are not set in BitGoAPI._constants\n    return _.merge({}, defaultConstants(this.getEnv()), BitGoAPI._constants?.[this.getEnv()] || {});\n  }\n\n  /**\n   * Execute an asset request which does not need HMAC validation\n   * @param url The URL for the asset request\n   * @returns {Promise<any>} The response body\n   */\n  protected async executeAssetRequest(url: string): Promise<any> {\n    const req = this.getAgentRequest('get', url);\n    req.set('BitGo-SDK-Version', this._version);\n    if (this._customProxyAgent) {\n      req.agent(this._customProxyAgent);\n    }\n    // Set the request timeout to just above 5 minutes by default\n    req.timeout((process.env.BITGO_TIMEOUT as any) * 1000 || 305 * 1000);\n    if (this.getAdditionalHeadersCb) {\n      const additionalHeaders = this.getAdditionalHeadersCb('get', url);\n      for (const { key, value } of additionalHeaders) {\n        req.set(key, value);\n      }\n    }\n    const result = await req;\n    return result.body;\n  }\n\n  /**\n   * Pack keychains into batches using First Fit Decreasing (FFD) algorithm.\n   *\n   * @param keychains - V1 keychains\n   * @param v2Keychains - V2 keychains\n   * @param maxBatchSizeBytes - Maximum byte size per batch\n   * @private\n   */\n  private packKeychainsFFD(\n    keychains: Record<string, string>,\n    v2Keychains: Record<string, string>,\n    maxBatchSizeBytes: number\n  ): Array<{ v1Batch: Record<string, string>; v2Batch: Record<string, string>; sizeBytes: number }> {\n    const entrySize = (id: string, value: string) => Buffer.byteLength(id, 'utf8') + Buffer.byteLength(value, 'utf8');\n\n    const items = [\n      ...Object.entries(keychains).map(([id, value]) => ({ id, value, sizeBytes: entrySize(id, value), isV2: false })),\n      ...Object.entries(v2Keychains).map(([id, value]) => ({ id, value, sizeBytes: entrySize(id, value), isV2: true })),\n    ].sort((a, b) => b.sizeBytes - a.sizeBytes);\n\n    const bins: Array<{ v1Batch: Record<string, string>; v2Batch: Record<string, string>; sizeBytes: number }> = [];\n\n    for (const item of items) {\n      if (item.sizeBytes > maxBatchSizeBytes) {\n        throw new Error(`Keychain with id ${item.id} exceeds the maximum batch size and cannot be processed`);\n      }\n\n      const target = bins.find((bin) => bin.sizeBytes + item.sizeBytes <= maxBatchSizeBytes);\n      if (target) {\n        if (item.isV2) {\n          target.v2Batch[item.id] = item.value;\n        } else {\n          target.v1Batch[item.id] = item.value;\n        }\n        target.sizeBytes += item.sizeBytes;\n      } else {\n        const newBin = {\n          v1Batch: {} as Record<string, string>,\n          v2Batch: {} as Record<string, string>,\n          sizeBytes: item.sizeBytes,\n        };\n        if (item.isV2) {\n          newBin.v2Batch[item.id] = item.value;\n        } else {\n          newBin.v1Batch[item.id] = item.value;\n        }\n        bins.push(newBin);\n      }\n    }\n\n    return bins;\n  }\n\n  /**\n   * Process keychain password updates in batches with retry logic.\n   * Uses First Fit Decreasing (FFD) bin packing to ensure no batch exceeds\n   * maxBatchSizeKB\n   *\n   * @param keychains - The v1 keychains to update\n   * @param v2Keychains - The v2 keychains to update\n   * @param maxBatchSizeKB - Maximum payload size per batch in kilobytes\n   * @param maxRetries - Maximum number of retries per batch\n   * @private\n   */\n  private async processKeychainPasswordUpdatesInBatches(\n    keychains: Record<string, string>,\n    v2Keychains: Record<string, string>,\n    maxBatchSizeKB: number,\n    maxRetries: number\n  ): Promise<void> {\n    const maxBatchSizeBytes = maxBatchSizeKB * 1024;\n    const bins = this.packKeychainsFFD(keychains, v2Keychains, maxBatchSizeBytes);\n\n    for (let i = 0; i < bins.length; i++) {\n      const { v1Batch, v2Batch } = bins[i];\n\n      let retryCount = 0;\n      let success = false;\n\n      while (retryCount < maxRetries && !success) {\n        try {\n          const response = await this.put(this.url('/user/keychains', 2))\n            .send({\n              keychains: v1Batch,\n              v2_keychains: v2Batch,\n            })\n            .result();\n\n          // Check if there are any failed keychains in the response\n          const hasFailed =\n            (response.failed?.v1 && Object.keys(response.failed.v1).length > 0) ||\n            (response.failed?.v2 && Object.keys(response.failed.v2).length > 0);\n\n          if (hasFailed) {\n            throw new Error(`Batch ${i + 1} had failed keychains: ${JSON.stringify(response.failed)}`);\n          }\n\n          success = true;\n        } catch (error) {\n          retryCount++;\n\n          if (retryCount >= maxRetries) {\n            throw new Error(`Batch ${i + 1} failed after ${maxRetries} retries: ${error.message}`);\n          }\n        }\n      }\n    }\n  }\n}\n"]}