@bitgo-beta/abstract-eth 1.2.3-alpha.19 → 1.2.3-alpha.191

package/dist/src/abstractEthLikeNewCoins.js

@@ -0,0 +1,1882 @@
+"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 = void 0;
+/**
+ * @prettier
+ */
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const statics_1 = require("@bitgo-beta/statics");
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const tx_1 = require("@ethereumjs/tx");
+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_1 = __importDefault(require("secp256k1"));
+const abstractEthLikeCoin_1 = require("./abstractEthLikeCoin");
+const ethLikeToken_1 = require("./ethLikeToken");
+const lib_1 = require("./lib");
+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() {
+        var _a;
+        return (_a = this.staticsCoin) === null || _a === void 0 ? void 0 : _a.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) {
+        var _a;
+        // if eip1559 params are specified, default to london hardfork, otherwise,
+        // default to tangerine whistle to avoid replay protection issues
+        const defaultHardfork = !!eip1559 ? 'london' : exports.optionalDeps.EthCommon.Hardfork.TangerineWhistle;
+        const ethLikeCommon = AbstractEthLikeNewCoins.getCustomChainCommon(replayProtectionOptions === null || replayProtectionOptions === void 0 ? void 0 : replayProtectionOptions.chain);
+        ethLikeCommon.setHardfork((_a = replayProtectionOptions === null || replayProtectionOptions === void 0 ? void 0 : replayProtectionOptions.hardfork) !== null && _a !== void 0 ? _a : 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
+     * @returns {BigNumber} address balance
+     */
+    async queryAddressBalance(address) {
+        const result = await this.recoveryBlockchainExplorerQuery({
+            module: 'account',
+            action: 'balance',
+            address: address,
+        });
+        // 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
+     * @returns {Promise<Number>} sequence ID
+     */
+    async querySequenceId(address) {
+        // 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({
+            module: 'proxy',
+            action: 'eth_call',
+            to: address,
+            data: sequenceIdData,
+            tag: 'latest',
+        });
+        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
+     * @returns {Promise<number>}
+     */
+    async getAddressNonce(address) {
+        // Get nonce for backup key (should be 0)
+        let nonce = 0;
+        const result = await this.recoveryBlockchainExplorerQuery({
+            module: 'account',
+            action: 'txlist',
+            address,
+        });
+        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
+     * @returns {Promise<OfflineVaultTxInfo>}
+     */
+    async formatForOfflineVault(txInfo, ethTx, userKey, backupKey, gasPrice, gasLimit, eip1559, replayProtectionOptions) {
+        if (!ethTx.to) {
+            throw new Error('Eth tx must have a `to` address');
+        }
+        const backupHDNode = utxo_lib_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')}`),
+            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) {
+        var _a;
+        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((_a = params.txPrebuild.halfSigned) === null || _a === void 0 ? void 0 : _a.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) {
+        var _a;
+        // 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((_a = this.staticsCoin) === null || _a === void 0 ? void 0 : _a.name)
+            .key(new lib_1.KeyPair({ prv: params.prv }).getKeys().prv);
+        const transaction = await txBuilder.build();
+        const 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,
+        };
+        return { halfSigned: txParams };
+    }
+    /**
+     * Method to validate recovery params
+     * @param {RecoverOptions} params
+     * @returns {void}
+     */
+    validateRecoveryParams(params) {
+        if (lodash_1.default.isUndefined(params.userKey)) {
+            throw new Error('missing userKey');
+        }
+        if (lodash_1.default.isUndefined(params.backupKey)) {
+            throw new Error('missing backupKey');
+        }
+        if (lodash_1.default.isUndefined(params.walletPassphrase) && !params.userKey.startsWith('xpub') && !params.isTss) {
+            throw new Error('missing wallet passphrase');
+        }
+        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');
+        }
+    }
+    /**
+     * Method to sign tss recovery transaction
+     * @param {ECDSA.KeyCombined} userKeyCombined
+     * @param {ECDSA.KeyCombined} backupKeyCombined
+     * @param {string} txHex
+     * @param {Object} options
+     * @param {EcdsaTypes.SerializedNtilde} options.rangeProofChallenge
+     * @returns {Promise<ECDSAMethodTypes.Signature>}
+     */
+    async signRecoveryTSS(userKeyCombined, backupKeyCombined, txHex, openSSLBytes, { rangeProofChallenge, } = {}) {
+        if (!userKeyCombined || !backupKeyCombined) {
+            throw new Error('Missing key combined shares for user or backup');
+        }
+        const MPC = new sdk_core_1.Ecdsa();
+        const signerOneIndex = userKeyCombined.xShare.i;
+        const signerTwoIndex = backupKeyCombined.xShare.i;
+        rangeProofChallenge =
+            rangeProofChallenge !== null && rangeProofChallenge !== void 0 ? rangeProofChallenge : sdk_lib_mpc_1.EcdsaTypes.serializeNtildeWithProofs(await sdk_lib_mpc_1.EcdsaRangeProof.generateNtilde(openSSLBytes));
+        const userToBackupPaillierChallenge = await sdk_lib_mpc_1.EcdsaPaillierProof.generateP((0, sdk_core_1.hexToBigInt)(userKeyCombined.yShares[signerTwoIndex].n));
+        const backupToUserPaillierChallenge = await sdk_lib_mpc_1.EcdsaPaillierProof.generateP((0, sdk_core_1.hexToBigInt)(backupKeyCombined.yShares[signerOneIndex].n));
+        const userXShare = MPC.appendChallenge(userKeyCombined.xShare, rangeProofChallenge, sdk_lib_mpc_1.EcdsaTypes.serializePaillierChallenge({ p: userToBackupPaillierChallenge }));
+        const userYShare = MPC.appendChallenge(userKeyCombined.yShares[signerTwoIndex], rangeProofChallenge, sdk_lib_mpc_1.EcdsaTypes.serializePaillierChallenge({ p: backupToUserPaillierChallenge }));
+        const backupXShare = MPC.appendChallenge(backupKeyCombined.xShare, rangeProofChallenge, sdk_lib_mpc_1.EcdsaTypes.serializePaillierChallenge({ p: backupToUserPaillierChallenge }));
+        const backupYShare = MPC.appendChallenge(backupKeyCombined.yShares[signerOneIndex], rangeProofChallenge, sdk_lib_mpc_1.EcdsaTypes.serializePaillierChallenge({ p: userToBackupPaillierChallenge }));
+        const signShares = await MPC.signShare(userXShare, userYShare);
+        const signConvertS21 = await MPC.signConvertStep1({
+            xShare: backupXShare,
+            yShare: backupYShare,
+            kShare: signShares.kShare,
+        });
+        const signConvertS12 = await MPC.signConvertStep2({
+            aShare: signConvertS21.aShare,
+            wShare: signShares.wShare,
+        });
+        const signConvertS21_2 = await MPC.signConvertStep3({
+            muShare: signConvertS12.muShare,
+            bShare: signConvertS21.bShare,
+        });
+        const [signCombineOne, signCombineTwo] = [
+            MPC.signCombine({
+                gShare: signConvertS12.gShare,
+                signIndex: {
+                    i: signConvertS12.muShare.i,
+                    j: signConvertS12.muShare.j,
+                },
+            }),
+            MPC.signCombine({
+                gShare: signConvertS21_2.gShare,
+                signIndex: {
+                    i: signConvertS21_2.signIndex.i,
+                    j: signConvertS21_2.signIndex.j,
+                },
+            }),
+        ];
+        const MESSAGE = Buffer.from(txHex, 'hex');
+        const [signA, signB] = [
+            MPC.sign(MESSAGE, signCombineOne.oShare, signCombineTwo.dShare, (0, keccak_1.default)('keccak256')),
+            MPC.sign(MESSAGE, signCombineTwo.oShare, signCombineOne.dShare, (0, keccak_1.default)('keccak256')),
+        ];
+        return MPC.constructSignature([signA, signB]);
+    }
+    /**
+     * Helper which combines key shares of user and backup
+     * @param {string} userPublicOrPrivateKeyShare
+     * @param {string} backupPrivateOrPublicKeyShare
+     * @param {string} walletPassphrase
+     * @returns {[ECDSAMethodTypes.KeyCombined, ECDSAMethodTypes.KeyCombined]}
+     */
+    getKeyCombinedFromTssKeyShares(userPublicOrPrivateKeyShare, backupPrivateOrPublicKeyShare, walletPassphrase) {
+        let backupPrv;
+        let userPrv;
+        try {
+            backupPrv = this.bitgo.decrypt({
+                input: backupPrivateOrPublicKeyShare,
+                password: walletPassphrase,
+            });
+            userPrv = this.bitgo.decrypt({
+                input: userPublicOrPrivateKeyShare,
+                password: walletPassphrase,
+            });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting backup keychain: ${e.message}`);
+        }
+        const userSigningMaterial = JSON.parse(userPrv);
+        const backupSigningMaterial = JSON.parse(backupPrv);
+        if (!userSigningMaterial.backupNShare) {
+            throw new Error('Invalid user key - missing backupNShare');
+        }
+        if (!backupSigningMaterial.userNShare) {
+            throw new Error('Invalid backup key - missing userNShare');
+        }
+        const MPC = new sdk_core_1.Ecdsa();
+        const userKeyCombined = MPC.keyCombine(userSigningMaterial.pShare, [
+            userSigningMaterial.bitgoNShare,
+            userSigningMaterial.backupNShare,
+        ]);
+        const userSigningKeyDerived = MPC.keyDerive(userSigningMaterial.pShare, [userSigningMaterial.bitgoNShare, userSigningMaterial.backupNShare], 'm/0');
+        const userKeyDerivedCombined = {
+            xShare: userSigningKeyDerived.xShare,
+            yShares: userKeyCombined.yShares,
+        };
+        const backupKeyCombined = MPC.keyCombine(backupSigningMaterial.pShare, [
+            userSigningKeyDerived.nShares[2],
+            backupSigningMaterial.bitgoNShare,
+        ]);
+        if (userKeyDerivedCombined.xShare.y !== backupKeyCombined.xShare.y ||
+            userKeyDerivedCombined.xShare.chaincode !== backupKeyCombined.xShare.chaincode) {
+            throw new Error('Common keychains do not match');
+        }
+        return [userKeyDerivedCombined, backupKeyCombined];
+    }
+    /**
+     * 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, params.openSSLBytes);
+        }
+        return this.recoverEthLike(params);
+    }
+    /**
+     * 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) {
+        var _a, _b, _c;
+        // 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 = (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 = utxo_lib_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);
+        // get balance of backupKey to ensure funds are available to pay fees
+        const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress);
+        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 (((_a = this.staticsCoin) === null || _a === void 0 ? void 0 : _a.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);
+        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((_b = this.staticsCoin) === null || _b === void 0 ? void 0 : _b.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((_c = this.staticsCoin) === null || _c === void 0 ? void 0 : _c.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(),
+        };
+    }
+    /**
+     * 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) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.validateEvmBasedRecoveryParams(params);
+        // Clean up whitespace from entered values
+        const userKey = params.userKey.replace(/\s/g, '');
+        const bitgoFeeAddress = (_a = params.bitgoFeeAddress) === null || _a === void 0 ? void 0 : _a.replace(/\s/g, '').toLowerCase();
+        const bitgoDestinationAddress = (_b = params.bitgoDestinationAddress) === null || _b === void 0 ? void 0 : _b.replace(/\s/g, '').toLowerCase();
+        const recoveryDestination = (_c = params.recoveryDestination) === null || _c === void 0 ? void 0 : _c.replace(/\s/g, '').toLowerCase();
+        const walletContractAddress = (_d = params.walletContractAddress) === null || _d === void 0 ? void 0 : _d.replace(/\s/g, '').toLowerCase();
+        const tokenContractAddress = (_e = params.tokenContractAddress) === null || _e === void 0 ? void 0 : _e.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');
+            }
+        }
+        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));
+        const bitgoFeeAddressNonce = await this.getAddressNonce(bitgoFeeAddress);
+        // get balance of bitgoFeeAddress to ensure funds are available to pay fees
+        const bitgoFeeAddressBalance = await this.queryAddressBalance(bitgoFeeAddress);
+        const totalGasNeeded = 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.`);
+        }
+        if (tokenContractAddress) {
+            return this.recoverEthLikeTokenforEvmBasedRecovery(params, bitgoFeeAddressNonce, gasLimit, gasPrice, userKey, userSigningKey);
+        }
+        // get balance of wallet
+        const txAmount = await this.queryAddressBalance(walletContractAddress);
+        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);
+        const txInfo = {
+            recipients: recipients,
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            gasLimit: gasLimit.toString(10),
+            isEvmBasedCrossChainRecovery: true,
+        };
+        const network = this.getNetwork();
+        const batcherContractAddress = network === null || network === void 0 ? void 0 : 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((_f = this.staticsCoin) === null || _f === void 0 ? void 0 : _f.name)
+                .amount(batchExecutionInfo.totalAmount)
+                .contractSequenceId(sequenceId)
+                .expirationTime(this.getDefaultExpireTime())
+                .to(recoveryDestination);
+        }
+        else {
+            transferBuilder
+                .coin((_g = this.staticsCoin) === null || _g === void 0 ? void 0 : _g.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);
+        }
+        const tx = await txBuilder.build();
+        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,
+        };
+        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
+     * @returns {BigNumber} token balaance in base units
+     */
+    async queryAddressTokenBalance(tokenContractAddress, walletContractAddress) {
+        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({
+            module: 'account',
+            action: 'tokenbalance',
+            contractaddress: tokenContractAddress,
+            address: walletContractAddress,
+            tag: 'latest',
+        });
+        // 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) {
+        var _a, _b, _c;
+        // get token balance of wallet
+        const txAmount = await this.queryAddressTokenBalance(params.tokenContractAddress, params.walletContractAddress);
+        // 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 txInfo = {
+            recipients: recipients,
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            gasLimit: gasLimit.toString(10),
+            isEvmBasedCrossChainRecovery: true,
+        };
+        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 = (_b = (0, lib_1.getToken)(params.tokenContractAddress, network, (_a = this.staticsCoin) === null || _a === void 0 ? void 0 : _a.family)) === null || _b === void 0 ? void 0 : _b.name;
+        transferBuilder
+            .amount(txAmount)
+            .contractSequenceId(sequenceId)
+            .expirationTime(this.getDefaultExpireTime())
+            .to(params.recoveryDestination);
+        if (token) {
+            transferBuilder.coin(token);
+        }
+        else {
+            transferBuilder
+                .coin((_c = this.staticsCoin) === null || _c === void 0 ? void 0 : _c.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);
+        }
+        const tx = await txBuilder.build();
+        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,
+        };
+        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, openSSLBytes) {
+        this.validateRecoveryParams(params);
+        // Clean up whitespace from entered values
+        const userPublicOrPrivateKeyShare = params.userKey.replace(/\s/g, '');
+        const backupPrivateOrPublicKeyShare = 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 ((0, sdk_core_1.getIsUnsignedSweep)({
+            userKey: userPublicOrPrivateKeyShare,
+            backupKey: backupPrivateOrPublicKeyShare,
+            isTss: params.isTss,
+        })) {
+            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);
+        }
+        else {
+            const isGG18SigningMaterial = sdk_core_1.ECDSAUtils.isGG18SigningMaterial(userPublicOrPrivateKeyShare, params.walletPassphrase);
+            let signature;
+            let unsignedTx;
+            if (isGG18SigningMaterial) {
+                const [userKeyCombined, backupKeyCombined] = this.getKeyCombinedFromTssKeyShares(userPublicOrPrivateKeyShare, backupPrivateOrPublicKeyShare, params.walletPassphrase);
+                const backupKeyPair = new lib_1.KeyPair({ pub: backupKeyCombined.xShare.y });
+                const baseAddress = backupKeyPair.getAddress();
+                unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;
+                signature = await this.signRecoveryTSS(userKeyCombined, backupKeyCombined, unsignedTx.getMessageToSign(false).toString('hex'), openSSLBytes);
+            }
+            else {
+                const { userKeyShare, backupKeyShare, commonKeyChain } = await sdk_core_1.ECDSAUtils.getMpcV2RecoveryKeyShares(userPublicOrPrivateKeyShare, backupPrivateOrPublicKeyShare, params.walletPassphrase);
+                const MPC = new sdk_core_1.Ecdsa();
+                const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm');
+                const backupKeyPair = new lib_1.KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+                const baseAddress = backupKeyPair.getAddress();
+                unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;
+                const messageHash = unsignedTx.getMessageToSign(true);
+                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 buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params) {
+        const nonce = await this.getAddressNonce(baseAddress);
+        const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit);
+        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) {
+        const baseAddressBalance = await this.queryAddressBalance(baseAddress);
+        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;
+    }
+    async recoveryBlockchainExplorerQuery(query) {
+        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 = utxo_lib_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_1.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 = utxo_lib_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_1.default.ecdsaVerify(sig, messageBuffer, serverPubkeyBuffer);
+        if (!isValidSignature) {
+            throw new Error(`Hop txid signature invalid - pub: ${serverXpub}, msg: ${messageBuffer === null || messageBuffer === void 0 ? void 0 : messageBuffer.toString()}, sig: ${signatureBuffer === null || signatureBuffer === void 0 ? void 0 : 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 = utxo_lib_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 === null || coinSpecific === void 0 ? void 0 : 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) {
+            return true;
+        }
+        else {
+            const ethNetwork = this.getNetwork();
+            const forwarderFactoryAddress = ethNetwork === null || ethNetwork === void 0 ? void 0 : ethNetwork.forwarderFactoryAddress;
+            const forwarderImplementationAddress = ethNetwork === null || ethNetwork === void 0 ? void 0 : 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) {
+        return txPrebuild.coin === this.getChain();
+    }
+    /**
+     * 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}
+     */
+    verifyTssTransaction(params) {
+        var _a;
+        const { txParams, txPrebuild, wallet } = params;
+        if (!(txParams === null || txParams === void 0 ? void 0 : txParams.recipients) &&
+            !(((_a = txParams.prebuildTx) === null || _a === void 0 ? void 0 : _a.consolidateId) ||
+                (txParams.type && ['acceleration', 'fillNonce', 'transferToken'].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`);
+        }
+        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 === null || txParams === void 0 ? void 0 : txParams.recipients) || !(txPrebuild === null || txPrebuild === void 0 ? void 0 : 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(`txPrebuild should only have 1 recipient but ${txPrebuild.recipients.length} found`);
+        }
+        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
+            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 === null || ethNetwork === void 0 ? void 0 : 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.
+     */
+    encodeMessage(message) {
+        const prefix = `\u0019Ethereum Signed Message:\n${message.length}`;
+        return prefix.concat(message);
+    }
+    /**
+     * 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();
+            }
+        }
+    }
+}
+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  Ecdsa,\n  ECDSAMethodTypes,\n  EthereumLibraryUnavailableError,\n  FeeEstimateOptions,\n  FullySignedTransaction,\n  getIsUnsignedSweep,\n  HalfSignedTransaction,\n  hexToBigInt,\n  InvalidAddressError,\n  InvalidAddressVerificationObjectPropertyError,\n  IWallet,\n  KeyPair,\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  Util,\n  VerifyAddressOptions as BaseVerifyAddressOptions,\n  VerifyTransactionOptions,\n  Wallet,\n  ECDSAUtils,\n} from '@bitgo-beta/sdk-core';\nimport { EcdsaPaillierProof, EcdsaRangeProof, EcdsaTypes } from '@bitgo-beta/sdk-lib-mpc';\nimport {\n  BaseCoin as StaticsBaseCoin,\n  CoinMap,\n  coins,\n  EthereumNetwork as EthLikeNetwork,\n  ethGasConfigs,\n} from '@bitgo-beta/statics';\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport type * as EthLikeCommon from '@ethereumjs/common';\nimport type * as EthLikeTxLib from '@ethereumjs/tx';\nimport { FeeMarketEIP1559Transaction, Transaction as LegacyTransaction } from '@ethereumjs/tx';\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, stripHexPrefix } 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  getCommon,\n  getProxyInitcode,\n  getToken,\n  KeyPair as KeyPairLib,\n  TransactionBuilder,\n  TransferBuilder,\n} from './lib';\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  };\n  gasLimit: number;\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}\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}\n\ninterface UnformattedTxInfo {\n  recipient: Recipient;\n}\n\nexport type RecoverOptionsWithBytes = {\n  isTss: true;\n  openSSLBytes: Uint8Array;\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} & 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}\n\ninterface 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 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 tangerine whistle to avoid replay protection issues\n    const defaultHardfork = !!eip1559 ? 'london' : optionalDeps.EthCommon.Hardfork.TangerineWhistle;\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   * @returns {BigNumber} address balance\n   */\n  async queryAddressBalance(address: string): Promise<any> {\n    const result = await this.recoveryBlockchainExplorerQuery({\n      module: 'account',\n      action: 'balance',\n      address: address,\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   * @returns {Promise<Number>} sequence ID\n   */\n  async querySequenceId(address: 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      module: 'proxy',\n      action: 'eth_call',\n      to: address,\n      data: sequenceIdData,\n      tag: 'latest',\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   * @returns {Promise<number>}\n   */\n  async getAddressNonce(address: string): Promise<number> {\n    // Get nonce for backup key (should be 0)\n    let nonce = 0;\n\n    const result = await this.recoveryBlockchainExplorerQuery({\n      module: 'account',\n      action: 'txlist',\n      address,\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   * @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  ): 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      ),\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    const transaction = await txBuilder.build();\n\n    const recipients = transaction.outputs.map((output) => ({ address: output.address, amount: output.value }));\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    };\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 (_.isUndefined(params.userKey)) {\n      throw new Error('missing userKey');\n    }\n\n    if (_.isUndefined(params.backupKey)) {\n      throw new Error('missing backupKey');\n    }\n\n    if (_.isUndefined(params.walletPassphrase) && !params.userKey.startsWith('xpub') && !params.isTss) {\n      throw new Error('missing wallet passphrase');\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   * Method to sign tss recovery transaction\n   * @param {ECDSA.KeyCombined} userKeyCombined\n   * @param {ECDSA.KeyCombined} backupKeyCombined\n   * @param {string} txHex\n   * @param {Object} options\n   * @param {EcdsaTypes.SerializedNtilde} options.rangeProofChallenge\n   * @returns {Promise<ECDSAMethodTypes.Signature>}\n   */\n  private async signRecoveryTSS(\n    userKeyCombined: ECDSA.KeyCombined,\n    backupKeyCombined: ECDSA.KeyCombined,\n    txHex: string,\n    openSSLBytes: Uint8Array,\n    {\n      rangeProofChallenge,\n    }: {\n      rangeProofChallenge?: EcdsaTypes.SerializedNtilde;\n    } = {}\n  ): Promise<ECDSAMethodTypes.Signature> {\n    if (!userKeyCombined || !backupKeyCombined) {\n      throw new Error('Missing key combined shares for user or backup');\n    }\n\n    const MPC = new Ecdsa();\n    const signerOneIndex = userKeyCombined.xShare.i;\n    const signerTwoIndex = backupKeyCombined.xShare.i;\n\n    rangeProofChallenge =\n      rangeProofChallenge ?? EcdsaTypes.serializeNtildeWithProofs(await EcdsaRangeProof.generateNtilde(openSSLBytes));\n\n    const userToBackupPaillierChallenge = await EcdsaPaillierProof.generateP(\n      hexToBigInt(userKeyCombined.yShares[signerTwoIndex].n)\n    );\n    const backupToUserPaillierChallenge = await EcdsaPaillierProof.generateP(\n      hexToBigInt(backupKeyCombined.yShares[signerOneIndex].n)\n    );\n\n    const userXShare = MPC.appendChallenge(\n      userKeyCombined.xShare,\n      rangeProofChallenge,\n      EcdsaTypes.serializePaillierChallenge({ p: userToBackupPaillierChallenge })\n    );\n    const userYShare = MPC.appendChallenge(\n      userKeyCombined.yShares[signerTwoIndex],\n      rangeProofChallenge,\n      EcdsaTypes.serializePaillierChallenge({ p: backupToUserPaillierChallenge })\n    );\n    const backupXShare = MPC.appendChallenge(\n      backupKeyCombined.xShare,\n      rangeProofChallenge,\n      EcdsaTypes.serializePaillierChallenge({ p: backupToUserPaillierChallenge })\n    );\n    const backupYShare = MPC.appendChallenge(\n      backupKeyCombined.yShares[signerOneIndex],\n      rangeProofChallenge,\n      EcdsaTypes.serializePaillierChallenge({ p: userToBackupPaillierChallenge })\n    );\n\n    const signShares: ECDSA.SignShareRT = await MPC.signShare(userXShare, userYShare);\n\n    const signConvertS21 = await MPC.signConvertStep1({\n      xShare: backupXShare,\n      yShare: backupYShare, // YShare corresponding to the other participant signerOne\n      kShare: signShares.kShare,\n    });\n    const signConvertS12 = await MPC.signConvertStep2({\n      aShare: signConvertS21.aShare,\n      wShare: signShares.wShare,\n    });\n    const signConvertS21_2 = await MPC.signConvertStep3({\n      muShare: signConvertS12.muShare,\n      bShare: signConvertS21.bShare,\n    });\n\n    const [signCombineOne, signCombineTwo] = [\n      MPC.signCombine({\n        gShare: signConvertS12.gShare,\n        signIndex: {\n          i: signConvertS12.muShare.i,\n          j: signConvertS12.muShare.j,\n        },\n      }),\n      MPC.signCombine({\n        gShare: signConvertS21_2.gShare,\n        signIndex: {\n          i: signConvertS21_2.signIndex.i,\n          j: signConvertS21_2.signIndex.j,\n        },\n      }),\n    ];\n\n    const MESSAGE = Buffer.from(txHex, 'hex');\n\n    const [signA, signB] = [\n      MPC.sign(MESSAGE, signCombineOne.oShare, signCombineTwo.dShare, Keccak('keccak256')),\n      MPC.sign(MESSAGE, signCombineTwo.oShare, signCombineOne.dShare, Keccak('keccak256')),\n    ];\n\n    return MPC.constructSignature([signA, signB]);\n  }\n\n  /**\n   * Helper which combines key shares of user and backup\n   * @param {string} userPublicOrPrivateKeyShare\n   * @param {string} backupPrivateOrPublicKeyShare\n   * @param {string} walletPassphrase\n   * @returns {[ECDSAMethodTypes.KeyCombined, ECDSAMethodTypes.KeyCombined]}\n   */\n  private getKeyCombinedFromTssKeyShares(\n    userPublicOrPrivateKeyShare: string,\n    backupPrivateOrPublicKeyShare: string,\n    walletPassphrase?: string\n  ): [ECDSAMethodTypes.KeyCombined, ECDSAMethodTypes.KeyCombined] {\n    let backupPrv;\n    let userPrv;\n    try {\n      backupPrv = this.bitgo.decrypt({\n        input: backupPrivateOrPublicKeyShare,\n        password: walletPassphrase,\n      });\n      userPrv = this.bitgo.decrypt({\n        input: userPublicOrPrivateKeyShare,\n        password: walletPassphrase,\n      });\n    } catch (e) {\n      throw new Error(`Error decrypting backup keychain: ${e.message}`);\n    }\n\n    const userSigningMaterial = JSON.parse(userPrv) as ECDSAMethodTypes.SigningMaterial;\n    const backupSigningMaterial = JSON.parse(backupPrv) as ECDSAMethodTypes.SigningMaterial;\n\n    if (!userSigningMaterial.backupNShare) {\n      throw new Error('Invalid user key - missing backupNShare');\n    }\n\n    if (!backupSigningMaterial.userNShare) {\n      throw new Error('Invalid backup key - missing userNShare');\n    }\n\n    const MPC = new Ecdsa();\n\n    const userKeyCombined = MPC.keyCombine(userSigningMaterial.pShare, [\n      userSigningMaterial.bitgoNShare,\n      userSigningMaterial.backupNShare,\n    ]);\n    const userSigningKeyDerived = MPC.keyDerive(\n      userSigningMaterial.pShare,\n      [userSigningMaterial.bitgoNShare, userSigningMaterial.backupNShare],\n      'm/0'\n    );\n    const userKeyDerivedCombined = {\n      xShare: userSigningKeyDerived.xShare,\n      yShares: userKeyCombined.yShares,\n    };\n    const backupKeyCombined = MPC.keyCombine(backupSigningMaterial.pShare, [\n      userSigningKeyDerived.nShares[2],\n      backupSigningMaterial.bitgoNShare,\n    ]);\n    if (\n      userKeyDerivedCombined.xShare.y !== backupKeyCombined.xShare.y ||\n      userKeyDerivedCombined.xShare.chaincode !== backupKeyCombined.xShare.chaincode\n    ) {\n      throw new Error('Common keychains do not match');\n    }\n    return [userKeyDerivedCombined, backupKeyCombined];\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> {\n    if (params.isTss === true) {\n      return this.recoverTSS(params, params.openSSLBytes);\n    }\n    return this.recoverEthLike(params);\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 = 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);\n    // get balance of backupKey to ensure funds are available to pay fees\n    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress);\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);\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  /**\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    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    const bitgoFeeAddressNonce = await this.getAddressNonce(bitgoFeeAddress);\n\n    // get balance of bitgoFeeAddress to ensure funds are available to pay fees\n    const bitgoFeeAddressBalance = await this.queryAddressBalance(bitgoFeeAddress);\n    const totalGasNeeded = 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    if (tokenContractAddress) {\n      return this.recoverEthLikeTokenforEvmBasedRecovery(\n        params,\n        bitgoFeeAddressNonce,\n        gasLimit,\n        gasPrice,\n        userKey,\n        userSigningKey\n      );\n    }\n\n    // get balance of wallet\n    const txAmount = await this.queryAddressBalance(walletContractAddress);\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);\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 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    const tx = await txBuilder.build();\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    };\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   * @returns {BigNumber} token balaance in base units\n   */\n  async queryAddressTokenBalance(tokenContractAddress: string, walletContractAddress: string): 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      module: 'account',\n      action: 'tokenbalance',\n      contractaddress: tokenContractAddress,\n      address: walletContractAddress,\n      tag: 'latest',\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  ) {\n    // get token balance of wallet\n    const txAmount = await this.queryAddressTokenBalance(\n      params.tokenContractAddress as string,\n      params.walletContractAddress\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 txInfo = {\n      recipients: recipients,\n      expireTime: this.getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      gasLimit: gasLimit.toString(10),\n      isEvmBasedCrossChainRecovery: true,\n    };\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    const tx = await txBuilder.build();\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    };\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    openSSLBytes: Uint8Array\n  ): Promise<RecoveryInfo | OfflineVaultTxInfo> {\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    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 (\n      getIsUnsignedSweep({\n        userKey: userPublicOrPrivateKeyShare,\n        backupKey: backupPrivateOrPublicKeyShare,\n        isTss: params.isTss,\n      })\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    } else {\n      const isGG18SigningMaterial = ECDSAUtils.isGG18SigningMaterial(\n        userPublicOrPrivateKeyShare,\n        params.walletPassphrase\n      );\n      let signature: ECDSAMethodTypes.Signature;\n      let unsignedTx: EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction;\n      if (isGG18SigningMaterial) {\n        const [userKeyCombined, backupKeyCombined] = this.getKeyCombinedFromTssKeyShares(\n          userPublicOrPrivateKeyShare,\n          backupPrivateOrPublicKeyShare,\n          params.walletPassphrase\n        );\n        const backupKeyPair = new KeyPairLib({ pub: backupKeyCombined.xShare.y });\n        const baseAddress = backupKeyPair.getAddress();\n\n        unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;\n\n        signature = await this.signRecoveryTSS(\n          userKeyCombined,\n          backupKeyCombined,\n          unsignedTx.getMessageToSign(false).toString('hex'),\n          openSSLBytes\n        );\n      } else {\n        const { userKeyShare, backupKeyShare, commonKeyChain } = await ECDSAUtils.getMpcV2RecoveryKeyShares(\n          userPublicOrPrivateKeyShare,\n          backupPrivateOrPublicKeyShare,\n          params.walletPassphrase\n        );\n\n        const MPC = new Ecdsa();\n        const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm');\n        const backupKeyPair = new KeyPairLib({ pub: derivedCommonKeyChain.slice(0, 66) });\n        const baseAddress = backupKeyPair.getAddress();\n\n        unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;\n\n        const messageHash = unsignedTx.getMessageToSign(true);\n\n        signature = await ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);\n      }\n\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 buildTssRecoveryTxn(baseAddress: string, gasPrice: any, gasLimit: any, params: RecoverOptions) {\n    const nonce = await this.getAddressNonce(baseAddress);\n    const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit);\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) {\n    const baseAddressBalance = await this.queryAddressBalance(baseAddress);\n\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\n    const txAmount = baseAddressBalance.sub(totalGasNeeded);\n    return txAmount;\n  }\n\n  async recoveryBlockchainExplorerQuery(query: Record<string, 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      },\n      gasLimit,\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  private 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) {\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    return txPrebuild.coin === this.getChain();\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  verifyTssTransaction(params: VerifyEthTransactionOptions): boolean {\n    const { txParams, txPrebuild, wallet } = params;\n    if (\n      !txParams?.recipients &&\n      !(\n        txParams.prebuildTx?.consolidateId ||\n        (txParams.type && ['acceleration', 'fillNonce', 'transferToken'].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    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(`txPrebuild should only have 1 recipient but ${txPrebuild.recipients.length} found`);\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      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      // 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.\n   */\n  encodeMessage(message: string): string {\n    const prefix = `\\u0019Ethereum Signed Message:\\n${message.length}`;\n    return prefix.concat(message);\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  }\n}\n"]}