@bitgo-beta/sdk-core 8.2.1-beta.98 → 8.2.1-beta.980

package/dist/src/bitgo/utils/tss/baseTSSUtils.d.ts

@@ -3,17 +3,24 @@ import { Key, SerializedKeyPair } from 'openpgp';
 import { IBaseCoin, KeychainsTriplet } from '../../baseCoin';
 import { BitGoBase } from '../../bitgoBase';
 import { Keychain } from '../../keychain';
-import { IWallet, BackupProvider } from '../../wallet';
+import { IWallet } from '../../wallet';
 import { MpcUtils } from '../mpcUtils';
-import { BitgoHeldBackupKeyShare, CustomGShareGeneratingFunction, CustomRShareGeneratingFunction, ITssUtils, PrebuildTransactionWithIntentOptions, SignatureShareRecord, TSSParams, TxRequest, TxRequestVersion, CreateKeychainParamsBase, IntentOptionsForMessage, IntentOptionsForTypedData, CreateBitGoKeychainParamsBase, CommitmentShareRecord, EncryptedSignerShareRecord, CustomCommitmentGeneratingFunction, TSSParamsForMessage, RequestType, CustomPaillierModulusGetterFunction, CustomKShareGeneratingFunction, CustomMuDeltaShareGeneratingFunction, CustomSShareGeneratingFunction } from './baseTypes';
+import { BitgoHeldBackupKeyShare, CustomGShareGeneratingFunction, CustomRShareGeneratingFunction, ITssUtils, PrebuildTransactionWithIntentOptions, SignatureShareRecord, TSSParams, TxRequest, TxRequestVersion, CreateKeychainParamsBase, IntentOptionsForMessage, IntentOptionsForTypedData, CreateBitGoKeychainParamsBase, CommitmentShareRecord, EncryptedSignerShareRecord, CustomCommitmentGeneratingFunction, TSSParamsForMessage, RequestType, CustomPaillierModulusGetterFunction, CustomKShareGeneratingFunction, CustomMuDeltaShareGeneratingFunction, CustomSShareGeneratingFunction, CustomMPCv2SigningRound1GeneratingFunction, CustomMPCv2SigningRound2GeneratingFunction, CustomMPCv2SigningRound3GeneratingFunction, TSSParamsWithPrv } from './baseTypes';
 import { GShare, SignShare } from '../../../account-lib/mpc/tss';
+import * as openpgp from 'openpgp';
 /**
  * BaseTssUtil class which different signature schemes have to extend
  */
 export default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtils<KeyShare> {
     private _wallet?;
+    protected bitgoPublicGpgKey: openpgp.Key;
+    protected bitgoMPCv2PublicGpgKey: openpgp.Key | undefined;
     constructor(bitgo: BitGoBase, baseCoin: IBaseCoin, wallet?: IWallet);
     get wallet(): IWallet;
+    protected setBitgoGpgPubKey(bitgo: any): Promise<void>;
+    pickBitgoPubGpgKeyForSigning(isMpcv2: boolean, reqId?: IRequestTracer, enterpriseId?: string): Promise<openpgp.Key>;
+    getBitgoPublicGpgKey(): Promise<openpgp.Key>;
+    getBitgoMpcv2PublicGpgKey(): Promise<openpgp.Key>;
     createBitgoHeldBackupKeyShare(userGpgKey: SerializedKeyPair<string>, enterprise: string | undefined): Promise<BitgoHeldBackupKeyShare>;
     finalizeBitgoHeldBackupKeyShare(keyId: string, commonKeychain: string, userKeyShare: KeyShare, bitgoKeychain: Keychain, userGpgKey: SerializedKeyPair<string>, backupGpgKey: Key): Promise<BitgoHeldBackupKeyShare>;
     createUserKeychain(params: CreateKeychainParamsBase): Promise<Keychain>;
@@ -24,10 +31,9 @@ export default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtil
         enterprise?: string | undefined;
         originalPasscodeEncryptionCode?: string | undefined;
         isThirdPartyBackup?: boolean;
-        backupProvider?: BackupProvider;
     }): Promise<KeychainsTriplet>;
-    signTxRequest(params: TSSParams): Promise<TxRequest>;
-    signTxRequestForMessage(params: TSSParams): Promise<TxRequest>;
+    signTxRequest(params: TSSParamsWithPrv): Promise<TxRequest>;
+    signTxRequestForMessage(params: TSSParamsForMessage): Promise<TxRequest>;
     /**
      * Signs a transaction using TSS for EdDSA and through utilization of custom share generators
      *
@@ -48,6 +54,17 @@ export default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtil
      * @param {CustomSShareGeneratingFunction} externalSignerSShareGenerator a function that creates S shares in the ECDSA TSS flow.
      */
     signEcdsaTssUsingExternalSigner(params: TSSParams | TSSParamsForMessage, requestType: RequestType, externalSignerPaillierModulusGetter: CustomPaillierModulusGetterFunction, externalSignerKShareGenerator: CustomKShareGeneratingFunction, externalSignerMuDeltaShareGenerator: CustomMuDeltaShareGeneratingFunction, externalSignerSShareGenerator: CustomSShareGeneratingFunction): Promise<TxRequest>;
+    /**
+     * Signs a transaction using TSS MPCv2 for ECDSA and through utilization of custom share generators
+     *
+     * @param {TSSParams | TSSParamsForMessage} params - params object that represents parameters to sign a transaction or a message.
+     * @param {CustomMPCv2SigningRound1GeneratingFunction} externalSignerMPCv2SigningRound1Generator - a function that creates MPCv2 Round 1 shares in the ECDSA TSS MPCv2 flow.
+     * @param {CustomMPCv2SigningRound2GeneratingFunction} externalSignerMPCv2SigningRound2Generator - a function that creates MPCv2 Round 2 shares in the ECDSA TSS MPCv2 flow.
+     * @param {CustomMPCv2SigningRound3GeneratingFunction} externalSignerMPCv2SigningRound3Generator - a function that creates MPCv2 Round 3 shares in the ECDSA TSS MPCv2 flow.
+     * @param {RequestType} requestType - the type of the request to sign (transaction or message).
+     * @returns {Promise<TxRequest>} - a signed tx request
+     */
+    signEcdsaMPCv2TssUsingExternalSigner(params: TSSParams | TSSParamsForMessage, externalSignerMPCv2SigningRound1Generator: CustomMPCv2SigningRound1GeneratingFunction, externalSignerMPCv2SigningRound2Generator: CustomMPCv2SigningRound2GeneratingFunction, externalSignerMPCv2SigningRound3Generator: CustomMPCv2SigningRound3GeneratingFunction, requestType?: RequestType): Promise<TxRequest>;
     /**
      * Create an Commitment (User to BitGo) share from an unsigned transaction and private user signing material
      * EDDSA only
@@ -63,6 +80,7 @@ export default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtil
         txRequest: TxRequest;
         prv: string;
         walletPassphrase: string;
+        bitgoGpgPubKey: string;
     }): Promise<{
         userToBitgoCommitment: CommitmentShareRecord;
         encryptedSignerShare: EncryptedSignerShareRecord;
@@ -138,16 +156,18 @@ export default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtil
      * Call delete signature shares for a txRequest, the endpoint delete the signatures and return them
      *
      * @param {string} txRequestId tx id reference to delete signature shares
+     * @param {IRequestTracer} reqId - the request tracer request id
      * @returns {SignatureShareRecord[]}
      */
-    deleteSignatureShares(txRequestId: string): Promise<SignatureShareRecord[]>;
+    deleteSignatureShares(txRequestId: string, reqId?: IRequestTracer): Promise<SignatureShareRecord[]>;
     /**
      * Initialize the send procedure once Bitgo has the User To Bitgo GShare
      *
      * @param {String} txRequestId - the txRequest Id
+     * @param {IRequestTracer} reqId - the request tracer request id
      * @returns {Promise<any>}
      */
-    sendTxRequest(txRequestId: string): Promise<any>;
+    sendTxRequest(txRequestId: string, reqId?: IRequestTracer): Promise<any>;
     /**
      * Delete signature shares, get the tx request without them from the db and sign it to finally send it.
      *
@@ -163,24 +183,28 @@ export default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtil
      * Gets the latest Tx Request by id
      *
      * @param {String} txRequestId - the txRequest Id
+     * @param {IRequestTracer} reqId - request tracer request id
      * @returns {Promise<TxRequest>}
      */
-    getTxRequest(txRequestId: string): Promise<TxRequest>;
-    /**
-     * Checks whether the third party backup provider is valid/supported
-     * @param backupProvider - the backup provider client selected
-     */
-    isValidThirdPartyBackupProvider(backupProvider: BackupProvider | string | undefined): backupProvider is BackupProvider;
+    getTxRequest(txRequestId: string, reqId?: IRequestTracer): Promise<TxRequest>;
     /**
      * It gets the appropriate BitGo GPG public key for key creation based on a
      * combination of coin and the feature flags on the user and their enterprise if set.
      * @param enterpriseId - enterprise under which user wants to create the wallet
+     * @param isMPCv2 - true to get the MPCv2 GPG public key, defaults to false
+     * @param reqId - request tracer request id
      */
-    getBitgoGpgPubkeyBasedOnFeatureFlags(enterpriseId: string | undefined): Promise<Key>;
+    getBitgoGpgPubkeyBasedOnFeatureFlags(enterpriseId: string | undefined, isMPCv2?: boolean, reqId?: IRequestTracer): Promise<Key>;
     /**
      * Returns supported TxRequest versions for this wallet
+     * @deprecated Whenever needed, use apiVersion 'full' for TSS wallets
      */
     supportedTxRequestVersions(): TxRequestVersion[];
+    /**
+     * Returns true if the txRequest is using apiVersion == full and is pending approval
+     * @param txRequest
+     * @returns boolean
+     */
     isPendingApprovalTxRequestFull(txRequest: TxRequest): boolean;
 }
 //# sourceMappingURL=baseTSSUtils.d.ts.map

package/dist/src/bitgo/utils/tss/baseTSSUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"baseTSSUtils.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/baseTSSUtils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"baseTSSUtils.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/baseTSSUtils.ts"],"names":[],"mappings":"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"}

package/dist/src/bitgo/utils/tss/baseTSSUtils.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -11,18 +15,33 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const openpgp_1 = require("openpgp");
+const keychain_1 = require("../../keychain");
 const tss_1 = require("../../tss");
 const mpcUtils_1 = require("../mpcUtils");
 const _ = __importStar(require("lodash"));
+const util_1 = require("../util");
+const openpgp = __importStar(require("openpgp"));
+const bitgoPubKeys_1 = require("../../tss/bitgoPubKeys");
+const opengpgUtils_1 = require("../opengpgUtils");
 /**
  * BaseTssUtil class which different signature schemes have to extend
  */
@@ -37,6 +56,62 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
         }
         return this._wallet;
     }
+    async setBitgoGpgPubKey(bitgo) {
+        const { mpcV1, mpcV2 } = await (0, opengpgUtils_1.getBitgoGpgPubKey)(bitgo);
+        // Do not unset the MPCv1 key if it is already set. This is to avoid unsetting if extra constants api calls fail.
+        if (mpcV1 !== undefined) {
+            this.bitgoPublicGpgKey = mpcV1;
+        }
+        // Do not unset the MPCv2 key if it is already set
+        if (mpcV2 !== undefined) {
+            this.bitgoMPCv2PublicGpgKey = mpcV2;
+        }
+    }
+    async pickBitgoPubGpgKeyForSigning(isMpcv2, reqId, enterpriseId) {
+        let bitgoGpgPubKey;
+        try {
+            const bitgoKeyChain = await this.baseCoin.keychains().get({ id: this.wallet.keyIds()[keychain_1.KeyIndices.BITGO], reqId });
+            if (!bitgoKeyChain || !bitgoKeyChain.hsmType) {
+                throw new Error('Missing Bitgo GPG Pub Key Type.');
+            }
+            bitgoGpgPubKey = await openpgp.readKey({
+                armoredKey: (0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)(this.bitgo.getEnv(), bitgoKeyChain.hsmType === 'nitro' ? 'nitro' : 'onprem', isMpcv2 ? 'mpcv2' : 'mpcv1'),
+            });
+        }
+        catch (e) {
+            if (!(0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+                console.warn(`Unable to get BitGo GPG key based on key data with error: ${e}. Fetching BitGo GPG key based on feature flags.`);
+                // First try to get the key based on feature flags, if that fails, fallback to the default key from constants api.
+                bitgoGpgPubKey = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(enterpriseId, isMpcv2, reqId)
+                    .then(async (pubKey) => pubKey ?? (isMpcv2 ? await this.getBitgoMpcv2PublicGpgKey() : await this.getBitgoPublicGpgKey()))
+                    .catch(async (e) => (isMpcv2 ? await this.getBitgoMpcv2PublicGpgKey() : await this.getBitgoPublicGpgKey()));
+            }
+            else {
+                throw new Error(`Environment "${this.bitgo.getEnv()}" requires a BitGo GPG Pub Key Config in BitGoJS for TSS. Error thrown while getting the key from config: ${e}`);
+            }
+        }
+        return bitgoGpgPubKey;
+    }
+    async getBitgoPublicGpgKey() {
+        if (!this.bitgoPublicGpgKey) {
+            // retry getting bitgo's gpg key
+            await this.setBitgoGpgPubKey(this.bitgo);
+            if (!this.bitgoPublicGpgKey) {
+                throw new Error("Failed to get Bitgo's gpg key");
+            }
+        }
+        return this.bitgoPublicGpgKey;
+    }
+    async getBitgoMpcv2PublicGpgKey() {
+        if (!this.bitgoMPCv2PublicGpgKey) {
+            // retry getting bitgo's gpg key
+            await this.setBitgoGpgPubKey(this.bitgo);
+            if (!this.bitgoMPCv2PublicGpgKey) {
+                throw new Error("Failed to get Bitgo's gpg key");
+            }
+        }
+        return this.bitgoMPCv2PublicGpgKey;
+    }
     async createBitgoHeldBackupKeyShare(userGpgKey, enterprise) {
         const keyResponse = await this.bitgo
             .post(this.baseCoin.url('/krs/backupkeys'))
@@ -98,6 +173,19 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
     signEcdsaTssUsingExternalSigner(params, requestType, externalSignerPaillierModulusGetter, externalSignerKShareGenerator, externalSignerMuDeltaShareGenerator, externalSignerSShareGenerator) {
         throw new Error('Method not implemented.');
     }
+    /**
+     * Signs a transaction using TSS MPCv2 for ECDSA and through utilization of custom share generators
+     *
+     * @param {TSSParams | TSSParamsForMessage} params - params object that represents parameters to sign a transaction or a message.
+     * @param {CustomMPCv2SigningRound1GeneratingFunction} externalSignerMPCv2SigningRound1Generator - a function that creates MPCv2 Round 1 shares in the ECDSA TSS MPCv2 flow.
+     * @param {CustomMPCv2SigningRound2GeneratingFunction} externalSignerMPCv2SigningRound2Generator - a function that creates MPCv2 Round 2 shares in the ECDSA TSS MPCv2 flow.
+     * @param {CustomMPCv2SigningRound3GeneratingFunction} externalSignerMPCv2SigningRound3Generator - a function that creates MPCv2 Round 3 shares in the ECDSA TSS MPCv2 flow.
+     * @param {RequestType} requestType - the type of the request to sign (transaction or message).
+     * @returns {Promise<TxRequest>} - a signed tx request
+     */
+    signEcdsaMPCv2TssUsingExternalSigner(params, externalSignerMPCv2SigningRound1Generator, externalSignerMPCv2SigningRound2Generator, externalSignerMPCv2SigningRound3Generator, requestType) {
+        throw new Error('Method not implemented.');
+    }
     /**
      * Create an Commitment (User to BitGo) share from an unsigned transaction and private user signing material
      * EDDSA only
@@ -156,6 +244,8 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
             apiVersion: apiVersion,
             preview,
         };
+        const reqTracer = params.reqId || new util_1.RequestTracer();
+        this.bitgo.setRequestTracer(reqTracer);
         const unsignedTx = (await this.bitgo
             .post(this.bitgo.url('/wallet/' + this.wallet.id() + '/txrequests', 2))
             .send(whitelistedParams)
@@ -170,18 +260,17 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
      * @param preview
      */
     async createTxRequestWithIntentForMessageSigning(params, apiVersion = 'full', preview) {
-        var _a, _b;
         const intentOptions = {
             custodianMessageId: params.custodianMessageId,
             intentType: params.intentType,
             sequenceId: params.sequenceId,
             comment: params.comment,
-            memo: (_a = params.memo) === null || _a === void 0 ? void 0 : _a.value,
+            memo: params.memo?.value,
             isTss: params.isTss,
             messageRaw: params.messageRaw,
-            messageEncoded: (_b = params.messageEncoded) !== null && _b !== void 0 ? _b : '',
+            messageEncoded: params.messageEncoded ?? '',
         };
-        return this.createTxRequestBase(intentOptions, apiVersion, preview);
+        return this.createTxRequestBase(intentOptions, apiVersion, preview, params.reqId);
     }
     /**
      * Create a tx request from params for type data signing
@@ -191,25 +280,24 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
      * @param preview
      */
     async createTxRequestWithIntentForTypedDataSigning(params, apiVersion = 'full', preview) {
-        var _a, _b;
         const intentOptions = {
             custodianMessageId: params.custodianMessageId,
             intentType: params.intentType,
             sequenceId: params.sequenceId,
             comment: params.comment,
-            memo: (_a = params.memo) === null || _a === void 0 ? void 0 : _a.value,
+            memo: params.memo?.value,
             isTss: params.isTss,
             messageRaw: params.typedDataRaw,
-            messageEncoded: (_b = params.typedDataEncoded) !== null && _b !== void 0 ? _b : '',
+            messageEncoded: params.typedDataEncoded ?? '',
         };
-        return this.createTxRequestBase(intentOptions, apiVersion, preview);
+        return this.createTxRequestBase(intentOptions, apiVersion, preview, params.reqId);
     }
     /**
      * Calls Bitgo API to create tx request.
      *
      * @private
      */
-    async createTxRequestBase(intentOptions, apiVersion, preview) {
+    async createTxRequestBase(intentOptions, apiVersion, preview, reqId) {
         const whitelistedParams = {
             intent: {
                 ...intentOptions,
@@ -217,6 +305,8 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
             apiVersion,
             preview,
         };
+        const reqTracer = reqId || new util_1.RequestTracer();
+        this.bitgo.setRequestTracer(reqTracer);
         return this.bitgo
             .post(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests`, 2))
             .send(whitelistedParams)
@@ -226,9 +316,12 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
      * Call delete signature shares for a txRequest, the endpoint delete the signatures and return them
      *
      * @param {string} txRequestId tx id reference to delete signature shares
+     * @param {IRequestTracer} reqId - the request tracer request id
      * @returns {SignatureShareRecord[]}
      */
-    async deleteSignatureShares(txRequestId) {
+    async deleteSignatureShares(txRequestId, reqId) {
+        const reqTracer = reqId || new util_1.RequestTracer();
+        this.bitgo.setRequestTracer(reqTracer);
         return this.bitgo
             .del(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests/${txRequestId}/signatureshares`, 2))
             .send()
@@ -238,10 +331,13 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
      * Initialize the send procedure once Bitgo has the User To Bitgo GShare
      *
      * @param {String} txRequestId - the txRequest Id
+     * @param {IRequestTracer} reqId - the request tracer request id
      * @returns {Promise<any>}
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async sendTxRequest(txRequestId) {
+    async sendTxRequest(txRequestId, reqId) {
+        const reqTracer = reqId || new util_1.RequestTracer();
+        this.bitgo.setRequestTracer(reqTracer);
         return this.bitgo
             .post(this.baseCoin.url('/wallet/' + this.wallet.id() + '/tx/send'))
             .send({ txRequestId })
@@ -258,66 +354,66 @@ class BaseTssUtils extends mpcUtils_1.MpcUtils {
      * @returns {Promise<any>}
      */
     async recreateTxRequest(txRequestId, decryptedPrv, reqId) {
-        await this.deleteSignatureShares(txRequestId);
+        await this.deleteSignatureShares(txRequestId, reqId);
         // after delete signatures shares get the tx without them
-        const txRequest = await tss_1.getTxRequest(this.bitgo, this.wallet.id(), txRequestId);
+        const txRequest = await (0, tss_1.getTxRequest)(this.bitgo, this.wallet.id(), txRequestId, reqId);
         return await this.signTxRequest({ txRequest, prv: decryptedPrv, reqId });
     }
     /**
      * Gets the latest Tx Request by id
      *
      * @param {String} txRequestId - the txRequest Id
+     * @param {IRequestTracer} reqId - request tracer request id
      * @returns {Promise<TxRequest>}
      */
-    async getTxRequest(txRequestId) {
-        return tss_1.getTxRequest(this.bitgo, this.wallet.id(), txRequestId);
-    }
-    /**
-     * Checks whether the third party backup provider is valid/supported
-     * @param backupProvider - the backup provider client selected
-     */
-    isValidThirdPartyBackupProvider(backupProvider) {
-        // As of now, BitGo is the only supported KRS provider for TSS
-        return !!(backupProvider && backupProvider === 'BitGoTrustAsKrs');
+    async getTxRequest(txRequestId, reqId) {
+        return (0, tss_1.getTxRequest)(this.bitgo, this.wallet.id(), txRequestId, reqId);
     }
     /**
      * It gets the appropriate BitGo GPG public key for key creation based on a
      * combination of coin and the feature flags on the user and their enterprise if set.
      * @param enterpriseId - enterprise under which user wants to create the wallet
+     * @param isMPCv2 - true to get the MPCv2 GPG public key, defaults to false
+     * @param reqId - request tracer request id
      */
-    async getBitgoGpgPubkeyBasedOnFeatureFlags(enterpriseId) {
+    async getBitgoGpgPubkeyBasedOnFeatureFlags(enterpriseId, isMPCv2 = false, reqId) {
+        const reqTracer = reqId || new util_1.RequestTracer();
+        this.bitgo.setRequestTracer(reqTracer);
         const response = await this.bitgo
             .get(this.baseCoin.url('/tss/pubkey'))
             .query({ enterpriseId })
+            .retry(3)
             .result();
-        const bitgoPublicKeyStr = response.publicKey;
-        return openpgp_1.readKey({ armoredKey: bitgoPublicKeyStr });
+        const bitgoPublicKeyStr = isMPCv2 ? response.mpcv2PublicKey : response.publicKey;
+        return (0, openpgp_1.readKey)({ armoredKey: bitgoPublicKeyStr });
     }
     /**
      * Returns supported TxRequest versions for this wallet
+     * @deprecated Whenever needed, use apiVersion 'full' for TSS wallets
      */
     supportedTxRequestVersions() {
-        var _a, _b, _c, _d;
-        const walletType = (_a = this._wallet) === null || _a === void 0 ? void 0 : _a.type();
-        const supportedWalletTypes = ['custodial', 'cold', 'hot'];
-        if (!walletType || ((_b = this._wallet) === null || _b === void 0 ? void 0 : _b.multisigType()) !== 'tss' || !supportedWalletTypes.includes(walletType)) {
+        if (!this._wallet || this._wallet.type() === 'trading' || this._wallet.multisigType() !== 'tss') {
             return [];
         }
-        else if (((_c = this._wallet) === null || _c === void 0 ? void 0 : _c.baseCoin.getMPCAlgorithm()) === 'ecdsa') {
-            return ['full'];
-        }
-        else if (walletType === 'custodial' || walletType === 'cold') {
+        else if (this._wallet.baseCoin.getMPCAlgorithm() === 'ecdsa') {
             return ['full'];
         }
-        else if (((_d = this._wallet) === null || _d === void 0 ? void 0 : _d.baseCoin.getMPCAlgorithm()) === 'eddsa' && walletType === 'hot') {
+        else if (this._wallet.baseCoin.getMPCAlgorithm() === 'eddsa' && this._wallet.type() === 'hot') {
             return ['lite', 'full'];
         }
-        return [];
+        else {
+            return ['full'];
+        }
     }
+    /**
+     * Returns true if the txRequest is using apiVersion == full and is pending approval
+     * @param txRequest
+     * @returns boolean
+     */
     isPendingApprovalTxRequestFull(txRequest) {
         const { apiVersion, state } = txRequest;
         return apiVersion === 'full' && 'pendingApproval' === state;
     }
 }
 exports.default = BaseTssUtils;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"baseTSSUtils.js","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/baseTSSUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import { IRequestTracer } from '../../../api';\nimport { Key, readKey, SerializedKeyPair } from 'openpgp';\nimport { IBaseCoin, KeychainsTriplet } from '../../baseCoin';\nimport { BitGoBase } from '../../bitgoBase';\nimport { Keychain } from '../../keychain';\nimport { getTxRequest } from '../../tss';\nimport { IWallet, BackupProvider } from '../../wallet';\nimport { MpcUtils } from '../mpcUtils';\nimport * as _ from 'lodash';\nimport {\n  BitgoGPGPublicKey,\n  BitgoHeldBackupKeyShare,\n  CustomGShareGeneratingFunction,\n  CustomRShareGeneratingFunction,\n  ITssUtils,\n  PrebuildTransactionWithIntentOptions,\n  SignatureShareRecord,\n  TSSParams,\n  TxRequest,\n  TxRequestVersion,\n  CreateKeychainParamsBase,\n  IntentOptionsForMessage,\n  PopulatedIntentForMessageSigning,\n  IntentOptionsForTypedData,\n  PopulatedIntentForTypedDataSigning,\n  CreateBitGoKeychainParamsBase,\n  CommitmentShareRecord,\n  EncryptedSignerShareRecord,\n  CustomCommitmentGeneratingFunction,\n  TSSParamsForMessage,\n  RequestType,\n  CustomPaillierModulusGetterFunction,\n  CustomKShareGeneratingFunction,\n  CustomMuDeltaShareGeneratingFunction,\n  CustomSShareGeneratingFunction,\n} from './baseTypes';\nimport { GShare, SignShare } from '../../../account-lib/mpc/tss';\n\n/**\n * BaseTssUtil class which different signature schemes have to extend\n */\nexport default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtils<KeyShare> {\n  private _wallet?: IWallet;\n\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin, wallet?: IWallet) {\n    super(bitgo, baseCoin);\n    this._wallet = wallet;\n  }\n\n  get wallet(): IWallet {\n    if (_.isNil(this._wallet)) {\n      throw new Error('Wallet not defined');\n    }\n    return this._wallet;\n  }\n\n  async createBitgoHeldBackupKeyShare(\n    userGpgKey: SerializedKeyPair<string>,\n    enterprise: string | undefined\n  ): Promise<BitgoHeldBackupKeyShare> {\n    const keyResponse = await this.bitgo\n      .post(this.baseCoin.url('/krs/backupkeys'))\n      .send({\n        enterprise,\n        userGPGPublicKey: userGpgKey.publicKey,\n      })\n      .result();\n    if (!keyResponse || !keyResponse.keyShares) {\n      throw new Error('Failed to get backup shares from BitGo.');\n    }\n    return {\n      id: keyResponse.id,\n      keyShares: keyResponse.keyShares,\n    };\n  }\n\n  public finalizeBitgoHeldBackupKeyShare(\n    keyId: string,\n    commonKeychain: string,\n    userKeyShare: KeyShare,\n    bitgoKeychain: Keychain,\n    userGpgKey: SerializedKeyPair<string>,\n    backupGpgKey: Key\n  ): Promise<BitgoHeldBackupKeyShare> {\n    throw new Error('Method not implemented.');\n  }\n\n  createUserKeychain(params: CreateKeychainParamsBase): Promise<Keychain> {\n    throw new Error('Method not implemented.');\n  }\n\n  createBackupKeychain(params: CreateKeychainParamsBase): Promise<Keychain> {\n    throw new Error('Method not implemented.');\n  }\n\n  createBitgoKeychain(params: CreateBitGoKeychainParamsBase): Promise<Keychain> {\n    throw new Error('Method not implemented.');\n  }\n\n  createKeychains(params: {\n    passphrase: string;\n    enterprise?: string | undefined;\n    originalPasscodeEncryptionCode?: string | undefined;\n    isThirdPartyBackup?: boolean;\n    backupProvider?: BackupProvider;\n  }): Promise<KeychainsTriplet> {\n    throw new Error('Method not implemented.');\n  }\n\n  signTxRequest(params: TSSParams): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  signTxRequestForMessage(params: TSSParams): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Signs a transaction using TSS for EdDSA and through utilization of custom share generators\n   *\n   * @param {string | TxRequest} txRequest - transaction request with unsigned transaction\n   * @param {CustomRShareGeneratingFunction} externalSignerRShareGenerator a function that creates R shares in the EdDSA TSS flow\n   * @param {CustomGShareGeneratingFunction} externalSignerGShareGenerator a function that creates G shares in the EdDSA TSS flow\n   * @returns {Promise<TxRequest>} - a signed tx request\n   */\n  signEddsaTssUsingExternalSigner(\n    txRequest: string | TxRequest,\n    externalSignerCommitmentGenerator: CustomCommitmentGeneratingFunction,\n    externalSignerRShareGenerator: CustomRShareGeneratingFunction,\n    externalSignerGShareGenerator: CustomGShareGeneratingFunction\n  ): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Signs a transaction using TSS for ECDSA and through utilization of custom share generators\n   *\n   * @param {params: TSSParams | TSSParamsForMessage} params - params object that represents parameters to sign a transaction or a message.\n   * @param {RequestType} requestType - the type of the request to sign (transaction or message).\n   * @param {CustomPaillierModulusGetterFunction} externalSignerPaillierModulusGetter a function that creates Paillier Modulus shares in the ECDSA TSS flow.\n   * @param {CustomKShareGeneratingFunction} externalSignerKShareGenerator a function that creates K shares in the ECDSA TSS flow.\n   * @param {CustomMuDeltaShareGeneratingFunction} externalSignerMuDeltaShareGenerator a function that creates Mu and Delta shares in the ECDSA TSS flow.\n   * @param {CustomSShareGeneratingFunction} externalSignerSShareGenerator a function that creates S shares in the ECDSA TSS flow.\n   */\n  signEcdsaTssUsingExternalSigner(\n    params: TSSParams | TSSParamsForMessage,\n    requestType: RequestType,\n    externalSignerPaillierModulusGetter: CustomPaillierModulusGetterFunction,\n    externalSignerKShareGenerator: CustomKShareGeneratingFunction,\n    externalSignerMuDeltaShareGenerator: CustomMuDeltaShareGeneratingFunction,\n    externalSignerSShareGenerator: CustomSShareGeneratingFunction\n  ): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Create an Commitment (User to BitGo) share from an unsigned transaction and private user signing material\n   * EDDSA only\n   *\n   * @param {Object} params - params object\n   * @param {TxRequest} params.txRequest - transaction request with unsigned transaction\n   * @param {string} params.prv - user signing material\n   * @param {string} params.walletPassphrase - wallet passphrase\n   *\n   * @returns {Promise<{ userToBitgoCommitment: CommitmentShareRecor, encryptedSignerShare: EncryptedSignerShareRecord }>} - Commitment Share and the Encrypted Signer Share to BitGo\n   */\n  createCommitmentShareFromTxRequest(params: { txRequest: TxRequest; prv: string; walletPassphrase: string }): Promise<{\n    userToBitgoCommitment: CommitmentShareRecord;\n    encryptedSignerShare: EncryptedSignerShareRecord;\n    encryptedUserToBitgoRShare: EncryptedSignerShareRecord;\n  }> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Create an R (User to BitGo) share from an unsigned transaction and private user signing material\n   *\n   * @param {Object} params - params object\n   * @param {TxRequest} params.txRequest - transaction request with unsigned transaction\n   * @param {string} params.prv - user signing material\n   * @param {string} [params.walletPassphrase] - wallet passphrase\n   * @param {EncryptedSignerShareRecord} [params.encryptedUserToBitgoRShare] - encrypted user to bitgo R share generated in the commitment phase\n   * @returns {Promise<{ rShare: SignShare }>} - R Share to BitGo\n   */\n  createRShareFromTxRequest(params: {\n    txRequest: TxRequest;\n    walletPassphrase: string;\n    encryptedUserToBitgoRShare: EncryptedSignerShareRecord;\n  }): Promise<{ rShare: SignShare }> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Create a G (User to BitGo) share from an unsigned transaction and private user signing material\n   *\n   * @param {Object} params - params object\n   * @param {TxRequest} params.txRequest - transaction request with unsigned transaction\n   * @param {string} params.prv - user signing material\n   * @param {SignatureShareRecord} params.bitgoToUserRShare - BitGo to User R Share\n   * @param {SignShare} params.userToBitgoRShare - User to BitGo R Share\n   * @param {CommitmentShareRecord} params.bitgoToUserCommitment - BitGo to User Commitment\n   * @returns {Promise<GShare>} - GShare from User to BitGo\n   */\n  createGShareFromTxRequest(params: {\n    txRequest: TxRequest;\n    prv: string;\n    bitgoToUserRShare: SignatureShareRecord;\n    userToBitgoRShare: SignShare;\n    bitgoToUserCommitment: CommitmentShareRecord;\n  }): Promise<GShare> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Builds a tx request from params and verify it\n   *\n   * @param {PrebuildTransactionWithIntentOptions} params - parameters to build the tx\n   * @param {TxRequestVersion} apiVersion lite or full\n   * @param {boolean} preview boolean indicating if this is to preview a tx request, which will not initiate policy checks or pending approvals\n   * @returns {Promise<TxRequest>} - a built tx request\n   */\n  async prebuildTxWithIntent(\n    params: PrebuildTransactionWithIntentOptions,\n    apiVersion: TxRequestVersion = 'lite',\n    preview?: boolean\n  ): Promise<TxRequest> {\n    const intentOptions = this.populateIntent(this.baseCoin, params);\n\n    const whitelistedParams = {\n      intent: {\n        ...intentOptions,\n      },\n      apiVersion: apiVersion,\n      preview,\n    };\n\n    const unsignedTx = (await this.bitgo\n      .post(this.bitgo.url('/wallet/' + this.wallet.id() + '/txrequests', 2))\n      .send(whitelistedParams)\n      .result()) as TxRequest;\n\n    return unsignedTx;\n  }\n\n  /**\n   * Create a tx request from params for message signing\n   *\n   * @param params\n   * @param apiVersion\n   * @param preview\n   */\n  async createTxRequestWithIntentForMessageSigning(\n    params: IntentOptionsForMessage,\n    apiVersion: TxRequestVersion = 'full',\n    preview?: boolean\n  ): Promise<TxRequest> {\n    const intentOptions: PopulatedIntentForMessageSigning = {\n      custodianMessageId: params.custodianMessageId,\n      intentType: params.intentType,\n      sequenceId: params.sequenceId,\n      comment: params.comment,\n      memo: params.memo?.value,\n      isTss: params.isTss,\n      messageRaw: params.messageRaw,\n      messageEncoded: params.messageEncoded ?? '',\n    };\n\n    return this.createTxRequestBase(intentOptions, apiVersion, preview);\n  }\n\n  /**\n   * Create a tx request from params for type data signing\n   *\n   * @param params\n   * @param apiVersion\n   * @param preview\n   */\n  async createTxRequestWithIntentForTypedDataSigning(\n    params: IntentOptionsForTypedData,\n    apiVersion: TxRequestVersion = 'full',\n    preview?: boolean\n  ): Promise<TxRequest> {\n    const intentOptions: PopulatedIntentForTypedDataSigning = {\n      custodianMessageId: params.custodianMessageId,\n      intentType: params.intentType,\n      sequenceId: params.sequenceId,\n      comment: params.comment,\n      memo: params.memo?.value,\n      isTss: params.isTss,\n      messageRaw: params.typedDataRaw,\n      messageEncoded: params.typedDataEncoded ?? '',\n    };\n\n    return this.createTxRequestBase(intentOptions, apiVersion, preview);\n  }\n\n  /**\n   * Calls Bitgo API to create tx request.\n   *\n   * @private\n   */\n  private async createTxRequestBase(\n    intentOptions: PopulatedIntentForTypedDataSigning | PopulatedIntentForMessageSigning,\n    apiVersion: TxRequestVersion,\n    preview?: boolean\n  ): Promise<TxRequest> {\n    const whitelistedParams = {\n      intent: {\n        ...intentOptions,\n      },\n      apiVersion,\n      preview,\n    };\n\n    return this.bitgo\n      .post(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests`, 2))\n      .send(whitelistedParams)\n      .result();\n  }\n\n  /**\n   * Call delete signature shares for a txRequest, the endpoint delete the signatures and return them\n   *\n   * @param {string} txRequestId tx id reference to delete signature shares\n   * @returns {SignatureShareRecord[]}\n   */\n  async deleteSignatureShares(txRequestId: string): Promise<SignatureShareRecord[]> {\n    return this.bitgo\n      .del(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests/${txRequestId}/signatureshares`, 2))\n      .send()\n      .result();\n  }\n\n  /**\n   * Initialize the send procedure once Bitgo has the User To Bitgo GShare\n   *\n   * @param {String} txRequestId - the txRequest Id\n   * @returns {Promise<any>}\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  async sendTxRequest(txRequestId: string): Promise<any> {\n    return this.bitgo\n      .post(this.baseCoin.url('/wallet/' + this.wallet.id() + '/tx/send'))\n      .send({ txRequestId })\n      .result();\n  }\n\n  /**\n   * Delete signature shares, get the tx request without them from the db and sign it to finally send it.\n   *\n   * Note : This can be performed in order to reach latest network conditions required on pending approval flow.\n   *\n   * @param {String} txRequestId - the txRequest Id to make the requests.\n   * @param {String} decryptedPrv - decrypted prv to sign the tx request.\n   * @param {RequestTracer} reqId id tracer.\n   * @returns {Promise<any>}\n   */\n  async recreateTxRequest(txRequestId: string, decryptedPrv: string, reqId: IRequestTracer): Promise<TxRequest> {\n    await this.deleteSignatureShares(txRequestId);\n    // after delete signatures shares get the tx without them\n    const txRequest = await getTxRequest(this.bitgo, this.wallet.id(), txRequestId);\n    return await this.signTxRequest({ txRequest, prv: decryptedPrv, reqId });\n  }\n\n  /**\n   * Gets the latest Tx Request by id\n   *\n   * @param {String} txRequestId - the txRequest Id\n   * @returns {Promise<TxRequest>}\n   */\n  async getTxRequest(txRequestId: string): Promise<TxRequest> {\n    return getTxRequest(this.bitgo, this.wallet.id(), txRequestId);\n  }\n\n  /**\n   * Checks whether the third party backup provider is valid/supported\n   * @param backupProvider - the backup provider client selected\n   */\n  isValidThirdPartyBackupProvider(\n    backupProvider: BackupProvider | string | undefined\n  ): backupProvider is BackupProvider {\n    // As of now, BitGo is the only supported KRS provider for TSS\n    return !!(backupProvider && backupProvider === 'BitGoTrustAsKrs');\n  }\n\n  /**\n   * It gets the appropriate BitGo GPG public key for key creation based on a\n   * combination of coin and the feature flags on the user and their enterprise if set.\n   * @param enterpriseId - enterprise under which user wants to create the wallet\n   */\n  public async getBitgoGpgPubkeyBasedOnFeatureFlags(enterpriseId: string | undefined): Promise<Key> {\n    const response: BitgoGPGPublicKey = await this.bitgo\n      .get(this.baseCoin.url('/tss/pubkey'))\n      .query({ enterpriseId })\n      .result();\n    const bitgoPublicKeyStr = response.publicKey as string;\n    return readKey({ armoredKey: bitgoPublicKeyStr });\n  }\n\n  /**\n   * Returns supported TxRequest versions for this wallet\n   */\n  public supportedTxRequestVersions(): TxRequestVersion[] {\n    const walletType = this._wallet?.type();\n    const supportedWalletTypes = ['custodial', 'cold', 'hot'];\n    if (!walletType || this._wallet?.multisigType() !== 'tss' || !supportedWalletTypes.includes(walletType)) {\n      return [];\n    } else if (this._wallet?.baseCoin.getMPCAlgorithm() === 'ecdsa') {\n      return ['full'];\n    } else if (walletType === 'custodial' || walletType === 'cold') {\n      return ['full'];\n    } else if (this._wallet?.baseCoin.getMPCAlgorithm() === 'eddsa' && walletType === 'hot') {\n      return ['lite', 'full'];\n    }\n    return [];\n  }\n\n  isPendingApprovalTxRequestFull(txRequest: TxRequest): boolean {\n    const { apiVersion, state } = txRequest;\n    return apiVersion === 'full' && 'pendingApproval' === state;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"baseTSSUtils.js","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/baseTSSUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import { IRequestTracer } from '../../../api';\nimport { Key, readKey, SerializedKeyPair } from 'openpgp';\nimport { IBaseCoin, KeychainsTriplet } from '../../baseCoin';\nimport { BitGoBase } from '../../bitgoBase';\nimport { Keychain, KeyIndices } from '../../keychain';\nimport { getTxRequest } from '../../tss';\nimport { IWallet } from '../../wallet';\nimport { MpcUtils } from '../mpcUtils';\nimport * as _ from 'lodash';\nimport {\n  BitgoGPGPublicKey,\n  BitgoHeldBackupKeyShare,\n  CustomGShareGeneratingFunction,\n  CustomRShareGeneratingFunction,\n  ITssUtils,\n  PrebuildTransactionWithIntentOptions,\n  SignatureShareRecord,\n  TSSParams,\n  TxRequest,\n  TxRequestVersion,\n  CreateKeychainParamsBase,\n  IntentOptionsForMessage,\n  PopulatedIntentForMessageSigning,\n  IntentOptionsForTypedData,\n  PopulatedIntentForTypedDataSigning,\n  CreateBitGoKeychainParamsBase,\n  CommitmentShareRecord,\n  EncryptedSignerShareRecord,\n  CustomCommitmentGeneratingFunction,\n  TSSParamsForMessage,\n  RequestType,\n  CustomPaillierModulusGetterFunction,\n  CustomKShareGeneratingFunction,\n  CustomMuDeltaShareGeneratingFunction,\n  CustomSShareGeneratingFunction,\n  CustomMPCv2SigningRound1GeneratingFunction,\n  CustomMPCv2SigningRound2GeneratingFunction,\n  CustomMPCv2SigningRound3GeneratingFunction,\n  TSSParamsWithPrv,\n} from './baseTypes';\nimport { GShare, SignShare } from '../../../account-lib/mpc/tss';\nimport { RequestTracer } from '../util';\nimport * as openpgp from 'openpgp';\nimport { envRequiresBitgoPubGpgKeyConfig, getBitgoMpcGpgPubKey } from '../../tss/bitgoPubKeys';\nimport { getBitgoGpgPubKey } from '../opengpgUtils';\n\n/**\n * BaseTssUtil class which different signature schemes have to extend\n */\nexport default class BaseTssUtils<KeyShare> extends MpcUtils implements ITssUtils<KeyShare> {\n  private _wallet?: IWallet;\n  protected bitgoPublicGpgKey: openpgp.Key;\n  protected bitgoMPCv2PublicGpgKey: openpgp.Key | undefined;\n\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin, wallet?: IWallet) {\n    super(bitgo, baseCoin);\n    this._wallet = wallet;\n  }\n\n  get wallet(): IWallet {\n    if (_.isNil(this._wallet)) {\n      throw new Error('Wallet not defined');\n    }\n    return this._wallet;\n  }\n\n  protected async setBitgoGpgPubKey(bitgo) {\n    const { mpcV1, mpcV2 } = await getBitgoGpgPubKey(bitgo);\n    // Do not unset the MPCv1 key if it is already set. This is to avoid unsetting if extra constants api calls fail.\n    if (mpcV1 !== undefined) {\n      this.bitgoPublicGpgKey = mpcV1;\n    }\n    // Do not unset the MPCv2 key if it is already set\n    if (mpcV2 !== undefined) {\n      this.bitgoMPCv2PublicGpgKey = mpcV2;\n    }\n  }\n\n  public async pickBitgoPubGpgKeyForSigning(\n    isMpcv2: boolean,\n    reqId?: IRequestTracer,\n    enterpriseId?: string\n  ): Promise<openpgp.Key> {\n    let bitgoGpgPubKey;\n    try {\n      const bitgoKeyChain = await this.baseCoin.keychains().get({ id: this.wallet.keyIds()[KeyIndices.BITGO], reqId });\n      if (!bitgoKeyChain || !bitgoKeyChain.hsmType) {\n        throw new Error('Missing Bitgo GPG Pub Key Type.');\n      }\n      bitgoGpgPubKey = await openpgp.readKey({\n        armoredKey: getBitgoMpcGpgPubKey(\n          this.bitgo.getEnv(),\n          bitgoKeyChain.hsmType === 'nitro' ? 'nitro' : 'onprem',\n          isMpcv2 ? 'mpcv2' : 'mpcv1'\n        ),\n      });\n    } catch (e) {\n      if (!envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n        console.warn(\n          `Unable to get BitGo GPG key based on key data with error: ${e}. Fetching BitGo GPG key based on feature flags.`\n        );\n        // First try to get the key based on feature flags, if that fails, fallback to the default key from constants api.\n        bitgoGpgPubKey = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(enterpriseId, isMpcv2, reqId)\n          .then(\n            async (pubKey) =>\n              pubKey ?? (isMpcv2 ? await this.getBitgoMpcv2PublicGpgKey() : await this.getBitgoPublicGpgKey())\n          )\n          .catch(async (e) => (isMpcv2 ? await this.getBitgoMpcv2PublicGpgKey() : await this.getBitgoPublicGpgKey()));\n      } else {\n        throw new Error(\n          `Environment \"${this.bitgo.getEnv()}\" requires a BitGo GPG Pub Key Config in BitGoJS for TSS. Error thrown while getting the key from config: ${e}`\n        );\n      }\n    }\n    return bitgoGpgPubKey;\n  }\n\n  async getBitgoPublicGpgKey(): Promise<openpgp.Key> {\n    if (!this.bitgoPublicGpgKey) {\n      // retry getting bitgo's gpg key\n      await this.setBitgoGpgPubKey(this.bitgo);\n      if (!this.bitgoPublicGpgKey) {\n        throw new Error(\"Failed to get Bitgo's gpg key\");\n      }\n    }\n\n    return this.bitgoPublicGpgKey;\n  }\n\n  async getBitgoMpcv2PublicGpgKey(): Promise<openpgp.Key> {\n    if (!this.bitgoMPCv2PublicGpgKey) {\n      // retry getting bitgo's gpg key\n      await this.setBitgoGpgPubKey(this.bitgo);\n      if (!this.bitgoMPCv2PublicGpgKey) {\n        throw new Error(\"Failed to get Bitgo's gpg key\");\n      }\n    }\n\n    return this.bitgoMPCv2PublicGpgKey;\n  }\n\n  async createBitgoHeldBackupKeyShare(\n    userGpgKey: SerializedKeyPair<string>,\n    enterprise: string | undefined\n  ): Promise<BitgoHeldBackupKeyShare> {\n    const keyResponse = await this.bitgo\n      .post(this.baseCoin.url('/krs/backupkeys'))\n      .send({\n        enterprise,\n        userGPGPublicKey: userGpgKey.publicKey,\n      })\n      .result();\n    if (!keyResponse || !keyResponse.keyShares) {\n      throw new Error('Failed to get backup shares from BitGo.');\n    }\n    return {\n      id: keyResponse.id,\n      keyShares: keyResponse.keyShares,\n    };\n  }\n\n  public finalizeBitgoHeldBackupKeyShare(\n    keyId: string,\n    commonKeychain: string,\n    userKeyShare: KeyShare,\n    bitgoKeychain: Keychain,\n    userGpgKey: SerializedKeyPair<string>,\n    backupGpgKey: Key\n  ): Promise<BitgoHeldBackupKeyShare> {\n    throw new Error('Method not implemented.');\n  }\n\n  createUserKeychain(params: CreateKeychainParamsBase): Promise<Keychain> {\n    throw new Error('Method not implemented.');\n  }\n\n  createBackupKeychain(params: CreateKeychainParamsBase): Promise<Keychain> {\n    throw new Error('Method not implemented.');\n  }\n\n  createBitgoKeychain(params: CreateBitGoKeychainParamsBase): Promise<Keychain> {\n    throw new Error('Method not implemented.');\n  }\n\n  createKeychains(params: {\n    passphrase: string;\n    enterprise?: string | undefined;\n    originalPasscodeEncryptionCode?: string | undefined;\n    isThirdPartyBackup?: boolean;\n  }): Promise<KeychainsTriplet> {\n    throw new Error('Method not implemented.');\n  }\n\n  signTxRequest(params: TSSParamsWithPrv): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  signTxRequestForMessage(params: TSSParamsForMessage): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Signs a transaction using TSS for EdDSA and through utilization of custom share generators\n   *\n   * @param {string | TxRequest} txRequest - transaction request with unsigned transaction\n   * @param {CustomRShareGeneratingFunction} externalSignerRShareGenerator a function that creates R shares in the EdDSA TSS flow\n   * @param {CustomGShareGeneratingFunction} externalSignerGShareGenerator a function that creates G shares in the EdDSA TSS flow\n   * @returns {Promise<TxRequest>} - a signed tx request\n   */\n  signEddsaTssUsingExternalSigner(\n    txRequest: string | TxRequest,\n    externalSignerCommitmentGenerator: CustomCommitmentGeneratingFunction,\n    externalSignerRShareGenerator: CustomRShareGeneratingFunction,\n    externalSignerGShareGenerator: CustomGShareGeneratingFunction\n  ): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Signs a transaction using TSS for ECDSA and through utilization of custom share generators\n   *\n   * @param {params: TSSParams | TSSParamsForMessage} params - params object that represents parameters to sign a transaction or a message.\n   * @param {RequestType} requestType - the type of the request to sign (transaction or message).\n   * @param {CustomPaillierModulusGetterFunction} externalSignerPaillierModulusGetter a function that creates Paillier Modulus shares in the ECDSA TSS flow.\n   * @param {CustomKShareGeneratingFunction} externalSignerKShareGenerator a function that creates K shares in the ECDSA TSS flow.\n   * @param {CustomMuDeltaShareGeneratingFunction} externalSignerMuDeltaShareGenerator a function that creates Mu and Delta shares in the ECDSA TSS flow.\n   * @param {CustomSShareGeneratingFunction} externalSignerSShareGenerator a function that creates S shares in the ECDSA TSS flow.\n   */\n  signEcdsaTssUsingExternalSigner(\n    params: TSSParams | TSSParamsForMessage,\n    requestType: RequestType,\n    externalSignerPaillierModulusGetter: CustomPaillierModulusGetterFunction,\n    externalSignerKShareGenerator: CustomKShareGeneratingFunction,\n    externalSignerMuDeltaShareGenerator: CustomMuDeltaShareGeneratingFunction,\n    externalSignerSShareGenerator: CustomSShareGeneratingFunction\n  ): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Signs a transaction using TSS MPCv2 for ECDSA and through utilization of custom share generators\n   *\n   * @param {TSSParams | TSSParamsForMessage} params - params object that represents parameters to sign a transaction or a message.\n   * @param {CustomMPCv2SigningRound1GeneratingFunction} externalSignerMPCv2SigningRound1Generator - a function that creates MPCv2 Round 1 shares in the ECDSA TSS MPCv2 flow.\n   * @param {CustomMPCv2SigningRound2GeneratingFunction} externalSignerMPCv2SigningRound2Generator - a function that creates MPCv2 Round 2 shares in the ECDSA TSS MPCv2 flow.\n   * @param {CustomMPCv2SigningRound3GeneratingFunction} externalSignerMPCv2SigningRound3Generator - a function that creates MPCv2 Round 3 shares in the ECDSA TSS MPCv2 flow.\n   * @param {RequestType} requestType - the type of the request to sign (transaction or message).\n   * @returns {Promise<TxRequest>} - a signed tx request\n   */\n  signEcdsaMPCv2TssUsingExternalSigner(\n    params: TSSParams | TSSParamsForMessage,\n    externalSignerMPCv2SigningRound1Generator: CustomMPCv2SigningRound1GeneratingFunction,\n    externalSignerMPCv2SigningRound2Generator: CustomMPCv2SigningRound2GeneratingFunction,\n    externalSignerMPCv2SigningRound3Generator: CustomMPCv2SigningRound3GeneratingFunction,\n    requestType?: RequestType\n  ): Promise<TxRequest> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Create an Commitment (User to BitGo) share from an unsigned transaction and private user signing material\n   * EDDSA only\n   *\n   * @param {Object} params - params object\n   * @param {TxRequest} params.txRequest - transaction request with unsigned transaction\n   * @param {string} params.prv - user signing material\n   * @param {string} params.walletPassphrase - wallet passphrase\n   *\n   * @returns {Promise<{ userToBitgoCommitment: CommitmentShareRecor, encryptedSignerShare: EncryptedSignerShareRecord }>} - Commitment Share and the Encrypted Signer Share to BitGo\n   */\n  createCommitmentShareFromTxRequest(params: {\n    txRequest: TxRequest;\n    prv: string;\n    walletPassphrase: string;\n    bitgoGpgPubKey: string;\n  }): Promise<{\n    userToBitgoCommitment: CommitmentShareRecord;\n    encryptedSignerShare: EncryptedSignerShareRecord;\n    encryptedUserToBitgoRShare: EncryptedSignerShareRecord;\n  }> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Create an R (User to BitGo) share from an unsigned transaction and private user signing material\n   *\n   * @param {Object} params - params object\n   * @param {TxRequest} params.txRequest - transaction request with unsigned transaction\n   * @param {string} params.prv - user signing material\n   * @param {string} [params.walletPassphrase] - wallet passphrase\n   * @param {EncryptedSignerShareRecord} [params.encryptedUserToBitgoRShare] - encrypted user to bitgo R share generated in the commitment phase\n   * @returns {Promise<{ rShare: SignShare }>} - R Share to BitGo\n   */\n  createRShareFromTxRequest(params: {\n    txRequest: TxRequest;\n    walletPassphrase: string;\n    encryptedUserToBitgoRShare: EncryptedSignerShareRecord;\n  }): Promise<{ rShare: SignShare }> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Create a G (User to BitGo) share from an unsigned transaction and private user signing material\n   *\n   * @param {Object} params - params object\n   * @param {TxRequest} params.txRequest - transaction request with unsigned transaction\n   * @param {string} params.prv - user signing material\n   * @param {SignatureShareRecord} params.bitgoToUserRShare - BitGo to User R Share\n   * @param {SignShare} params.userToBitgoRShare - User to BitGo R Share\n   * @param {CommitmentShareRecord} params.bitgoToUserCommitment - BitGo to User Commitment\n   * @returns {Promise<GShare>} - GShare from User to BitGo\n   */\n  createGShareFromTxRequest(params: {\n    txRequest: TxRequest;\n    prv: string;\n    bitgoToUserRShare: SignatureShareRecord;\n    userToBitgoRShare: SignShare;\n    bitgoToUserCommitment: CommitmentShareRecord;\n  }): Promise<GShare> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Builds a tx request from params and verify it\n   *\n   * @param {PrebuildTransactionWithIntentOptions} params - parameters to build the tx\n   * @param {TxRequestVersion} apiVersion lite or full\n   * @param {boolean} preview boolean indicating if this is to preview a tx request, which will not initiate policy checks or pending approvals\n   * @returns {Promise<TxRequest>} - a built tx request\n   */\n  async prebuildTxWithIntent(\n    params: PrebuildTransactionWithIntentOptions,\n    apiVersion: TxRequestVersion = 'lite',\n    preview?: boolean\n  ): Promise<TxRequest> {\n    const intentOptions = this.populateIntent(this.baseCoin, params);\n\n    const whitelistedParams = {\n      intent: {\n        ...intentOptions,\n      },\n      apiVersion: apiVersion,\n      preview,\n    };\n\n    const reqTracer = params.reqId || new RequestTracer();\n    this.bitgo.setRequestTracer(reqTracer);\n    const unsignedTx = (await this.bitgo\n      .post(this.bitgo.url('/wallet/' + this.wallet.id() + '/txrequests', 2))\n      .send(whitelistedParams)\n      .result()) as TxRequest;\n\n    return unsignedTx;\n  }\n\n  /**\n   * Create a tx request from params for message signing\n   *\n   * @param params\n   * @param apiVersion\n   * @param preview\n   */\n  async createTxRequestWithIntentForMessageSigning(\n    params: IntentOptionsForMessage,\n    apiVersion: TxRequestVersion = 'full',\n    preview?: boolean\n  ): Promise<TxRequest> {\n    const intentOptions: PopulatedIntentForMessageSigning = {\n      custodianMessageId: params.custodianMessageId,\n      intentType: params.intentType,\n      sequenceId: params.sequenceId,\n      comment: params.comment,\n      memo: params.memo?.value,\n      isTss: params.isTss,\n      messageRaw: params.messageRaw,\n      messageEncoded: params.messageEncoded ?? '',\n    };\n\n    return this.createTxRequestBase(intentOptions, apiVersion, preview, params.reqId);\n  }\n\n  /**\n   * Create a tx request from params for type data signing\n   *\n   * @param params\n   * @param apiVersion\n   * @param preview\n   */\n  async createTxRequestWithIntentForTypedDataSigning(\n    params: IntentOptionsForTypedData,\n    apiVersion: TxRequestVersion = 'full',\n    preview?: boolean\n  ): Promise<TxRequest> {\n    const intentOptions: PopulatedIntentForTypedDataSigning = {\n      custodianMessageId: params.custodianMessageId,\n      intentType: params.intentType,\n      sequenceId: params.sequenceId,\n      comment: params.comment,\n      memo: params.memo?.value,\n      isTss: params.isTss,\n      messageRaw: params.typedDataRaw,\n      messageEncoded: params.typedDataEncoded ?? '',\n    };\n\n    return this.createTxRequestBase(intentOptions, apiVersion, preview, params.reqId);\n  }\n\n  /**\n   * Calls Bitgo API to create tx request.\n   *\n   * @private\n   */\n  private async createTxRequestBase(\n    intentOptions: PopulatedIntentForTypedDataSigning | PopulatedIntentForMessageSigning,\n    apiVersion: TxRequestVersion,\n    preview?: boolean,\n    reqId?: IRequestTracer\n  ): Promise<TxRequest> {\n    const whitelistedParams = {\n      intent: {\n        ...intentOptions,\n      },\n      apiVersion,\n      preview,\n    };\n\n    const reqTracer = reqId || new RequestTracer();\n    this.bitgo.setRequestTracer(reqTracer);\n    return this.bitgo\n      .post(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests`, 2))\n      .send(whitelistedParams)\n      .result();\n  }\n\n  /**\n   * Call delete signature shares for a txRequest, the endpoint delete the signatures and return them\n   *\n   * @param {string} txRequestId tx id reference to delete signature shares\n   * @param {IRequestTracer} reqId - the request tracer request id\n   * @returns {SignatureShareRecord[]}\n   */\n  async deleteSignatureShares(txRequestId: string, reqId?: IRequestTracer): Promise<SignatureShareRecord[]> {\n    const reqTracer = reqId || new RequestTracer();\n    this.bitgo.setRequestTracer(reqTracer);\n    return this.bitgo\n      .del(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests/${txRequestId}/signatureshares`, 2))\n      .send()\n      .result();\n  }\n\n  /**\n   * Initialize the send procedure once Bitgo has the User To Bitgo GShare\n   *\n   * @param {String} txRequestId - the txRequest Id\n   * @param {IRequestTracer} reqId - the request tracer request id\n   * @returns {Promise<any>}\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  async sendTxRequest(txRequestId: string, reqId?: IRequestTracer): Promise<any> {\n    const reqTracer = reqId || new RequestTracer();\n    this.bitgo.setRequestTracer(reqTracer);\n    return this.bitgo\n      .post(this.baseCoin.url('/wallet/' + this.wallet.id() + '/tx/send'))\n      .send({ txRequestId })\n      .result();\n  }\n\n  /**\n   * Delete signature shares, get the tx request without them from the db and sign it to finally send it.\n   *\n   * Note : This can be performed in order to reach latest network conditions required on pending approval flow.\n   *\n   * @param {String} txRequestId - the txRequest Id to make the requests.\n   * @param {String} decryptedPrv - decrypted prv to sign the tx request.\n   * @param {RequestTracer} reqId id tracer.\n   * @returns {Promise<any>}\n   */\n  async recreateTxRequest(txRequestId: string, decryptedPrv: string, reqId: IRequestTracer): Promise<TxRequest> {\n    await this.deleteSignatureShares(txRequestId, reqId);\n    // after delete signatures shares get the tx without them\n    const txRequest = await getTxRequest(this.bitgo, this.wallet.id(), txRequestId, reqId);\n    return await this.signTxRequest({ txRequest, prv: decryptedPrv, reqId });\n  }\n\n  /**\n   * Gets the latest Tx Request by id\n   *\n   * @param {String} txRequestId - the txRequest Id\n   * @param {IRequestTracer} reqId - request tracer request id\n   * @returns {Promise<TxRequest>}\n   */\n  async getTxRequest(txRequestId: string, reqId?: IRequestTracer): Promise<TxRequest> {\n    return getTxRequest(this.bitgo, this.wallet.id(), txRequestId, reqId);\n  }\n\n  /**\n   * It gets the appropriate BitGo GPG public key for key creation based on a\n   * combination of coin and the feature flags on the user and their enterprise if set.\n   * @param enterpriseId - enterprise under which user wants to create the wallet\n   * @param isMPCv2 - true to get the MPCv2 GPG public key, defaults to false\n   * @param reqId - request tracer request id\n   */\n  public async getBitgoGpgPubkeyBasedOnFeatureFlags(\n    enterpriseId: string | undefined,\n    isMPCv2 = false,\n    reqId?: IRequestTracer\n  ): Promise<Key> {\n    const reqTracer = reqId || new RequestTracer();\n    this.bitgo.setRequestTracer(reqTracer);\n    const response: BitgoGPGPublicKey = await this.bitgo\n      .get(this.baseCoin.url('/tss/pubkey'))\n      .query({ enterpriseId })\n      .retry(3)\n      .result();\n    const bitgoPublicKeyStr = isMPCv2 ? response.mpcv2PublicKey : response.publicKey;\n    return readKey({ armoredKey: bitgoPublicKeyStr as string });\n  }\n\n  /**\n   * Returns supported TxRequest versions for this wallet\n   * @deprecated Whenever needed, use apiVersion 'full' for TSS wallets\n   */\n  public supportedTxRequestVersions(): TxRequestVersion[] {\n    if (!this._wallet || this._wallet.type() === 'trading' || this._wallet.multisigType() !== 'tss') {\n      return [];\n    } else if (this._wallet.baseCoin.getMPCAlgorithm() === 'ecdsa') {\n      return ['full'];\n    } else if (this._wallet.baseCoin.getMPCAlgorithm() === 'eddsa' && this._wallet.type() === 'hot') {\n      return ['lite', 'full'];\n    } else {\n      return ['full'];\n    }\n  }\n\n  /**\n   * Returns true if the txRequest is using apiVersion == full and is pending approval\n   * @param txRequest\n   * @returns boolean\n   */\n  isPendingApprovalTxRequestFull(txRequest: TxRequest): boolean {\n    const { apiVersion, state } = txRequest;\n    return apiVersion === 'full' && 'pendingApproval' === state;\n  }\n}\n"]}