@bitgo/abstract-eth 24.10.1 → 24.11.0

package/dist/src/abstractEthLikeNewCoins.js

@@ -0,0 +1,2229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractEthLikeNewCoins = exports.optionalDeps = exports.DEFAULT_SCAN_FACTOR = void 0;
+/**
+ * @prettier
+ */
+const sdk_core_1 = require("@bitgo/sdk-core");
+const sdk_lib_mpc_1 = require("@bitgo/sdk-lib-mpc");
+const secp256k1_1 = require("@bitgo/secp256k1");
+const statics_1 = require("@bitgo/statics");
+const tx_1 = require("@ethereumjs/tx");
+const rlp_1 = require("@ethereumjs/rlp");
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const bignumber_js_1 = require("bignumber.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const crypto_1 = require("crypto");
+const debug_1 = __importDefault(require("debug"));
+const ethereumjs_util_1 = require("ethereumjs-util");
+const keccak_1 = __importDefault(require("keccak"));
+const lodash_1 = __importDefault(require("lodash"));
+const secp256k1_2 = __importDefault(require("secp256k1"));
+const abstractEthLikeCoin_1 = require("./abstractEthLikeCoin");
+const ethLikeToken_1 = require("./ethLikeToken");
+const lib_1 = require("./lib");
+exports.DEFAULT_SCAN_FACTOR = 20;
+const debug = (0, debug_1.default)('bitgo:v2:ethlike');
+exports.optionalDeps = {
+    get ethAbi() {
+        try {
+            return require('ethereumjs-abi');
+        }
+        catch (e) {
+            debug('unable to load ethereumjs-abi:');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`ethereumjs-abi`);
+        }
+    },
+    get ethUtil() {
+        try {
+            return require('ethereumjs-util');
+        }
+        catch (e) {
+            debug('unable to load ethereumjs-util:');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`ethereumjs-util`);
+        }
+    },
+    get EthTx() {
+        try {
+            return require('@ethereumjs/tx');
+        }
+        catch (e) {
+            debug('unable to load @ethereumjs/tx');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`@ethereumjs/tx`);
+        }
+    },
+    get EthCommon() {
+        try {
+            return require('@ethereumjs/common');
+        }
+        catch (e) {
+            debug('unable to load @ethereumjs/common:');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`@ethereumjs/common`);
+        }
+    },
+};
+class AbstractEthLikeNewCoins extends abstractEthLikeCoin_1.AbstractEthLikeCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
+        /**
+         * Get the data required to make an ETH function call defined by the given types and values
+         *
+         * @param {string} functionName - The name of the function being called, e.g. transfer
+         * @param types The types of the function call in order
+         * @param values The values of the function call in order
+         * @return {Buffer} The combined data for the function call
+         */
+        this.getMethodCallData = (functionName, types, values) => {
+            return Buffer.concat([
+                // function signature
+                exports.optionalDeps.ethAbi.methodID(functionName, types),
+                // function arguments
+                exports.optionalDeps.ethAbi.rawEncode(types, values),
+            ]);
+        };
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this.staticsCoin = staticsCoin;
+        this.sendMethodName = 'sendMultiSig';
+    }
+    /**
+     * Method to return the coin's network object
+     * @returns {EthLikeNetwork | undefined}
+     */
+    getNetwork() {
+        return this.staticsCoin?.network;
+    }
+    /**
+     * Evaluates whether an address string is valid for this coin
+     * @param {string} address
+     * @returns {boolean} True if address is the valid ethlike adderss
+     */
+    isValidAddress(address) {
+        return exports.optionalDeps.ethUtil.isValidAddress(exports.optionalDeps.ethUtil.addHexPrefix(address));
+    }
+    /**
+     * Flag for sending data along with transactions
+     * @returns {boolean} True if okay to send tx data (ETH), false otherwise
+     */
+    transactionDataAllowed() {
+        return true;
+    }
+    /**
+     * Default expire time for a contract call (1 week)
+     * @returns {number} Time in seconds
+     */
+    getDefaultExpireTime() {
+        return Math.floor(new Date().getTime() / 1000) + 60 * 60 * 24 * 7;
+    }
+    /**
+     * Method to get the custom chain common object based on params from recovery
+     * @param {number} chainId - the chain id of the custom chain
+     * @returns {EthLikeCommon.default}
+     */
+    static getCustomChainCommon(chainId) {
+        const coinName = statics_1.CoinMap.coinNameFromChainId(chainId);
+        const coin = statics_1.coins.get(coinName);
+        const ethLikeCommon = (0, lib_1.getCommon)(coin.network);
+        return ethLikeCommon;
+    }
+    /**
+     * Gets correct Eth Common object based on params from either recovery or tx building
+     * @param {EIP1559} eip1559 - configs that specify whether we should construct an eip1559 tx
+     * @param {ReplayProtectionOptions} replayProtectionOptions - check if chain id supports replay protection
+     * @returns {EthLikeCommon.default}
+     */
+    static getEthLikeCommon(eip1559, replayProtectionOptions) {
+        // if eip1559 params are specified, default to london hardfork, otherwise,
+        // default to petersburg to avoid replay protection issues
+        const defaultHardfork = !!eip1559 ? 'london' : exports.optionalDeps.EthCommon.Hardfork.Petersburg;
+        const ethLikeCommon = AbstractEthLikeNewCoins.getCustomChainCommon(replayProtectionOptions?.chain);
+        ethLikeCommon.setHardfork(replayProtectionOptions?.hardfork ?? defaultHardfork);
+        return ethLikeCommon;
+    }
+    /**
+     * Method to build the tx object
+     * @param {BuildTransactionParams} params - params to build transaction
+     * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}
+     */
+    static buildTransaction(params) {
+        // if eip1559 params are specified, default to london hardfork, otherwise,
+        // default to tangerine whistle to avoid replay protection issues
+        const ethLikeCommon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);
+        const baseParams = {
+            to: params.to,
+            nonce: params.nonce,
+            value: params.value,
+            data: params.data,
+            gasLimit: new exports.optionalDeps.ethUtil.BN(params.gasLimit),
+        };
+        const unsignedEthTx = !!params.eip1559
+            ? exports.optionalDeps.EthTx.FeeMarketEIP1559Transaction.fromTxData({
+                ...baseParams,
+                maxFeePerGas: new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas),
+                maxPriorityFeePerGas: new exports.optionalDeps.ethUtil.BN(params.eip1559.maxPriorityFeePerGas),
+            }, { common: ethLikeCommon })
+            : exports.optionalDeps.EthTx.Transaction.fromTxData({
+                ...baseParams,
+                gasPrice: new exports.optionalDeps.ethUtil.BN(params.gasPrice),
+            }, { common: ethLikeCommon });
+        return unsignedEthTx;
+    }
+    /**
+     * Query explorer for the balance of an address
+     * @param {String} address - the ETHLike address
+     * @param {String} apiKey - optional API key to use instead of the one from the environment
+     * @returns {BigNumber} address balance
+     */
+    async queryAddressBalance(address, apiKey) {
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'account',
+            action: 'balance',
+            address: address,
+        }, apiKey);
+        // throw if the result does not exist or the result is not a valid number
+        if (!result || !result.result || isNaN(result.result)) {
+            throw new Error(`Could not obtain address balance for ${address} from the explorer, got: ${result.result}`);
+        }
+        return new exports.optionalDeps.ethUtil.BN(result.result, 10);
+    }
+    /**
+     * @param {Recipient[]} recipients - the recipients of the transaction
+     * @param {number} expireTime - the expire time of the transaction
+     * @param {number} contractSequenceId - the contract sequence id of the transaction
+     * @returns {string}
+     */
+    getOperationSha3ForExecuteAndConfirm(recipients, expireTime, contractSequenceId) {
+        if (!recipients || !Array.isArray(recipients)) {
+            throw new Error('expecting array of recipients');
+        }
+        // Right now we only support 1 recipient
+        if (recipients.length !== 1) {
+            throw new Error('must send to exactly 1 recipient');
+        }
+        if (!lodash_1.default.isNumber(expireTime)) {
+            throw new Error('expireTime must be number of seconds since epoch');
+        }
+        if (!lodash_1.default.isNumber(contractSequenceId)) {
+            throw new Error('contractSequenceId must be number');
+        }
+        // Check inputs
+        recipients.forEach(function (recipient) {
+            if (!lodash_1.default.isString(recipient.address) ||
+                !exports.optionalDeps.ethUtil.isValidAddress(exports.optionalDeps.ethUtil.addHexPrefix(recipient.address))) {
+                throw new Error('Invalid address: ' + recipient.address);
+            }
+            let amount;
+            try {
+                amount = new bignumber_js_1.BigNumber(recipient.amount);
+            }
+            catch (e) {
+                throw new Error('Invalid amount for: ' + recipient.address + ' - should be numeric');
+            }
+            recipient.amount = amount.toFixed(0);
+            if (recipient.data && !lodash_1.default.isString(recipient.data)) {
+                throw new Error('Data for recipient ' + recipient.address + ' - should be of type hex string');
+            }
+        });
+        const recipient = recipients[0];
+        return exports.optionalDeps.ethUtil.bufferToHex(exports.optionalDeps.ethAbi.soliditySHA3(...this.getOperation(recipient, expireTime, contractSequenceId)));
+    }
+    /**
+     * Get transfer operation for coin
+     * @param {Recipient} recipient - recipient info
+     * @param {number} expireTime - expiry time
+     * @param {number} contractSequenceId - sequence id
+     * @returns {Array} operation array
+     */
+    getOperation(recipient, expireTime, contractSequenceId) {
+        const network = this.getNetwork();
+        return [
+            ['string', 'address', 'uint', 'bytes', 'uint', 'uint'],
+            [
+                network.nativeCoinOperationHashPrefix,
+                new exports.optionalDeps.ethUtil.BN(exports.optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),
+                recipient.amount,
+                Buffer.from(exports.optionalDeps.ethUtil.stripHexPrefix(exports.optionalDeps.ethUtil.padToEven(recipient.data || '')), 'hex'),
+                expireTime,
+                contractSequenceId,
+            ],
+        ];
+    }
+    /**
+     * Queries the contract (via explorer API) for the next sequence ID
+     * @param {String} address - address of the contract
+     * @param {String} apiKey - optional API key to use instead of the one from the environment
+     * @returns {Promise<Number>} sequence ID
+     */
+    async querySequenceId(address, apiKey) {
+        // Get sequence ID using contract call
+        const sequenceIdMethodSignature = exports.optionalDeps.ethAbi.methodID('getNextSequenceId', []);
+        const sequenceIdArgs = exports.optionalDeps.ethAbi.rawEncode([], []);
+        const sequenceIdData = Buffer.concat([sequenceIdMethodSignature, sequenceIdArgs]).toString('hex');
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'proxy',
+            action: 'eth_call',
+            to: address,
+            data: sequenceIdData,
+            tag: 'latest',
+        }, apiKey);
+        if (!result || !result.result) {
+            throw new Error('Could not obtain sequence ID from explorer, got: ' + result.result);
+        }
+        const sequenceIdHex = result.result;
+        return new exports.optionalDeps.ethUtil.BN(sequenceIdHex.slice(2), 16).toNumber();
+    }
+    /**
+     * Recover an unsupported token from a BitGo multisig wallet
+     * This builds a half-signed transaction, for which there will be an admin route to co-sign and broadcast. Optionally
+     * the user can set params.broadcast = true and the half-signed tx will be sent to BitGo for cosigning and broadcasting
+     * @param {RecoverTokenOptions} params
+     * @param {Wallet} params.wallet - the wallet to recover the token from
+     * @param {string} params.tokenContractAddress - the contract address of the unsupported token
+     * @param {string} params.recipient - the destination address recovered tokens should be sent to
+     * @param {string} params.walletPassphrase - the wallet passphrase
+     * @param {string} params.prv - the xprv
+     * @param {boolean} params.broadcast - if true, we will automatically submit the half-signed tx to BitGo for cosigning and broadcasting
+     * @returns {Promise<RecoverTokenTransaction>}
+     */
+    async recoverToken(params) {
+        const network = this.getNetwork();
+        if (!lodash_1.default.isObject(params)) {
+            throw new Error(`recoverToken must be passed a params object. Got ${params} (type ${typeof params})`);
+        }
+        if (lodash_1.default.isUndefined(params.tokenContractAddress) || !lodash_1.default.isString(params.tokenContractAddress)) {
+            throw new Error(`tokenContractAddress must be a string, got ${params.tokenContractAddress} (type ${typeof params.tokenContractAddress})`);
+        }
+        if (!this.isValidAddress(params.tokenContractAddress)) {
+            throw new Error('tokenContractAddress not a valid address');
+        }
+        if (lodash_1.default.isUndefined(params.wallet) || !(params.wallet instanceof sdk_core_1.Wallet)) {
+            throw new Error(`wallet must be a wallet instance, got ${params.wallet} (type ${typeof params.wallet})`);
+        }
+        if (lodash_1.default.isUndefined(params.recipient) || !lodash_1.default.isString(params.recipient)) {
+            throw new Error(`recipient must be a string, got ${params.recipient} (type ${typeof params.recipient})`);
+        }
+        if (!this.isValidAddress(params.recipient)) {
+            throw new Error('recipient not a valid address');
+        }
+        if (!exports.optionalDeps.ethUtil.bufferToHex || !exports.optionalDeps.ethAbi.soliditySHA3) {
+            throw new Error('ethereum not fully supported in this environment');
+        }
+        // Get token balance from external API
+        const coinSpecific = params.wallet.coinSpecific();
+        if (!coinSpecific || !lodash_1.default.isString(coinSpecific.baseAddress)) {
+            throw new Error('missing required coin specific property baseAddress');
+        }
+        const recoveryAmount = await this.queryAddressTokenBalance(params.tokenContractAddress, coinSpecific.baseAddress);
+        if (params.broadcast) {
+            // We're going to create a normal ETH transaction that sends an amount of 0 ETH to the
+            // tokenContractAddress and encode the unsupported-token-send data in the data field
+            // #tricksy
+            const sendMethodArgs = [
+                {
+                    name: '_to',
+                    type: 'address',
+                    value: params.recipient,
+                },
+                {
+                    name: '_value',
+                    type: 'uint256',
+                    value: recoveryAmount.toString(10),
+                },
+            ];
+            const methodSignature = exports.optionalDeps.ethAbi.methodID('transfer', lodash_1.default.map(sendMethodArgs, 'type'));
+            const encodedArgs = exports.optionalDeps.ethAbi.rawEncode(lodash_1.default.map(sendMethodArgs, 'type'), lodash_1.default.map(sendMethodArgs, 'value'));
+            const sendData = Buffer.concat([methodSignature, encodedArgs]);
+            const broadcastParams = {
+                address: params.tokenContractAddress,
+                amount: '0',
+                data: sendData.toString('hex'),
+            };
+            if (params.walletPassphrase) {
+                broadcastParams.walletPassphrase = params.walletPassphrase;
+            }
+            else if (params.prv) {
+                broadcastParams.prv = params.prv;
+            }
+            return await params.wallet.send(broadcastParams);
+        }
+        const recipient = {
+            address: params.recipient,
+            amount: recoveryAmount.toString(10),
+        };
+        // This signature will be valid for one week
+        const expireTime = Math.floor(new Date().getTime() / 1000) + 60 * 60 * 24 * 7;
+        // Get sequence ID. We do this by building a 'fake' eth transaction, so the platform will increment and return us the new sequence id
+        // This _does_ require the user to have a non-zero wallet balance
+        const { nextContractSequenceId, gasPrice, gasLimit } = (await params.wallet.prebuildTransaction({
+            recipients: [
+                {
+                    address: params.recipient,
+                    amount: '1',
+                },
+            ],
+        }));
+        // these recoveries need to be processed by support, but if the customer sends any transactions before recovery is
+        // complete the sequence ID will be invalid. artificially inflate the sequence ID to allow more time for processing
+        const safeSequenceId = nextContractSequenceId + 1000;
+        // Build sendData for ethereum tx
+        const operationTypes = ['string', 'address', 'uint', 'address', 'uint', 'uint'];
+        const operationArgs = [
+            // Token operation has prefix has been added here so that ether operation hashes, signatures cannot be re-used for tokenSending
+            network.tokenOperationHashPrefix,
+            new exports.optionalDeps.ethUtil.BN(exports.optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),
+            recipient.amount,
+            new exports.optionalDeps.ethUtil.BN(exports.optionalDeps.ethUtil.stripHexPrefix(params.tokenContractAddress), 16),
+            expireTime,
+            safeSequenceId,
+        ];
+        const operationHash = exports.optionalDeps.ethUtil.bufferToHex(exports.optionalDeps.ethAbi.soliditySHA3(operationTypes, operationArgs));
+        const userPrv = await params.wallet.getPrv({
+            prv: params.prv,
+            walletPassphrase: params.walletPassphrase,
+        });
+        const signature = sdk_core_1.Util.ethSignMsgHash(operationHash, sdk_core_1.Util.xprvToEthPrivateKey(userPrv));
+        return {
+            halfSigned: {
+                recipient: recipient,
+                expireTime: expireTime,
+                contractSequenceId: safeSequenceId,
+                operationHash: operationHash,
+                signature: signature,
+                gasLimit: gasLimit,
+                gasPrice: gasPrice,
+                tokenContractAddress: params.tokenContractAddress,
+                walletId: params.wallet.id(),
+            },
+        };
+    }
+    /**
+     * Ensure either enterprise or newFeeAddress is passed, to know whether to create new key or use enterprise key
+     * @param {PrecreateBitGoOptions} params
+     * @param {string} params.enterprise {String} the enterprise id to associate with this key
+     * @param {string} params.newFeeAddress {Boolean} create a new fee address (enterprise not needed in this case)
+     * @returns {void}
+     */
+    preCreateBitGo(params) {
+        // We always need params object, since either enterprise or newFeeAddress is required
+        if (!lodash_1.default.isObject(params)) {
+            throw new Error(`preCreateBitGo must be passed a params object. Got ${params} (type ${typeof params})`);
+        }
+        if (lodash_1.default.isUndefined(params.enterprise) && lodash_1.default.isUndefined(params.newFeeAddress)) {
+            throw new Error('expecting enterprise when adding BitGo key. If you want to create a new ETH bitgo key, set the newFeeAddress parameter to true.');
+        }
+        // Check whether key should be an enterprise key or a BitGo key for a new fee address
+        if (!lodash_1.default.isUndefined(params.enterprise) && !lodash_1.default.isUndefined(params.newFeeAddress)) {
+            throw new Error(`Incompatible arguments - cannot pass both enterprise and newFeeAddress parameter.`);
+        }
+        if (!lodash_1.default.isUndefined(params.enterprise) && !lodash_1.default.isString(params.enterprise)) {
+            throw new Error(`enterprise should be a string - got ${params.enterprise} (type ${typeof params.enterprise})`);
+        }
+        if (!lodash_1.default.isUndefined(params.newFeeAddress) && !lodash_1.default.isBoolean(params.newFeeAddress)) {
+            throw new Error(`newFeeAddress should be a boolean - got ${params.newFeeAddress} (type ${typeof params.newFeeAddress})`);
+        }
+    }
+    /**
+     * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address
+     * @param {string} address
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     * @returns {Promise<number>}
+     */
+    async getAddressNonce(address, apiKey) {
+        // Get nonce for backup key (should be 0)
+        let nonce = 0;
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'account',
+            action: 'txlist',
+            address,
+        }, apiKey);
+        if (!result || !Array.isArray(result.result)) {
+            throw new Error('Unable to find next nonce from Etherscan, got: ' + JSON.stringify(result));
+        }
+        const backupKeyTxList = result.result;
+        if (backupKeyTxList.length > 0) {
+            // Calculate last nonce used
+            const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === address);
+            nonce = outgoingTxs.length;
+        }
+        return nonce;
+    }
+    /**
+     * Helper function for recover()
+     * This transforms the unsigned transaction information into a format the BitGo offline vault expects
+     * @param {UnformattedTxInfo} txInfo - tx info
+     * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object
+     * @param {string} userKey - the user's key
+     * @param {string} backupKey - the backup key
+     * @param {Buffer} gasPrice - gas price for the tx
+     * @param {number} gasLimit - gas limit for the tx
+     * @param {EIP1559} eip1559 - eip1559 params
+     * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options
+     * @param {apiKey} apiKey - optional apiKey to use when retrieving block chain data
+     * @returns {Promise<OfflineVaultTxInfo>}
+     */
+    async formatForOfflineVault(txInfo, ethTx, userKey, backupKey, gasPrice, gasLimit, eip1559, replayProtectionOptions, apiKey) {
+        if (!ethTx.to) {
+            throw new Error('Eth tx must have a `to` address');
+        }
+        const backupHDNode = secp256k1_1.bip32.fromBase58(backupKey);
+        const backupSigningKey = backupHDNode.publicKey;
+        const response = {
+            tx: ethTx.serialize().toString('hex'),
+            userKey,
+            backupKey,
+            coin: this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: [txInfo.recipient],
+            walletContractAddress: ethTx.to.toString(),
+            amount: txInfo.recipient.amount,
+            backupKeyNonce: await this.getAddressNonce(`0x${exports.optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`, apiKey),
+            eip1559,
+            replayProtectionOptions,
+        };
+        lodash_1.default.extend(response, txInfo);
+        response.nextContractSequenceId = response.contractSequenceId;
+        return response;
+    }
+    /**
+     * Helper function for recover()
+     * This transforms the unsigned transaction information into a format the BitGo offline vault expects
+     * @param {UnformattedTxInfo} txInfo - tx info
+     * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object
+     * @param {string} userKey - the user's key
+     * @param {string} backupKey - the backup key
+     * @param {Buffer} gasPrice - gas price for the tx
+     * @param {number} gasLimit - gas limit for the tx
+     * @param {number} backupKeyNonce - the nonce of the backup key address
+     * @param {EIP1559} eip1559 - eip1559 params
+     * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options
+     * @returns {Promise<OfflineVaultTxInfo>}
+     */
+    formatForOfflineVaultTSS(txInfo, ethTx, userKey, backupKey, gasPrice, gasLimit, backupKeyNonce, eip1559, replayProtectionOptions) {
+        if (!ethTx.to) {
+            throw new Error('Eth tx must have a `to` address');
+        }
+        const response = {
+            tx: ethTx.serialize().toString('hex'),
+            txHex: ethTx.getMessageToSign(false).toString(),
+            userKey,
+            backupKey,
+            coin: this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: [txInfo.recipient],
+            walletContractAddress: ethTx.to.toString(),
+            amount: txInfo.recipient.amount,
+            backupKeyNonce: backupKeyNonce,
+            eip1559,
+            replayProtectionOptions,
+        };
+        lodash_1.default.extend(response, txInfo);
+        return response;
+    }
+    /**
+     * Check whether the gas price passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasPrice - user defined gas price
+     * @returns {number} the gas price to use for this transaction
+     */
+    setGasPrice(userGasPrice) {
+        if (!userGasPrice) {
+            return statics_1.ethGasConfigs.defaultGasPrice;
+        }
+        const gasPriceMax = statics_1.ethGasConfigs.maximumGasPrice;
+        const gasPriceMin = statics_1.ethGasConfigs.minimumGasPrice;
+        if (userGasPrice < gasPriceMin || userGasPrice > gasPriceMax) {
+            throw new Error(`Gas price must be between ${gasPriceMin} and ${gasPriceMax}`);
+        }
+        return userGasPrice;
+    }
+    /**
+     * Check whether gas limit passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasLimit user defined gas limit
+     * @returns {number} the gas limit to use for this transaction
+     */
+    setGasLimit(userGasLimit) {
+        if (!userGasLimit) {
+            return statics_1.ethGasConfigs.defaultGasLimit;
+        }
+        const gasLimitMax = statics_1.ethGasConfigs.maximumGasLimit;
+        const gasLimitMin = statics_1.ethGasConfigs.minimumGasLimit;
+        if (userGasLimit < gasLimitMin || userGasLimit > gasLimitMax) {
+            throw new Error(`Gas limit must be between ${gasLimitMin} and ${gasLimitMax}`);
+        }
+        return userGasLimit;
+    }
+    /**
+     * Helper function for signTransaction for the rare case that SDK is doing the second signature
+     * Note: we are expecting this to be called from the offline vault
+     * @param {SignFinalOptions.txPrebuild} params.txPrebuild
+     * @param {string} params.prv
+     * @returns {{txHex: string}}
+     */
+    async signFinalEthLike(params) {
+        const signingKey = new lib_1.KeyPair({ prv: params.prv }).getKeys().prv;
+        if (lodash_1.default.isUndefined(signingKey)) {
+            throw new Error('missing private key');
+        }
+        const txBuilder = this.getTransactionBuilder(params.common);
+        try {
+            txBuilder.from(params.txPrebuild.halfSigned?.txHex);
+        }
+        catch (e) {
+            throw new Error('invalid half-signed transaction');
+        }
+        txBuilder.sign({ key: signingKey });
+        const tx = await txBuilder.build();
+        return {
+            txHex: tx.toBroadcastFormat(),
+        };
+    }
+    /**
+     * Assemble half-sign prebuilt transaction
+     * @param {SignTransactionOptions} params
+     */
+    async signTransaction(params) {
+        // Normally the SDK provides the first signature for an EthLike tx, but occasionally it provides the second and final one.
+        if (params.isLastSignature) {
+            // In this case when we're doing the second (final) signature, the logic is different.
+            return await this.signFinalEthLike(params);
+        }
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.from(params.txPrebuild.txHex);
+        txBuilder
+            .transfer()
+            .coin(this.staticsCoin?.name)
+            .key(new lib_1.KeyPair({ prv: params.prv }).getKeys().prv);
+        if (params.walletVersion) {
+            txBuilder.walletVersion(params.walletVersion);
+        }
+        const transaction = await txBuilder.build();
+        // In case of tx with contract data from a custodial wallet, we are running into an issue
+        // as halfSigned is not having the data field. So, we are adding the data field to the halfSigned tx
+        let recipients = params.txPrebuild.recipients || params.recipients;
+        if (recipients === undefined) {
+            recipients = transaction.outputs.map((output) => ({ address: output.address, amount: output.value }));
+        }
+        const txParams = {
+            eip1559: params.txPrebuild.eip1559,
+            txHex: transaction.toBroadcastFormat(),
+            recipients: recipients,
+            expiration: params.txPrebuild.expireTime,
+            hopTransaction: params.txPrebuild.hopTransaction,
+            custodianTransactionId: params.custodianTransactionId,
+            expireTime: params.expireTime,
+            contractSequenceId: params.txPrebuild.nextContractSequenceId,
+            sequenceId: params.sequenceId,
+            ...(params.txPrebuild.isBatch ? { isBatch: params.txPrebuild.isBatch } : {}),
+        };
+        return { halfSigned: txParams };
+    }
+    /**
+     * Method to validate recovery params
+     * @param {RecoverOptions} params
+     * @returns {void}
+     */
+    validateRecoveryParams(params) {
+        if (params.userKey === undefined) {
+            throw new Error('missing userKey');
+        }
+        if (params.backupKey === undefined) {
+            throw new Error('missing backupKey');
+        }
+        if (!params.isUnsignedSweep &&
+            params.walletPassphrase === undefined &&
+            !params.userKey.startsWith('xpub') &&
+            !params.isTss) {
+            throw new Error('missing wallet passphrase');
+        }
+        if (params.walletContractAddress === undefined || !this.isValidAddress(params.walletContractAddress)) {
+            throw new Error('invalid walletContractAddress');
+        }
+        if (params.recoveryDestination === undefined || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        if (!this.staticsCoin?.features.includes(statics_1.CoinFeature.EIP1559)) {
+            if (params.eip1559) {
+                throw new Error('Invalid fee params. EIP1559 not supported');
+            }
+            if (params.replayProtectionOptions?.hardfork === 'london') {
+                throw new Error('Invalid replayProtection options. Cannot use the hardfork "london" for this chain');
+            }
+        }
+    }
+    /**
+     * Helper which Adds signatures to tx object and re-serializes tx
+     * @param {EthLikeCommon.default} ethCommon
+     * @param {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction} tx
+     * @param {ECDSAMethodTypes.Signature} signature
+     * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}
+     */
+    getSignedTxFromSignature(ethCommon, tx, signature) {
+        // get signed Tx from signature
+        const txData = tx.toJSON();
+        const yParity = signature.recid;
+        const baseParams = {
+            to: txData.to,
+            nonce: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.nonce), 'hex'),
+            value: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.value), 'hex'),
+            gasLimit: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.gasLimit), 'hex'),
+            data: txData.data,
+            r: (0, ethereumjs_util_1.addHexPrefix)(signature.r),
+            s: (0, ethereumjs_util_1.addHexPrefix)(signature.s),
+        };
+        let finalTx;
+        if (txData.maxFeePerGas && txData.maxPriorityFeePerGas) {
+            finalTx = tx_1.FeeMarketEIP1559Transaction.fromTxData({
+                ...baseParams,
+                maxPriorityFeePerGas: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.maxPriorityFeePerGas), 'hex'),
+                maxFeePerGas: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.maxFeePerGas), 'hex'),
+                v: new bn_js_1.default(yParity.toString()),
+            }, { common: ethCommon });
+        }
+        else if (txData.gasPrice) {
+            const v = BigInt(35) + BigInt(yParity) + BigInt(ethCommon.chainIdBN().toNumber()) * BigInt(2);
+            finalTx = tx_1.Transaction.fromTxData({
+                ...baseParams,
+                v: new bn_js_1.default(v.toString()),
+                gasPrice: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.gasPrice.toString()), 'hex'),
+            }, { common: ethCommon });
+        }
+        return finalTx;
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     * @param {string} params.userKey - [encrypted] xprv
+     * @param {string} params.backupKey - [encrypted] xprv or xpub if the xprv is held by a KRS provider
+     * @param {string} params.walletPassphrase - used to decrypt userKey and backupKey
+     * @param {string} params.walletContractAddress - the ETH address of the wallet contract
+     * @param {string} params.krsProvider - necessary if backup key is held by KRS
+     * @param {string} params.recoveryDestination - target address to send recovered funds to
+     * @param {string} params.bitgoFeeAddress - wrong chain wallet fee address for evm based cross chain recovery txn
+     * @param {string} params.bitgoDestinationAddress - target bitgo address where fee will be sent for evm based cross chain recovery txn
+     */
+    async recover(params) {
+        if (params.isTss === true) {
+            return this.recoverTSS(params);
+        }
+        return this.recoverEthLike(params);
+    }
+    generateForwarderAddress(baseAddress, feeAddress, forwarderFactoryAddress, forwarderImplementationAddress, index) {
+        const salt = (0, ethereumjs_util_1.addHexPrefix)(index.toString(16));
+        const saltBuffer = (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.toBuffer)(salt), 32);
+        const { createForwarderParams, createForwarderTypes } = (0, lib_1.getCreateForwarderParamsAndTypes)(baseAddress, saltBuffer, feeAddress);
+        const calculationSalt = (0, ethereumjs_util_1.bufferToHex)(exports.optionalDeps.ethAbi.soliditySHA3(createForwarderTypes, createForwarderParams));
+        const initCode = (0, lib_1.getProxyInitcode)(forwarderImplementationAddress);
+        return (0, lib_1.calculateForwarderV1Address)(forwarderFactoryAddress, calculationSalt, initCode);
+    }
+    deriveAddressFromPublicKey(commonKeychain, index) {
+        const derivationPath = `m/${index}`;
+        const pubkeySize = 33;
+        const ecdsaMpc = new sdk_core_1.Ecdsa();
+        const derivedPublicKey = Buffer.from(ecdsaMpc.deriveUnhardened(commonKeychain, derivationPath), 'hex')
+            .subarray(0, pubkeySize)
+            .toString('hex');
+        const publicKey = Buffer.from(derivedPublicKey, 'hex').slice(0, 66).toString('hex');
+        const keyPair = new lib_1.KeyPair({ pub: publicKey });
+        const address = keyPair.getAddress();
+        return address;
+    }
+    getConsolidationAddress(params, index) {
+        const possibleConsolidationAddresses = [];
+        if (params.walletContractAddress && params.bitgoFeeAddress) {
+            const ethNetwork = this.getNetwork();
+            const forwarderFactoryAddress = ethNetwork?.walletV4ForwarderFactoryAddress;
+            const forwarderImplementationAddress = ethNetwork?.walletV4ForwarderImplementationAddress;
+            try {
+                const forwarderAddress = this.generateForwarderAddress(params.walletContractAddress, params.bitgoFeeAddress, forwarderFactoryAddress, forwarderImplementationAddress, index);
+                possibleConsolidationAddresses.push(forwarderAddress);
+            }
+            catch (e) {
+                console.log(`Failed to generate forwarder address: ${e.message}`);
+            }
+        }
+        if (params.userKey) {
+            try {
+                const derivedAddress = this.deriveAddressFromPublicKey(params.userKey, index);
+                possibleConsolidationAddresses.push(derivedAddress);
+            }
+            catch (e) {
+                console.log(`Failed to generate derived address: ${e}`);
+            }
+        }
+        if (possibleConsolidationAddresses.length === 0) {
+            throw new Error('Unable to generate consolidation address. Check that wallet contract address, fee address, or user key is valid.');
+        }
+        return possibleConsolidationAddresses;
+    }
+    async recoverConsolidations(params) {
+        const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+        const startIdx = params.startingScanIndex || 1;
+        const endIdx = params.endingScanIndex || startIdx + exports.DEFAULT_SCAN_FACTOR;
+        if (!params.walletContractAddress || params.walletContractAddress === '') {
+            throw new Error(`Invalid wallet contract address ${params.walletContractAddress}`);
+        }
+        if (!params.bitgoFeeAddress || params.bitgoFeeAddress === '') {
+            throw new Error(`Invalid fee address ${params.bitgoFeeAddress}`);
+        }
+        if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * exports.DEFAULT_SCAN_FACTOR) {
+            throw new Error(`Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`);
+        }
+        const consolidatedTransactions = [];
+        let lastScanIndex = startIdx;
+        for (let i = startIdx; i < endIdx; i++) {
+            const consolidationAddress = this.getConsolidationAddress(params, i);
+            for (const address of consolidationAddress) {
+                const recoverParams = {
+                    apiKey: params.apiKey,
+                    backupKey: params.backupKey || '',
+                    gasLimit: params.gasLimit,
+                    recoveryDestination: params.recoveryDestination || '',
+                    userKey: params.userKey || '',
+                    walletContractAddress: address,
+                    derivationSeed: '',
+                    isTss: params.isTss,
+                    eip1559: {
+                        maxFeePerGas: params.eip1559?.maxFeePerGas || 20,
+                        maxPriorityFeePerGas: params.eip1559?.maxPriorityFeePerGas || 200000,
+                    },
+                    replayProtectionOptions: {
+                        chain: params.replayProtectionOptions?.chain || 0,
+                        hardfork: params.replayProtectionOptions?.hardfork || 'london',
+                    },
+                    bitgoKey: '',
+                    ignoreAddressTypes: [],
+                };
+                let recoveryTransaction;
+                try {
+                    recoveryTransaction = await this.recover(recoverParams);
+                }
+                catch (e) {
+                    if (e.message === 'Did not find address with funds to recover' ||
+                        e.message === 'Did not find token account to recover tokens, please check token account' ||
+                        e.message === 'Not enough token funds to recover') {
+                        lastScanIndex = i;
+                        continue;
+                    }
+                    throw e;
+                }
+                if (isUnsignedSweep) {
+                    consolidatedTransactions.push(recoveryTransaction.txRequests[0]);
+                }
+                else {
+                    consolidatedTransactions.push(recoveryTransaction);
+                }
+            }
+            // To avoid rate limit for etherscan
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // lastScanIndex = i;
+        }
+        if (consolidatedTransactions.length === 0) {
+            throw new Error(`Did not find an address with sufficient funds to recover. Please start the next scan at address index ${lastScanIndex + 1}.`);
+        }
+        return { transactions: consolidatedTransactions, lastScanIndex };
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo for non-TSS transaction
+     * @param params
+     * @param {string} params.userKey [encrypted] xprv or xpub
+     * @param {string} params.backupKey [encrypted] xprv or xpub if the xprv is held by a KRS provider
+     * @param {string} params.walletPassphrase used to decrypt userKey and backupKey
+     * @param {string} params.walletContractAddress the EthLike address of the wallet contract
+     * @param {string} params.krsProvider necessary if backup key is held by KRS
+     * @param {string} params.recoveryDestination target address to send recovered funds to
+     * @param {string} params.bitgoFeeAddress wrong chain wallet fee address for evm based cross chain recovery txn
+     * @param {string} params.bitgoDestinationAddress target bitgo address where fee will be sent for evm based cross chain recovery txn
+     * @returns {Promise<RecoveryInfo | OfflineVaultTxInfo>}
+     */
+    async recoverEthLike(params) {
+        // bitgoFeeAddress is only defined when it is a evm cross chain recovery
+        // as we use fee from this wrong chain address for the recovery txn on the correct chain.
+        if (params.bitgoFeeAddress) {
+            return this.recoverEthLikeforEvmBasedRecovery(params);
+        }
+        this.validateRecoveryParams(params);
+        const isUnsignedSweep = params.isUnsignedSweep ?? (0, sdk_core_1.getIsUnsignedSweep)(params);
+        // Clean up whitespace from entered values
+        let userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        const gasLimit = new exports.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
+        const gasPrice = params.eip1559
+            ? new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : new exports.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));
+        if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {
+            try {
+                userKey = this.bitgo.decrypt({
+                    input: userKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting user keychain: ${e.message}`);
+            }
+        }
+        let backupKeyAddress;
+        let backupSigningKey;
+        if (isUnsignedSweep) {
+            const backupHDNode = secp256k1_1.bip32.fromBase58(backupKey);
+            backupSigningKey = backupHDNode.publicKey;
+            backupKeyAddress = `0x${exports.optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`;
+        }
+        else {
+            // Decrypt backup private key and get address
+            let backupPrv;
+            try {
+                backupPrv = this.bitgo.decrypt({
+                    input: backupKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting backup keychain: ${e.message}`);
+            }
+            const keyPair = new lib_1.KeyPair({ prv: backupPrv });
+            backupSigningKey = keyPair.getKeys().prv;
+            if (!backupSigningKey) {
+                throw new Error('no private key');
+            }
+            backupKeyAddress = keyPair.getAddress();
+        }
+        const backupKeyNonce = await this.getAddressNonce(backupKeyAddress, params.apiKey);
+        // get balance of backupKey to ensure funds are available to pay fees
+        const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);
+        let totalGasNeeded = gasPrice.mul(gasLimit);
+        // On optimism chain, L1 fees is to be paid as well apart from L2 fees
+        // So we are adding the amount that can be used up as l1 fees
+        if (this.staticsCoin?.family === 'opeth') {
+            totalGasNeeded = totalGasNeeded.add(new exports.optionalDeps.ethUtil.BN(statics_1.ethGasConfigs.opethGasL1Fees));
+        }
+        const weiToGwei = 10 ** 9;
+        if (backupKeyBalance.lt(totalGasNeeded)) {
+            throw new Error(`Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some funds to this address then retry.`);
+        }
+        // get balance of wallet
+        const txAmount = await this.queryAddressBalance(params.walletContractAddress, params.apiKey);
+        if (new bignumber_js_1.BigNumber(txAmount).isLessThanOrEqualTo(0)) {
+            throw new Error('Wallet does not have enough funds to recover');
+        }
+        // build recipients object
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: txAmount.toString(10),
+            },
+        ];
+        // Get sequence ID using contract call
+        // we need to wait between making two explorer api calls to avoid getting banned
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const sequenceId = await this.querySequenceId(params.walletContractAddress);
+        let operationHash, signature;
+        // Get operation hash and sign it
+        if (!isUnsignedSweep) {
+            operationHash = this.getOperationSha3ForExecuteAndConfirm(recipients, this.getDefaultExpireTime(), sequenceId);
+            signature = sdk_core_1.Util.ethSignMsgHash(operationHash, sdk_core_1.Util.xprvToEthPrivateKey(userKey));
+            try {
+                sdk_core_1.Util.ecRecoverEthAddress(operationHash, signature);
+            }
+            catch (e) {
+                throw new Error('Invalid signature');
+            }
+        }
+        const txInfo = {
+            recipient: recipients[0],
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            operationHash: operationHash,
+            signature: signature,
+            gasLimit: gasLimit.toString(10),
+        };
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.counter(backupKeyNonce);
+        txBuilder.contract(params.walletContractAddress);
+        let txFee;
+        if (params.eip1559) {
+            txFee = {
+                eip1559: {
+                    maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,
+                    maxFeePerGas: params.eip1559.maxFeePerGas,
+                },
+            };
+        }
+        else {
+            txFee = { fee: gasPrice.toString() };
+        }
+        txBuilder.fee({
+            ...txFee,
+            gasLimit: gasLimit.toString(),
+        });
+        const transferBuilder = txBuilder.transfer();
+        transferBuilder
+            .coin(this.staticsCoin?.name)
+            .amount(recipients[0].amount)
+            .contractSequenceId(sequenceId)
+            .expirationTime(this.getDefaultExpireTime())
+            .to(params.recoveryDestination);
+        const tx = await txBuilder.build();
+        if (isUnsignedSweep) {
+            const response = {
+                txHex: tx.toBroadcastFormat(),
+                userKey,
+                backupKey,
+                coin: this.getChain(),
+                gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+                gasLimit,
+                recipients: [txInfo.recipient],
+                walletContractAddress: tx.toJson().to,
+                amount: txInfo.recipient.amount,
+                backupKeyNonce,
+                eip1559: params.eip1559,
+            };
+            lodash_1.default.extend(response, txInfo);
+            response.nextContractSequenceId = response.contractSequenceId;
+            return response;
+        }
+        txBuilder
+            .transfer()
+            .coin(this.staticsCoin?.name)
+            .key(new lib_1.KeyPair({ prv: userKey }).getKeys().prv);
+        txBuilder.sign({ key: backupSigningKey });
+        const signedTx = await txBuilder.build();
+        return {
+            id: signedTx.toJson().id,
+            tx: signedTx.toBroadcastFormat(),
+        };
+    }
+    async sendCrossChainRecoveryTransaction(params) {
+        const buildResponse = await this.buildCrossChainRecoveryTransaction(params.recoveryId);
+        if (params.walletType === 'cold') {
+            return buildResponse;
+        }
+        if (!params.encryptedPrv) {
+            throw new Error('missing encryptedPrv');
+        }
+        let userKeyPrv;
+        try {
+            userKeyPrv = this.bitgo.decrypt({
+                input: params.encryptedPrv,
+                password: params.walletPassphrase,
+            });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting user keychain: ${e.message}`);
+        }
+        const keyPair = new lib_1.KeyPair({ prv: userKeyPrv });
+        const userSigningKey = keyPair.getKeys().prv;
+        if (!userSigningKey) {
+            throw new Error('no private key');
+        }
+        const txBuilder = this.getTransactionBuilder(params.common);
+        const txHex = buildResponse.txHex;
+        txBuilder.from(txHex);
+        if (buildResponse.walletVersion) {
+            // If walletVersion is provided, set it in the txBuilder
+            txBuilder.walletVersion(buildResponse.walletVersion);
+        }
+        txBuilder
+            .transfer()
+            .coin(this.staticsCoin?.name)
+            .key(userSigningKey);
+        const tx = await txBuilder.build();
+        const res = await this.bitgo
+            .post(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${params.recoveryId}/sign`))
+            .send({ txHex: tx.toBroadcastFormat() });
+        return {
+            coin: this.staticsCoin?.name,
+            txid: res.body.txid,
+        };
+    }
+    async buildCrossChainRecoveryTransaction(recoveryId) {
+        const res = await this.bitgo.get(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${recoveryId}/buildtx`));
+        return {
+            coin: res.body.coin,
+            txHex: res.body.txHex,
+            txid: res.body.txid,
+            walletVersion: res.body.walletVersion,
+        };
+    }
+    /**
+     * Builds a unsigned (for cold, custody wallet) or
+     * half-signed (for hot wallet) evm cross chain recovery transaction with
+     * same expected arguments as recover method.
+     * This helps recover funds from evm based wrong chain.
+     * @param {RecoverOptions} params
+     * @returns {Promise<RecoveryInfo | OfflineVaultTxInfo>}
+     */
+    async recoverEthLikeforEvmBasedRecovery(params) {
+        this.validateEvmBasedRecoveryParams(params);
+        // Clean up whitespace from entered values
+        const userKey = params.userKey.replace(/\s/g, '');
+        const bitgoFeeAddress = params.bitgoFeeAddress?.replace(/\s/g, '').toLowerCase();
+        const bitgoDestinationAddress = params.bitgoDestinationAddress?.replace(/\s/g, '').toLowerCase();
+        const recoveryDestination = params.recoveryDestination?.replace(/\s/g, '').toLowerCase();
+        const walletContractAddress = params.walletContractAddress?.replace(/\s/g, '').toLowerCase();
+        const tokenContractAddress = params.tokenContractAddress?.replace(/\s/g, '').toLowerCase();
+        let userSigningKey;
+        let userKeyPrv;
+        if (params.walletPassphrase) {
+            if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {
+                try {
+                    userKeyPrv = this.bitgo.decrypt({
+                        input: userKey,
+                        password: params.walletPassphrase,
+                    });
+                }
+                catch (e) {
+                    throw new Error(`Error decrypting user keychain: ${e.message}`);
+                }
+            }
+            const keyPair = new lib_1.KeyPair({ prv: userKeyPrv });
+            userSigningKey = keyPair.getKeys().prv;
+            if (!userSigningKey) {
+                throw new Error('no private key');
+            }
+        }
+        // Use default gasLimit for cold and custody wallets
+        let gasLimit = params.gasLimit || userKey.startsWith('xpub') || !userKey
+            ? new exports.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit))
+            : new exports.optionalDeps.ethUtil.BN(0);
+        const gasPrice = params.eip1559
+            ? new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : params.gasPrice
+                ? new exports.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice))
+                : await this.getGasPriceFromExternalAPI(this.staticsCoin?.name);
+        const bitgoFeeAddressNonce = await this.getAddressNonce(bitgoFeeAddress, params.apiKey);
+        if (tokenContractAddress) {
+            return this.recoverEthLikeTokenforEvmBasedRecovery(params, bitgoFeeAddressNonce, gasLimit, gasPrice, userKey, userSigningKey, params.apiKey);
+        }
+        // get balance of wallet
+        const txAmount = await this.queryAddressBalance(walletContractAddress, params.apiKey);
+        const bitgoFeePercentage = 0; // TODO: BG-71912 can change the fee% here.
+        const bitgoFeeAmount = txAmount * (bitgoFeePercentage / 100);
+        // build recipients object
+        const recipients = [
+            {
+                address: recoveryDestination,
+                amount: new bignumber_js_1.BigNumber(txAmount).minus(bitgoFeeAmount).toFixed(),
+            },
+        ];
+        if (bitgoFeePercentage > 0) {
+            if (lodash_1.default.isUndefined(bitgoDestinationAddress) || !this.isValidAddress(bitgoDestinationAddress)) {
+                throw new Error('invalid bitgoDestinationAddress');
+            }
+            recipients.push({
+                address: bitgoDestinationAddress,
+                amount: bitgoFeeAmount.toString(10),
+            });
+        }
+        // calculate batch data
+        const BATCH_METHOD_NAME = 'batch';
+        const BATCH_METHOD_TYPES = ['address[]', 'uint256[]'];
+        const batchExecutionInfo = this.getBatchExecutionInfo(recipients);
+        const batchData = exports.optionalDeps.ethUtil.addHexPrefix(this.getMethodCallData(BATCH_METHOD_NAME, BATCH_METHOD_TYPES, batchExecutionInfo.values).toString('hex'));
+        // Get sequence ID using contract call
+        // we need to wait between making two explorer api calls to avoid getting banned
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const sequenceId = await this.querySequenceId(walletContractAddress, params.apiKey);
+        const network = this.getNetwork();
+        const batcherContractAddress = network?.batcherContractAddress;
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.counter(bitgoFeeAddressNonce);
+        txBuilder.contract(walletContractAddress);
+        let txFee;
+        if (params.eip1559) {
+            txFee = {
+                eip1559: {
+                    maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,
+                    maxFeePerGas: params.eip1559.maxFeePerGas,
+                },
+            };
+        }
+        else {
+            txFee = { fee: gasPrice.toString() };
+        }
+        txBuilder.fee({
+            ...txFee,
+            gasLimit: gasLimit.toString(),
+        });
+        const transferBuilder = txBuilder.transfer();
+        if (!batcherContractAddress) {
+            transferBuilder
+                .coin(this.staticsCoin?.name)
+                .amount(batchExecutionInfo.totalAmount)
+                .contractSequenceId(sequenceId)
+                .expirationTime(this.getDefaultExpireTime())
+                .to(recoveryDestination);
+        }
+        else {
+            transferBuilder
+                .coin(this.staticsCoin?.name)
+                .amount(batchExecutionInfo.totalAmount)
+                .contractSequenceId(sequenceId)
+                .expirationTime(this.getDefaultExpireTime())
+                .to(batcherContractAddress)
+                .data(batchData);
+        }
+        if (params.walletPassphrase) {
+            transferBuilder.key(userSigningKey);
+        }
+        // If the intended chain is arbitrum or optimism, we need to use wallet version 4
+        // since these contracts construct operationHash differently
+        if (params.intendedChain && ['arbeth', 'opeth'].includes(statics_1.coins.get(params.intendedChain).family)) {
+            txBuilder.walletVersion(4);
+        }
+        // If gasLimit was not passed as a param or if it is not cold/custody wallet, then fetch the gasLimit from Explorer
+        if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {
+            const sendData = txBuilder.getSendData();
+            gasLimit = await this.getGasLimitFromExternalAPI(params.intendedChain, params.bitgoFeeAddress, params.walletContractAddress, sendData, params.apiKey);
+            txBuilder.fee({
+                ...txFee,
+                gasLimit: gasLimit.toString(),
+            });
+        }
+        // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees
+        await this.ensureSufficientBalance(bitgoFeeAddress, gasPrice, gasLimit, params.apiKey);
+        const tx = await txBuilder.build();
+        const txInfo = {
+            recipients: recipients,
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            gasLimit: gasLimit.toString(10),
+            isEvmBasedCrossChainRecovery: true,
+        };
+        const response = {
+            txHex: tx.toBroadcastFormat(),
+            userKey,
+            coin: this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: txInfo.recipients,
+            walletContractAddress: tx.toJson().to,
+            amount: batchExecutionInfo.totalAmount,
+            backupKeyNonce: bitgoFeeAddressNonce,
+            eip1559: params.eip1559,
+            ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),
+        };
+        lodash_1.default.extend(response, txInfo);
+        response.nextContractSequenceId = response.contractSequenceId;
+        if (params.walletPassphrase) {
+            const halfSignedTxn = {
+                halfSigned: {
+                    txHex: tx.toBroadcastFormat(),
+                    recipients: txInfo.recipients,
+                    expireTime: txInfo.expireTime,
+                },
+            };
+            lodash_1.default.extend(response, halfSignedTxn);
+            const feesUsed = {
+                gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+                gasLimit: exports.optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),
+            };
+            response['feesUsed'] = feesUsed;
+        }
+        return response;
+    }
+    /**
+     * Query explorer for the balance of an address for a token
+     * @param {string} tokenContractAddress - address where the token smart contract is hosted
+     * @param {string} walletContractAddress - address of the wallet
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     * @returns {BigNumber} token balaance in base units
+     */
+    async queryAddressTokenBalance(tokenContractAddress, walletContractAddress, apiKey) {
+        if (!exports.optionalDeps.ethUtil.isValidAddress(tokenContractAddress)) {
+            throw new Error('cannot get balance for invalid token address');
+        }
+        if (!exports.optionalDeps.ethUtil.isValidAddress(walletContractAddress)) {
+            throw new Error('cannot get token balance for invalid wallet address');
+        }
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'account',
+            action: 'tokenbalance',
+            contractaddress: tokenContractAddress,
+            address: walletContractAddress,
+            tag: 'latest',
+        }, apiKey);
+        // throw if the result does not exist or the result is not a valid number
+        if (!result || !result.result || isNaN(result.result)) {
+            throw new Error(`Could not obtain token address balance for ${tokenContractAddress} from Etherscan, got: ${result.result}`);
+        }
+        return new exports.optionalDeps.ethUtil.BN(result.result, 10);
+    }
+    async recoverEthLikeTokenforEvmBasedRecovery(params, bitgoFeeAddressNonce, gasLimit, gasPrice, userKey, userSigningKey, apiKey) {
+        // get token balance of wallet
+        const txAmount = await this.queryAddressTokenBalance(params.tokenContractAddress, params.walletContractAddress, apiKey);
+        // build recipients object
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: new bignumber_js_1.BigNumber(txAmount).toFixed(),
+            },
+        ];
+        // Get sequence ID using contract call
+        // we need to wait between making two explorer api calls to avoid getting banned
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const sequenceId = await this.querySequenceId(params.walletContractAddress);
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.counter(bitgoFeeAddressNonce);
+        txBuilder.contract(params.walletContractAddress);
+        let txFee;
+        if (params.eip1559) {
+            txFee = {
+                eip1559: {
+                    maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,
+                    maxFeePerGas: params.eip1559.maxFeePerGas,
+                },
+            };
+        }
+        else {
+            txFee = { fee: gasPrice.toString() };
+        }
+        txBuilder.fee({
+            ...txFee,
+            gasLimit: gasLimit.toString(),
+        });
+        const transferBuilder = txBuilder.transfer();
+        const network = this.getNetwork();
+        const token = (0, lib_1.getToken)(params.tokenContractAddress, network, this.staticsCoin?.family)?.name;
+        transferBuilder
+            .amount(txAmount)
+            .contractSequenceId(sequenceId)
+            .expirationTime(this.getDefaultExpireTime())
+            .to(params.recoveryDestination);
+        if (token) {
+            transferBuilder.coin(token);
+        }
+        else {
+            transferBuilder
+                .coin(this.staticsCoin?.name)
+                .tokenContractAddress(params.tokenContractAddress);
+        }
+        if (params.walletPassphrase) {
+            txBuilder.transfer().key(userSigningKey);
+        }
+        // If the intended chain is arbitrum or optimism, we need to use wallet version 4
+        // since these contracts construct operationHash differently
+        if (params.intendedChain && ['arbeth', 'opeth'].includes(statics_1.coins.get(params.intendedChain).family)) {
+            txBuilder.walletVersion(4);
+        }
+        if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {
+            const sendData = txBuilder.getSendData();
+            gasLimit = await this.getGasLimitFromExternalAPI(params.intendedChain, params.bitgoFeeAddress, params.walletContractAddress, sendData);
+            txBuilder.fee({
+                ...txFee,
+                gasLimit: gasLimit.toString(),
+            });
+        }
+        // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees
+        await this.ensureSufficientBalance(params.bitgoFeeAddress, gasPrice, gasLimit);
+        const tx = await txBuilder.build();
+        const txInfo = {
+            recipients: recipients,
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            gasLimit: gasLimit.toString(10),
+            isEvmBasedCrossChainRecovery: true,
+        };
+        const response = {
+            txHex: tx.toBroadcastFormat(),
+            userKey,
+            coin: token ? token : this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: txInfo.recipients,
+            walletContractAddress: tx.toJson().to,
+            amount: txAmount.toString(),
+            backupKeyNonce: bitgoFeeAddressNonce,
+            eip1559: params.eip1559,
+            ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),
+        };
+        lodash_1.default.extend(response, txInfo);
+        response.nextContractSequenceId = response.contractSequenceId;
+        if (params.walletPassphrase) {
+            const halfSignedTxn = {
+                halfSigned: {
+                    txHex: tx.toBroadcastFormat(),
+                    recipients: txInfo.recipients,
+                    expireTime: txInfo.expireTime,
+                },
+            };
+            lodash_1.default.extend(response, halfSignedTxn);
+            const feesUsed = {
+                gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+                gasLimit: exports.optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),
+            };
+            response['feesUsed'] = feesUsed;
+        }
+        return response;
+    }
+    /**
+     * Validate evm based cross chain recovery params
+     * @param params {RecoverOptions}
+     * @returns {void}
+     */
+    validateEvmBasedRecoveryParams(params) {
+        if (lodash_1.default.isUndefined(params.bitgoFeeAddress) || !this.isValidAddress(params.bitgoFeeAddress)) {
+            throw new Error('invalid bitgoFeeAddress');
+        }
+        if (lodash_1.default.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {
+            throw new Error('invalid walletContractAddress');
+        }
+        if (lodash_1.default.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+    }
+    /**
+     * Return types, values, and total amount in wei to send in a batch transaction, using the method signature
+     * `distributeBatch(address[], uint256[])`
+     * @param {Recipient[]} recipients - transaction recipients
+     * @returns {GetBatchExecutionInfoRT} information needed to execute the batch transaction
+     */
+    getBatchExecutionInfo(recipients) {
+        const addresses = [];
+        const amounts = [];
+        let sum = new bignumber_js_1.BigNumber('0');
+        lodash_1.default.forEach(recipients, ({ address, amount }) => {
+            addresses.push(address);
+            amounts.push(amount);
+            sum = sum.plus(amount);
+        });
+        return {
+            values: [addresses, amounts],
+            totalAmount: sum.toFixed(),
+        };
+    }
+    /**
+     * Build arguments to call the send method on the wallet contract
+     * @param txInfo
+     */
+    getSendMethodArgs(txInfo) {
+        // Method signature is
+        // sendMultiSig(address toAddress, uint value, bytes data, uint expireTime, uint sequenceId, bytes signature)
+        return [
+            {
+                name: 'toAddress',
+                type: 'address',
+                value: txInfo.recipient.address,
+            },
+            {
+                name: 'value',
+                type: 'uint',
+                value: txInfo.recipient.amount,
+            },
+            {
+                name: 'data',
+                type: 'bytes',
+                value: exports.optionalDeps.ethUtil.toBuffer(exports.optionalDeps.ethUtil.addHexPrefix(txInfo.recipient.data || '')),
+            },
+            {
+                name: 'expireTime',
+                type: 'uint',
+                value: txInfo.expireTime,
+            },
+            {
+                name: 'sequenceId',
+                type: 'uint',
+                value: txInfo.contractSequenceId,
+            },
+            {
+                name: 'signature',
+                type: 'bytes',
+                value: exports.optionalDeps.ethUtil.toBuffer(exports.optionalDeps.ethUtil.addHexPrefix(txInfo.signature)),
+            },
+        ];
+    }
+    /**
+     * Recovers a tx with TSS key shares
+     * same expected arguments as recover method, but with TSS key shares
+     */
+    async recoverTSS(params) {
+        this.validateRecoveryParams(params);
+        // Clean up whitespace from entered values
+        const userPublicOrPrivateKeyShare = params.userKey.replace(/\s/g, '');
+        const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\s/g, '');
+        if ((0, sdk_core_1.getIsUnsignedSweep)({
+            userKey: userPublicOrPrivateKeyShare,
+            backupKey: backupPrivateOrPublicKeyShare,
+            isTss: params.isTss,
+        })) {
+            return this.buildUnsignedSweepTxnTSS(params);
+        }
+        else {
+            const { userKeyShare, backupKeyShare, commonKeyChain } = await sdk_core_1.ECDSAUtils.getMpcV2RecoveryKeyShares(userPublicOrPrivateKeyShare, backupPrivateOrPublicKeyShare, params.walletPassphrase);
+            const { gasLimit, gasPrice } = await this.getGasValues(params);
+            const MPC = new sdk_core_1.Ecdsa();
+            const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm/0');
+            const backupKeyPair = new lib_1.KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+            const baseAddress = backupKeyPair.getAddress();
+            const unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;
+            const messageHash = unsignedTx.getMessageToSign(true);
+            const signature = await sdk_core_1.ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);
+            const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);
+            const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, signature);
+            return {
+                id: (0, ethereumjs_util_1.addHexPrefix)(signedTx.hash().toString('hex')),
+                tx: (0, ethereumjs_util_1.addHexPrefix)(signedTx.serialize().toString('hex')),
+            };
+        }
+    }
+    async getGasValues(params) {
+        const gasLimit = new exports.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
+        const gasPrice = params.eip1559
+            ? new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : new exports.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));
+        return { gasLimit, gasPrice };
+    }
+    async buildUnsignedSweepTxnTSS(params) {
+        const userPublicOrPrivateKeyShare = params.userKey.replace(/\s/g, '');
+        const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\s/g, '');
+        const { gasLimit, gasPrice } = await this.getGasValues(params);
+        const backupKeyPair = new lib_1.KeyPair({ pub: backupPrivateOrPublicKeyShare });
+        const baseAddress = backupKeyPair.getAddress();
+        const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);
+        return this.formatForOfflineVaultTSS(txInfo, tx, userPublicOrPrivateKeyShare, backupPrivateOrPublicKeyShare, gasPrice, gasLimit, nonce, params.eip1559, params.replayProtectionOptions);
+    }
+    async buildUnsignedSweepTxnMPCv2(params) {
+        const { gasLimit, gasPrice } = await this.getGasValues(params);
+        const recoverParams = params;
+        this.validateUnsignedSweepTSSParams(recoverParams);
+        const derivationPath = recoverParams.derivationSeed ? (0, sdk_lib_mpc_1.getDerivationPath)(recoverParams.derivationSeed) : 'm/0';
+        const MPC = new sdk_core_1.Ecdsa();
+        const derivedCommonKeyChain = MPC.deriveUnhardened(recoverParams.backupKey, derivationPath);
+        const backupKeyPair = new lib_1.KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+        const baseAddress = backupKeyPair.getAddress();
+        const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);
+        return this.buildTxRequestForOfflineVaultMPCv2(txInfo, tx, derivationPath, nonce, gasPrice, gasLimit, params.eip1559, params.replayProtectionOptions, recoverParams.backupKey);
+    }
+    async createBroadcastableSweepTransaction(params) {
+        const req = params.signatureShares;
+        const broadcastableTransactions = [];
+        let lastScanIndex = 0;
+        for (let i = 0; i < req.length; i++) {
+            const transaction = req[i]?.txRequest?.transactions?.[0]?.unsignedTx;
+            if (!req[i].ovc || !req[i].ovc[0].ecdsaSignature) {
+                throw new Error('Missing signature(s)');
+            }
+            if (!transaction.signableHex) {
+                throw new Error('Missing signable hex');
+            }
+            const signature = req[i].ovc[0].ecdsaSignature;
+            if (!signature) {
+                throw new Error('Signature is undefined');
+            }
+            const shares = signature.toString().split(':');
+            if (shares.length !== 4) {
+                throw new Error('Invalid signature');
+            }
+            const finalSignature = {
+                recid: Number(shares[0]),
+                r: shares[1],
+                s: shares[2],
+                y: shares[3],
+            };
+            if (!transaction.coinSpecific?.commonKeyChain) {
+                throw new Error(`Missing common keychain for transaction at index ${i}`);
+            }
+            const commonKeyChain = transaction.coinSpecific.commonKeyChain;
+            if (!transaction.derivationPath) {
+                throw new Error(`Missing derivation path for transaction at index ${i}`);
+            }
+            if (!commonKeyChain) {
+                throw new Error(`Missing common key chain for transaction at index ${i}`);
+            }
+            const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(transaction.eip1559, transaction.replayProtectionOptions);
+            let unsignedTx;
+            if (transaction.eip1559) {
+                unsignedTx = tx_1.FeeMarketEIP1559Transaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));
+            }
+            else {
+                unsignedTx = tx_1.Transaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));
+            }
+            const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, finalSignature);
+            broadcastableTransactions.push({
+                serializedTx: (0, ethereumjs_util_1.addHexPrefix)(signedTx.serialize().toString('hex')),
+            });
+            if (i === req.length - 1 && transaction.coinSpecific?.lastScanIndex) {
+                lastScanIndex = transaction.coinSpecific?.lastScanIndex;
+            }
+        }
+        return { transactions: broadcastableTransactions, lastScanIndex };
+    }
+    /**
+     * Method to validate recovery params
+     * @param {RecoverOptions} params
+     * @returns {void}
+     */
+    async validateUnsignedSweepTSSParams(params) {
+        if (lodash_1.default.isUndefined(params.backupKey) && params.backupKey === '') {
+            throw new Error('missing commonKeyChain');
+        }
+        if (!lodash_1.default.isUndefined(params.derivationSeed) && typeof params.derivationSeed !== 'string') {
+            throw new Error('invalid derivationSeed');
+        }
+        if (lodash_1.default.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('missing or invalid destinationAddress');
+        }
+    }
+    /**
+     * Helper function for recover()
+     * This transforms the unsigned transaction information into a format the BitGo offline vault expects
+     * @param {UnformattedTxInfo} txInfo - tx info
+     * @param {LegacyTransaction | FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object
+     * @param {string} derivationPath - the derivationPath
+     * @param {number} nonce - the nonce of the backup key address
+     * @param {Buffer} gasPrice - gas price for the tx
+     * @param {number} gasLimit - gas limit for the tx
+     * @param {EIP1559} eip1559 - eip1559 params
+     * @param replayProtectionOptions
+     * @param commonKeyChain
+     * @returns {Promise<OfflineVaultTxInfo>}
+     */
+    buildTxRequestForOfflineVaultMPCv2(txInfo, ethTx, derivationPath, nonce, gasPrice, gasLimit, eip1559, replayProtectionOptions, commonKeyChain) {
+        if (!ethTx.to) {
+            throw new Error('Eth tx must have a `to` address');
+        }
+        const fee = eip1559
+            ? gasLimit * eip1559.maxFeePerGas
+            : gasLimit * exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed();
+        const unsignedTx = {
+            serializedTxHex: ethTx.serialize().toString('hex'),
+            signableHex: ethTx instanceof tx_1.FeeMarketEIP1559Transaction
+                ? ethTx.getMessageToSign(false).toString('hex')
+                : Buffer.from(rlp_1.RLP.encode((0, ethereumjs_util_1.bufArrToArr)(ethTx.getMessageToSign(false)))).toString('hex'),
+            derivationPath: derivationPath,
+            feeInfo: {
+                fee: fee,
+                feeString: fee.toString(),
+            },
+            parsedTx: {
+                spendAmount: txInfo.recipient.amount,
+                outputs: [
+                    {
+                        coinName: this.getChain(),
+                        address: txInfo.recipient.address,
+                        valueString: txInfo.recipient.amount,
+                    },
+                ],
+            },
+            coinSpecific: {
+                commonKeyChain: commonKeyChain,
+            },
+            eip1559: eip1559,
+            replayProtectionOptions: replayProtectionOptions,
+        };
+        return {
+            txRequests: [
+                {
+                    walletCoin: this.getChain(),
+                    transactions: [
+                        {
+                            unsignedTx: unsignedTx,
+                            nonce: nonce,
+                            signatureShares: [],
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params) {
+        const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, params.apiKey);
+        const nonce = await this.getAddressNonce(baseAddress, params.apiKey);
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: txAmount.toString(10),
+            },
+        ];
+        const txInfo = {
+            recipient: recipients[0],
+            expireTime: this.getDefaultExpireTime(),
+            gasLimit: gasLimit.toString(10),
+        };
+        const txParams = {
+            to: params.recoveryDestination,
+            nonce: nonce,
+            value: txAmount,
+            gasPrice: gasPrice,
+            gasLimit: gasLimit,
+            data: Buffer.from('0x'),
+            eip1559: params.eip1559,
+            replayProtectionOptions: params.replayProtectionOptions,
+        };
+        const tx = AbstractEthLikeNewCoins.buildTransaction(txParams);
+        return { txInfo, tx, nonce };
+    }
+    async validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, apiKey) {
+        const baseAddressBalance = await this.queryAddressBalance(baseAddress, apiKey);
+        const totalGasNeeded = gasPrice.mul(gasLimit);
+        const weiToGwei = new bn_js_1.default(10 ** 9);
+        if (baseAddressBalance.lt(totalGasNeeded)) {
+            throw new Error(`Backup key address ${baseAddress} has balance ${baseAddressBalance.div(weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${totalGasNeeded.div(weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some ETH to this address then retry.`);
+        }
+        const txAmount = baseAddressBalance.sub(totalGasNeeded);
+        return txAmount;
+    }
+    /**
+     * Make a query to blockchain explorer for information such as balance, token balance, solidity calls
+     * @param query {Object} key-value pairs of parameters to append after /api
+     * @param apiKey {string} optional API key to use instead of the one from the environment
+     * @returns {Object} response from the blockchain explorer
+     */
+    async recoveryBlockchainExplorerQuery(query, apiKey) {
+        throw new Error('method not implemented');
+    }
+    /**
+     * Creates the extra parameters needed to build a hop transaction
+     * @param buildParams The original build parameters
+     * @returns extra parameters object to merge with the original build parameters object and send to the platform
+     */
+    async createHopTransactionParams(buildParams) {
+        const wallet = buildParams.wallet;
+        const recipients = buildParams.recipients;
+        const walletPassphrase = buildParams.walletPassphrase;
+        const userKeychain = await this.keychains().get({ id: wallet.keyIds()[0] });
+        const userPrv = wallet.getUserPrv({ keychain: userKeychain, walletPassphrase });
+        const userPrvBuffer = secp256k1_1.bip32.fromBase58(userPrv).privateKey;
+        if (!userPrvBuffer) {
+            throw new Error('invalid userPrv');
+        }
+        if (!recipients || !Array.isArray(recipients)) {
+            throw new Error('expecting array of recipients');
+        }
+        // Right now we only support 1 recipient
+        if (recipients.length !== 1) {
+            throw new Error('must send to exactly 1 recipient');
+        }
+        const recipientAddress = recipients[0].address;
+        const recipientAmount = recipients[0].amount;
+        const feeEstimateParams = {
+            recipient: recipientAddress,
+            amount: recipientAmount,
+            hop: true,
+        };
+        const feeEstimate = await this.feeEstimate(feeEstimateParams);
+        const gasLimit = feeEstimate.gasLimitEstimate;
+        const gasPrice = Math.round(feeEstimate.feeEstimate / gasLimit);
+        const gasPriceMax = gasPrice * 5;
+        // Payment id a random number so its different for every tx
+        const paymentId = Math.floor(Math.random() * 10000000000).toString();
+        const hopDigest = AbstractEthLikeNewCoins.getHopDigest([
+            recipientAddress,
+            recipientAmount,
+            gasPriceMax.toString(),
+            gasLimit.toString(),
+            paymentId,
+        ]);
+        const userReqSig = exports.optionalDeps.ethUtil.addHexPrefix(Buffer.from(secp256k1_2.default.ecdsaSign(hopDigest, userPrvBuffer).signature).toString('hex'));
+        return {
+            hopParams: {
+                gasPriceMax,
+                userReqSig,
+                paymentId,
+                gasLimit,
+            },
+        };
+    }
+    /**
+     * Validates that the hop prebuild from the HSM is valid and correct
+     * @param {IWallet} wallet - The wallet that the prebuild is for
+     * @param {HopPrebuild} hopPrebuild - The prebuild to validate
+     * @param {Object} originalParams - The original parameters passed to prebuildTransaction
+     * @param {Recipient[]} originalParams.recipients - The original recipients array
+     * @returns {void}
+     * @throws Error if The prebuild is invalid
+     */
+    async validateHopPrebuild(wallet, hopPrebuild, originalParams) {
+        const { tx, id, signature } = hopPrebuild;
+        // first, validate the HSM signature
+        const serverXpub = sdk_core_1.common.Environments[this.bitgo.getEnv()].hsmXpub;
+        const serverPubkeyBuffer = secp256k1_1.bip32.fromBase58(serverXpub).publicKey;
+        const signatureBuffer = Buffer.from(exports.optionalDeps.ethUtil.stripHexPrefix(signature), 'hex');
+        const messageBuffer = Buffer.from(exports.optionalDeps.ethUtil.padToEven(exports.optionalDeps.ethUtil.stripHexPrefix(id)), 'hex');
+        const sig = new Uint8Array(signatureBuffer.slice(1));
+        const isValidSignature = secp256k1_2.default.ecdsaVerify(sig, messageBuffer, serverPubkeyBuffer);
+        if (!isValidSignature) {
+            throw new Error(`Hop txid signature invalid - pub: ${serverXpub}, msg: ${messageBuffer?.toString()}, sig: ${signatureBuffer?.toString()}`);
+        }
+        const builtHopTx = exports.optionalDeps.EthTx.TransactionFactory.fromSerializedData(exports.optionalDeps.ethUtil.toBuffer(tx));
+        // If original params are given, we can check them against the transaction prebuild params
+        if (!lodash_1.default.isNil(originalParams)) {
+            const { recipients } = originalParams;
+            // Then validate that the tx params actually equal the requested params
+            const originalAmount = new bignumber_js_1.BigNumber(recipients[0].amount);
+            const originalDestination = recipients[0].address;
+            const hopAmount = new bignumber_js_1.BigNumber(exports.optionalDeps.ethUtil.bufferToHex(builtHopTx.value));
+            if (!builtHopTx.to) {
+                throw new Error(`Transaction does not have a destination address`);
+            }
+            const hopDestination = builtHopTx.to.toString();
+            if (!hopAmount.eq(originalAmount)) {
+                throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);
+            }
+            if (hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {
+                throw new Error(`Hop destination: ${hopDestination} does not equal original recipient: ${hopDestination}`);
+            }
+        }
+        if (!builtHopTx.verifySignature()) {
+            // We dont want to continue at all in this case, at risk of ETH being stuck on the hop address
+            throw new Error(`Invalid hop transaction signature, txid: ${id}`);
+        }
+        if (exports.optionalDeps.ethUtil.addHexPrefix(builtHopTx.hash().toString('hex')) !== id) {
+            throw new Error(`Signed hop txid does not equal actual txid`);
+        }
+    }
+    /**
+     * Gets the hop digest for the user to sign. This is validated in the HSM to prove that the user requested this tx
+     * @param {string[]} paramsArr - The parameters to hash together for the digest
+     * @returns {Buffer}
+     */
+    static getHopDigest(paramsArr) {
+        const hash = (0, keccak_1.default)('keccak256');
+        hash.update([AbstractEthLikeNewCoins.hopTransactionSalt, ...paramsArr].join('$'));
+        return hash.digest();
+    }
+    /**
+     * Modify prebuild before sending it to the server. Add things like hop transaction params
+     * @param {BuildOptions} buildParams - The whitelisted parameters for this prebuild
+     * @param {boolean} buildParams.hop - True if this should prebuild a hop tx, else false
+     * @param {Recipient[]} buildParams.recipients - The recipients array of this transaction
+     * @param {Wallet} buildParams.wallet - The wallet sending this tx
+     * @param {string} buildParams.walletPassphrase - the passphrase for this wallet
+     * @returns {Promise<BuildOptions>}
+     */
+    async getExtraPrebuildParams(buildParams) {
+        if (!lodash_1.default.isUndefined(buildParams.hop) &&
+            buildParams.hop &&
+            !lodash_1.default.isUndefined(buildParams.wallet) &&
+            !lodash_1.default.isUndefined(buildParams.recipients) &&
+            !lodash_1.default.isUndefined(buildParams.walletPassphrase)) {
+            if (this instanceof ethLikeToken_1.EthLikeToken) {
+                throw new Error(`Hop transactions are not enabled for ERC-20 tokens, nor are they necessary. Please remove the 'hop' parameter and try again.`);
+            }
+            return (await this.createHopTransactionParams({
+                wallet: buildParams.wallet,
+                recipients: buildParams.recipients,
+                walletPassphrase: buildParams.walletPassphrase,
+            }));
+        }
+        return {};
+    }
+    /**
+     * Modify prebuild after receiving it from the server. Add things like nlocktime
+     * @param {TransactionPrebuild} params - The prebuild to modify
+     * @returns {TransactionPrebuild} The modified prebuild
+     */
+    async postProcessPrebuild(params) {
+        if (!lodash_1.default.isUndefined(params.hopTransaction) && !lodash_1.default.isUndefined(params.wallet) && !lodash_1.default.isUndefined(params.buildParams)) {
+            await this.validateHopPrebuild(params.wallet, params.hopTransaction, params.buildParams);
+        }
+        return params;
+    }
+    /**
+     * Coin-specific things done before signing a transaction, i.e. verification
+     * @param {PresignTransactionOptions} params
+     * @returns {Promise<PresignTransactionOptions>}
+     */
+    async presignTransaction(params) {
+        if (!lodash_1.default.isUndefined(params.hopTransaction) && !lodash_1.default.isUndefined(params.wallet) && !lodash_1.default.isUndefined(params.buildParams)) {
+            await this.validateHopPrebuild(params.wallet, params.hopTransaction);
+        }
+        return params;
+    }
+    /**
+     * Fetch fee estimate information from the server
+     * @param {Object} params - The params passed into the function
+     * @param {boolean} [params.hop] - True if we should estimate fee for a hop transaction
+     * @param {string} [params.recipient] - The recipient of the transaction to estimate a send to
+     * @param {string} [params.data] - The ETH tx data to estimate a send for
+     * @returns {Object} The fee info returned from the server
+     */
+    async feeEstimate(params) {
+        const query = {};
+        if (params && params.hop) {
+            query.hop = params.hop;
+        }
+        if (params && params.recipient) {
+            query.recipient = params.recipient;
+        }
+        if (params && params.data) {
+            query.data = params.data;
+        }
+        if (params && params.amount) {
+            query.amount = params.amount;
+        }
+        return await this.bitgo.get(this.url('/tx/fee')).query(query).result();
+    }
+    /**
+     * Generate secp256k1 key pair
+     *
+     * @param {Buffer} seed
+     * @returns {KeyPair} object with generated pub and prv
+     */
+    generateKeyPair(seed) {
+        if (!seed) {
+            // An extended private key has both a normal 256 bit private key and a 256
+            // bit chain code, both of which must be random. 512 bits is therefore the
+            // maximum entropy and gives us maximum security against cracking.
+            seed = (0, crypto_1.randomBytes)(512 / 8);
+        }
+        const extendedKey = secp256k1_1.bip32.fromSeed(seed);
+        const xpub = extendedKey.neutered().toBase58();
+        return {
+            pub: xpub,
+            prv: extendedKey.toBase58(),
+        };
+    }
+    async parseTransaction(params) {
+        return {};
+    }
+    /**
+     * Make sure an address is a wallet address and throw an error if it's not.
+     * @param {Object} params
+     * @param {string} params.address - The derived address string on the network
+     * @param {Object} params.coinSpecific - Coin-specific details for the address such as a forwarderVersion
+     * @param {string} params.baseAddress - The base address of the wallet on the network
+     * @throws {InvalidAddressError}
+     * @throws {InvalidAddressVerificationObjectPropertyError}
+     * @throws {UnexpectedAddressError}
+     * @returns {boolean} True iff address is a wallet address
+     */
+    async isWalletAddress(params) {
+        const ethUtil = exports.optionalDeps.ethUtil;
+        let expectedAddress;
+        let actualAddress;
+        const { address, coinSpecific, baseAddress, impliedForwarderVersion = coinSpecific?.forwarderVersion } = params;
+        if (address && !this.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        // base address is required to calculate the salt which is used in calculateForwarderV1Address method
+        if (lodash_1.default.isUndefined(baseAddress) || !this.isValidAddress(baseAddress)) {
+            throw new sdk_core_1.InvalidAddressError('invalid base address');
+        }
+        if (!lodash_1.default.isObject(coinSpecific)) {
+            throw new sdk_core_1.InvalidAddressVerificationObjectPropertyError('address validation failure: coinSpecific field must be an object');
+        }
+        if (impliedForwarderVersion === 0 || impliedForwarderVersion === 3 || impliedForwarderVersion === 5) {
+            return true;
+        }
+        else {
+            const ethNetwork = this.getNetwork();
+            const forwarderFactoryAddress = ethNetwork?.forwarderFactoryAddress;
+            const forwarderImplementationAddress = ethNetwork?.forwarderImplementationAddress;
+            const initcode = (0, lib_1.getProxyInitcode)(forwarderImplementationAddress);
+            const saltBuffer = ethUtil.setLengthLeft(Buffer.from(ethUtil.padToEven(ethUtil.stripHexPrefix(coinSpecific.salt || '')), 'hex'), 32);
+            // Hash the wallet base address with the given salt, so the address directly relies on the base address
+            const calculationSalt = exports.optionalDeps.ethUtil.bufferToHex(exports.optionalDeps.ethAbi.soliditySHA3(['address', 'bytes32'], [baseAddress, saltBuffer]));
+            expectedAddress = (0, lib_1.calculateForwarderV1Address)(forwarderFactoryAddress, calculationSalt, initcode);
+            actualAddress = address;
+        }
+        if (expectedAddress !== actualAddress) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);
+        }
+        return true;
+    }
+    /**
+     *
+     * @param {TransactionPrebuild} txPrebuild
+     * @returns {boolean}
+     */
+    verifyCoin(txPrebuild) {
+        const nativeCoin = this.getChain().split(':')[0];
+        return txPrebuild.coin === nativeCoin;
+    }
+    /**
+     * Verify if a tss transaction is valid
+     *
+     * @param {VerifyEthTransactionOptions} params
+     * @param {TransactionParams} params.txParams - params object passed to send
+     * @param {TransactionPrebuild} params.txPrebuild - prebuild object returned by server
+     * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against
+     * @returns {boolean}
+     */
+    async verifyTssTransaction(params) {
+        const { txParams, txPrebuild, wallet } = params;
+        if (!txParams?.recipients &&
+            !(txParams.prebuildTx?.consolidateId ||
+                (txParams.type && ['acceleration', 'fillNonce', 'transferToken', 'tokenApproval'].includes(txParams.type)))) {
+            throw new Error(`missing txParams`);
+        }
+        if (!wallet || !txPrebuild) {
+            throw new Error(`missing params`);
+        }
+        if (txParams.hop && txParams.recipients && txParams.recipients.length > 1) {
+            throw new Error(`tx cannot be both a batch and hop transaction`);
+        }
+        if (txParams.type && ['transfer'].includes(txParams.type)) {
+            if (txParams.recipients && txParams.recipients.length === 1) {
+                const recipients = txParams.recipients;
+                const expectedAmount = recipients[0].amount.toString();
+                const expectedDestination = recipients[0].address;
+                const txBuilder = this.getTransactionBuilder();
+                txBuilder.from(txPrebuild.txHex);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                if (txJson.data === '0x') {
+                    if (expectedAmount !== txJson.value) {
+                        throw new Error('the transaction amount in txPrebuild does not match the value given by client');
+                    }
+                    if (expectedDestination.toLowerCase() !== txJson.to.toLowerCase()) {
+                        throw new Error('destination address does not match with the recipient address');
+                    }
+                }
+                else if (txJson.data.startsWith('0xa9059cbb')) {
+                    const [recipientAddress, amount] = (0, lib_1.getRawDecoded)(['address', 'uint256'], (0, lib_1.getBufferedByteCode)('0xa9059cbb', txJson.data));
+                    if (expectedAmount !== amount.toString()) {
+                        throw new Error('the transaction amount in txPrebuild does not match the value given by client');
+                    }
+                    if (expectedDestination.toLowerCase() !== (0, ethereumjs_util_1.addHexPrefix)(recipientAddress.toString()).toLowerCase()) {
+                        throw new Error('destination address does not match with the recipient address');
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Verify that a transaction prebuild complies with the original intention
+     *
+     * @param {VerifyEthTransactionOptions} params
+     * @param {TransactionParams} params.txParams - params object passed to send
+     * @param {TransactionPrebuild} params.txPrebuild - prebuild object returned by server
+     * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against
+     * @returns {boolean}
+     */
+    async verifyTransaction(params) {
+        const ethNetwork = this.getNetwork();
+        const { txParams, txPrebuild, wallet, walletType } = params;
+        if (walletType === 'tss') {
+            return this.verifyTssTransaction(params);
+        }
+        if (!txParams?.recipients || !txPrebuild?.recipients || !wallet) {
+            throw new Error(`missing params`);
+        }
+        if (txParams.hop && txParams.recipients.length > 1) {
+            throw new Error(`tx cannot be both a batch and hop transaction`);
+        }
+        if (txPrebuild.recipients.length > 1) {
+            throw new Error(`${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`);
+        }
+        if (txParams.hop && txPrebuild.hopTransaction) {
+            // Check recipient amount for hop transaction
+            if (txParams.recipients.length !== 1) {
+                throw new Error(`hop transaction only supports 1 recipient but ${txParams.recipients.length} found`);
+            }
+            // Check tx sends to hop address
+            const decodedHopTx = exports.optionalDeps.EthTx.TransactionFactory.fromSerializedData(exports.optionalDeps.ethUtil.toBuffer(txPrebuild.hopTransaction.tx));
+            const expectedHopAddress = exports.optionalDeps.ethUtil.stripHexPrefix(decodedHopTx.getSenderAddress().toString());
+            const actualHopAddress = exports.optionalDeps.ethUtil.stripHexPrefix(txPrebuild.recipients[0].address);
+            if (expectedHopAddress.toLowerCase() !== actualHopAddress.toLowerCase()) {
+                throw new Error('recipient address of txPrebuild does not match hop address');
+            }
+            // Convert TransactionRecipient array to Recipient array
+            const recipients = txParams.recipients.map((r) => {
+                return {
+                    address: r.address,
+                    amount: typeof r.amount === 'number' ? r.amount.toString() : r.amount,
+                };
+            });
+            // Check destination address and amount
+            await this.validateHopPrebuild(wallet, txPrebuild.hopTransaction, { recipients });
+        }
+        else if (txParams.recipients.length > 1) {
+            // Check total amount for batch transaction
+            if (txParams.tokenName) {
+                const expectedTotalAmount = new bignumber_js_1.BigNumber(0);
+                if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                    throw new Error('batch token transaction amount in txPrebuild should be zero for token transfers');
+                }
+            }
+            else {
+                let expectedTotalAmount = new bignumber_js_1.BigNumber(0);
+                for (let i = 0; i < txParams.recipients.length; i++) {
+                    expectedTotalAmount = expectedTotalAmount.plus(txParams.recipients[i].amount);
+                }
+                if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                    throw new Error('batch transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client');
+                }
+            }
+            // Check batch transaction is sent to the batcher contract address for the chain
+            const batcherContractAddress = ethNetwork?.batcherContractAddress;
+            if (!batcherContractAddress ||
+                batcherContractAddress.toLowerCase() !== txPrebuild.recipients[0].address.toLowerCase()) {
+                throw new Error('recipient address of txPrebuild does not match batcher address');
+            }
+        }
+        else {
+            // Check recipient address and amount for normal transaction
+            if (txParams.recipients.length !== 1) {
+                throw new Error(`normal transaction only supports 1 recipient but ${txParams.recipients.length} found`);
+            }
+            const expectedAmount = new bignumber_js_1.BigNumber(txParams.recipients[0].amount);
+            if (!expectedAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                throw new Error('normal transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client');
+            }
+            if (this.isETHAddress(txParams.recipients[0].address) &&
+                txParams.recipients[0].address !== txPrebuild.recipients[0].address) {
+                throw new Error('destination address in normal txPrebuild does not match that in txParams supplied by client');
+            }
+        }
+        // Check coin is correct for all transaction types
+        if (!this.verifyCoin(txPrebuild)) {
+            throw new Error(`coin in txPrebuild did not match that in txParams supplied by client`);
+        }
+        return true;
+    }
+    /**
+     * Check if address is valid eth address
+     * @param address
+     * @returns {boolean}
+     */
+    isETHAddress(address) {
+        return !!address.match(/0x[a-fA-F0-9]{40}/);
+    }
+    /**
+     * Transform message to accommodate specific blockchain requirements.
+     * @param {string} message - the message to prepare
+     * @return {string} the prepared message as a hex encoded string.
+     */
+    encodeMessage(message) {
+        const prefix = `\u0019Ethereum Signed Message:\n${message.length}`;
+        return Buffer.from(prefix.concat(message)).toString('hex');
+    }
+    /**
+     * Transform the Typed data to accomodate the blockchain requirements (EIP-712)
+     * @param {TypedData} typedData - the typed data to prepare
+     * @return {Buffer} a buffer of the result
+     */
+    encodeTypedData(typedData) {
+        const version = typedData.version;
+        if (version === eth_sig_util_1.SignTypedDataVersion.V1) {
+            throw new Error('SignTypedData v1 is not supported due to security concerns');
+        }
+        const typedDataRaw = JSON.parse(typedData.typedDataRaw);
+        const sanitizedData = eth_sig_util_1.TypedDataUtils.sanitizeData(typedDataRaw);
+        const parts = [Buffer.from('1901', 'hex')];
+        const eip712Domain = 'EIP712Domain';
+        parts.push(eth_sig_util_1.TypedDataUtils.hashStruct(eip712Domain, sanitizedData.domain, sanitizedData.types, version));
+        if (sanitizedData.primaryType !== eip712Domain) {
+            parts.push(eth_sig_util_1.TypedDataUtils.hashStruct(sanitizedData.primaryType, sanitizedData.message, sanitizedData.types, version));
+        }
+        return Buffer.concat(parts);
+    }
+    /**
+     * Build the data to transfer an ERC-721 or ERC-1155 token to another address
+     * @param params
+     */
+    buildNftTransferData(params) {
+        const { tokenContractAddress, recipientAddress, fromAddress } = params;
+        switch (params.type) {
+            case 'ERC721': {
+                const tokenId = params.tokenId;
+                const contractData = new lib_1.ERC721TransferBuilder()
+                    .tokenContractAddress(tokenContractAddress)
+                    .to(recipientAddress)
+                    .from(fromAddress)
+                    .tokenId(tokenId)
+                    .build();
+                return contractData;
+            }
+            case 'ERC1155': {
+                const entries = params.entries;
+                const transferBuilder = new lib_1.ERC1155TransferBuilder()
+                    .tokenContractAddress(tokenContractAddress)
+                    .to(recipientAddress)
+                    .from(fromAddress);
+                for (const entry of entries) {
+                    transferBuilder.entry(parseInt(entry.tokenId, 10), entry.amount);
+                }
+                return transferBuilder.build();
+            }
+            default:
+                throw new Error(`Unsupported NFT type: ${params.type}`);
+        }
+    }
+    /**
+     * Fetch the gas price from the explorer
+     * @param {string} wrongChainCoin - the coin that we're getting gas price for
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     */
+    async getGasPriceFromExternalAPI(wrongChainCoin, apiKey) {
+        try {
+            const res = await this.recoveryBlockchainExplorerQuery({
+                chainid: this.getChainId().toString(),
+                module: 'proxy',
+                action: 'eth_gasPrice',
+            }, apiKey);
+            const gasPrice = new bn_js_1.default(res.result.slice(2), 16);
+            console.log(` Got gas price: ${gasPrice}`);
+            return gasPrice;
+        }
+        catch (e) {
+            throw new Error(`Failed to get gas price. Please make sure to use the api key of ${wrongChainCoin}`);
+        }
+    }
+    /**
+     * Fetch the gas limit from the explorer
+     * @param intendedChain
+     * @param from
+     * @param to
+     * @param data
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     */
+    async getGasLimitFromExternalAPI(intendedChain, from, to, data, apiKey) {
+        try {
+            const res = await this.recoveryBlockchainExplorerQuery({
+                chainid: this.getChainId().toString(),
+                module: 'proxy',
+                action: 'eth_estimateGas',
+                from,
+                to,
+                data,
+            }, apiKey);
+            const gasLimit = new bn_js_1.default(res.result.slice(2), 16);
+            console.log(`Got gas limit: ${gasLimit}`);
+            return gasLimit;
+        }
+        catch (e) {
+            throw new Error(`Failed to get gas limit. Please make sure to use the privateKey aka userKey of ${intendedChain} wallet ${to}`);
+        }
+    }
+    /**
+     * Get the balance of bitgoFeeAddress to ensure funds are available to pay fees
+     * @param bitgoFeeAddress
+     * @param gasPrice
+     * @param gasLimit
+     * @param apiKey - optional API key to use instead of the one from the environment
+     */
+    async ensureSufficientBalance(bitgoFeeAddress, gasPrice, gasLimit, apiKey) {
+        const bitgoFeeAddressBalance = await this.queryAddressBalance(bitgoFeeAddress, apiKey);
+        const totalGasNeeded = Number(gasPrice.mul(gasLimit));
+        const weiToGwei = 10 ** 9;
+        if (bitgoFeeAddressBalance.lt(totalGasNeeded)) {
+            throw new Error(`Fee address ${bitgoFeeAddress} has balance ${(bitgoFeeAddressBalance / weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some ${this.getChain()} to this address then retry.`);
+        }
+    }
+}
+exports.AbstractEthLikeNewCoins = AbstractEthLikeNewCoins;
+AbstractEthLikeNewCoins.hopTransactionSalt = 'bitgoHopAddressRequestSalt';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractEthLikeNewCoins.js","sourceRoot":"","sources":["../../src/abstractEthLikeNewCoins.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport {\n  AddressCoinSpecific,\n  BitGoBase,\n  BuildNftTransferDataOptions,\n  common,\n  Ecdsa,\n  ECDSAMethodTypes,\n  ECDSAUtils,\n  EthereumLibraryUnavailableError,\n  FeeEstimateOptions,\n  FullySignedTransaction,\n  getIsUnsignedSweep,\n  HalfSignedTransaction,\n  InvalidAddressError,\n  InvalidAddressVerificationObjectPropertyError,\n  IWallet,\n  KeyPair,\n  MPCSweepRecoveryOptions,\n  MPCSweepTxs,\n  MPCTx,\n  MPCTxs,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  PrebuildTransactionResult,\n  PresignTransactionOptions as BasePresignTransactionOptions,\n  Recipient,\n  SignTransactionOptions as BaseSignTransactionOptions,\n  TransactionParams,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  TransactionRecipient,\n  TypedData,\n  UnexpectedAddressError,\n  UnsignedTransactionTss,\n  Util,\n  VerifyAddressOptions as BaseVerifyAddressOptions,\n  VerifyTransactionOptions,\n  Wallet,\n} from '@bitgo/sdk-core';\nimport { getDerivationPath } from '@bitgo/sdk-lib-mpc';\nimport { bip32 } from '@bitgo/secp256k1';\nimport {\n  BaseCoin as StaticsBaseCoin,\n  CoinFeature,\n  CoinMap,\n  coins,\n  EthereumNetwork as EthLikeNetwork,\n  ethGasConfigs,\n} from '@bitgo/statics';\nimport type * as EthLikeCommon from '@ethereumjs/common';\nimport type * as EthLikeTxLib from '@ethereumjs/tx';\nimport { FeeMarketEIP1559Transaction, Transaction as LegacyTransaction } from '@ethereumjs/tx';\nimport { RLP } from '@ethereumjs/rlp';\nimport { SignTypedDataVersion, TypedDataUtils, TypedMessage } from '@metamask/eth-sig-util';\nimport { BigNumber } from 'bignumber.js';\nimport BN from 'bn.js';\nimport { randomBytes } from 'crypto';\nimport debugLib from 'debug';\nimport { addHexPrefix, bufArrToArr, stripHexPrefix, bufferToHex, setLengthLeft, toBuffer } from 'ethereumjs-util';\nimport Keccak from 'keccak';\nimport _ from 'lodash';\nimport secp256k1 from 'secp256k1';\n\nimport { AbstractEthLikeCoin } from './abstractEthLikeCoin';\nimport { EthLikeToken } from './ethLikeToken';\nimport {\n  calculateForwarderV1Address,\n  ERC1155TransferBuilder,\n  ERC721TransferBuilder,\n  getBufferedByteCode,\n  getCommon,\n  getCreateForwarderParamsAndTypes,\n  getProxyInitcode,\n  getRawDecoded,\n  getToken,\n  KeyPair as KeyPairLib,\n  TransactionBuilder,\n  TransferBuilder,\n} from './lib';\nimport { SendCrossChainRecoveryOptions } from './types';\n\n/**\n * The prebuilt hop transaction returned from the HSM\n */\ninterface HopPrebuild {\n  tx: string;\n  id: string;\n  signature: string;\n  paymentId: string;\n  gasPrice: number;\n  gasLimit: number;\n  amount: number;\n  recipient: string;\n  nonce: number;\n  userReqSig: string;\n  gasPriceMax: number;\n}\n\n/**\n * The extra parameters to send to platform build route for hop transactions\n */\ninterface HopParams {\n  hopParams: {\n    gasPriceMax: number;\n    userReqSig: string;\n    paymentId: string;\n    gasLimit: number;\n  };\n}\n\nexport interface EIP1559 {\n  maxPriorityFeePerGas: number;\n  maxFeePerGas: number;\n}\n\nexport interface ReplayProtectionOptions {\n  chain: string | number;\n  hardfork: string;\n}\n\nexport interface TransactionPrebuild extends BaseTransactionPrebuild {\n  hopTransaction?: HopPrebuild;\n  buildParams: {\n    recipients: Recipient[];\n  };\n  recipients: TransactionRecipient[];\n  nextContractSequenceId: number;\n  gasPrice: number;\n  gasLimit: number;\n  isBatch: boolean;\n  coin: string;\n  token?: string;\n}\n\nexport interface SignFinalOptions {\n  txPrebuild: {\n    eip1559?: EIP1559;\n    replayProtectionOptions?: ReplayProtectionOptions;\n    gasPrice?: string;\n    gasLimit?: string;\n    recipients?: Recipient[];\n    halfSigned?: {\n      expireTime: number;\n      contractSequenceId: number;\n      backupKeyNonce?: number;\n      signature: string;\n      txHex?: string;\n    };\n    nextContractSequenceId?: number;\n    hopTransaction?: string;\n    backupKeyNonce?: number;\n    isBatch?: boolean;\n    txHex?: string;\n    expireTime?: number;\n  };\n  signingKeyNonce?: number;\n  walletContractAddress?: string;\n  prv: string;\n  recipients?: Recipient[];\n  common?: EthLikeCommon.default;\n}\n\nexport interface SignTransactionOptions extends BaseSignTransactionOptions, SignFinalOptions {\n  isLastSignature?: boolean;\n  expireTime?: number;\n  sequenceId?: number;\n  gasLimit?: number;\n  gasPrice?: number;\n  custodianTransactionId?: string;\n  common?: EthLikeCommon.default;\n  walletVersion?: number;\n}\n\nexport type SignedTransaction = HalfSignedTransaction | FullySignedTransaction;\n\nexport interface FeesUsed {\n  gasPrice: number;\n  gasLimit: number;\n}\n\ninterface PrecreateBitGoOptions {\n  enterprise?: string;\n  newFeeAddress?: string;\n}\n\nexport interface OfflineVaultTxInfo {\n  nextContractSequenceId?: string;\n  contractSequenceId?: string;\n  tx?: string;\n  txHex?: string;\n  userKey?: string;\n  backupKey?: string;\n  coin: string;\n  gasPrice: number;\n  gasLimit: number;\n  recipients: Recipient[];\n  walletContractAddress: string;\n  amount: string;\n  backupKeyNonce: number;\n  // For Eth Specific Coins\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n  // For Hot Wallet EvmBasedCrossChainRecovery Specific\n  halfSigned?: HalfSignedTransaction;\n  feesUsed?: FeesUsed;\n  isEvmBasedCrossChainRecovery?: boolean;\n  walletVersion?: number;\n}\n\ninterface UnformattedTxInfo {\n  recipient: Recipient;\n}\n\nexport type UnsignedSweepTxMPCv2 = {\n  txRequests: {\n    transactions: [\n      {\n        unsignedTx: UnsignedTransactionTss;\n        nonce: number;\n        signatureShares: [];\n      }\n    ];\n    walletCoin: string;\n  }[];\n};\n\nexport type UnsignedBuilConsolidation = {\n  transactions: MPCSweepTxs[] | UnsignedSweepTxMPCv2[] | RecoveryInfo[] | OfflineVaultTxInfo[];\n  lastScanIndex: number;\n};\n\nexport type RecoverOptionsWithBytes = {\n  isTss: true;\n  /**\n   * @deprecated this is no longer used\n   */\n  openSSLBytes?: Uint8Array;\n};\n\nexport type NonTSSRecoverOptions = {\n  isTss?: false | undefined;\n};\n\nexport type TSSRecoverOptions = RecoverOptionsWithBytes | NonTSSRecoverOptions;\n\nexport type RecoverOptions = {\n  userKey: string;\n  backupKey: string;\n  walletPassphrase?: string;\n  walletContractAddress: string; // use this as walletBaseAddress for TSS\n  recoveryDestination: string;\n  krsProvider?: string;\n  gasPrice?: number;\n  gasLimit?: number;\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n  bitgoFeeAddress?: string;\n  bitgoDestinationAddress?: string;\n  tokenContractAddress?: string;\n  intendedChain?: string;\n  common?: EthLikeCommon.default;\n  derivationSeed?: string;\n  apiKey?: string; // optional API key to use instead of the one from the environment\n  isUnsignedSweep?: boolean; // specify if this is an unsigned recovery\n} & TSSRecoverOptions;\n\nexport type GetBatchExecutionInfoRT = {\n  values: [string[], string[]];\n  totalAmount: string;\n};\n\nexport interface BuildTransactionParams {\n  to: string;\n  nonce?: number;\n  value: number;\n  data?: Buffer;\n  gasPrice?: number;\n  gasLimit?: number;\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n}\n\nexport interface RecoveryInfo {\n  id: string;\n  tx: string;\n  backupKey?: string;\n  coin?: string;\n}\n\nexport interface RecoverTokenTransaction {\n  halfSigned: {\n    recipient: Recipient;\n    expireTime: number;\n    contractSequenceId: number;\n    operationHash: string;\n    signature: string;\n    gasLimit: number;\n    gasPrice: number;\n    tokenContractAddress: string;\n    walletId: string;\n  };\n}\n\nexport interface RecoverTokenOptions {\n  tokenContractAddress: string;\n  wallet: Wallet;\n  recipient: string;\n  broadcast?: boolean;\n  walletPassphrase?: string;\n  prv?: string;\n}\n\nexport interface GetSendMethodArgsOptions {\n  recipient: Recipient;\n  expireTime: number;\n  contractSequenceId: number;\n  signature: string;\n}\n\nexport interface SendMethodArgs {\n  name: string;\n  type: string;\n  value: any;\n}\n\ninterface HopTransactionBuildOptions {\n  wallet: Wallet;\n  recipients: Recipient[];\n  walletPassphrase: string;\n}\n\nexport interface BuildOptions {\n  hop?: boolean;\n  wallet?: Wallet;\n  recipients?: Recipient[];\n  walletPassphrase?: string;\n  [index: string]: unknown;\n}\n\ninterface FeeEstimate {\n  gasLimitEstimate: number;\n  feeEstimate: number;\n}\n\n// TODO: This interface will need to be updated for the new fee model introduced in the London Hard Fork\ninterface EthTransactionParams extends TransactionParams {\n  gasPrice?: number;\n  gasLimit?: number;\n  hopParams?: HopParams;\n  hop?: boolean;\n  prebuildTx?: PrebuildTransactionResult;\n  tokenName?: string;\n}\n\nexport interface VerifyEthTransactionOptions extends VerifyTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  txParams: EthTransactionParams;\n}\n\ninterface PresignTransactionOptions extends TransactionPrebuild, BasePresignTransactionOptions {\n  wallet: Wallet;\n}\n\ninterface EthAddressCoinSpecifics extends AddressCoinSpecific {\n  forwarderVersion: number;\n  salt?: string;\n}\n\nexport const DEFAULT_SCAN_FACTOR = 20;\nexport interface EthConsolidationRecoveryOptions {\n  coinName?: string;\n  walletContractAddress?: string;\n  apiKey?: string;\n  isTss?: boolean;\n  userKey?: string;\n  backupKey?: string;\n  walletPassphrase?: string;\n  recoveryDestination?: string;\n  krsProvider?: string;\n  gasPrice?: number;\n  gasLimit?: number;\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n  bitgoFeeAddress?: string;\n  bitgoDestinationAddress?: string;\n  tokenContractAddress?: string;\n  intendedChain?: string;\n  common?: EthLikeCommon.default;\n  derivationSeed?: string;\n  bitgoKey?: string;\n  startingScanIndex?: number;\n  endingScanIndex?: number;\n  ignoreAddressTypes?: unknown;\n}\n\nexport interface VerifyEthAddressOptions extends BaseVerifyAddressOptions {\n  baseAddress: string;\n  coinSpecific: EthAddressCoinSpecifics;\n  forwarderVersion: number;\n}\n\nconst debug = debugLib('bitgo:v2:ethlike');\n\nexport const optionalDeps = {\n  get ethAbi() {\n    try {\n      return require('ethereumjs-abi');\n    } catch (e) {\n      debug('unable to load ethereumjs-abi:');\n      debug(e.stack);\n      throw new EthereumLibraryUnavailableError(`ethereumjs-abi`);\n    }\n  },\n\n  get ethUtil() {\n    try {\n      return require('ethereumjs-util');\n    } catch (e) {\n      debug('unable to load ethereumjs-util:');\n      debug(e.stack);\n      throw new EthereumLibraryUnavailableError(`ethereumjs-util`);\n    }\n  },\n\n  get EthTx(): typeof EthLikeTxLib {\n    try {\n      return require('@ethereumjs/tx');\n    } catch (e) {\n      debug('unable to load @ethereumjs/tx');\n      debug(e.stack);\n      throw new EthereumLibraryUnavailableError(`@ethereumjs/tx`);\n    }\n  },\n\n  get EthCommon(): typeof EthLikeCommon {\n    try {\n      return require('@ethereumjs/common');\n    } catch (e) {\n      debug('unable to load @ethereumjs/common:');\n      debug(e.stack);\n      throw new EthereumLibraryUnavailableError(`@ethereumjs/common`);\n    }\n  },\n};\n\nexport abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {\n  static hopTransactionSalt = 'bitgoHopAddressRequestSalt';\n  protected readonly sendMethodName: 'sendMultiSig' | 'sendMultiSigToken';\n\n  readonly staticsCoin?: Readonly<StaticsBaseCoin>;\n\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo, staticsCoin);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this.staticsCoin = staticsCoin;\n    this.sendMethodName = 'sendMultiSig';\n  }\n\n  /**\n   * Method to return the coin's network object\n   * @returns {EthLikeNetwork | undefined}\n   */\n  getNetwork(): EthLikeNetwork | undefined {\n    return this.staticsCoin?.network as EthLikeNetwork;\n  }\n\n  /**\n   * Evaluates whether an address string is valid for this coin\n   * @param {string} address\n   * @returns {boolean} True if address is the valid ethlike adderss\n   */\n  isValidAddress(address: string): boolean {\n    return optionalDeps.ethUtil.isValidAddress(optionalDeps.ethUtil.addHexPrefix(address));\n  }\n\n  /**\n   * Flag for sending data along with transactions\n   * @returns {boolean} True if okay to send tx data (ETH), false otherwise\n   */\n  transactionDataAllowed() {\n    return true;\n  }\n\n  /**\n   * Default expire time for a contract call (1 week)\n   * @returns {number} Time in seconds\n   */\n  getDefaultExpireTime(): number {\n    return Math.floor(new Date().getTime() / 1000) + 60 * 60 * 24 * 7;\n  }\n\n  /**\n   * Method to get the custom chain common object based on params from recovery\n   * @param {number} chainId - the chain id of the custom chain\n   * @returns {EthLikeCommon.default}\n   */\n  static getCustomChainCommon(chainId: number): EthLikeCommon.default {\n    const coinName = CoinMap.coinNameFromChainId(chainId);\n    const coin = coins.get(coinName);\n    const ethLikeCommon = getCommon(coin.network as EthLikeNetwork);\n    return ethLikeCommon;\n  }\n\n  /**\n   * Gets correct Eth Common object based on params from either recovery or tx building\n   * @param {EIP1559} eip1559 - configs that specify whether we should construct an eip1559 tx\n   * @param {ReplayProtectionOptions} replayProtectionOptions - check if chain id supports replay protection\n   * @returns {EthLikeCommon.default}\n   */\n  private static getEthLikeCommon(\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions\n  ): EthLikeCommon.default {\n    // if eip1559 params are specified, default to london hardfork, otherwise,\n    // default to petersburg to avoid replay protection issues\n    const defaultHardfork = !!eip1559 ? 'london' : optionalDeps.EthCommon.Hardfork.Petersburg;\n    const ethLikeCommon = AbstractEthLikeNewCoins.getCustomChainCommon(replayProtectionOptions?.chain as number);\n    ethLikeCommon.setHardfork(replayProtectionOptions?.hardfork ?? defaultHardfork);\n    return ethLikeCommon;\n  }\n\n  /**\n   * Method to build the tx object\n   * @param {BuildTransactionParams} params - params to build transaction\n   * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}\n   */\n  static buildTransaction(\n    params: BuildTransactionParams\n  ): EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction {\n    // if eip1559 params are specified, default to london hardfork, otherwise,\n    // default to tangerine whistle to avoid replay protection issues\n    const ethLikeCommon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);\n    const baseParams = {\n      to: params.to,\n      nonce: params.nonce,\n      value: params.value,\n      data: params.data,\n      gasLimit: new optionalDeps.ethUtil.BN(params.gasLimit),\n    };\n\n    const unsignedEthTx = !!params.eip1559\n      ? optionalDeps.EthTx.FeeMarketEIP1559Transaction.fromTxData(\n          {\n            ...baseParams,\n            maxFeePerGas: new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas),\n            maxPriorityFeePerGas: new optionalDeps.ethUtil.BN(params.eip1559.maxPriorityFeePerGas),\n          },\n          { common: ethLikeCommon }\n        )\n      : optionalDeps.EthTx.Transaction.fromTxData(\n          {\n            ...baseParams,\n            gasPrice: new optionalDeps.ethUtil.BN(params.gasPrice),\n          },\n          { common: ethLikeCommon }\n        );\n\n    return unsignedEthTx;\n  }\n\n  /**\n   * Query explorer for the balance of an address\n   * @param {String} address - the ETHLike address\n   * @param {String} apiKey - optional API key to use instead of the one from the environment\n   * @returns {BigNumber} address balance\n   */\n  async queryAddressBalance(address: string, apiKey?: string): Promise<any> {\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'account',\n        action: 'balance',\n        address: address,\n      },\n      apiKey\n    );\n    // throw if the result does not exist or the result is not a valid number\n    if (!result || !result.result || isNaN(result.result)) {\n      throw new Error(`Could not obtain address balance for ${address} from the explorer, got: ${result.result}`);\n    }\n    return new optionalDeps.ethUtil.BN(result.result, 10);\n  }\n\n  /**\n   * @param {Recipient[]} recipients - the recipients of the transaction\n   * @param {number} expireTime - the expire time of the transaction\n   * @param {number} contractSequenceId - the contract sequence id of the transaction\n   * @returns {string}\n   */\n  getOperationSha3ForExecuteAndConfirm(\n    recipients: Recipient[],\n    expireTime: number,\n    contractSequenceId: number\n  ): string {\n    if (!recipients || !Array.isArray(recipients)) {\n      throw new Error('expecting array of recipients');\n    }\n\n    // Right now we only support 1 recipient\n    if (recipients.length !== 1) {\n      throw new Error('must send to exactly 1 recipient');\n    }\n\n    if (!_.isNumber(expireTime)) {\n      throw new Error('expireTime must be number of seconds since epoch');\n    }\n\n    if (!_.isNumber(contractSequenceId)) {\n      throw new Error('contractSequenceId must be number');\n    }\n\n    // Check inputs\n    recipients.forEach(function (recipient) {\n      if (\n        !_.isString(recipient.address) ||\n        !optionalDeps.ethUtil.isValidAddress(optionalDeps.ethUtil.addHexPrefix(recipient.address))\n      ) {\n        throw new Error('Invalid address: ' + recipient.address);\n      }\n\n      let amount: BigNumber;\n      try {\n        amount = new BigNumber(recipient.amount);\n      } catch (e) {\n        throw new Error('Invalid amount for: ' + recipient.address + ' - should be numeric');\n      }\n\n      recipient.amount = amount.toFixed(0);\n\n      if (recipient.data && !_.isString(recipient.data)) {\n        throw new Error('Data for recipient ' + recipient.address + ' - should be of type hex string');\n      }\n    });\n\n    const recipient = recipients[0];\n    return optionalDeps.ethUtil.bufferToHex(\n      optionalDeps.ethAbi.soliditySHA3(...this.getOperation(recipient, expireTime, contractSequenceId))\n    );\n  }\n\n  /**\n   * Get transfer operation for coin\n   * @param {Recipient} recipient - recipient info\n   * @param {number} expireTime - expiry time\n   * @param {number} contractSequenceId - sequence id\n   * @returns {Array} operation array\n   */\n  getOperation(recipient: Recipient, expireTime: number, contractSequenceId: number): (string | Buffer)[][] {\n    const network = this.getNetwork() as EthLikeNetwork;\n    return [\n      ['string', 'address', 'uint', 'bytes', 'uint', 'uint'],\n      [\n        network.nativeCoinOperationHashPrefix,\n        new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),\n        recipient.amount,\n        Buffer.from(optionalDeps.ethUtil.stripHexPrefix(optionalDeps.ethUtil.padToEven(recipient.data || '')), 'hex'),\n        expireTime,\n        contractSequenceId,\n      ],\n    ];\n  }\n\n  /**\n   * Queries the contract (via explorer API) for the next sequence ID\n   * @param {String} address - address of the contract\n   * @param {String} apiKey - optional API key to use instead of the one from the environment\n   * @returns {Promise<Number>} sequence ID\n   */\n  async querySequenceId(address: string, apiKey?: string): Promise<number> {\n    // Get sequence ID using contract call\n    const sequenceIdMethodSignature = optionalDeps.ethAbi.methodID('getNextSequenceId', []);\n    const sequenceIdArgs = optionalDeps.ethAbi.rawEncode([], []);\n    const sequenceIdData = Buffer.concat([sequenceIdMethodSignature, sequenceIdArgs]).toString('hex');\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'proxy',\n        action: 'eth_call',\n        to: address,\n        data: sequenceIdData,\n        tag: 'latest',\n      },\n      apiKey\n    );\n    if (!result || !result.result) {\n      throw new Error('Could not obtain sequence ID from explorer, got: ' + result.result);\n    }\n    const sequenceIdHex = result.result;\n    return new optionalDeps.ethUtil.BN(sequenceIdHex.slice(2), 16).toNumber();\n  }\n\n  /**\n   * Recover an unsupported token from a BitGo multisig wallet\n   * This builds a half-signed transaction, for which there will be an admin route to co-sign and broadcast. Optionally\n   * the user can set params.broadcast = true and the half-signed tx will be sent to BitGo for cosigning and broadcasting\n   * @param {RecoverTokenOptions} params\n   * @param {Wallet} params.wallet - the wallet to recover the token from\n   * @param {string} params.tokenContractAddress - the contract address of the unsupported token\n   * @param {string} params.recipient - the destination address recovered tokens should be sent to\n   * @param {string} params.walletPassphrase - the wallet passphrase\n   * @param {string} params.prv - the xprv\n   * @param {boolean} params.broadcast - if true, we will automatically submit the half-signed tx to BitGo for cosigning and broadcasting\n   * @returns {Promise<RecoverTokenTransaction>}\n   */\n  async recoverToken(params: RecoverTokenOptions): Promise<RecoverTokenTransaction> {\n    const network = this.getNetwork() as EthLikeNetwork;\n    if (!_.isObject(params)) {\n      throw new Error(`recoverToken must be passed a params object. Got ${params} (type ${typeof params})`);\n    }\n\n    if (_.isUndefined(params.tokenContractAddress) || !_.isString(params.tokenContractAddress)) {\n      throw new Error(\n        `tokenContractAddress must be a string, got ${\n          params.tokenContractAddress\n        } (type ${typeof params.tokenContractAddress})`\n      );\n    }\n\n    if (!this.isValidAddress(params.tokenContractAddress)) {\n      throw new Error('tokenContractAddress not a valid address');\n    }\n\n    if (_.isUndefined(params.wallet) || !(params.wallet instanceof Wallet)) {\n      throw new Error(`wallet must be a wallet instance, got ${params.wallet} (type ${typeof params.wallet})`);\n    }\n\n    if (_.isUndefined(params.recipient) || !_.isString(params.recipient)) {\n      throw new Error(`recipient must be a string, got ${params.recipient} (type ${typeof params.recipient})`);\n    }\n\n    if (!this.isValidAddress(params.recipient)) {\n      throw new Error('recipient not a valid address');\n    }\n\n    if (!optionalDeps.ethUtil.bufferToHex || !optionalDeps.ethAbi.soliditySHA3) {\n      throw new Error('ethereum not fully supported in this environment');\n    }\n\n    // Get token balance from external API\n    const coinSpecific = params.wallet.coinSpecific();\n    if (!coinSpecific || !_.isString(coinSpecific.baseAddress)) {\n      throw new Error('missing required coin specific property baseAddress');\n    }\n    const recoveryAmount = await this.queryAddressTokenBalance(params.tokenContractAddress, coinSpecific.baseAddress);\n\n    if (params.broadcast) {\n      // We're going to create a normal ETH transaction that sends an amount of 0 ETH to the\n      // tokenContractAddress and encode the unsupported-token-send data in the data field\n      // #tricksy\n      const sendMethodArgs = [\n        {\n          name: '_to',\n          type: 'address',\n          value: params.recipient,\n        },\n        {\n          name: '_value',\n          type: 'uint256',\n          value: recoveryAmount.toString(10),\n        },\n      ];\n      const methodSignature = optionalDeps.ethAbi.methodID('transfer', _.map(sendMethodArgs, 'type'));\n      const encodedArgs = optionalDeps.ethAbi.rawEncode(_.map(sendMethodArgs, 'type'), _.map(sendMethodArgs, 'value'));\n      const sendData = Buffer.concat([methodSignature, encodedArgs]);\n\n      const broadcastParams: any = {\n        address: params.tokenContractAddress,\n        amount: '0',\n        data: sendData.toString('hex'),\n      };\n\n      if (params.walletPassphrase) {\n        broadcastParams.walletPassphrase = params.walletPassphrase;\n      } else if (params.prv) {\n        broadcastParams.prv = params.prv;\n      }\n\n      return await params.wallet.send(broadcastParams);\n    }\n\n    const recipient = {\n      address: params.recipient,\n      amount: recoveryAmount.toString(10),\n    };\n\n    // This signature will be valid for one week\n    const expireTime = Math.floor(new Date().getTime() / 1000) + 60 * 60 * 24 * 7;\n\n    // Get sequence ID. We do this by building a 'fake' eth transaction, so the platform will increment and return us the new sequence id\n    // This _does_ require the user to have a non-zero wallet balance\n    const { nextContractSequenceId, gasPrice, gasLimit } = (await params.wallet.prebuildTransaction({\n      recipients: [\n        {\n          address: params.recipient,\n          amount: '1',\n        },\n      ],\n    })) as any;\n\n    // these recoveries need to be processed by support, but if the customer sends any transactions before recovery is\n    // complete the sequence ID will be invalid. artificially inflate the sequence ID to allow more time for processing\n    const safeSequenceId = nextContractSequenceId + 1000;\n\n    // Build sendData for ethereum tx\n    const operationTypes = ['string', 'address', 'uint', 'address', 'uint', 'uint'];\n    const operationArgs = [\n      // Token operation has prefix has been added here so that ether operation hashes, signatures cannot be re-used for tokenSending\n      network.tokenOperationHashPrefix,\n      new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),\n      recipient.amount,\n      new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(params.tokenContractAddress), 16),\n      expireTime,\n      safeSequenceId,\n    ];\n\n    const operationHash = optionalDeps.ethUtil.bufferToHex(\n      optionalDeps.ethAbi.soliditySHA3(operationTypes, operationArgs)\n    );\n\n    const userPrv = await params.wallet.getPrv({\n      prv: params.prv,\n      walletPassphrase: params.walletPassphrase,\n    });\n\n    const signature = Util.ethSignMsgHash(operationHash, Util.xprvToEthPrivateKey(userPrv));\n\n    return {\n      halfSigned: {\n        recipient: recipient,\n        expireTime: expireTime,\n        contractSequenceId: safeSequenceId,\n        operationHash: operationHash,\n        signature: signature,\n        gasLimit: gasLimit,\n        gasPrice: gasPrice,\n        tokenContractAddress: params.tokenContractAddress,\n        walletId: params.wallet.id(),\n      },\n    };\n  }\n\n  /**\n   * Ensure either enterprise or newFeeAddress is passed, to know whether to create new key or use enterprise key\n   * @param {PrecreateBitGoOptions} params\n   * @param {string} params.enterprise {String} the enterprise id to associate with this key\n   * @param {string} params.newFeeAddress {Boolean} create a new fee address (enterprise not needed in this case)\n   * @returns {void}\n   */\n  preCreateBitGo(params: PrecreateBitGoOptions): void {\n    // We always need params object, since either enterprise or newFeeAddress is required\n    if (!_.isObject(params)) {\n      throw new Error(`preCreateBitGo must be passed a params object. Got ${params} (type ${typeof params})`);\n    }\n\n    if (_.isUndefined(params.enterprise) && _.isUndefined(params.newFeeAddress)) {\n      throw new Error(\n        'expecting enterprise when adding BitGo key. If you want to create a new ETH bitgo key, set the newFeeAddress parameter to true.'\n      );\n    }\n\n    // Check whether key should be an enterprise key or a BitGo key for a new fee address\n    if (!_.isUndefined(params.enterprise) && !_.isUndefined(params.newFeeAddress)) {\n      throw new Error(`Incompatible arguments - cannot pass both enterprise and newFeeAddress parameter.`);\n    }\n\n    if (!_.isUndefined(params.enterprise) && !_.isString(params.enterprise)) {\n      throw new Error(`enterprise should be a string - got ${params.enterprise} (type ${typeof params.enterprise})`);\n    }\n\n    if (!_.isUndefined(params.newFeeAddress) && !_.isBoolean(params.newFeeAddress)) {\n      throw new Error(\n        `newFeeAddress should be a boolean - got ${params.newFeeAddress} (type ${typeof params.newFeeAddress})`\n      );\n    }\n  }\n\n  /**\n   * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address\n   * @param {string} address\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   * @returns {Promise<number>}\n   */\n  async getAddressNonce(address: string, apiKey?: string): Promise<number> {\n    // Get nonce for backup key (should be 0)\n    let nonce = 0;\n\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'account',\n        action: 'txlist',\n        address,\n      },\n      apiKey\n    );\n    if (!result || !Array.isArray(result.result)) {\n      throw new Error('Unable to find next nonce from Etherscan, got: ' + JSON.stringify(result));\n    }\n    const backupKeyTxList = result.result;\n    if (backupKeyTxList.length > 0) {\n      // Calculate last nonce used\n      const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === address);\n      nonce = outgoingTxs.length;\n    }\n    return nonce;\n  }\n\n  /**\n   * Helper function for recover()\n   * This transforms the unsigned transaction information into a format the BitGo offline vault expects\n   * @param {UnformattedTxInfo} txInfo - tx info\n   * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object\n   * @param {string} userKey - the user's key\n   * @param {string} backupKey - the backup key\n   * @param {Buffer} gasPrice - gas price for the tx\n   * @param {number} gasLimit - gas limit for the tx\n   * @param {EIP1559} eip1559 - eip1559 params\n   * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options\n   * @param {apiKey} apiKey - optional apiKey to use when retrieving block chain data\n   * @returns {Promise<OfflineVaultTxInfo>}\n   */\n  async formatForOfflineVault(\n    txInfo: UnformattedTxInfo,\n    ethTx: EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction,\n    userKey: string,\n    backupKey: string,\n    gasPrice: Buffer,\n    gasLimit: number,\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions,\n    apiKey?: string\n  ): Promise<OfflineVaultTxInfo> {\n    if (!ethTx.to) {\n      throw new Error('Eth tx must have a `to` address');\n    }\n    const backupHDNode = bip32.fromBase58(backupKey);\n    const backupSigningKey = backupHDNode.publicKey;\n    const response: OfflineVaultTxInfo = {\n      tx: ethTx.serialize().toString('hex'),\n      userKey,\n      backupKey,\n      coin: this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: [txInfo.recipient],\n      walletContractAddress: ethTx.to.toString(),\n      amount: txInfo.recipient.amount as string,\n      backupKeyNonce: await this.getAddressNonce(\n        `0x${optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`,\n        apiKey\n      ),\n      eip1559,\n      replayProtectionOptions,\n    };\n    _.extend(response, txInfo);\n    response.nextContractSequenceId = response.contractSequenceId;\n    return response;\n  }\n\n  /**\n   * Helper function for recover()\n   * This transforms the unsigned transaction information into a format the BitGo offline vault expects\n   * @param {UnformattedTxInfo} txInfo - tx info\n   * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object\n   * @param {string} userKey - the user's key\n   * @param {string} backupKey - the backup key\n   * @param {Buffer} gasPrice - gas price for the tx\n   * @param {number} gasLimit - gas limit for the tx\n   * @param {number} backupKeyNonce - the nonce of the backup key address\n   * @param {EIP1559} eip1559 - eip1559 params\n   * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options\n   * @returns {Promise<OfflineVaultTxInfo>}\n   */\n  formatForOfflineVaultTSS(\n    txInfo: UnformattedTxInfo,\n    ethTx: EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction,\n    userKey: string,\n    backupKey: string,\n    gasPrice: Buffer,\n    gasLimit: number,\n    backupKeyNonce: number,\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions\n  ): OfflineVaultTxInfo {\n    if (!ethTx.to) {\n      throw new Error('Eth tx must have a `to` address');\n    }\n    const response: OfflineVaultTxInfo = {\n      tx: ethTx.serialize().toString('hex'),\n      txHex: ethTx.getMessageToSign(false).toString(),\n      userKey,\n      backupKey,\n      coin: this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: [txInfo.recipient],\n      walletContractAddress: ethTx.to.toString(),\n      amount: txInfo.recipient.amount as string,\n      backupKeyNonce: backupKeyNonce,\n      eip1559,\n      replayProtectionOptions,\n    };\n    _.extend(response, txInfo);\n    return response;\n  }\n\n  /**\n   * Check whether the gas price passed in by user are within our max and min bounds\n   * If they are not set, set them to the defaults\n   * @param {number} userGasPrice - user defined gas price\n   * @returns {number} the gas price to use for this transaction\n   */\n  setGasPrice(userGasPrice?: number): number {\n    if (!userGasPrice) {\n      return ethGasConfigs.defaultGasPrice;\n    }\n\n    const gasPriceMax = ethGasConfigs.maximumGasPrice;\n    const gasPriceMin = ethGasConfigs.minimumGasPrice;\n    if (userGasPrice < gasPriceMin || userGasPrice > gasPriceMax) {\n      throw new Error(`Gas price must be between ${gasPriceMin} and ${gasPriceMax}`);\n    }\n    return userGasPrice;\n  }\n  /**\n   * Check whether gas limit passed in by user are within our max and min bounds\n   * If they are not set, set them to the defaults\n   * @param {number} userGasLimit user defined gas limit\n   * @returns {number} the gas limit to use for this transaction\n   */\n  setGasLimit(userGasLimit?: number): number {\n    if (!userGasLimit) {\n      return ethGasConfigs.defaultGasLimit;\n    }\n    const gasLimitMax = ethGasConfigs.maximumGasLimit;\n    const gasLimitMin = ethGasConfigs.minimumGasLimit;\n    if (userGasLimit < gasLimitMin || userGasLimit > gasLimitMax) {\n      throw new Error(`Gas limit must be between ${gasLimitMin} and ${gasLimitMax}`);\n    }\n    return userGasLimit;\n  }\n\n  /**\n   * Helper function for signTransaction for the rare case that SDK is doing the second signature\n   * Note: we are expecting this to be called from the offline vault\n   * @param {SignFinalOptions.txPrebuild} params.txPrebuild\n   * @param {string} params.prv\n   * @returns {{txHex: string}}\n   */\n  async signFinalEthLike(params: SignFinalOptions): Promise<FullySignedTransaction> {\n    const signingKey = new KeyPairLib({ prv: params.prv }).getKeys().prv;\n    if (_.isUndefined(signingKey)) {\n      throw new Error('missing private key');\n    }\n    const txBuilder = this.getTransactionBuilder(params.common);\n    try {\n      txBuilder.from(params.txPrebuild.halfSigned?.txHex);\n    } catch (e) {\n      throw new Error('invalid half-signed transaction');\n    }\n    txBuilder.sign({ key: signingKey });\n    const tx = await txBuilder.build();\n    return {\n      txHex: tx.toBroadcastFormat(),\n    };\n  }\n\n  /**\n   * Assemble half-sign prebuilt transaction\n   * @param {SignTransactionOptions} params\n   */\n  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    // Normally the SDK provides the first signature for an EthLike tx, but occasionally it provides the second and final one.\n    if (params.isLastSignature) {\n      // In this case when we're doing the second (final) signature, the logic is different.\n      return await this.signFinalEthLike(params);\n    }\n    const txBuilder = this.getTransactionBuilder(params.common);\n    txBuilder.from(params.txPrebuild.txHex);\n    txBuilder\n      .transfer()\n      .coin(this.staticsCoin?.name as string)\n      .key(new KeyPairLib({ prv: params.prv }).getKeys().prv!);\n    if (params.walletVersion) {\n      txBuilder.walletVersion(params.walletVersion);\n    }\n    const transaction = await txBuilder.build();\n\n    // In case of tx with contract data from a custodial wallet, we are running into an issue\n    // as halfSigned is not having the data field. So, we are adding the data field to the halfSigned tx\n    let recipients = params.txPrebuild.recipients || params.recipients;\n    if (recipients === undefined) {\n      recipients = transaction.outputs.map((output) => ({ address: output.address, amount: output.value }));\n    }\n\n    const txParams = {\n      eip1559: params.txPrebuild.eip1559,\n      txHex: transaction.toBroadcastFormat(),\n      recipients: recipients,\n      expiration: params.txPrebuild.expireTime,\n      hopTransaction: params.txPrebuild.hopTransaction,\n      custodianTransactionId: params.custodianTransactionId,\n      expireTime: params.expireTime,\n      contractSequenceId: params.txPrebuild.nextContractSequenceId as number,\n      sequenceId: params.sequenceId,\n      ...(params.txPrebuild.isBatch ? { isBatch: params.txPrebuild.isBatch } : {}),\n    };\n\n    return { halfSigned: txParams };\n  }\n\n  /**\n   * Method to validate recovery params\n   * @param {RecoverOptions} params\n   * @returns {void}\n   */\n  validateRecoveryParams(params: RecoverOptions): void {\n    if (params.userKey === undefined) {\n      throw new Error('missing userKey');\n    }\n\n    if (params.backupKey === undefined) {\n      throw new Error('missing backupKey');\n    }\n\n    if (\n      !params.isUnsignedSweep &&\n      params.walletPassphrase === undefined &&\n      !params.userKey.startsWith('xpub') &&\n      !params.isTss\n    ) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    if (params.walletContractAddress === undefined || !this.isValidAddress(params.walletContractAddress)) {\n      throw new Error('invalid walletContractAddress');\n    }\n\n    if (params.recoveryDestination === undefined || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n\n    if (!this.staticsCoin?.features.includes(CoinFeature.EIP1559)) {\n      if (params.eip1559) {\n        throw new Error('Invalid fee params. EIP1559 not supported');\n      }\n      if (params.replayProtectionOptions?.hardfork === 'london') {\n        throw new Error('Invalid replayProtection options. Cannot use the hardfork \"london\" for this chain');\n      }\n    }\n  }\n\n  /**\n   * Helper which Adds signatures to tx object and re-serializes tx\n   * @param {EthLikeCommon.default} ethCommon\n   * @param {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction} tx\n   * @param {ECDSAMethodTypes.Signature} signature\n   * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}\n   */\n  private getSignedTxFromSignature(\n    ethCommon: EthLikeCommon.default,\n    tx: EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction,\n    signature: ECDSAMethodTypes.Signature\n  ) {\n    // get signed Tx from signature\n    const txData = tx.toJSON();\n    const yParity = signature.recid;\n    const baseParams = {\n      to: txData.to,\n      nonce: new BN(stripHexPrefix(txData.nonce!), 'hex'),\n      value: new BN(stripHexPrefix(txData.value!), 'hex'),\n      gasLimit: new BN(stripHexPrefix(txData.gasLimit!), 'hex'),\n      data: txData.data,\n      r: addHexPrefix(signature.r),\n      s: addHexPrefix(signature.s),\n    };\n\n    let finalTx;\n    if (txData.maxFeePerGas && txData.maxPriorityFeePerGas) {\n      finalTx = FeeMarketEIP1559Transaction.fromTxData(\n        {\n          ...baseParams,\n          maxPriorityFeePerGas: new BN(stripHexPrefix(txData.maxPriorityFeePerGas!), 'hex'),\n          maxFeePerGas: new BN(stripHexPrefix(txData.maxFeePerGas!), 'hex'),\n          v: new BN(yParity.toString()),\n        },\n        { common: ethCommon }\n      );\n    } else if (txData.gasPrice) {\n      const v = BigInt(35) + BigInt(yParity) + BigInt(ethCommon.chainIdBN().toNumber()) * BigInt(2);\n      finalTx = LegacyTransaction.fromTxData(\n        {\n          ...baseParams,\n          v: new BN(v.toString()),\n          gasPrice: new BN(stripHexPrefix(txData.gasPrice!.toString()), 'hex'),\n        },\n        { common: ethCommon }\n      );\n    }\n\n    return finalTx;\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param params\n   * @param {string} params.userKey - [encrypted] xprv\n   * @param {string} params.backupKey - [encrypted] xprv or xpub if the xprv is held by a KRS provider\n   * @param {string} params.walletPassphrase - used to decrypt userKey and backupKey\n   * @param {string} params.walletContractAddress - the ETH address of the wallet contract\n   * @param {string} params.krsProvider - necessary if backup key is held by KRS\n   * @param {string} params.recoveryDestination - target address to send recovered funds to\n   * @param {string} params.bitgoFeeAddress - wrong chain wallet fee address for evm based cross chain recovery txn\n   * @param {string} params.bitgoDestinationAddress - target bitgo address where fee will be sent for evm based cross chain recovery txn\n   */\n  async recover(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    if (params.isTss === true) {\n      return this.recoverTSS(params);\n    }\n    return this.recoverEthLike(params);\n  }\n\n  generateForwarderAddress(\n    baseAddress: string,\n    feeAddress: string,\n    forwarderFactoryAddress: string,\n    forwarderImplementationAddress: string,\n    index: number\n  ): string {\n    const salt = addHexPrefix(index.toString(16));\n    const saltBuffer = setLengthLeft(toBuffer(salt), 32);\n\n    const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(\n      baseAddress,\n      saltBuffer,\n      feeAddress\n    );\n\n    const calculationSalt = bufferToHex(optionalDeps.ethAbi.soliditySHA3(createForwarderTypes, createForwarderParams));\n\n    const initCode = getProxyInitcode(forwarderImplementationAddress);\n    return calculateForwarderV1Address(forwarderFactoryAddress, calculationSalt, initCode);\n  }\n\n  deriveAddressFromPublicKey(commonKeychain: string, index: number): string {\n    const derivationPath = `m/${index}`;\n    const pubkeySize = 33;\n\n    const ecdsaMpc = new Ecdsa();\n    const derivedPublicKey = Buffer.from(ecdsaMpc.deriveUnhardened(commonKeychain, derivationPath), 'hex')\n      .subarray(0, pubkeySize)\n      .toString('hex');\n\n    const publicKey = Buffer.from(derivedPublicKey, 'hex').slice(0, 66).toString('hex');\n\n    const keyPair = new KeyPairLib({ pub: publicKey });\n    const address = keyPair.getAddress();\n    return address;\n  }\n\n  getConsolidationAddress(params: EthConsolidationRecoveryOptions, index: number): string[] {\n    const possibleConsolidationAddresses: string[] = [];\n    if (params.walletContractAddress && params.bitgoFeeAddress) {\n      const ethNetwork = this.getNetwork();\n      const forwarderFactoryAddress = ethNetwork?.walletV4ForwarderFactoryAddress as string;\n      const forwarderImplementationAddress = ethNetwork?.walletV4ForwarderImplementationAddress as string;\n      try {\n        const forwarderAddress = this.generateForwarderAddress(\n          params.walletContractAddress,\n          params.bitgoFeeAddress,\n          forwarderFactoryAddress,\n          forwarderImplementationAddress,\n          index\n        );\n        possibleConsolidationAddresses.push(forwarderAddress);\n      } catch (e) {\n        console.log(`Failed to generate forwarder address: ${e.message}`);\n      }\n    }\n\n    if (params.userKey) {\n      try {\n        const derivedAddress = this.deriveAddressFromPublicKey(params.userKey, index);\n        possibleConsolidationAddresses.push(derivedAddress);\n      } catch (e) {\n        console.log(`Failed to generate derived address: ${e}`);\n      }\n    }\n\n    if (possibleConsolidationAddresses.length === 0) {\n      throw new Error(\n        'Unable to generate consolidation address. Check that wallet contract address, fee address, or user key is valid.'\n      );\n    }\n    return possibleConsolidationAddresses;\n  }\n\n  async recoverConsolidations(params: EthConsolidationRecoveryOptions): Promise<UnsignedBuilConsolidation> {\n    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n    const startIdx = params.startingScanIndex || 1;\n    const endIdx = params.endingScanIndex || startIdx + DEFAULT_SCAN_FACTOR;\n\n    if (!params.walletContractAddress || params.walletContractAddress === '') {\n      throw new Error(`Invalid wallet contract address ${params.walletContractAddress}`);\n    }\n\n    if (!params.bitgoFeeAddress || params.bitgoFeeAddress === '') {\n      throw new Error(`Invalid fee address ${params.bitgoFeeAddress}`);\n    }\n\n    if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * DEFAULT_SCAN_FACTOR) {\n      throw new Error(\n        `Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`\n      );\n    }\n\n    const consolidatedTransactions: any[] = [];\n    let lastScanIndex = startIdx;\n\n    for (let i = startIdx; i < endIdx; i++) {\n      const consolidationAddress = this.getConsolidationAddress(params, i);\n      for (const address of consolidationAddress) {\n        const recoverParams = {\n          apiKey: params.apiKey,\n          backupKey: params.backupKey || '',\n          gasLimit: params.gasLimit,\n          recoveryDestination: params.recoveryDestination || '',\n          userKey: params.userKey || '',\n          walletContractAddress: address,\n          derivationSeed: '',\n          isTss: params.isTss,\n          eip1559: {\n            maxFeePerGas: params.eip1559?.maxFeePerGas || 20,\n            maxPriorityFeePerGas: params.eip1559?.maxPriorityFeePerGas || 200000,\n          },\n          replayProtectionOptions: {\n            chain: params.replayProtectionOptions?.chain || 0,\n            hardfork: params.replayProtectionOptions?.hardfork || 'london',\n          },\n          bitgoKey: '',\n          ignoreAddressTypes: [],\n        };\n        let recoveryTransaction;\n        try {\n          recoveryTransaction = await this.recover(recoverParams);\n        } catch (e) {\n          if (\n            e.message === 'Did not find address with funds to recover' ||\n            e.message === 'Did not find token account to recover tokens, please check token account' ||\n            e.message === 'Not enough token funds to recover'\n          ) {\n            lastScanIndex = i;\n            continue;\n          }\n          throw e;\n        }\n        if (isUnsignedSweep) {\n          consolidatedTransactions.push((recoveryTransaction as MPCSweepTxs).txRequests[0]);\n        } else {\n          consolidatedTransactions.push(recoveryTransaction);\n        }\n      }\n      // To avoid rate limit for etherscan\n      await new Promise((resolve) => setTimeout(resolve, 1000));\n      // lastScanIndex = i;\n    }\n\n    if (consolidatedTransactions.length === 0) {\n      throw new Error(\n        `Did not find an address with sufficient funds to recover. Please start the next scan at address index ${\n          lastScanIndex + 1\n        }.`\n      );\n    }\n    return { transactions: consolidatedTransactions, lastScanIndex };\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo for non-TSS transaction\n   * @param params\n   * @param {string} params.userKey [encrypted] xprv or xpub\n   * @param {string} params.backupKey [encrypted] xprv or xpub if the xprv is held by a KRS provider\n   * @param {string} params.walletPassphrase used to decrypt userKey and backupKey\n   * @param {string} params.walletContractAddress the EthLike address of the wallet contract\n   * @param {string} params.krsProvider necessary if backup key is held by KRS\n   * @param {string} params.recoveryDestination target address to send recovered funds to\n   * @param {string} params.bitgoFeeAddress wrong chain wallet fee address for evm based cross chain recovery txn\n   * @param {string} params.bitgoDestinationAddress target bitgo address where fee will be sent for evm based cross chain recovery txn\n   * @returns {Promise<RecoveryInfo | OfflineVaultTxInfo>}\n   */\n  protected async recoverEthLike(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo> {\n    // bitgoFeeAddress is only defined when it is a evm cross chain recovery\n    // as we use fee from this wrong chain address for the recovery txn on the correct chain.\n    if (params.bitgoFeeAddress) {\n      return this.recoverEthLikeforEvmBasedRecovery(params);\n    }\n\n    this.validateRecoveryParams(params);\n    const isUnsignedSweep = params.isUnsignedSweep ?? getIsUnsignedSweep(params);\n\n    // Clean up whitespace from entered values\n    let userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n    const gasLimit = new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));\n\n    if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {\n      try {\n        userKey = this.bitgo.decrypt({\n          input: userKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting user keychain: ${e.message}`);\n      }\n    }\n    let backupKeyAddress;\n    let backupSigningKey;\n    if (isUnsignedSweep) {\n      const backupHDNode = bip32.fromBase58(backupKey);\n      backupSigningKey = backupHDNode.publicKey;\n      backupKeyAddress = `0x${optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`;\n    } else {\n      // Decrypt backup private key and get address\n      let backupPrv;\n\n      try {\n        backupPrv = this.bitgo.decrypt({\n          input: backupKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting backup keychain: ${e.message}`);\n      }\n\n      const keyPair = new KeyPairLib({ prv: backupPrv });\n      backupSigningKey = keyPair.getKeys().prv;\n      if (!backupSigningKey) {\n        throw new Error('no private key');\n      }\n      backupKeyAddress = keyPair.getAddress();\n    }\n\n    const backupKeyNonce = await this.getAddressNonce(backupKeyAddress, params.apiKey);\n    // get balance of backupKey to ensure funds are available to pay fees\n    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);\n    let totalGasNeeded = gasPrice.mul(gasLimit);\n\n    // On optimism chain, L1 fees is to be paid as well apart from L2 fees\n    // So we are adding the amount that can be used up as l1 fees\n    if (this.staticsCoin?.family === 'opeth') {\n      totalGasNeeded = totalGasNeeded.add(new optionalDeps.ethUtil.BN(ethGasConfigs.opethGasL1Fees));\n    }\n\n    const weiToGwei = 10 ** 9;\n    if (backupKeyBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some funds to this address then retry.`\n      );\n    }\n\n    // get balance of wallet\n    const txAmount = await this.queryAddressBalance(params.walletContractAddress, params.apiKey);\n    if (new BigNumber(txAmount).isLessThanOrEqualTo(0)) {\n      throw new Error('Wallet does not have enough funds to recover');\n    }\n\n    // build recipients object\n    const recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: txAmount.toString(10),\n      },\n    ];\n\n    // Get sequence ID using contract call\n    // we need to wait between making two explorer api calls to avoid getting banned\n    await new Promise((resolve) => setTimeout(resolve, 1000));\n    const sequenceId = await this.querySequenceId(params.walletContractAddress);\n\n    let operationHash, signature;\n    // Get operation hash and sign it\n    if (!isUnsignedSweep) {\n      operationHash = this.getOperationSha3ForExecuteAndConfirm(recipients, this.getDefaultExpireTime(), sequenceId);\n      signature = Util.ethSignMsgHash(operationHash, Util.xprvToEthPrivateKey(userKey));\n\n      try {\n        Util.ecRecoverEthAddress(operationHash, signature);\n      } catch (e) {\n        throw new Error('Invalid signature');\n      }\n    }\n\n    const txInfo = {\n      recipient: recipients[0],\n      expireTime: this.getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      operationHash: operationHash,\n      signature: signature,\n      gasLimit: gasLimit.toString(10),\n    };\n\n    const txBuilder = this.getTransactionBuilder(params.common) as TransactionBuilder;\n    txBuilder.counter(backupKeyNonce);\n    txBuilder.contract(params.walletContractAddress);\n    let txFee;\n    if (params.eip1559) {\n      txFee = {\n        eip1559: {\n          maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,\n          maxFeePerGas: params.eip1559.maxFeePerGas,\n        },\n      };\n    } else {\n      txFee = { fee: gasPrice.toString() };\n    }\n    txBuilder.fee({\n      ...txFee,\n      gasLimit: gasLimit.toString(),\n    });\n    const transferBuilder = txBuilder.transfer() as TransferBuilder;\n    transferBuilder\n      .coin(this.staticsCoin?.name as string)\n      .amount(recipients[0].amount)\n      .contractSequenceId(sequenceId)\n      .expirationTime(this.getDefaultExpireTime())\n      .to(params.recoveryDestination);\n\n    const tx = await txBuilder.build();\n    if (isUnsignedSweep) {\n      const response: OfflineVaultTxInfo = {\n        txHex: tx.toBroadcastFormat(),\n        userKey,\n        backupKey,\n        coin: this.getChain(),\n        gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n        gasLimit,\n        recipients: [txInfo.recipient],\n        walletContractAddress: tx.toJson().to,\n        amount: txInfo.recipient.amount,\n        backupKeyNonce,\n        eip1559: params.eip1559,\n      };\n      _.extend(response, txInfo);\n      response.nextContractSequenceId = response.contractSequenceId;\n      return response;\n    }\n\n    txBuilder\n      .transfer()\n      .coin(this.staticsCoin?.name as string)\n      .key(new KeyPairLib({ prv: userKey }).getKeys().prv as string);\n    txBuilder.sign({ key: backupSigningKey });\n\n    const signedTx = await txBuilder.build();\n\n    return {\n      id: signedTx.toJson().id,\n      tx: signedTx.toBroadcastFormat(),\n    };\n  }\n\n  async sendCrossChainRecoveryTransaction(\n    params: SendCrossChainRecoveryOptions\n  ): Promise<{ coin: string; txHex?: string; txid: string }> {\n    const buildResponse = await this.buildCrossChainRecoveryTransaction(params.recoveryId);\n    if (params.walletType === 'cold') {\n      return buildResponse;\n    }\n    if (!params.encryptedPrv) {\n      throw new Error('missing encryptedPrv');\n    }\n\n    let userKeyPrv;\n    try {\n      userKeyPrv = this.bitgo.decrypt({\n        input: params.encryptedPrv,\n        password: params.walletPassphrase,\n      });\n    } catch (e) {\n      throw new Error(`Error decrypting user keychain: ${e.message}`);\n    }\n    const keyPair = new KeyPairLib({ prv: userKeyPrv });\n    const userSigningKey = keyPair.getKeys().prv;\n    if (!userSigningKey) {\n      throw new Error('no private key');\n    }\n\n    const txBuilder = this.getTransactionBuilder(params.common) as TransactionBuilder;\n    const txHex = buildResponse.txHex;\n    txBuilder.from(txHex);\n    if (buildResponse.walletVersion) {\n      // If walletVersion is provided, set it in the txBuilder\n      txBuilder.walletVersion(buildResponse.walletVersion);\n    }\n    txBuilder\n      .transfer()\n      .coin(this.staticsCoin?.name as string)\n      .key(userSigningKey);\n    const tx = await txBuilder.build();\n    const res = await this.bitgo\n      .post(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${params.recoveryId}/sign`))\n      .send({ txHex: tx.toBroadcastFormat() });\n    return {\n      coin: this.staticsCoin?.name as string,\n      txid: res.body.txid,\n    };\n  }\n\n  async buildCrossChainRecoveryTransaction(\n    recoveryId: string\n  ): Promise<{ coin: string; txHex: string; txid: string; walletVersion?: number }> {\n    const res = await this.bitgo.get(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${recoveryId}/buildtx`));\n    return {\n      coin: res.body.coin,\n      txHex: res.body.txHex,\n      txid: res.body.txid,\n      walletVersion: res.body.walletVersion,\n    };\n  }\n\n  /**\n   * Builds a unsigned (for cold, custody wallet) or\n   * half-signed (for hot wallet) evm cross chain recovery transaction with\n   * same expected arguments as recover method.\n   * This helps recover funds from evm based wrong chain.\n   * @param {RecoverOptions} params\n   * @returns {Promise<RecoveryInfo | OfflineVaultTxInfo>}\n   */\n  protected async recoverEthLikeforEvmBasedRecovery(\n    params: RecoverOptions\n  ): Promise<RecoveryInfo | OfflineVaultTxInfo> {\n    this.validateEvmBasedRecoveryParams(params);\n\n    // Clean up whitespace from entered values\n    const userKey = params.userKey.replace(/\\s/g, '');\n    const bitgoFeeAddress = params.bitgoFeeAddress?.replace(/\\s/g, '').toLowerCase() as string;\n    const bitgoDestinationAddress = params.bitgoDestinationAddress?.replace(/\\s/g, '').toLowerCase() as string;\n    const recoveryDestination = params.recoveryDestination?.replace(/\\s/g, '').toLowerCase() as string;\n    const walletContractAddress = params.walletContractAddress?.replace(/\\s/g, '').toLowerCase() as string;\n    const tokenContractAddress = params.tokenContractAddress?.replace(/\\s/g, '').toLowerCase() as string;\n\n    let userSigningKey;\n    let userKeyPrv;\n    if (params.walletPassphrase) {\n      if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {\n        try {\n          userKeyPrv = this.bitgo.decrypt({\n            input: userKey,\n            password: params.walletPassphrase,\n          });\n        } catch (e) {\n          throw new Error(`Error decrypting user keychain: ${e.message}`);\n        }\n      }\n\n      const keyPair = new KeyPairLib({ prv: userKeyPrv });\n      userSigningKey = keyPair.getKeys().prv;\n      if (!userSigningKey) {\n        throw new Error('no private key');\n      }\n    }\n\n    // Use default gasLimit for cold and custody wallets\n    let gasLimit =\n      params.gasLimit || userKey.startsWith('xpub') || !userKey\n        ? new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit))\n        : new optionalDeps.ethUtil.BN(0);\n\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : params.gasPrice\n      ? new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice))\n      : await this.getGasPriceFromExternalAPI(this.staticsCoin?.name as string);\n\n    const bitgoFeeAddressNonce = await this.getAddressNonce(bitgoFeeAddress, params.apiKey);\n\n    if (tokenContractAddress) {\n      return this.recoverEthLikeTokenforEvmBasedRecovery(\n        params,\n        bitgoFeeAddressNonce,\n        gasLimit,\n        gasPrice,\n        userKey,\n        userSigningKey,\n        params.apiKey\n      );\n    }\n\n    // get balance of wallet\n    const txAmount = await this.queryAddressBalance(walletContractAddress, params.apiKey);\n\n    const bitgoFeePercentage = 0; // TODO: BG-71912 can change the fee% here.\n    const bitgoFeeAmount = txAmount * (bitgoFeePercentage / 100);\n\n    // build recipients object\n    const recipients: Recipient[] = [\n      {\n        address: recoveryDestination,\n        amount: new BigNumber(txAmount).minus(bitgoFeeAmount).toFixed(),\n      },\n    ];\n\n    if (bitgoFeePercentage > 0) {\n      if (_.isUndefined(bitgoDestinationAddress) || !this.isValidAddress(bitgoDestinationAddress)) {\n        throw new Error('invalid bitgoDestinationAddress');\n      }\n\n      recipients.push({\n        address: bitgoDestinationAddress,\n        amount: bitgoFeeAmount.toString(10),\n      });\n    }\n\n    // calculate batch data\n    const BATCH_METHOD_NAME = 'batch';\n    const BATCH_METHOD_TYPES = ['address[]', 'uint256[]'];\n    const batchExecutionInfo = this.getBatchExecutionInfo(recipients);\n    const batchData = optionalDeps.ethUtil.addHexPrefix(\n      this.getMethodCallData(BATCH_METHOD_NAME, BATCH_METHOD_TYPES, batchExecutionInfo.values).toString('hex')\n    );\n\n    // Get sequence ID using contract call\n    // we need to wait between making two explorer api calls to avoid getting banned\n    await new Promise((resolve) => setTimeout(resolve, 1000));\n    const sequenceId = await this.querySequenceId(walletContractAddress, params.apiKey);\n\n    const network = this.getNetwork();\n    const batcherContractAddress = network?.batcherContractAddress as string;\n\n    const txBuilder = this.getTransactionBuilder(params.common) as TransactionBuilder;\n    txBuilder.counter(bitgoFeeAddressNonce);\n    txBuilder.contract(walletContractAddress);\n    let txFee;\n    if (params.eip1559) {\n      txFee = {\n        eip1559: {\n          maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,\n          maxFeePerGas: params.eip1559.maxFeePerGas,\n        },\n      };\n    } else {\n      txFee = { fee: gasPrice.toString() };\n    }\n    txBuilder.fee({\n      ...txFee,\n      gasLimit: gasLimit.toString(),\n    });\n\n    const transferBuilder = txBuilder.transfer() as TransferBuilder;\n    if (!batcherContractAddress) {\n      transferBuilder\n        .coin(this.staticsCoin?.name as string)\n        .amount(batchExecutionInfo.totalAmount)\n        .contractSequenceId(sequenceId)\n        .expirationTime(this.getDefaultExpireTime())\n        .to(recoveryDestination);\n    } else {\n      transferBuilder\n        .coin(this.staticsCoin?.name as string)\n        .amount(batchExecutionInfo.totalAmount)\n        .contractSequenceId(sequenceId)\n        .expirationTime(this.getDefaultExpireTime())\n        .to(batcherContractAddress)\n        .data(batchData);\n    }\n\n    if (params.walletPassphrase) {\n      transferBuilder.key(userSigningKey);\n    }\n\n    // If the intended chain is arbitrum or optimism, we need to use wallet version 4\n    // since these contracts construct operationHash differently\n    if (params.intendedChain && ['arbeth', 'opeth'].includes(coins.get(params.intendedChain).family)) {\n      txBuilder.walletVersion(4);\n    }\n\n    // If gasLimit was not passed as a param or if it is not cold/custody wallet, then fetch the gasLimit from Explorer\n    if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {\n      const sendData = txBuilder.getSendData();\n      gasLimit = await this.getGasLimitFromExternalAPI(\n        params.intendedChain as string,\n        params.bitgoFeeAddress as string,\n        params.walletContractAddress,\n        sendData,\n        params.apiKey\n      );\n      txBuilder.fee({\n        ...txFee,\n        gasLimit: gasLimit.toString(),\n      });\n    }\n\n    // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees\n    await this.ensureSufficientBalance(bitgoFeeAddress, gasPrice, gasLimit, params.apiKey);\n\n    const tx = await txBuilder.build();\n\n    const txInfo = {\n      recipients: recipients,\n      expireTime: this.getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      gasLimit: gasLimit.toString(10),\n      isEvmBasedCrossChainRecovery: true,\n    };\n\n    const response: OfflineVaultTxInfo = {\n      txHex: tx.toBroadcastFormat(),\n      userKey,\n      coin: this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: txInfo.recipients,\n      walletContractAddress: tx.toJson().to,\n      amount: batchExecutionInfo.totalAmount,\n      backupKeyNonce: bitgoFeeAddressNonce,\n      eip1559: params.eip1559,\n      ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),\n    };\n    _.extend(response, txInfo);\n    response.nextContractSequenceId = response.contractSequenceId;\n\n    if (params.walletPassphrase) {\n      const halfSignedTxn: HalfSignedTransaction = {\n        halfSigned: {\n          txHex: tx.toBroadcastFormat(),\n          recipients: txInfo.recipients,\n          expireTime: txInfo.expireTime,\n        },\n      };\n      _.extend(response, halfSignedTxn);\n\n      const feesUsed: FeesUsed = {\n        gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n        gasLimit: optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),\n      };\n      response['feesUsed'] = feesUsed;\n    }\n\n    return response;\n  }\n\n  /**\n   * Query explorer for the balance of an address for a token\n   * @param {string} tokenContractAddress - address where the token smart contract is hosted\n   * @param {string} walletContractAddress - address of the wallet\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   * @returns {BigNumber} token balaance in base units\n   */\n  async queryAddressTokenBalance(\n    tokenContractAddress: string,\n    walletContractAddress: string,\n    apiKey?: string\n  ): Promise<any> {\n    if (!optionalDeps.ethUtil.isValidAddress(tokenContractAddress)) {\n      throw new Error('cannot get balance for invalid token address');\n    }\n    if (!optionalDeps.ethUtil.isValidAddress(walletContractAddress)) {\n      throw new Error('cannot get token balance for invalid wallet address');\n    }\n\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'account',\n        action: 'tokenbalance',\n        contractaddress: tokenContractAddress,\n        address: walletContractAddress,\n        tag: 'latest',\n      },\n      apiKey\n    );\n    // throw if the result does not exist or the result is not a valid number\n    if (!result || !result.result || isNaN(result.result)) {\n      throw new Error(\n        `Could not obtain token address balance for ${tokenContractAddress} from Etherscan, got: ${result.result}`\n      );\n    }\n    return new optionalDeps.ethUtil.BN(result.result, 10);\n  }\n\n  async recoverEthLikeTokenforEvmBasedRecovery(\n    params: RecoverOptions,\n    bitgoFeeAddressNonce: number,\n    gasLimit,\n    gasPrice,\n    userKey,\n    userSigningKey,\n    apiKey?: string\n  ) {\n    // get token balance of wallet\n    const txAmount = await this.queryAddressTokenBalance(\n      params.tokenContractAddress as string,\n      params.walletContractAddress,\n      apiKey\n    );\n\n    // build recipients object\n    const recipients: Recipient[] = [\n      {\n        address: params.recoveryDestination,\n        amount: new BigNumber(txAmount).toFixed(),\n      },\n    ];\n\n    // Get sequence ID using contract call\n    // we need to wait between making two explorer api calls to avoid getting banned\n    await new Promise((resolve) => setTimeout(resolve, 1000));\n    const sequenceId = await this.querySequenceId(params.walletContractAddress);\n\n    const txBuilder = this.getTransactionBuilder(params.common) as TransactionBuilder;\n    txBuilder.counter(bitgoFeeAddressNonce);\n    txBuilder.contract(params.walletContractAddress as string);\n    let txFee;\n    if (params.eip1559) {\n      txFee = {\n        eip1559: {\n          maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,\n          maxFeePerGas: params.eip1559.maxFeePerGas,\n        },\n      };\n    } else {\n      txFee = { fee: gasPrice.toString() };\n    }\n    txBuilder.fee({\n      ...txFee,\n      gasLimit: gasLimit.toString(),\n    });\n\n    const transferBuilder = txBuilder.transfer() as TransferBuilder;\n\n    const network = this.getNetwork();\n    const token = getToken(\n      params.tokenContractAddress as string,\n      network as EthLikeNetwork,\n      this.staticsCoin?.family as string\n    )?.name as string;\n\n    transferBuilder\n      .amount(txAmount)\n      .contractSequenceId(sequenceId)\n      .expirationTime(this.getDefaultExpireTime())\n      .to(params.recoveryDestination);\n\n    if (token) {\n      transferBuilder.coin(token);\n    } else {\n      transferBuilder\n        .coin(this.staticsCoin?.name as string)\n        .tokenContractAddress(params.tokenContractAddress as string);\n    }\n\n    if (params.walletPassphrase) {\n      txBuilder.transfer().key(userSigningKey);\n    }\n    // If the intended chain is arbitrum or optimism, we need to use wallet version 4\n    // since these contracts construct operationHash differently\n    if (params.intendedChain && ['arbeth', 'opeth'].includes(coins.get(params.intendedChain).family)) {\n      txBuilder.walletVersion(4);\n    }\n\n    if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {\n      const sendData = txBuilder.getSendData();\n      gasLimit = await this.getGasLimitFromExternalAPI(\n        params.intendedChain as string,\n        params.bitgoFeeAddress as string,\n        params.walletContractAddress,\n        sendData\n      );\n      txBuilder.fee({\n        ...txFee,\n        gasLimit: gasLimit.toString(),\n      });\n    }\n\n    // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees\n    await this.ensureSufficientBalance(params.bitgoFeeAddress as string, gasPrice, gasLimit);\n\n    const tx = await txBuilder.build();\n\n    const txInfo = {\n      recipients: recipients,\n      expireTime: this.getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      gasLimit: gasLimit.toString(10),\n      isEvmBasedCrossChainRecovery: true,\n    };\n\n    const response: OfflineVaultTxInfo = {\n      txHex: tx.toBroadcastFormat(),\n      userKey,\n      coin: token ? token : this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: txInfo.recipients,\n      walletContractAddress: tx.toJson().to,\n      amount: txAmount.toString(),\n      backupKeyNonce: bitgoFeeAddressNonce,\n      eip1559: params.eip1559,\n      ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),\n    };\n    _.extend(response, txInfo);\n    response.nextContractSequenceId = response.contractSequenceId;\n\n    if (params.walletPassphrase) {\n      const halfSignedTxn: HalfSignedTransaction = {\n        halfSigned: {\n          txHex: tx.toBroadcastFormat(),\n          recipients: txInfo.recipients,\n          expireTime: txInfo.expireTime,\n        },\n      };\n      _.extend(response, halfSignedTxn);\n\n      const feesUsed: FeesUsed = {\n        gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n        gasLimit: optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),\n      };\n      response['feesUsed'] = feesUsed;\n    }\n\n    return response;\n  }\n\n  /**\n   * Validate evm based cross chain recovery params\n   * @param params {RecoverOptions}\n   * @returns {void}\n   */\n  validateEvmBasedRecoveryParams(params: RecoverOptions): void {\n    if (_.isUndefined(params.bitgoFeeAddress) || !this.isValidAddress(params.bitgoFeeAddress)) {\n      throw new Error('invalid bitgoFeeAddress');\n    }\n\n    if (_.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {\n      throw new Error('invalid walletContractAddress');\n    }\n\n    if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n  }\n\n  /**\n   * Return types, values, and total amount in wei to send in a batch transaction, using the method signature\n   * `distributeBatch(address[], uint256[])`\n   * @param {Recipient[]} recipients - transaction recipients\n   * @returns {GetBatchExecutionInfoRT} information needed to execute the batch transaction\n   */\n  getBatchExecutionInfo(recipients: Recipient[]): GetBatchExecutionInfoRT {\n    const addresses: string[] = [];\n    const amounts: string[] = [];\n    let sum = new BigNumber('0');\n    _.forEach(recipients, ({ address, amount }) => {\n      addresses.push(address);\n      amounts.push(amount as string);\n      sum = sum.plus(amount);\n    });\n\n    return {\n      values: [addresses, amounts],\n      totalAmount: sum.toFixed(),\n    };\n  }\n\n  /**\n   * Get the data required to make an ETH function call defined by the given types and values\n   *\n   * @param {string} functionName - The name of the function being called, e.g. transfer\n   * @param types The types of the function call in order\n   * @param values The values of the function call in order\n   * @return {Buffer} The combined data for the function call\n   */\n  getMethodCallData = (functionName, types, values) => {\n    return Buffer.concat([\n      // function signature\n      optionalDeps.ethAbi.methodID(functionName, types),\n      // function arguments\n      optionalDeps.ethAbi.rawEncode(types, values),\n    ]);\n  };\n\n  /**\n   * Build arguments to call the send method on the wallet contract\n   * @param txInfo\n   */\n  getSendMethodArgs(txInfo: GetSendMethodArgsOptions): SendMethodArgs[] {\n    // Method signature is\n    // sendMultiSig(address toAddress, uint value, bytes data, uint expireTime, uint sequenceId, bytes signature)\n    return [\n      {\n        name: 'toAddress',\n        type: 'address',\n        value: txInfo.recipient.address,\n      },\n      {\n        name: 'value',\n        type: 'uint',\n        value: txInfo.recipient.amount,\n      },\n      {\n        name: 'data',\n        type: 'bytes',\n        value: optionalDeps.ethUtil.toBuffer(optionalDeps.ethUtil.addHexPrefix(txInfo.recipient.data || '')),\n      },\n      {\n        name: 'expireTime',\n        type: 'uint',\n        value: txInfo.expireTime,\n      },\n      {\n        name: 'sequenceId',\n        type: 'uint',\n        value: txInfo.contractSequenceId,\n      },\n      {\n        name: 'signature',\n        type: 'bytes',\n        value: optionalDeps.ethUtil.toBuffer(optionalDeps.ethUtil.addHexPrefix(txInfo.signature)),\n      },\n    ];\n  }\n\n  /**\n   * Recovers a tx with TSS key shares\n   * same expected arguments as recover method, but with TSS key shares\n   */\n  protected async recoverTSS(\n    params: RecoverOptions\n  ): Promise<RecoveryInfo | OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    this.validateRecoveryParams(params);\n    // Clean up whitespace from entered values\n    const userPublicOrPrivateKeyShare = params.userKey.replace(/\\s/g, '');\n    const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\\s/g, '');\n\n    if (\n      getIsUnsignedSweep({\n        userKey: userPublicOrPrivateKeyShare,\n        backupKey: backupPrivateOrPublicKeyShare,\n        isTss: params.isTss,\n      })\n    ) {\n      return this.buildUnsignedSweepTxnTSS(params);\n    } else {\n      const { userKeyShare, backupKeyShare, commonKeyChain } = await ECDSAUtils.getMpcV2RecoveryKeyShares(\n        userPublicOrPrivateKeyShare,\n        backupPrivateOrPublicKeyShare,\n        params.walletPassphrase\n      );\n\n      const { gasLimit, gasPrice } = await this.getGasValues(params);\n\n      const MPC = new Ecdsa();\n      const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm/0');\n      const backupKeyPair = new KeyPairLib({ pub: derivedCommonKeyChain.slice(0, 66) });\n      const baseAddress = backupKeyPair.getAddress();\n      const unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;\n      const messageHash = unsignedTx.getMessageToSign(true);\n      const signature = await ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);\n      const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);\n      const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, signature);\n\n      return {\n        id: addHexPrefix(signedTx.hash().toString('hex')),\n        tx: addHexPrefix(signedTx.serialize().toString('hex')),\n      };\n    }\n  }\n\n  private async getGasValues(params: RecoverOptions): Promise<{ gasLimit: number; gasPrice: Buffer }> {\n    const gasLimit = new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));\n    return { gasLimit, gasPrice };\n  }\n\n  protected async buildUnsignedSweepTxnTSS(params: RecoverOptions): Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    const userPublicOrPrivateKeyShare = params.userKey.replace(/\\s/g, '');\n    const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\\s/g, '');\n\n    const { gasLimit, gasPrice } = await this.getGasValues(params);\n\n    const backupKeyPair = new KeyPairLib({ pub: backupPrivateOrPublicKeyShare });\n    const baseAddress = backupKeyPair.getAddress();\n    const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);\n    return this.formatForOfflineVaultTSS(\n      txInfo,\n      tx,\n      userPublicOrPrivateKeyShare,\n      backupPrivateOrPublicKeyShare,\n      gasPrice,\n      gasLimit,\n      nonce,\n      params.eip1559,\n      params.replayProtectionOptions\n    );\n  }\n\n  protected async buildUnsignedSweepTxnMPCv2(params: RecoverOptions): Promise<UnsignedSweepTxMPCv2> {\n    const { gasLimit, gasPrice } = await this.getGasValues(params);\n\n    const recoverParams = params as RecoverOptions;\n    this.validateUnsignedSweepTSSParams(recoverParams);\n\n    const derivationPath = recoverParams.derivationSeed ? getDerivationPath(recoverParams.derivationSeed) : 'm/0';\n    const MPC = new Ecdsa();\n    const derivedCommonKeyChain = MPC.deriveUnhardened(recoverParams.backupKey as string, derivationPath);\n    const backupKeyPair = new KeyPairLib({ pub: derivedCommonKeyChain.slice(0, 66) });\n    const baseAddress = backupKeyPair.getAddress();\n    const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);\n    return this.buildTxRequestForOfflineVaultMPCv2(\n      txInfo,\n      tx,\n      derivationPath,\n      nonce,\n      gasPrice,\n      gasLimit,\n      params.eip1559,\n      params.replayProtectionOptions,\n      recoverParams.backupKey as string\n    );\n  }\n\n  async createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs> {\n    const req = params.signatureShares;\n    const broadcastableTransactions: MPCTx[] = [];\n    let lastScanIndex = 0;\n\n    for (let i = 0; i < req.length; i++) {\n      const transaction = req[i]?.txRequest?.transactions?.[0]?.unsignedTx as unknown as UnsignedTransactionTss;\n      if (!req[i].ovc || !req[i].ovc[0].ecdsaSignature) {\n        throw new Error('Missing signature(s)');\n      }\n      if (!transaction.signableHex) {\n        throw new Error('Missing signable hex');\n      }\n      const signature = req[i].ovc[0].ecdsaSignature;\n      if (!signature) {\n        throw new Error('Signature is undefined');\n      }\n      const shares: string[] = signature.toString().split(':');\n      if (shares.length !== 4) {\n        throw new Error('Invalid signature');\n      }\n      const finalSignature: ECDSAMethodTypes.Signature = {\n        recid: Number(shares[0]),\n        r: shares[1],\n        s: shares[2],\n        y: shares[3],\n      } as unknown as ECDSAMethodTypes.Signature;\n\n      if (!transaction.coinSpecific?.commonKeyChain) {\n        throw new Error(`Missing common keychain for transaction at index ${i}`);\n      }\n      const commonKeyChain = transaction.coinSpecific.commonKeyChain;\n      if (!transaction.derivationPath) {\n        throw new Error(`Missing derivation path for transaction at index ${i}`);\n      }\n      if (!commonKeyChain) {\n        throw new Error(`Missing common key chain for transaction at index ${i}`);\n      }\n\n      const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(\n        transaction.eip1559,\n        transaction.replayProtectionOptions\n      );\n      let unsignedTx: EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction;\n      if (transaction.eip1559) {\n        unsignedTx = FeeMarketEIP1559Transaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));\n      } else {\n        unsignedTx = LegacyTransaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));\n      }\n      const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, finalSignature);\n      broadcastableTransactions.push({\n        serializedTx: addHexPrefix(signedTx.serialize().toString('hex')),\n      });\n\n      if (i === req.length - 1 && transaction.coinSpecific?.lastScanIndex) {\n        lastScanIndex = transaction.coinSpecific?.lastScanIndex as number;\n      }\n    }\n\n    return { transactions: broadcastableTransactions, lastScanIndex };\n  }\n\n  /**\n   * Method to validate recovery params\n   * @param {RecoverOptions} params\n   * @returns {void}\n   */\n  private async validateUnsignedSweepTSSParams(params: RecoverOptions): Promise<void> {\n    if (_.isUndefined(params.backupKey) && params.backupKey === '') {\n      throw new Error('missing commonKeyChain');\n    }\n    if (!_.isUndefined(params.derivationSeed) && typeof params.derivationSeed !== 'string') {\n      throw new Error('invalid derivationSeed');\n    }\n    if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('missing or invalid destinationAddress');\n    }\n  }\n\n  /**\n   * Helper function for recover()\n   * This transforms the unsigned transaction information into a format the BitGo offline vault expects\n   * @param {UnformattedTxInfo} txInfo - tx info\n   * @param {LegacyTransaction | FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object\n   * @param {string} derivationPath - the derivationPath\n   * @param {number} nonce - the nonce of the backup key address\n   * @param {Buffer} gasPrice - gas price for the tx\n   * @param {number} gasLimit - gas limit for the tx\n   * @param {EIP1559} eip1559 - eip1559 params\n   * @param replayProtectionOptions\n   * @param commonKeyChain\n   * @returns {Promise<OfflineVaultTxInfo>}\n   */\n  private buildTxRequestForOfflineVaultMPCv2(\n    txInfo: UnformattedTxInfo,\n    ethTx: LegacyTransaction | FeeMarketEIP1559Transaction,\n    derivationPath: string,\n    nonce: number,\n    gasPrice: Buffer,\n    gasLimit: number,\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions,\n    commonKeyChain?: string\n  ): UnsignedSweepTxMPCv2 {\n    if (!ethTx.to) {\n      throw new Error('Eth tx must have a `to` address');\n    }\n\n    const fee = eip1559\n      ? gasLimit * eip1559.maxFeePerGas\n      : gasLimit * optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed();\n\n    const unsignedTx: UnsignedTransactionTss = {\n      serializedTxHex: ethTx.serialize().toString('hex'),\n      signableHex:\n        ethTx instanceof FeeMarketEIP1559Transaction\n          ? ethTx.getMessageToSign(false).toString('hex')\n          : Buffer.from(RLP.encode(bufArrToArr(ethTx.getMessageToSign(false)))).toString('hex'),\n      derivationPath: derivationPath,\n      feeInfo: {\n        fee: fee,\n        feeString: fee.toString(),\n      },\n      parsedTx: {\n        spendAmount: txInfo.recipient.amount,\n        outputs: [\n          {\n            coinName: this.getChain(),\n            address: txInfo.recipient.address,\n            valueString: txInfo.recipient.amount,\n          },\n        ],\n      },\n      coinSpecific: {\n        commonKeyChain: commonKeyChain,\n      },\n      eip1559: eip1559,\n      replayProtectionOptions: replayProtectionOptions,\n    };\n\n    return {\n      txRequests: [\n        {\n          walletCoin: this.getChain(),\n          transactions: [\n            {\n              unsignedTx: unsignedTx,\n              nonce: nonce,\n              signatureShares: [],\n            },\n          ],\n        },\n      ],\n    };\n  }\n\n  private async buildTssRecoveryTxn(baseAddress: string, gasPrice: any, gasLimit: any, params: RecoverOptions) {\n    const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, params.apiKey);\n    const nonce = await this.getAddressNonce(baseAddress, params.apiKey);\n    const recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: txAmount.toString(10),\n      },\n    ];\n\n    const txInfo = {\n      recipient: recipients[0],\n      expireTime: this.getDefaultExpireTime(),\n      gasLimit: gasLimit.toString(10),\n    };\n\n    const txParams = {\n      to: params.recoveryDestination,\n      nonce: nonce,\n      value: txAmount,\n      gasPrice: gasPrice,\n      gasLimit: gasLimit,\n      data: Buffer.from('0x'),\n      eip1559: params.eip1559,\n      replayProtectionOptions: params.replayProtectionOptions,\n    };\n\n    const tx = AbstractEthLikeNewCoins.buildTransaction(txParams);\n    return { txInfo, tx, nonce };\n  }\n\n  async validateBalanceAndGetTxAmount(baseAddress: string, gasPrice: BN, gasLimit: BN, apiKey?: string) {\n    const baseAddressBalance = await this.queryAddressBalance(baseAddress, apiKey);\n    const totalGasNeeded = gasPrice.mul(gasLimit);\n    const weiToGwei = new BN(10 ** 9);\n    if (baseAddressBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Backup key address ${baseAddress} has balance ${baseAddressBalance.div(weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${totalGasNeeded.div(weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some ETH to this address then retry.`\n      );\n    }\n    const txAmount = baseAddressBalance.sub(totalGasNeeded);\n    return txAmount;\n  }\n\n  /**\n   * Make a query to blockchain explorer for information such as balance, token balance, solidity calls\n   * @param query {Object} key-value pairs of parameters to append after /api\n   * @param apiKey {string} optional API key to use instead of the one from the environment\n   * @returns {Object} response from the blockchain explorer\n   */\n  async recoveryBlockchainExplorerQuery(query: Record<string, string>, apiKey?: string): Promise<any> {\n    throw new Error('method not implemented');\n  }\n\n  /**\n   * Creates the extra parameters needed to build a hop transaction\n   * @param buildParams The original build parameters\n   * @returns extra parameters object to merge with the original build parameters object and send to the platform\n   */\n  async createHopTransactionParams(buildParams: HopTransactionBuildOptions): Promise<HopParams> {\n    const wallet = buildParams.wallet;\n    const recipients = buildParams.recipients;\n    const walletPassphrase = buildParams.walletPassphrase;\n\n    const userKeychain = await this.keychains().get({ id: wallet.keyIds()[0] });\n    const userPrv = wallet.getUserPrv({ keychain: userKeychain, walletPassphrase });\n    const userPrvBuffer = bip32.fromBase58(userPrv).privateKey;\n    if (!userPrvBuffer) {\n      throw new Error('invalid userPrv');\n    }\n    if (!recipients || !Array.isArray(recipients)) {\n      throw new Error('expecting array of recipients');\n    }\n\n    // Right now we only support 1 recipient\n    if (recipients.length !== 1) {\n      throw new Error('must send to exactly 1 recipient');\n    }\n    const recipientAddress = recipients[0].address;\n    const recipientAmount = recipients[0].amount as string;\n    const feeEstimateParams = {\n      recipient: recipientAddress,\n      amount: recipientAmount,\n      hop: true,\n    };\n    const feeEstimate: FeeEstimate = await this.feeEstimate(feeEstimateParams);\n\n    const gasLimit = feeEstimate.gasLimitEstimate;\n    const gasPrice = Math.round(feeEstimate.feeEstimate / gasLimit);\n    const gasPriceMax = gasPrice * 5;\n    // Payment id a random number so its different for every tx\n    const paymentId = Math.floor(Math.random() * 10000000000).toString();\n    const hopDigest: Buffer = AbstractEthLikeNewCoins.getHopDigest([\n      recipientAddress,\n      recipientAmount,\n      gasPriceMax.toString(),\n      gasLimit.toString(),\n      paymentId,\n    ]);\n\n    const userReqSig = optionalDeps.ethUtil.addHexPrefix(\n      Buffer.from(secp256k1.ecdsaSign(hopDigest, userPrvBuffer).signature).toString('hex')\n    );\n\n    return {\n      hopParams: {\n        gasPriceMax,\n        userReqSig,\n        paymentId,\n        gasLimit,\n      },\n    };\n  }\n\n  /**\n   * Validates that the hop prebuild from the HSM is valid and correct\n   * @param {IWallet} wallet - The wallet that the prebuild is for\n   * @param {HopPrebuild} hopPrebuild - The prebuild to validate\n   * @param {Object} originalParams - The original parameters passed to prebuildTransaction\n   * @param {Recipient[]} originalParams.recipients - The original recipients array\n   * @returns {void}\n   * @throws Error if The prebuild is invalid\n   */\n  async validateHopPrebuild(\n    wallet: IWallet,\n    hopPrebuild: HopPrebuild,\n    originalParams?: { recipients: Recipient[] }\n  ): Promise<void> {\n    const { tx, id, signature } = hopPrebuild;\n\n    // first, validate the HSM signature\n    const serverXpub = common.Environments[this.bitgo.getEnv()].hsmXpub;\n    const serverPubkeyBuffer: Buffer = bip32.fromBase58(serverXpub).publicKey;\n    const signatureBuffer: Buffer = Buffer.from(optionalDeps.ethUtil.stripHexPrefix(signature), 'hex');\n    const messageBuffer: Buffer = Buffer.from(\n      optionalDeps.ethUtil.padToEven(optionalDeps.ethUtil.stripHexPrefix(id)),\n      'hex'\n    );\n\n    const sig = new Uint8Array(signatureBuffer.slice(1));\n    const isValidSignature: boolean = secp256k1.ecdsaVerify(sig, messageBuffer, serverPubkeyBuffer);\n    if (!isValidSignature) {\n      throw new Error(\n        `Hop txid signature invalid - pub: ${serverXpub}, msg: ${messageBuffer?.toString()}, sig: ${signatureBuffer?.toString()}`\n      );\n    }\n\n    const builtHopTx = optionalDeps.EthTx.TransactionFactory.fromSerializedData(optionalDeps.ethUtil.toBuffer(tx));\n    // If original params are given, we can check them against the transaction prebuild params\n    if (!_.isNil(originalParams)) {\n      const { recipients } = originalParams;\n\n      // Then validate that the tx params actually equal the requested params\n      const originalAmount = new BigNumber(recipients[0].amount);\n      const originalDestination: string = recipients[0].address;\n\n      const hopAmount = new BigNumber(optionalDeps.ethUtil.bufferToHex(builtHopTx.value));\n      if (!builtHopTx.to) {\n        throw new Error(`Transaction does not have a destination address`);\n      }\n      const hopDestination = builtHopTx.to.toString();\n      if (!hopAmount.eq(originalAmount)) {\n        throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);\n      }\n      if (hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {\n        throw new Error(`Hop destination: ${hopDestination} does not equal original recipient: ${hopDestination}`);\n      }\n    }\n\n    if (!builtHopTx.verifySignature()) {\n      // We dont want to continue at all in this case, at risk of ETH being stuck on the hop address\n      throw new Error(`Invalid hop transaction signature, txid: ${id}`);\n    }\n    if (optionalDeps.ethUtil.addHexPrefix(builtHopTx.hash().toString('hex')) !== id) {\n      throw new Error(`Signed hop txid does not equal actual txid`);\n    }\n  }\n\n  /**\n   * Gets the hop digest for the user to sign. This is validated in the HSM to prove that the user requested this tx\n   * @param {string[]} paramsArr - The parameters to hash together for the digest\n   * @returns {Buffer}\n   */\n  public static getHopDigest(paramsArr: string[]): Buffer {\n    const hash = Keccak('keccak256');\n    hash.update([AbstractEthLikeNewCoins.hopTransactionSalt, ...paramsArr].join('$'));\n    return hash.digest();\n  }\n\n  /**\n   * Modify prebuild before sending it to the server. Add things like hop transaction params\n   * @param {BuildOptions} buildParams - The whitelisted parameters for this prebuild\n   * @param {boolean} buildParams.hop - True if this should prebuild a hop tx, else false\n   * @param {Recipient[]} buildParams.recipients - The recipients array of this transaction\n   * @param {Wallet} buildParams.wallet - The wallet sending this tx\n   * @param {string} buildParams.walletPassphrase - the passphrase for this wallet\n   * @returns {Promise<BuildOptions>}\n   */\n  async getExtraPrebuildParams(buildParams: BuildOptions): Promise<BuildOptions> {\n    if (\n      !_.isUndefined(buildParams.hop) &&\n      buildParams.hop &&\n      !_.isUndefined(buildParams.wallet) &&\n      !_.isUndefined(buildParams.recipients) &&\n      !_.isUndefined(buildParams.walletPassphrase)\n    ) {\n      if (this instanceof EthLikeToken) {\n        throw new Error(\n          `Hop transactions are not enabled for ERC-20 tokens, nor are they necessary. Please remove the 'hop' parameter and try again.`\n        );\n      }\n      return (await this.createHopTransactionParams({\n        wallet: buildParams.wallet,\n        recipients: buildParams.recipients,\n        walletPassphrase: buildParams.walletPassphrase,\n      })) as any;\n    }\n    return {};\n  }\n\n  /**\n   * Modify prebuild after receiving it from the server. Add things like nlocktime\n   * @param {TransactionPrebuild} params - The prebuild to modify\n   * @returns {TransactionPrebuild} The modified prebuild\n   */\n  async postProcessPrebuild(params: TransactionPrebuild): Promise<TransactionPrebuild> {\n    if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {\n      await this.validateHopPrebuild(params.wallet, params.hopTransaction, params.buildParams);\n    }\n    return params;\n  }\n\n  /**\n   * Coin-specific things done before signing a transaction, i.e. verification\n   * @param {PresignTransactionOptions} params\n   * @returns {Promise<PresignTransactionOptions>}\n   */\n  async presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions> {\n    if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {\n      await this.validateHopPrebuild(params.wallet, params.hopTransaction);\n    }\n    return params;\n  }\n\n  /**\n   * Fetch fee estimate information from the server\n   * @param {Object} params - The params passed into the function\n   * @param {boolean} [params.hop] - True if we should estimate fee for a hop transaction\n   * @param {string} [params.recipient] - The recipient of the transaction to estimate a send to\n   * @param {string} [params.data] - The ETH tx data to estimate a send for\n   * @returns {Object} The fee info returned from the server\n   */\n  async feeEstimate(params: FeeEstimateOptions): Promise<FeeEstimate> {\n    const query: FeeEstimateOptions = {};\n    if (params && params.hop) {\n      query.hop = params.hop;\n    }\n    if (params && params.recipient) {\n      query.recipient = params.recipient;\n    }\n    if (params && params.data) {\n      query.data = params.data;\n    }\n    if (params && params.amount) {\n      query.amount = params.amount;\n    }\n\n    return await this.bitgo.get(this.url('/tx/fee')).query(query).result();\n  }\n\n  /**\n   * Generate secp256k1 key pair\n   *\n   * @param {Buffer} seed\n   * @returns {KeyPair} object with generated pub and prv\n   */\n  generateKeyPair(seed: Buffer): KeyPair {\n    if (!seed) {\n      // An extended private key has both a normal 256 bit private key and a 256\n      // bit chain code, both of which must be random. 512 bits is therefore the\n      // maximum entropy and gives us maximum security against cracking.\n      seed = randomBytes(512 / 8);\n    }\n    const extendedKey = bip32.fromSeed(seed);\n    const xpub = extendedKey.neutered().toBase58();\n    return {\n      pub: xpub,\n      prv: extendedKey.toBase58(),\n    };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Make sure an address is a wallet address and throw an error if it's not.\n   * @param {Object} params\n   * @param {string} params.address - The derived address string on the network\n   * @param {Object} params.coinSpecific - Coin-specific details for the address such as a forwarderVersion\n   * @param {string} params.baseAddress - The base address of the wallet on the network\n   * @throws {InvalidAddressError}\n   * @throws {InvalidAddressVerificationObjectPropertyError}\n   * @throws {UnexpectedAddressError}\n   * @returns {boolean} True iff address is a wallet address\n   */\n  async isWalletAddress(params: VerifyEthAddressOptions): Promise<boolean> {\n    const ethUtil = optionalDeps.ethUtil;\n\n    let expectedAddress;\n    let actualAddress;\n\n    const { address, coinSpecific, baseAddress, impliedForwarderVersion = coinSpecific?.forwarderVersion } = params;\n\n    if (address && !this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    // base address is required to calculate the salt which is used in calculateForwarderV1Address method\n    if (_.isUndefined(baseAddress) || !this.isValidAddress(baseAddress)) {\n      throw new InvalidAddressError('invalid base address');\n    }\n\n    if (!_.isObject(coinSpecific)) {\n      throw new InvalidAddressVerificationObjectPropertyError(\n        'address validation failure: coinSpecific field must be an object'\n      );\n    }\n\n    if (impliedForwarderVersion === 0 || impliedForwarderVersion === 3 || impliedForwarderVersion === 5) {\n      return true;\n    } else {\n      const ethNetwork = this.getNetwork();\n      const forwarderFactoryAddress = ethNetwork?.forwarderFactoryAddress as string;\n      const forwarderImplementationAddress = ethNetwork?.forwarderImplementationAddress as string;\n\n      const initcode = getProxyInitcode(forwarderImplementationAddress);\n      const saltBuffer = ethUtil.setLengthLeft(\n        Buffer.from(ethUtil.padToEven(ethUtil.stripHexPrefix(coinSpecific.salt || '')), 'hex'),\n        32\n      );\n\n      // Hash the wallet base address with the given salt, so the address directly relies on the base address\n      const calculationSalt = optionalDeps.ethUtil.bufferToHex(\n        optionalDeps.ethAbi.soliditySHA3(['address', 'bytes32'], [baseAddress, saltBuffer])\n      );\n\n      expectedAddress = calculateForwarderV1Address(forwarderFactoryAddress, calculationSalt, initcode);\n      actualAddress = address;\n    }\n\n    if (expectedAddress !== actualAddress) {\n      throw new UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);\n    }\n\n    return true;\n  }\n\n  /**\n   *\n   * @param {TransactionPrebuild} txPrebuild\n   * @returns {boolean}\n   */\n  verifyCoin(txPrebuild: TransactionPrebuild): boolean {\n    const nativeCoin = this.getChain().split(':')[0];\n    return txPrebuild.coin === nativeCoin;\n  }\n\n  /**\n   * Verify if a tss transaction is valid\n   *\n   * @param {VerifyEthTransactionOptions} params\n   * @param {TransactionParams} params.txParams - params object passed to send\n   * @param {TransactionPrebuild} params.txPrebuild - prebuild object returned by server\n   * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against\n   * @returns {boolean}\n   */\n  async verifyTssTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild, wallet } = params;\n    if (\n      !txParams?.recipients &&\n      !(\n        txParams.prebuildTx?.consolidateId ||\n        (txParams.type && ['acceleration', 'fillNonce', 'transferToken', 'tokenApproval'].includes(txParams.type))\n      )\n    ) {\n      throw new Error(`missing txParams`);\n    }\n    if (!wallet || !txPrebuild) {\n      throw new Error(`missing params`);\n    }\n    if (txParams.hop && txParams.recipients && txParams.recipients.length > 1) {\n      throw new Error(`tx cannot be both a batch and hop transaction`);\n    }\n\n    if (txParams.type && ['transfer'].includes(txParams.type)) {\n      if (txParams.recipients && txParams.recipients.length === 1) {\n        const recipients = txParams.recipients;\n        const expectedAmount = recipients[0].amount.toString();\n        const expectedDestination = recipients[0].address;\n\n        const txBuilder = this.getTransactionBuilder();\n        txBuilder.from(txPrebuild.txHex);\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n        if (txJson.data === '0x') {\n          if (expectedAmount !== txJson.value) {\n            throw new Error('the transaction amount in txPrebuild does not match the value given by client');\n          }\n          if (expectedDestination.toLowerCase() !== txJson.to.toLowerCase()) {\n            throw new Error('destination address does not match with the recipient address');\n          }\n        } else if (txJson.data.startsWith('0xa9059cbb')) {\n          const [recipientAddress, amount] = getRawDecoded(\n            ['address', 'uint256'],\n            getBufferedByteCode('0xa9059cbb', txJson.data)\n          );\n          if (expectedAmount !== amount.toString()) {\n            throw new Error('the transaction amount in txPrebuild does not match the value given by client');\n          }\n          if (expectedDestination.toLowerCase() !== addHexPrefix(recipientAddress.toString()).toLowerCase()) {\n            throw new Error('destination address does not match with the recipient address');\n          }\n        }\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Verify that a transaction prebuild complies with the original intention\n   *\n   * @param {VerifyEthTransactionOptions} params\n   * @param {TransactionParams} params.txParams - params object passed to send\n   * @param {TransactionPrebuild} params.txPrebuild - prebuild object returned by server\n   * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against\n   * @returns {boolean}\n   */\n  async verifyTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const ethNetwork = this.getNetwork();\n    const { txParams, txPrebuild, wallet, walletType } = params;\n\n    if (walletType === 'tss') {\n      return this.verifyTssTransaction(params);\n    }\n\n    if (!txParams?.recipients || !txPrebuild?.recipients || !wallet) {\n      throw new Error(`missing params`);\n    }\n    if (txParams.hop && txParams.recipients.length > 1) {\n      throw new Error(`tx cannot be both a batch and hop transaction`);\n    }\n    if (txPrebuild.recipients.length > 1) {\n      throw new Error(\n        `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n      );\n    }\n    if (txParams.hop && txPrebuild.hopTransaction) {\n      // Check recipient amount for hop transaction\n      if (txParams.recipients.length !== 1) {\n        throw new Error(`hop transaction only supports 1 recipient but ${txParams.recipients.length} found`);\n      }\n\n      // Check tx sends to hop address\n      const decodedHopTx = optionalDeps.EthTx.TransactionFactory.fromSerializedData(\n        optionalDeps.ethUtil.toBuffer(txPrebuild.hopTransaction.tx)\n      );\n      const expectedHopAddress = optionalDeps.ethUtil.stripHexPrefix(decodedHopTx.getSenderAddress().toString());\n      const actualHopAddress = optionalDeps.ethUtil.stripHexPrefix(txPrebuild.recipients[0].address);\n      if (expectedHopAddress.toLowerCase() !== actualHopAddress.toLowerCase()) {\n        throw new Error('recipient address of txPrebuild does not match hop address');\n      }\n\n      // Convert TransactionRecipient array to Recipient array\n      const recipients: Recipient[] = txParams.recipients.map((r) => {\n        return {\n          address: r.address,\n          amount: typeof r.amount === 'number' ? r.amount.toString() : r.amount,\n        };\n      });\n\n      // Check destination address and amount\n      await this.validateHopPrebuild(wallet, txPrebuild.hopTransaction, { recipients });\n    } else if (txParams.recipients.length > 1) {\n      // Check total amount for batch transaction\n      if (txParams.tokenName) {\n        const expectedTotalAmount = new BigNumber(0);\n        if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n          throw new Error('batch token transaction amount in txPrebuild should be zero for token transfers');\n        }\n      } else {\n        let expectedTotalAmount = new BigNumber(0);\n        for (let i = 0; i < txParams.recipients.length; i++) {\n          expectedTotalAmount = expectedTotalAmount.plus(txParams.recipients[i].amount);\n        }\n        if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n          throw new Error(\n            'batch transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client'\n          );\n        }\n      }\n\n      // Check batch transaction is sent to the batcher contract address for the chain\n      const batcherContractAddress = ethNetwork?.batcherContractAddress;\n      if (\n        !batcherContractAddress ||\n        batcherContractAddress.toLowerCase() !== txPrebuild.recipients[0].address.toLowerCase()\n      ) {\n        throw new Error('recipient address of txPrebuild does not match batcher address');\n      }\n    } else {\n      // Check recipient address and amount for normal transaction\n      if (txParams.recipients.length !== 1) {\n        throw new Error(`normal transaction only supports 1 recipient but ${txParams.recipients.length} found`);\n      }\n      const expectedAmount = new BigNumber(txParams.recipients[0].amount);\n      if (!expectedAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n        throw new Error(\n          'normal transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client'\n        );\n      }\n      if (\n        this.isETHAddress(txParams.recipients[0].address) &&\n        txParams.recipients[0].address !== txPrebuild.recipients[0].address\n      ) {\n        throw new Error('destination address in normal txPrebuild does not match that in txParams supplied by client');\n      }\n    }\n    // Check coin is correct for all transaction types\n    if (!this.verifyCoin(txPrebuild)) {\n      throw new Error(`coin in txPrebuild did not match that in txParams supplied by client`);\n    }\n    return true;\n  }\n\n  /**\n   * Check if address is valid eth address\n   * @param address\n   * @returns {boolean}\n   */\n  private isETHAddress(address: string): boolean {\n    return !!address.match(/0x[a-fA-F0-9]{40}/);\n  }\n\n  /**\n   * Transform message to accommodate specific blockchain requirements.\n   * @param {string} message - the message to prepare\n   * @return {string} the prepared message as a hex encoded string.\n   */\n  encodeMessage(message: string): string {\n    const prefix = `\\u0019Ethereum Signed Message:\\n${message.length}`;\n    return Buffer.from(prefix.concat(message)).toString('hex');\n  }\n\n  /**\n   * Transform the Typed data to accomodate the blockchain requirements (EIP-712)\n   * @param {TypedData} typedData - the typed data to prepare\n   * @return {Buffer} a buffer of the result\n   */\n  encodeTypedData(typedData: TypedData): Buffer {\n    const version = typedData.version;\n    if (version === SignTypedDataVersion.V1) {\n      throw new Error('SignTypedData v1 is not supported due to security concerns');\n    }\n    const typedDataRaw = JSON.parse(typedData.typedDataRaw);\n    const sanitizedData = TypedDataUtils.sanitizeData(typedDataRaw as unknown as TypedMessage<any>);\n    const parts = [Buffer.from('1901', 'hex')];\n    const eip712Domain = 'EIP712Domain';\n    parts.push(TypedDataUtils.hashStruct(eip712Domain, sanitizedData.domain, sanitizedData.types, version));\n\n    if (sanitizedData.primaryType !== eip712Domain) {\n      parts.push(\n        TypedDataUtils.hashStruct(\n          sanitizedData.primaryType as string,\n          sanitizedData.message,\n          sanitizedData.types,\n          version\n        )\n      );\n    }\n    return Buffer.concat(parts);\n  }\n\n  /**\n   * Build the data to transfer an ERC-721 or ERC-1155 token to another address\n   * @param params\n   */\n  buildNftTransferData(params: BuildNftTransferDataOptions): string {\n    const { tokenContractAddress, recipientAddress, fromAddress } = params;\n    switch (params.type) {\n      case 'ERC721': {\n        const tokenId = params.tokenId;\n        const contractData = new ERC721TransferBuilder()\n          .tokenContractAddress(tokenContractAddress)\n          .to(recipientAddress)\n          .from(fromAddress)\n          .tokenId(tokenId)\n          .build();\n        return contractData;\n      }\n\n      case 'ERC1155': {\n        const entries = params.entries;\n        const transferBuilder = new ERC1155TransferBuilder()\n          .tokenContractAddress(tokenContractAddress)\n          .to(recipientAddress)\n          .from(fromAddress);\n\n        for (const entry of entries) {\n          transferBuilder.entry(parseInt(entry.tokenId, 10), entry.amount);\n        }\n\n        return transferBuilder.build();\n      }\n\n      default:\n        throw new Error(`Unsupported NFT type: ${params.type}`);\n    }\n  }\n\n  /**\n   * Fetch the gas price from the explorer\n   * @param {string} wrongChainCoin - the coin that we're getting gas price for\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   */\n  async getGasPriceFromExternalAPI(wrongChainCoin: string, apiKey?: string): Promise<BN> {\n    try {\n      const res = await this.recoveryBlockchainExplorerQuery(\n        {\n          chainid: this.getChainId().toString(),\n          module: 'proxy',\n          action: 'eth_gasPrice',\n        },\n        apiKey\n      );\n      const gasPrice = new BN(res.result.slice(2), 16);\n      console.log(` Got gas price: ${gasPrice}`);\n      return gasPrice;\n    } catch (e) {\n      throw new Error(`Failed to get gas price. Please make sure to use the api key of ${wrongChainCoin}`);\n    }\n  }\n\n  /**\n   * Fetch the gas limit from the explorer\n   * @param intendedChain\n   * @param from\n   * @param to\n   * @param data\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   */\n  async getGasLimitFromExternalAPI(\n    intendedChain: string,\n    from: string,\n    to: string,\n    data: string,\n    apiKey?: string\n  ): Promise<BN> {\n    try {\n      const res = await this.recoveryBlockchainExplorerQuery(\n        {\n          chainid: this.getChainId().toString(),\n          module: 'proxy',\n          action: 'eth_estimateGas',\n          from,\n          to,\n          data,\n        },\n        apiKey\n      );\n      const gasLimit = new BN(res.result.slice(2), 16);\n      console.log(`Got gas limit: ${gasLimit}`);\n      return gasLimit;\n    } catch (e) {\n      throw new Error(\n        `Failed to get gas limit. Please make sure to use the privateKey aka userKey of ${intendedChain} wallet ${to}`\n      );\n    }\n  }\n\n  /**\n   * Get the balance of bitgoFeeAddress to ensure funds are available to pay fees\n   * @param bitgoFeeAddress\n   * @param gasPrice\n   * @param gasLimit\n   * @param apiKey - optional API key to use instead of the one from the environment\n   */\n  async ensureSufficientBalance(bitgoFeeAddress: string, gasPrice: BN, gasLimit: BN, apiKey?: string): Promise<void> {\n    const bitgoFeeAddressBalance = await this.queryAddressBalance(bitgoFeeAddress, apiKey);\n    const totalGasNeeded = Number(gasPrice.mul(gasLimit));\n    const weiToGwei = 10 ** 9;\n    if (bitgoFeeAddressBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Fee address ${bitgoFeeAddress} has balance ${(bitgoFeeAddressBalance / weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some ${this.getChain()} to this address then retry.`\n      );\n    }\n  }\n}\n"]}