@bitgo-beta/abstract-eth 1.0.2-beta.234 → 1.0.2-beta.2340

package/dist/src/abstractEthLikeNewCoins.js

@@ -0,0 +1,2891 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractEthLikeNewCoins = exports.optionalDeps = exports.DEFAULT_SCAN_FACTOR = void 0;
+exports.isVerifyContractBaseAddressOptions = isVerifyContractBaseAddressOptions;
+/**
+ * @prettier
+ */
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const statics_1 = require("@bitgo-beta/statics");
+const tx_1 = require("@ethereumjs/tx");
+const rlp_1 = require("@ethereumjs/rlp");
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const bignumber_js_1 = require("bignumber.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const crypto_1 = require("crypto");
+const debug_1 = __importDefault(require("debug"));
+const ethereumjs_util_1 = require("ethereumjs-util");
+const keccak_1 = __importDefault(require("keccak"));
+const lodash_1 = __importDefault(require("lodash"));
+const secp256k1_2 = __importDefault(require("secp256k1"));
+const abstractEthLikeCoin_1 = require("./abstractEthLikeCoin");
+const ethLikeToken_1 = require("./ethLikeToken");
+const lib_1 = require("./lib");
+exports.DEFAULT_SCAN_FACTOR = 20;
+/**
+ * Type guard to check if params are for BIP32 base address verification (V1, V2, V4)
+ * These wallet versions use ethAddress for address derivation
+ */
+function isVerifyContractBaseAddressOptions(params) {
+    return ((params.walletVersion === 1 || params.walletVersion === 2 || params.walletVersion === 4) &&
+        'keychains' in params &&
+        Array.isArray(params.keychains) &&
+        params.keychains.length === 3 &&
+        params.keychains.every((kc) => 'ethAddress' in kc && typeof kc.ethAddress === 'string'));
+}
+const debug = (0, debug_1.default)('bitgo:v2:ethlike');
+let erc7984WrappersByUnderlying;
+/**
+ * Lowercased wrapper (spender) addresses of every registered ERC-7984 shield pair, keyed by the lowercased
+ * address of the pair's underlying ERC-20. Statics is static for the lifetime of the process, so this is
+ * computed once.
+ */
+function getErc7984WrappersByUnderlying() {
+    if (!erc7984WrappersByUnderlying) {
+        const byUnderlying = new Map();
+        statics_1.coins.forEach((coin) => {
+            if (coin instanceof statics_1.Erc7984Coin && coin.underlyingErc20Address && coin.contractAddress) {
+                const underlying = coin.underlyingErc20Address.toLowerCase();
+                const wrappers = byUnderlying.get(underlying) ?? new Set();
+                wrappers.add(coin.contractAddress.toLowerCase());
+                byUnderlying.set(underlying, wrappers);
+            }
+        });
+        erc7984WrappersByUnderlying = byUnderlying;
+    }
+    return erc7984WrappersByUnderlying;
+}
+exports.optionalDeps = {
+    get ethAbi() {
+        try {
+            return require('ethereumjs-abi');
+        }
+        catch (e) {
+            debug('unable to load ethereumjs-abi:');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`ethereumjs-abi`);
+        }
+    },
+    get ethUtil() {
+        try {
+            return require('ethereumjs-util');
+        }
+        catch (e) {
+            debug('unable to load ethereumjs-util:');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`ethereumjs-util`);
+        }
+    },
+    get EthTx() {
+        try {
+            return require('@ethereumjs/tx');
+        }
+        catch (e) {
+            debug('unable to load @ethereumjs/tx');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`@ethereumjs/tx`);
+        }
+    },
+    get EthCommon() {
+        try {
+            return require('@ethereumjs/common');
+        }
+        catch (e) {
+            debug('unable to load @ethereumjs/common:');
+            debug(e.stack);
+            throw new sdk_core_1.EthereumLibraryUnavailableError(`@ethereumjs/common`);
+        }
+    },
+};
+class AbstractEthLikeNewCoins extends abstractEthLikeCoin_1.AbstractEthLikeCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
+        /**
+         * Get the data required to make an ETH function call defined by the given types and values
+         *
+         * @param {string} functionName - The name of the function being called, e.g. transfer
+         * @param types The types of the function call in order
+         * @param values The values of the function call in order
+         * @return {Buffer} The combined data for the function call
+         */
+        this.getMethodCallData = (functionName, types, values) => {
+            return Buffer.concat([
+                // function signature
+                exports.optionalDeps.ethAbi.methodID(functionName, types),
+                // function arguments
+                exports.optionalDeps.ethAbi.rawEncode(types, values),
+            ]);
+        };
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this.staticsCoin = staticsCoin;
+        this.sendMethodName = 'sendMultiSig';
+    }
+    /**
+     * Method to return the coin's network object
+     * @returns {EthLikeNetwork | undefined}
+     */
+    getNetwork() {
+        return this.staticsCoin?.network;
+    }
+    /**
+     * Evaluates whether an address string is valid for this coin
+     * @param {string} address
+     * @returns {boolean} True if address is the valid ethlike adderss
+     */
+    isValidAddress(address) {
+        return exports.optionalDeps.ethUtil.isValidAddress(exports.optionalDeps.ethUtil.addHexPrefix(address));
+    }
+    /**
+     * Flag for sending data along with transactions
+     * @returns {boolean} True if okay to send tx data (ETH), false otherwise
+     */
+    transactionDataAllowed() {
+        return true;
+    }
+    /** @inheritDoc */
+    supportsMessageSigning() {
+        return true;
+    }
+    /** @inheritDoc */
+    supportsSigningTypedData() {
+        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.coins.coinNameFromChainId(chainId);
+        if (!coinName) {
+            throw new statics_1.ChainIdNotFoundError(chainId);
+        }
+        const coin = statics_1.coins.get(coinName);
+        const ethLikeCommon = (0, lib_1.getCommon)(coin.network);
+        return ethLikeCommon;
+    }
+    /**
+     * Gets correct Eth Common object based on params from either recovery or tx building
+     * @param {EIP1559} eip1559 - configs that specify whether we should construct an eip1559 tx
+     * @param {ReplayProtectionOptions} replayProtectionOptions - check if chain id supports replay protection
+     * @returns {EthLikeCommon.default}
+     */
+    static getEthLikeCommon(eip1559, replayProtectionOptions) {
+        // if eip1559 params are specified, default to london hardfork, otherwise,
+        // default to petersburg to avoid replay protection issues
+        const defaultHardfork = !!eip1559 ? 'london' : exports.optionalDeps.EthCommon.Hardfork.Petersburg;
+        const ethLikeCommon = AbstractEthLikeNewCoins.getCustomChainCommon(replayProtectionOptions?.chain);
+        ethLikeCommon.setHardfork(replayProtectionOptions?.hardfork ?? defaultHardfork);
+        return ethLikeCommon;
+    }
+    /**
+     * Method to build the tx object
+     * @param {BuildTransactionParams} params - params to build transaction
+     * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}
+     */
+    static buildTransaction(params) {
+        // if eip1559 params are specified, default to london hardfork, otherwise,
+        // default to tangerine whistle to avoid replay protection issues
+        const ethLikeCommon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);
+        const baseParams = {
+            to: params.to,
+            nonce: params.nonce,
+            value: params.value,
+            data: params.data,
+            gasLimit: new exports.optionalDeps.ethUtil.BN(params.gasLimit),
+        };
+        const unsignedEthTx = !!params.eip1559
+            ? exports.optionalDeps.EthTx.FeeMarketEIP1559Transaction.fromTxData({
+                ...baseParams,
+                maxFeePerGas: new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas),
+                maxPriorityFeePerGas: new exports.optionalDeps.ethUtil.BN(params.eip1559.maxPriorityFeePerGas),
+            }, { common: ethLikeCommon })
+            : exports.optionalDeps.EthTx.Transaction.fromTxData({
+                ...baseParams,
+                gasPrice: new exports.optionalDeps.ethUtil.BN(params.gasPrice),
+            }, { common: ethLikeCommon });
+        return unsignedEthTx;
+    }
+    /**
+     * Query explorer for the balance of an address
+     * @param {String} address - the ETHLike address
+     * @param {String} apiKey - optional API key to use instead of the one from the environment
+     * @returns {BigNumber} address balance
+     */
+    async queryAddressBalance(address, apiKey) {
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'account',
+            action: 'balance',
+            address: address,
+        }, apiKey);
+        // throw if the result does not exist or the result is not a valid number
+        if (!result || !result.result || isNaN(result.result)) {
+            throw new sdk_core_1.RecoveryProviderError(`Could not obtain address balance for ${address} from the explorer, got: ${result.result}`);
+        }
+        return new exports.optionalDeps.ethUtil.BN(result.result, 10);
+    }
+    /**
+     * @param {Recipient[]} recipients - the recipients of the transaction
+     * @param {number} expireTime - the expire time of the transaction
+     * @param {number} contractSequenceId - the contract sequence id of the transaction
+     * @returns {string}
+     */
+    getOperationSha3ForExecuteAndConfirm(recipients, expireTime, contractSequenceId) {
+        if (!recipients || !Array.isArray(recipients)) {
+            throw new Error('expecting array of recipients');
+        }
+        // Right now we only support 1 recipient
+        if (recipients.length !== 1) {
+            throw new Error('must send to exactly 1 recipient');
+        }
+        if (!lodash_1.default.isNumber(expireTime)) {
+            throw new Error('expireTime must be number of seconds since epoch');
+        }
+        if (!lodash_1.default.isNumber(contractSequenceId)) {
+            throw new Error('contractSequenceId must be number');
+        }
+        // Check inputs
+        recipients.forEach(function (recipient) {
+            if (!lodash_1.default.isString(recipient.address) ||
+                !exports.optionalDeps.ethUtil.isValidAddress(exports.optionalDeps.ethUtil.addHexPrefix(recipient.address))) {
+                throw new Error('Invalid address: ' + recipient.address);
+            }
+            let amount;
+            try {
+                amount = new bignumber_js_1.BigNumber(recipient.amount);
+            }
+            catch (e) {
+                throw new Error('Invalid amount for: ' + recipient.address + ' - should be numeric');
+            }
+            recipient.amount = amount.toFixed(0);
+            if (recipient.data && !lodash_1.default.isString(recipient.data)) {
+                throw new Error('Data for recipient ' + recipient.address + ' - should be of type hex string');
+            }
+        });
+        const recipient = recipients[0];
+        return exports.optionalDeps.ethUtil.bufferToHex(exports.optionalDeps.ethAbi.soliditySHA3(...this.getOperation(recipient, expireTime, contractSequenceId)));
+    }
+    /**
+     * Get transfer operation for coin
+     * @param {Recipient} recipient - recipient info
+     * @param {number} expireTime - expiry time
+     * @param {number} contractSequenceId - sequence id
+     * @returns {Array} operation array
+     */
+    getOperation(recipient, expireTime, contractSequenceId) {
+        const network = this.getNetwork();
+        return [
+            ['string', 'address', 'uint', 'bytes', 'uint', 'uint'],
+            [
+                network.nativeCoinOperationHashPrefix,
+                new exports.optionalDeps.ethUtil.BN(exports.optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),
+                recipient.amount,
+                Buffer.from(exports.optionalDeps.ethUtil.stripHexPrefix(exports.optionalDeps.ethUtil.padToEven(recipient.data || '')), 'hex'),
+                expireTime,
+                contractSequenceId,
+            ],
+        ];
+    }
+    /**
+     * Queries the contract (via explorer API) for the next sequence ID
+     * @param {String} address - address of the contract
+     * @param {String} apiKey - optional API key to use instead of the one from the environment
+     * @returns {Promise<Number>} sequence ID
+     */
+    async querySequenceId(address, apiKey) {
+        // Get sequence ID using contract call
+        const sequenceIdMethodSignature = exports.optionalDeps.ethAbi.methodID('getNextSequenceId', []);
+        const sequenceIdArgs = exports.optionalDeps.ethAbi.rawEncode([], []);
+        const sequenceIdData = Buffer.concat([sequenceIdMethodSignature, sequenceIdArgs]).toString('hex');
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'proxy',
+            action: 'eth_call',
+            to: address,
+            data: sequenceIdData,
+            tag: 'latest',
+        }, apiKey);
+        if (!result || !result.result) {
+            throw new sdk_core_1.RecoveryProviderError('Could not obtain sequence ID from explorer, got: ' + result.result);
+        }
+        const sequenceIdHex = result.result;
+        return new exports.optionalDeps.ethUtil.BN(sequenceIdHex.slice(2), 16).toNumber();
+    }
+    /**
+     * Recover an unsupported token from a BitGo multisig wallet
+     * This builds a half-signed transaction, for which there will be an admin route to co-sign and broadcast. Optionally
+     * the user can set params.broadcast = true and the half-signed tx will be sent to BitGo for cosigning and broadcasting
+     * @param {RecoverTokenOptions} params
+     * @param {Wallet} params.wallet - the wallet to recover the token from
+     * @param {string} params.tokenContractAddress - the contract address of the unsupported token
+     * @param {string} params.recipient - the destination address recovered tokens should be sent to
+     * @param {string} params.walletPassphrase - the wallet passphrase
+     * @param {string} params.prv - the xprv
+     * @param {boolean} params.broadcast - if true, we will automatically submit the half-signed tx to BitGo for cosigning and broadcasting
+     * @returns {Promise<RecoverTokenTransaction>}
+     */
+    async recoverToken(params) {
+        const network = this.getNetwork();
+        if (!lodash_1.default.isObject(params)) {
+            throw new Error(`recoverToken must be passed a params object. Got ${params} (type ${typeof params})`);
+        }
+        if (lodash_1.default.isUndefined(params.tokenContractAddress) || !lodash_1.default.isString(params.tokenContractAddress)) {
+            throw new Error(`tokenContractAddress must be a string, got ${params.tokenContractAddress} (type ${typeof params.tokenContractAddress})`);
+        }
+        if (!this.isValidAddress(params.tokenContractAddress)) {
+            throw new Error('tokenContractAddress not a valid address');
+        }
+        if (lodash_1.default.isUndefined(params.wallet) || !(params.wallet instanceof sdk_core_1.Wallet)) {
+            throw new Error(`wallet must be a wallet instance, got ${params.wallet} (type ${typeof params.wallet})`);
+        }
+        if (lodash_1.default.isUndefined(params.recipient) || !lodash_1.default.isString(params.recipient)) {
+            throw new Error(`recipient must be a string, got ${params.recipient} (type ${typeof params.recipient})`);
+        }
+        if (!this.isValidAddress(params.recipient)) {
+            throw new Error('recipient not a valid address');
+        }
+        if (!exports.optionalDeps.ethUtil.bufferToHex || !exports.optionalDeps.ethAbi.soliditySHA3) {
+            throw new Error('ethereum not fully supported in this environment');
+        }
+        // Get token balance from external API
+        const coinSpecific = params.wallet.coinSpecific();
+        if (!coinSpecific || !lodash_1.default.isString(coinSpecific.baseAddress)) {
+            throw new Error('missing required coin specific property baseAddress');
+        }
+        const recoveryAmount = await this.queryAddressTokenBalance(params.tokenContractAddress, coinSpecific.baseAddress);
+        if (params.broadcast) {
+            // We're going to create a normal ETH transaction that sends an amount of 0 ETH to the
+            // tokenContractAddress and encode the unsupported-token-send data in the data field
+            // #tricksy
+            const sendMethodArgs = [
+                {
+                    name: '_to',
+                    type: 'address',
+                    value: params.recipient,
+                },
+                {
+                    name: '_value',
+                    type: 'uint256',
+                    value: recoveryAmount.toString(10),
+                },
+            ];
+            const methodSignature = exports.optionalDeps.ethAbi.methodID('transfer', lodash_1.default.map(sendMethodArgs, 'type'));
+            const encodedArgs = exports.optionalDeps.ethAbi.rawEncode(lodash_1.default.map(sendMethodArgs, 'type'), lodash_1.default.map(sendMethodArgs, 'value'));
+            const sendData = Buffer.concat([methodSignature, encodedArgs]);
+            const broadcastParams = {
+                address: params.tokenContractAddress,
+                amount: '0',
+                data: sendData.toString('hex'),
+            };
+            if (params.walletPassphrase) {
+                broadcastParams.walletPassphrase = params.walletPassphrase;
+            }
+            else if (params.prv) {
+                broadcastParams.prv = params.prv;
+            }
+            return await params.wallet.send(broadcastParams);
+        }
+        const recipient = {
+            address: params.recipient,
+            amount: recoveryAmount.toString(10),
+        };
+        // This signature will be valid for one week
+        const expireTime = Math.floor(new Date().getTime() / 1000) + 60 * 60 * 24 * 7;
+        // Get sequence ID. We do this by building a 'fake' eth transaction, so the platform will increment and return us the new sequence id
+        // This _does_ require the user to have a non-zero wallet balance
+        const { nextContractSequenceId, gasPrice, gasLimit } = (await params.wallet.prebuildTransaction({
+            recipients: [
+                {
+                    address: params.recipient,
+                    amount: '1',
+                },
+            ],
+        }));
+        // these recoveries need to be processed by support, but if the customer sends any transactions before recovery is
+        // complete the sequence ID will be invalid. artificially inflate the sequence ID to allow more time for processing
+        const safeSequenceId = nextContractSequenceId + 1000;
+        // Build sendData for ethereum tx
+        const operationTypes = ['string', 'address', 'uint', 'address', 'uint', 'uint'];
+        const operationArgs = [
+            // Token operation has prefix has been added here so that ether operation hashes, signatures cannot be re-used for tokenSending
+            network.tokenOperationHashPrefix,
+            new exports.optionalDeps.ethUtil.BN(exports.optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),
+            recipient.amount,
+            new exports.optionalDeps.ethUtil.BN(exports.optionalDeps.ethUtil.stripHexPrefix(params.tokenContractAddress), 16),
+            expireTime,
+            safeSequenceId,
+        ];
+        const operationHash = exports.optionalDeps.ethUtil.bufferToHex(exports.optionalDeps.ethAbi.soliditySHA3(operationTypes, operationArgs));
+        const userPrv = await params.wallet.getPrv({
+            prv: params.prv,
+            walletPassphrase: params.walletPassphrase,
+        });
+        const signature = sdk_core_1.Util.ethSignMsgHash(operationHash, sdk_core_1.Util.xprvToEthPrivateKey(userPrv));
+        return {
+            halfSigned: {
+                recipient: recipient,
+                expireTime: expireTime,
+                contractSequenceId: safeSequenceId,
+                operationHash: operationHash,
+                signature: signature,
+                gasLimit: gasLimit,
+                gasPrice: gasPrice,
+                tokenContractAddress: params.tokenContractAddress,
+                walletId: params.wallet.id(),
+            },
+        };
+    }
+    /**
+     * Ensure either enterprise or newFeeAddress is passed, to know whether to create new key or use enterprise key
+     * @param {PrecreateBitGoOptions} params
+     * @param {string} params.enterprise {String} the enterprise id to associate with this key
+     * @param {string} params.newFeeAddress {Boolean} create a new fee address (enterprise not needed in this case)
+     * @returns {void}
+     */
+    preCreateBitGo(params) {
+        // We always need params object, since either enterprise or newFeeAddress is required
+        if (!lodash_1.default.isObject(params)) {
+            throw new Error(`preCreateBitGo must be passed a params object. Got ${params} (type ${typeof params})`);
+        }
+        if (lodash_1.default.isUndefined(params.enterprise) && lodash_1.default.isUndefined(params.newFeeAddress)) {
+            throw new Error('expecting enterprise when adding BitGo key. If you want to create a new ETH bitgo key, set the newFeeAddress parameter to true.');
+        }
+        // Check whether key should be an enterprise key or a BitGo key for a new fee address
+        if (!lodash_1.default.isUndefined(params.enterprise) && !lodash_1.default.isUndefined(params.newFeeAddress)) {
+            throw new Error(`Incompatible arguments - cannot pass both enterprise and newFeeAddress parameter.`);
+        }
+        if (!lodash_1.default.isUndefined(params.enterprise) && !lodash_1.default.isString(params.enterprise)) {
+            throw new Error(`enterprise should be a string - got ${params.enterprise} (type ${typeof params.enterprise})`);
+        }
+        if (!lodash_1.default.isUndefined(params.newFeeAddress) && !lodash_1.default.isBoolean(params.newFeeAddress)) {
+            throw new Error(`newFeeAddress should be a boolean - got ${params.newFeeAddress} (type ${typeof params.newFeeAddress})`);
+        }
+    }
+    /**
+     * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address
+     * @param {string} address
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     * @returns {Promise<number>}
+     */
+    async getAddressNonce(address, apiKey) {
+        // Get nonce for backup key (should be 0)
+        let nonce = 0;
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'account',
+            action: 'txlist',
+            address,
+        }, apiKey);
+        if (result && typeof result?.nonce === 'number') {
+            return Number(result.nonce);
+        }
+        if (!result || !Array.isArray(result.result)) {
+            throw new sdk_core_1.RecoveryProviderError('Unable to find next nonce from Etherscan, got: ' + JSON.stringify(result));
+        }
+        const backupKeyTxList = result.result;
+        if (backupKeyTxList.length > 0) {
+            // Calculate last nonce used
+            const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === address);
+            nonce = outgoingTxs.length;
+        }
+        return nonce;
+    }
+    /**
+     * Helper function for recover()
+     * This transforms the unsigned transaction information into a format the BitGo offline vault expects
+     * @param {UnformattedTxInfo} txInfo - tx info
+     * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object
+     * @param {string} userKey - the user's key
+     * @param {string} backupKey - the backup key
+     * @param {Buffer} gasPrice - gas price for the tx
+     * @param {number} gasLimit - gas limit for the tx
+     * @param {EIP1559} eip1559 - eip1559 params
+     * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options
+     * @param {apiKey} apiKey - optional apiKey to use when retrieving block chain data
+     * @returns {Promise<OfflineVaultTxInfo>}
+     */
+    async formatForOfflineVault(txInfo, ethTx, userKey, backupKey, gasPrice, gasLimit, eip1559, replayProtectionOptions, apiKey) {
+        if (!ethTx.to) {
+            throw new Error('Eth tx must have a `to` address');
+        }
+        const backupHDNode = secp256k1_1.bip32.fromBase58(backupKey);
+        const backupSigningKey = backupHDNode.publicKey;
+        const response = {
+            tx: ethTx.serialize().toString('hex'),
+            userKey,
+            backupKey,
+            coin: this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: [txInfo.recipient],
+            walletContractAddress: ethTx.to.toString(),
+            amount: txInfo.recipient.amount,
+            backupKeyNonce: await this.getAddressNonce(`0x${exports.optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`, apiKey),
+            eip1559,
+            replayProtectionOptions,
+        };
+        lodash_1.default.extend(response, txInfo);
+        response.nextContractSequenceId = response.contractSequenceId;
+        return response;
+    }
+    /**
+     * Helper function for recover()
+     * This transforms the unsigned transaction information into a format the BitGo offline vault expects
+     * @param {UnformattedTxInfo} txInfo - tx info
+     * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object
+     * @param {string} userKey - the user's key
+     * @param {string} backupKey - the backup key
+     * @param {Buffer} gasPrice - gas price for the tx
+     * @param {number} gasLimit - gas limit for the tx
+     * @param {number} backupKeyNonce - the nonce of the backup key address
+     * @param {EIP1559} eip1559 - eip1559 params
+     * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options
+     * @returns {Promise<OfflineVaultTxInfo>}
+     */
+    formatForOfflineVaultTSS(txInfo, ethTx, userKey, backupKey, gasPrice, gasLimit, backupKeyNonce, eip1559, replayProtectionOptions) {
+        if (!ethTx.to) {
+            throw new Error('Eth tx must have a `to` address');
+        }
+        const response = {
+            tx: ethTx.serialize().toString('hex'),
+            txHex: ethTx.getMessageToSign(false).toString(),
+            userKey,
+            backupKey,
+            coin: this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: [txInfo.recipient],
+            walletContractAddress: ethTx.to.toString(),
+            amount: txInfo.recipient.amount,
+            backupKeyNonce: backupKeyNonce,
+            eip1559,
+            replayProtectionOptions,
+        };
+        lodash_1.default.extend(response, txInfo);
+        return response;
+    }
+    /**
+     * Check whether the gas price passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasPrice - user defined gas price
+     * @returns {number} the gas price to use for this transaction
+     */
+    setGasPrice(userGasPrice) {
+        if (!userGasPrice) {
+            return statics_1.ethGasConfigs.defaultGasPrice;
+        }
+        const gasPriceMax = statics_1.ethGasConfigs.maximumGasPrice;
+        const gasPriceMin = statics_1.ethGasConfigs.minimumGasPrice;
+        if (userGasPrice < gasPriceMin || userGasPrice > gasPriceMax) {
+            throw new Error(`Gas price must be between ${gasPriceMin} and ${gasPriceMax}`);
+        }
+        return userGasPrice;
+    }
+    /**
+     * Check whether gas limit passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasLimit user defined gas limit
+     * @returns {number} the gas limit to use for this transaction
+     */
+    setGasLimit(userGasLimit) {
+        if (!userGasLimit) {
+            return statics_1.ethGasConfigs.defaultGasLimit;
+        }
+        const gasLimitMax = statics_1.ethGasConfigs.maximumGasLimit;
+        const gasLimitMin = statics_1.ethGasConfigs.minimumGasLimit;
+        if (userGasLimit < gasLimitMin || userGasLimit > gasLimitMax) {
+            throw new Error(`Gas limit must be between ${gasLimitMin} and ${gasLimitMax}`);
+        }
+        return userGasLimit;
+    }
+    /**
+     * Helper function for signTransaction for the rare case that SDK is doing the second signature
+     * Note: we are expecting this to be called from the offline vault
+     * @param {SignFinalOptions.txPrebuild} params.txPrebuild
+     * @param {string} params.prv
+     * @returns {{txHex: string}}
+     */
+    async signFinalEthLike(params) {
+        const signingKey = new lib_1.KeyPair({ prv: params.prv }).getKeys().prv;
+        if (lodash_1.default.isUndefined(signingKey)) {
+            throw new Error('missing private key');
+        }
+        const txBuilder = this.getTransactionBuilder(params.common);
+        try {
+            txBuilder.from(params.txPrebuild.halfSigned?.txHex);
+        }
+        catch (e) {
+            throw new Error('invalid half-signed transaction');
+        }
+        txBuilder.sign({ key: signingKey });
+        const tx = await txBuilder.build();
+        return {
+            txHex: tx.toBroadcastFormat(),
+        };
+    }
+    /**
+     * Assemble half-sign prebuilt transaction
+     * @param {SignTransactionOptions} params
+     */
+    async signTransaction(params) {
+        // Normally the SDK provides the first signature for an EthLike tx, but occasionally it provides the second and final one.
+        if (params.isLastSignature) {
+            // In this case when we're doing the second (final) signature, the logic is different.
+            return await this.signFinalEthLike(params);
+        }
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.from(params.txPrebuild.txHex);
+        txBuilder
+            .transfer()
+            .coin(this.staticsCoin?.name)
+            .key(new lib_1.KeyPair({ prv: params.prv }).getKeys().prv);
+        if (params.walletVersion) {
+            txBuilder.walletVersion(params.walletVersion);
+        }
+        const transaction = await txBuilder.build();
+        // In case of tx with contract data from a custodial wallet, we are running into an issue
+        // as halfSigned is not having the data field. So, we are adding the data field to the halfSigned tx
+        let recipients = params.txPrebuild.recipients || params.recipients;
+        if (recipients === undefined) {
+            recipients = transaction.outputs.map((output) => ({ address: output.address, amount: output.value }));
+        }
+        const txParams = {
+            eip1559: params.txPrebuild.eip1559,
+            txHex: transaction.toBroadcastFormat(),
+            recipients: recipients,
+            expiration: params.txPrebuild.expireTime,
+            hopTransaction: params.txPrebuild.hopTransaction,
+            custodianTransactionId: params.custodianTransactionId,
+            expireTime: params.expireTime,
+            contractSequenceId: params.txPrebuild.nextContractSequenceId,
+            sequenceId: params.sequenceId,
+            ...(params.txPrebuild.isBatch ? { isBatch: params.txPrebuild.isBatch } : {}),
+        };
+        return { halfSigned: txParams };
+    }
+    /**
+     * Method to validate recovery params
+     * @param {RecoverOptions} params
+     * @returns {void}
+     */
+    validateRecoveryParams(params) {
+        if (params.userKey === undefined) {
+            throw new Error('missing userKey');
+        }
+        if (params.backupKey === undefined) {
+            throw new Error('missing backupKey');
+        }
+        if (!params.isUnsignedSweep &&
+            params.walletPassphrase === undefined &&
+            !params.userKey.startsWith('xpub') &&
+            !params.isTss) {
+            throw new Error('missing wallet passphrase');
+        }
+        if (params.walletContractAddress === undefined || !this.isValidAddress(params.walletContractAddress)) {
+            throw new Error('invalid walletContractAddress');
+        }
+        if (params.recoveryDestination === undefined || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        if (!this.staticsCoin?.features.includes(statics_1.CoinFeature.EIP1559)) {
+            if (params.eip1559) {
+                throw new Error('Invalid fee params. EIP1559 not supported');
+            }
+            if (params.replayProtectionOptions?.hardfork === 'london') {
+                throw new Error('Invalid replayProtection options. Cannot use the hardfork "london" for this chain');
+            }
+        }
+    }
+    /**
+     * Helper which Adds signatures to tx object and re-serializes tx
+     * @param {EthLikeCommon.default} ethCommon
+     * @param {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction} tx
+     * @param {ECDSAMethodTypes.Signature} signature
+     * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}
+     */
+    getSignedTxFromSignature(ethCommon, tx, signature) {
+        // get signed Tx from signature
+        const txData = tx.toJSON();
+        const yParity = signature.recid;
+        const baseParams = {
+            to: txData.to,
+            nonce: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.nonce), 'hex'),
+            value: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.value), 'hex'),
+            gasLimit: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.gasLimit), 'hex'),
+            data: txData.data,
+            r: (0, ethereumjs_util_1.addHexPrefix)(signature.r),
+            s: (0, ethereumjs_util_1.addHexPrefix)(signature.s),
+        };
+        let finalTx;
+        if (txData.maxFeePerGas && txData.maxPriorityFeePerGas) {
+            finalTx = tx_1.FeeMarketEIP1559Transaction.fromTxData({
+                ...baseParams,
+                maxPriorityFeePerGas: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.maxPriorityFeePerGas), 'hex'),
+                maxFeePerGas: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.maxFeePerGas), 'hex'),
+                v: new bn_js_1.default(yParity.toString()),
+            }, { common: ethCommon });
+        }
+        else if (txData.gasPrice) {
+            const v = BigInt(35) + BigInt(yParity) + BigInt(ethCommon.chainIdBN().toNumber()) * BigInt(2);
+            finalTx = tx_1.Transaction.fromTxData({
+                ...baseParams,
+                v: new bn_js_1.default(v.toString()),
+                gasPrice: new bn_js_1.default((0, ethereumjs_util_1.stripHexPrefix)(txData.gasPrice.toString()), 'hex'),
+            }, { common: ethCommon });
+        }
+        return finalTx;
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     * @param {string} params.userKey - [encrypted] xprv
+     * @param {string} params.backupKey - [encrypted] xprv or xpub if the xprv is held by a KRS provider
+     * @param {string} params.walletPassphrase - used to decrypt userKey and backupKey
+     * @param {string} params.walletContractAddress - the ETH address of the wallet contract
+     * @param {string} params.krsProvider - necessary if backup key is held by KRS
+     * @param {string} params.recoveryDestination - target address to send recovered funds to
+     * @param {string} params.bitgoFeeAddress - wrong chain wallet fee address for evm based cross chain recovery txn
+     * @param {string} params.bitgoDestinationAddress - target bitgo address where fee will be sent for evm based cross chain recovery txn
+     */
+    async recover(params) {
+        if (params.isTss === true) {
+            return this.recoverTSS(params);
+        }
+        return this.recoverEthLike(params);
+    }
+    generateForwarderAddress(baseAddress, feeAddress, forwarderFactoryAddress, forwarderImplementationAddress, index) {
+        const salt = (0, ethereumjs_util_1.addHexPrefix)(index.toString(16));
+        const saltBuffer = (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.toBuffer)(salt), 32);
+        const { createForwarderParams, createForwarderTypes } = (0, lib_1.getCreateForwarderParamsAndTypes)(baseAddress, saltBuffer, feeAddress);
+        const calculationSalt = (0, ethereumjs_util_1.bufferToHex)(exports.optionalDeps.ethAbi.soliditySHA3(createForwarderTypes, createForwarderParams));
+        const initCode = (0, lib_1.getProxyInitcode)(forwarderImplementationAddress);
+        return (0, lib_1.calculateForwarderV1Address)(forwarderFactoryAddress, calculationSalt, initCode);
+    }
+    deriveAddressFromPublicKey(commonKeychain, index) {
+        const derivationPath = `m/${index}`;
+        const pubkeySize = 33;
+        const ecdsaMpc = new sdk_core_1.Ecdsa();
+        const derivedPublicKey = Buffer.from(ecdsaMpc.deriveUnhardened(commonKeychain, derivationPath), 'hex')
+            .subarray(0, pubkeySize)
+            .toString('hex');
+        const publicKey = Buffer.from(derivedPublicKey, 'hex').slice(0, 66).toString('hex');
+        const keyPair = new lib_1.KeyPair({ pub: publicKey });
+        const address = keyPair.getAddress();
+        return address;
+    }
+    getConsolidationAddress(params, index) {
+        const possibleConsolidationAddresses = [];
+        if (params.walletContractAddress && params.bitgoFeeAddress) {
+            const ethNetwork = this.getNetwork();
+            const forwarderFactoryAddress = ethNetwork?.walletV4ForwarderFactoryAddress;
+            const forwarderImplementationAddress = ethNetwork?.walletV4ForwarderImplementationAddress;
+            try {
+                const forwarderAddress = this.generateForwarderAddress(params.walletContractAddress, params.bitgoFeeAddress, forwarderFactoryAddress, forwarderImplementationAddress, index);
+                possibleConsolidationAddresses.push(forwarderAddress);
+            }
+            catch (e) {
+                console.log(`Failed to generate forwarder address: ${e.message}`);
+            }
+        }
+        if (params.userKey) {
+            try {
+                const derivedAddress = this.deriveAddressFromPublicKey(params.userKey, index);
+                possibleConsolidationAddresses.push(derivedAddress);
+            }
+            catch (e) {
+                console.log(`Failed to generate derived address: ${e}`);
+            }
+        }
+        if (possibleConsolidationAddresses.length === 0) {
+            throw new Error('Unable to generate consolidation address. Check that wallet contract address, fee address, or user key is valid.');
+        }
+        return possibleConsolidationAddresses;
+    }
+    async recoverConsolidations(params) {
+        const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+        const startIdx = params.startingScanIndex || 1;
+        const endIdx = params.endingScanIndex || startIdx + exports.DEFAULT_SCAN_FACTOR;
+        if (!params.walletContractAddress || params.walletContractAddress === '') {
+            throw new Error(`Invalid wallet contract address ${params.walletContractAddress}`);
+        }
+        if (!params.bitgoFeeAddress || params.bitgoFeeAddress === '') {
+            throw new Error(`Invalid fee address ${params.bitgoFeeAddress}`);
+        }
+        if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * exports.DEFAULT_SCAN_FACTOR) {
+            throw new Error(`Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`);
+        }
+        const consolidatedTransactions = [];
+        let lastScanIndex = startIdx;
+        for (let i = startIdx; i < endIdx; i++) {
+            const consolidationAddress = this.getConsolidationAddress(params, i);
+            for (const address of consolidationAddress) {
+                const recoverParams = {
+                    apiKey: params.apiKey,
+                    backupKey: params.backupKey || '',
+                    gasLimit: params.gasLimit,
+                    recoveryDestination: params.recoveryDestination || '',
+                    userKey: params.userKey || '',
+                    walletContractAddress: address,
+                    derivationSeed: '',
+                    isTss: params.isTss,
+                    eip1559: {
+                        maxFeePerGas: params.eip1559?.maxFeePerGas || 20,
+                        maxPriorityFeePerGas: params.eip1559?.maxPriorityFeePerGas || 200000,
+                    },
+                    replayProtectionOptions: {
+                        chain: params.replayProtectionOptions?.chain || 0,
+                        hardfork: params.replayProtectionOptions?.hardfork || 'london',
+                    },
+                    bitgoKey: '',
+                    ignoreAddressTypes: [],
+                };
+                let recoveryTransaction;
+                try {
+                    recoveryTransaction = await this.recover(recoverParams);
+                }
+                catch (e) {
+                    if (e instanceof sdk_core_1.ErrorNoInputToRecover) {
+                        lastScanIndex = i;
+                        continue;
+                    }
+                    throw e;
+                }
+                if (isUnsignedSweep) {
+                    consolidatedTransactions.push(recoveryTransaction.txRequests[0]);
+                }
+                else {
+                    consolidatedTransactions.push(recoveryTransaction);
+                }
+            }
+            // To avoid rate limit for etherscan
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // lastScanIndex = i;
+        }
+        if (consolidatedTransactions.length === 0) {
+            throw new Error(`Did not find an address with sufficient funds to recover. Please start the next scan at address index ${lastScanIndex + 1}.`);
+        }
+        return { transactions: consolidatedTransactions, lastScanIndex };
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo for non-TSS transaction
+     * @param params
+     * @param {string} params.userKey [encrypted] xprv or xpub
+     * @param {string} params.backupKey [encrypted] xprv or xpub if the xprv is held by a KRS provider
+     * @param {string} params.walletPassphrase used to decrypt userKey and backupKey
+     * @param {string} params.walletContractAddress the EthLike address of the wallet contract
+     * @param {string} params.krsProvider necessary if backup key is held by KRS
+     * @param {string} params.recoveryDestination target address to send recovered funds to
+     * @param {string} params.bitgoFeeAddress wrong chain wallet fee address for evm based cross chain recovery txn
+     * @param {string} params.bitgoDestinationAddress target bitgo address where fee will be sent for evm based cross chain recovery txn
+     * @returns {Promise<RecoveryInfo | OfflineVaultTxInfo>}
+     */
+    async recoverEthLike(params) {
+        // bitgoFeeAddress is only defined when it is a evm cross chain recovery
+        // as we use fee from this wrong chain address for the recovery txn on the correct chain.
+        if (params.bitgoFeeAddress) {
+            return this.recoverEthLikeforEvmBasedRecovery(params);
+        }
+        this.validateRecoveryParams(params);
+        const isUnsignedSweep = params.isUnsignedSweep ?? (0, sdk_core_1.getIsUnsignedSweep)(params);
+        // Clean up whitespace from entered values
+        let userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        const gasLimit = new exports.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
+        const gasPrice = params.eip1559
+            ? new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : new exports.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));
+        if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {
+            try {
+                userKey = await this.bitgo.decrypt({
+                    input: userKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting user keychain: ${e.message}`);
+            }
+        }
+        let backupKeyAddress;
+        let backupSigningKey;
+        if (isUnsignedSweep) {
+            const backupHDNode = secp256k1_1.bip32.fromBase58(backupKey);
+            backupSigningKey = backupHDNode.publicKey;
+            backupKeyAddress = `0x${exports.optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`;
+        }
+        else {
+            // Decrypt backup private key and get address
+            let backupPrv;
+            try {
+                backupPrv = await this.bitgo.decrypt({
+                    input: backupKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting backup keychain: ${e.message}`);
+            }
+            const keyPair = new lib_1.KeyPair({ prv: backupPrv });
+            backupSigningKey = keyPair.getKeys().prv;
+            if (!backupSigningKey) {
+                throw new Error('no private key');
+            }
+            backupKeyAddress = keyPair.getAddress();
+        }
+        const backupKeyNonce = await this.getAddressNonce(backupKeyAddress, params.apiKey);
+        // get balance of backupKey to ensure funds are available to pay fees
+        const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);
+        let totalGasNeeded = gasPrice.mul(gasLimit);
+        // On L2 chains with L1 data fees, add buffer for L1 fees
+        if (this.staticsCoin?.family !== undefined && lib_1.coinFamiliesWithL1Fees.includes(this.staticsCoin.family)) {
+            totalGasNeeded = totalGasNeeded.add(new exports.optionalDeps.ethUtil.BN(statics_1.ethGasConfigs.l1GasFeeBuffer));
+        }
+        const weiToGwei = 10 ** 9;
+        if (backupKeyBalance.lt(totalGasNeeded)) {
+            throw new Error(`Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some funds to this address then retry.`);
+        }
+        // get balance of wallet
+        const txAmount = await this.queryAddressBalance(params.walletContractAddress, params.apiKey);
+        if (new bignumber_js_1.BigNumber(txAmount).isLessThanOrEqualTo(0)) {
+            throw new sdk_core_1.ErrorNoInputToRecover('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, params.apiKey);
+        let operationHash, signature;
+        // Get operation hash and sign it
+        if (!isUnsignedSweep) {
+            operationHash = this.getOperationSha3ForExecuteAndConfirm(recipients, this.getDefaultExpireTime(), sequenceId);
+            signature = sdk_core_1.Util.ethSignMsgHash(operationHash, sdk_core_1.Util.xprvToEthPrivateKey(userKey));
+            try {
+                sdk_core_1.Util.ecRecoverEthAddress(operationHash, signature);
+            }
+            catch (e) {
+                throw new Error('Invalid signature');
+            }
+        }
+        const txInfo = {
+            recipient: recipients[0],
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            operationHash: operationHash,
+            signature: signature,
+            gasLimit: gasLimit.toString(10),
+        };
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.counter(backupKeyNonce);
+        txBuilder.contract(params.walletContractAddress);
+        let txFee;
+        if (params.eip1559) {
+            txFee = {
+                eip1559: {
+                    maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,
+                    maxFeePerGas: params.eip1559.maxFeePerGas,
+                },
+            };
+        }
+        else {
+            txFee = { fee: gasPrice.toString() };
+        }
+        txBuilder.fee({
+            ...txFee,
+            gasLimit: gasLimit.toString(),
+        });
+        const transferBuilder = txBuilder.transfer();
+        transferBuilder
+            .coin(this.staticsCoin?.name)
+            .amount(recipients[0].amount)
+            .contractSequenceId(sequenceId)
+            .expirationTime(this.getDefaultExpireTime())
+            .to(params.recoveryDestination);
+        const tx = await txBuilder.build();
+        if (isUnsignedSweep) {
+            const response = {
+                txHex: tx.toBroadcastFormat(),
+                userKey,
+                backupKey,
+                coin: this.getChain(),
+                gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+                gasLimit,
+                recipients: [txInfo.recipient],
+                walletContractAddress: tx.toJson().to,
+                amount: txInfo.recipient.amount,
+                backupKeyNonce,
+                eip1559: params.eip1559,
+            };
+            lodash_1.default.extend(response, txInfo);
+            response.nextContractSequenceId = response.contractSequenceId;
+            return response;
+        }
+        txBuilder
+            .transfer()
+            .coin(this.staticsCoin?.name)
+            .key(new lib_1.KeyPair({ prv: userKey }).getKeys().prv);
+        txBuilder.sign({ key: backupSigningKey });
+        const signedTx = await txBuilder.build();
+        return {
+            id: signedTx.toJson().id,
+            tx: signedTx.toBroadcastFormat(),
+        };
+    }
+    /**
+     * Extract recipients from transaction hex
+     * @param txHex - The transaction hex string
+     * @returns Array of recipients with address and amount
+     */
+    async extractRecipientsFromTxHex(txHex) {
+        const txBuffer = exports.optionalDeps.ethUtil.toBuffer(txHex);
+        const decodedTx = exports.optionalDeps.EthTx.TransactionFactory.fromSerializedData(txBuffer);
+        const recipients = [];
+        if (decodedTx.data && decodedTx.data.length > 0) {
+            const dataHex = exports.optionalDeps.ethUtil.bufferToHex(decodedTx.data);
+            const transferData = (0, lib_1.decodeTransferData)(dataHex);
+            if (transferData.to) {
+                recipients.push({
+                    address: transferData.to,
+                    amount: transferData.amount,
+                });
+            }
+        }
+        return recipients;
+    }
+    async sendCrossChainRecoveryTransaction(params) {
+        const buildResponse = await this.buildCrossChainRecoveryTransaction(params.recoveryId);
+        if (params.walletType === 'cold') {
+            return buildResponse;
+        }
+        if (!params.encryptedPrv) {
+            throw new Error('missing encryptedPrv');
+        }
+        let userKeyPrv;
+        try {
+            userKeyPrv = await this.bitgo.decrypt({
+                input: params.encryptedPrv,
+                password: params.walletPassphrase,
+            });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting user keychain: ${e.message}`);
+        }
+        const keyPair = new lib_1.KeyPair({ prv: userKeyPrv });
+        const userSigningKey = keyPair.getKeys().prv;
+        if (!userSigningKey) {
+            throw new Error('no private key');
+        }
+        const txBuilder = this.getTransactionBuilder(params.common);
+        const txHex = buildResponse.txHex;
+        txBuilder.from(txHex);
+        if (buildResponse.walletVersion) {
+            // If walletVersion is provided, set it in the txBuilder
+            txBuilder.walletVersion(buildResponse.walletVersion);
+        }
+        txBuilder
+            .transfer()
+            .coin(this.staticsCoin?.name)
+            .key(userSigningKey);
+        const tx = await txBuilder.build();
+        const res = await this.bitgo
+            .post(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${params.recoveryId}/sign`))
+            .send({ txHex: tx.toBroadcastFormat() });
+        return {
+            coin: this.staticsCoin?.name,
+            txid: res.body.txid,
+        };
+    }
+    async buildCrossChainRecoveryTransaction(recoveryId) {
+        const res = await this.bitgo.get(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${recoveryId}/buildtx`));
+        // Extract recipients from the transaction hex
+        const recipients = await this.extractRecipientsFromTxHex(res.body.txHex);
+        return {
+            coin: res.body.coin,
+            txHex: res.body.txHex,
+            txid: res.body.txid,
+            walletVersion: res.body.walletVersion,
+            recipients,
+        };
+    }
+    /**
+     * Builds a unsigned (for cold, custody wallet) or
+     * half-signed (for hot wallet) evm cross chain recovery transaction with
+     * same expected arguments as recover method.
+     * This helps recover funds from evm based wrong chain.
+     * @param {RecoverOptions} params
+     * @returns {Promise<RecoveryInfo | OfflineVaultTxInfo>}
+     */
+    async recoverEthLikeforEvmBasedRecovery(params) {
+        this.validateEvmBasedRecoveryParams(params);
+        // Clean up whitespace from entered values
+        const userKey = params.userKey.replace(/\s/g, '');
+        const bitgoFeeAddress = params.bitgoFeeAddress?.replace(/\s/g, '').toLowerCase();
+        const bitgoDestinationAddress = params.bitgoDestinationAddress?.replace(/\s/g, '').toLowerCase();
+        const recoveryDestination = params.recoveryDestination?.replace(/\s/g, '').toLowerCase();
+        const walletContractAddress = params.walletContractAddress?.replace(/\s/g, '').toLowerCase();
+        const tokenContractAddress = params.tokenContractAddress?.replace(/\s/g, '').toLowerCase();
+        let userSigningKey;
+        let userKeyPrv;
+        if (params.walletPassphrase) {
+            if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {
+                try {
+                    userKeyPrv = await this.bitgo.decrypt({
+                        input: userKey,
+                        password: params.walletPassphrase,
+                    });
+                }
+                catch (e) {
+                    throw new Error(`Error decrypting user keychain: ${e.message}`);
+                }
+            }
+            const keyPair = new lib_1.KeyPair({ prv: userKeyPrv });
+            userSigningKey = keyPair.getKeys().prv;
+            if (!userSigningKey) {
+                throw new Error('no private key');
+            }
+        }
+        // Use default gasLimit for cold and custody wallets
+        let gasLimit = params.gasLimit || userKey.startsWith('xpub') || !userKey
+            ? new exports.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit))
+            : new exports.optionalDeps.ethUtil.BN(0);
+        const gasPrice = params.eip1559
+            ? new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : params.gasPrice
+                ? new exports.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice))
+                : await this.getGasPriceFromExternalAPI(this.staticsCoin?.name, params.apiKey);
+        const bitgoFeeAddressNonce = await this.getAddressNonce(bitgoFeeAddress, params.apiKey);
+        if (tokenContractAddress) {
+            return this.recoverEthLikeTokenforEvmBasedRecovery(params, bitgoFeeAddressNonce, gasLimit, gasPrice, userKey, userSigningKey, params.apiKey);
+        }
+        // get balance of wallet
+        const txAmount = await this.queryAddressBalance(walletContractAddress, params.apiKey);
+        const bitgoFeePercentage = 0; // TODO: BG-71912 can change the fee% here.
+        const bitgoFeeAmount = txAmount * (bitgoFeePercentage / 100);
+        // build recipients object
+        const recipients = [
+            {
+                address: recoveryDestination,
+                amount: new bignumber_js_1.BigNumber(txAmount).minus(bitgoFeeAmount).toFixed(),
+            },
+        ];
+        if (bitgoFeePercentage > 0) {
+            if (lodash_1.default.isUndefined(bitgoDestinationAddress) || !this.isValidAddress(bitgoDestinationAddress)) {
+                throw new Error('invalid bitgoDestinationAddress');
+            }
+            recipients.push({
+                address: bitgoDestinationAddress,
+                amount: bitgoFeeAmount.toString(10),
+            });
+        }
+        // calculate batch data
+        const BATCH_METHOD_NAME = 'batch';
+        const BATCH_METHOD_TYPES = ['address[]', 'uint256[]'];
+        const batchExecutionInfo = this.getBatchExecutionInfo(recipients);
+        const batchData = exports.optionalDeps.ethUtil.addHexPrefix(this.getMethodCallData(BATCH_METHOD_NAME, BATCH_METHOD_TYPES, batchExecutionInfo.values).toString('hex'));
+        // Get sequence ID using contract call
+        // we need to wait between making two explorer api calls to avoid getting banned
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const sequenceId = await this.querySequenceId(walletContractAddress, params.apiKey);
+        const network = this.getNetwork();
+        const batcherContractAddress = network?.batcherContractAddress;
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.counter(bitgoFeeAddressNonce);
+        txBuilder.contract(walletContractAddress);
+        let txFee;
+        if (params.eip1559) {
+            txFee = {
+                eip1559: {
+                    maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,
+                    maxFeePerGas: params.eip1559.maxFeePerGas,
+                },
+            };
+        }
+        else {
+            txFee = { fee: gasPrice.toString() };
+        }
+        txBuilder.fee({
+            ...txFee,
+            gasLimit: gasLimit.toString(),
+        });
+        const transferBuilder = txBuilder.transfer();
+        if (!batcherContractAddress) {
+            transferBuilder
+                .coin(this.staticsCoin?.name)
+                .amount(batchExecutionInfo.totalAmount)
+                .contractSequenceId(sequenceId)
+                .expirationTime(this.getDefaultExpireTime())
+                .to(recoveryDestination);
+        }
+        else {
+            transferBuilder
+                .coin(this.staticsCoin?.name)
+                .amount(batchExecutionInfo.totalAmount)
+                .contractSequenceId(sequenceId)
+                .expirationTime(this.getDefaultExpireTime())
+                .to(batcherContractAddress)
+                .data(batchData);
+        }
+        if (params.walletPassphrase) {
+            transferBuilder.key(userSigningKey);
+        }
+        // If the intended chain is arbitrum or optimism, we need to use wallet version 4
+        // since these contracts construct operationHash differently
+        if (params.intendedChain && ['arbeth', 'opeth'].includes(statics_1.coins.get(params.intendedChain).family)) {
+            txBuilder.walletVersion(4);
+        }
+        // If gasLimit was not passed as a param or if it is not cold/custody wallet, then fetch the gasLimit from Explorer
+        if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {
+            const sendData = txBuilder.getSendData();
+            gasLimit = await this.getGasLimitFromExternalAPI(params.intendedChain, params.bitgoFeeAddress, params.walletContractAddress, sendData, params.apiKey);
+            txBuilder.fee({
+                ...txFee,
+                gasLimit: gasLimit.toString(),
+            });
+        }
+        // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees
+        await this.ensureSufficientBalance(bitgoFeeAddress, gasPrice, gasLimit, params.apiKey);
+        const tx = await txBuilder.build();
+        const txInfo = {
+            recipients: recipients,
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            gasLimit: gasLimit.toString(10),
+            isEvmBasedCrossChainRecovery: true,
+        };
+        const response = {
+            txHex: tx.toBroadcastFormat(),
+            userKey,
+            coin: this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: txInfo.recipients,
+            walletContractAddress: tx.toJson().to,
+            amount: batchExecutionInfo.totalAmount,
+            backupKeyNonce: bitgoFeeAddressNonce,
+            eip1559: params.eip1559,
+            ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),
+        };
+        lodash_1.default.extend(response, txInfo);
+        response.nextContractSequenceId = response.contractSequenceId;
+        if (params.walletPassphrase) {
+            const halfSignedTxn = {
+                halfSigned: {
+                    txHex: tx.toBroadcastFormat(),
+                    recipients: txInfo.recipients,
+                    expireTime: txInfo.expireTime,
+                },
+            };
+            lodash_1.default.extend(response, halfSignedTxn);
+            const feesUsed = {
+                gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+                gasLimit: exports.optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),
+            };
+            response['feesUsed'] = feesUsed;
+        }
+        return response;
+    }
+    /**
+     * Query explorer for the balance of an address for a token
+     * @param {string} tokenContractAddress - address where the token smart contract is hosted
+     * @param {string} walletContractAddress - address of the wallet
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     * @returns {BigNumber} token balaance in base units
+     */
+    async queryAddressTokenBalance(tokenContractAddress, walletContractAddress, apiKey) {
+        if (!exports.optionalDeps.ethUtil.isValidAddress(tokenContractAddress)) {
+            throw new Error('cannot get balance for invalid token address');
+        }
+        if (!exports.optionalDeps.ethUtil.isValidAddress(walletContractAddress)) {
+            throw new Error('cannot get token balance for invalid wallet address');
+        }
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'account',
+            action: 'tokenbalance',
+            contractaddress: tokenContractAddress,
+            address: walletContractAddress,
+            tag: 'latest',
+        }, apiKey);
+        // throw if the result does not exist or the result is not a valid number
+        if (!result || !result.result || isNaN(result.result)) {
+            throw new sdk_core_1.RecoveryProviderError(`Could not obtain token address balance for ${tokenContractAddress} from Etherscan, got: ${result.result}`);
+        }
+        return new exports.optionalDeps.ethUtil.BN(result.result, 10);
+    }
+    async recoverEthLikeTokenforEvmBasedRecovery(params, bitgoFeeAddressNonce, gasLimit, gasPrice, userKey, userSigningKey, apiKey) {
+        // get token balance of wallet
+        const txAmount = await this.queryAddressTokenBalance(params.tokenContractAddress, params.walletContractAddress, apiKey);
+        // build recipients object
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: new bignumber_js_1.BigNumber(txAmount).toFixed(),
+            },
+        ];
+        // Get sequence ID using contract call
+        // we need to wait between making two explorer api calls to avoid getting banned
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const sequenceId = await this.querySequenceId(params.walletContractAddress, params.apiKey);
+        const txBuilder = this.getTransactionBuilder(params.common);
+        txBuilder.counter(bitgoFeeAddressNonce);
+        txBuilder.contract(params.walletContractAddress);
+        let txFee;
+        if (params.eip1559) {
+            txFee = {
+                eip1559: {
+                    maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,
+                    maxFeePerGas: params.eip1559.maxFeePerGas,
+                },
+            };
+        }
+        else {
+            txFee = { fee: gasPrice.toString() };
+        }
+        txBuilder.fee({
+            ...txFee,
+            gasLimit: gasLimit.toString(),
+        });
+        const transferBuilder = txBuilder.transfer();
+        const network = this.getNetwork();
+        const token = (0, lib_1.getToken)(params.tokenContractAddress, network, this.staticsCoin?.family)?.name;
+        transferBuilder
+            .amount(txAmount)
+            .contractSequenceId(sequenceId)
+            .expirationTime(this.getDefaultExpireTime())
+            .to(params.recoveryDestination);
+        if (token) {
+            transferBuilder.coin(token);
+        }
+        else {
+            transferBuilder
+                .coin(this.staticsCoin?.name)
+                .tokenContractAddress(params.tokenContractAddress);
+        }
+        if (params.walletPassphrase) {
+            txBuilder.transfer().key(userSigningKey);
+        }
+        // If the intended chain is arbitrum or optimism, we need to use wallet version 4
+        // since these contracts construct operationHash differently
+        if (params.intendedChain && ['arbeth', 'opeth'].includes(statics_1.coins.get(params.intendedChain).family)) {
+            txBuilder.walletVersion(4);
+        }
+        if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {
+            const sendData = txBuilder.getSendData();
+            gasLimit = await this.getGasLimitFromExternalAPI(params.intendedChain, params.bitgoFeeAddress, params.walletContractAddress, sendData, apiKey);
+            txBuilder.fee({
+                ...txFee,
+                gasLimit: gasLimit.toString(),
+            });
+        }
+        // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees
+        await this.ensureSufficientBalance(params.bitgoFeeAddress, gasPrice, gasLimit, params.apiKey);
+        const tx = await txBuilder.build();
+        const txInfo = {
+            recipients: recipients,
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            gasLimit: gasLimit.toString(10),
+            isEvmBasedCrossChainRecovery: true,
+        };
+        const response = {
+            txHex: tx.toBroadcastFormat(),
+            userKey,
+            coin: token ? token : this.getChain(),
+            gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+            gasLimit,
+            recipients: txInfo.recipients,
+            walletContractAddress: tx.toJson().to,
+            amount: txAmount.toString(),
+            backupKeyNonce: bitgoFeeAddressNonce,
+            eip1559: params.eip1559,
+            ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),
+        };
+        lodash_1.default.extend(response, txInfo);
+        response.nextContractSequenceId = response.contractSequenceId;
+        if (params.walletPassphrase) {
+            const halfSignedTxn = {
+                halfSigned: {
+                    txHex: tx.toBroadcastFormat(),
+                    recipients: txInfo.recipients,
+                    expireTime: txInfo.expireTime,
+                },
+            };
+            lodash_1.default.extend(response, halfSignedTxn);
+            const feesUsed = {
+                gasPrice: exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+                gasLimit: exports.optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),
+            };
+            response['feesUsed'] = feesUsed;
+        }
+        return response;
+    }
+    /**
+     * Validate evm based cross chain recovery params
+     * @param params {RecoverOptions}
+     * @returns {void}
+     */
+    validateEvmBasedRecoveryParams(params) {
+        if (lodash_1.default.isUndefined(params.bitgoFeeAddress) || !this.isValidAddress(params.bitgoFeeAddress)) {
+            throw new Error('invalid bitgoFeeAddress');
+        }
+        if (lodash_1.default.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {
+            throw new Error('invalid walletContractAddress');
+        }
+        if (lodash_1.default.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+    }
+    /**
+     * Return types, values, and total amount in wei to send in a batch transaction, using the method signature
+     * `distributeBatch(address[], uint256[])`
+     * @param {Recipient[]} recipients - transaction recipients
+     * @returns {GetBatchExecutionInfoRT} information needed to execute the batch transaction
+     */
+    getBatchExecutionInfo(recipients) {
+        const addresses = [];
+        const amounts = [];
+        let sum = new bignumber_js_1.BigNumber('0');
+        lodash_1.default.forEach(recipients, ({ address, amount }) => {
+            addresses.push(address);
+            amounts.push(amount);
+            sum = sum.plus(amount);
+        });
+        return {
+            values: [addresses, amounts],
+            totalAmount: sum.toFixed(),
+        };
+    }
+    /**
+     * Build arguments to call the send method on the wallet contract
+     * @param txInfo
+     */
+    getSendMethodArgs(txInfo) {
+        // Method signature is
+        // sendMultiSig(address toAddress, uint value, bytes data, uint expireTime, uint sequenceId, bytes signature)
+        return [
+            {
+                name: 'toAddress',
+                type: 'address',
+                value: txInfo.recipient.address,
+            },
+            {
+                name: 'value',
+                type: 'uint',
+                value: txInfo.recipient.amount,
+            },
+            {
+                name: 'data',
+                type: 'bytes',
+                value: exports.optionalDeps.ethUtil.toBuffer(exports.optionalDeps.ethUtil.addHexPrefix(txInfo.recipient.data || '')),
+            },
+            {
+                name: 'expireTime',
+                type: 'uint',
+                value: txInfo.expireTime,
+            },
+            {
+                name: 'sequenceId',
+                type: 'uint',
+                value: txInfo.contractSequenceId,
+            },
+            {
+                name: 'signature',
+                type: 'bytes',
+                value: exports.optionalDeps.ethUtil.toBuffer(exports.optionalDeps.ethUtil.addHexPrefix(txInfo.signature)),
+            },
+        ];
+    }
+    /**
+     * Recovers a tx with TSS key shares
+     * same expected arguments as recover method, but with TSS key shares
+     */
+    async recoverTSS(params) {
+        this.validateRecoveryParams(params);
+        // Clean up whitespace from entered values
+        const userPublicOrPrivateKeyShare = params.userKey.replace(/\s/g, '');
+        const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\s/g, '');
+        if ((0, sdk_core_1.getIsUnsignedSweep)({
+            userKey: userPublicOrPrivateKeyShare,
+            backupKey: backupPrivateOrPublicKeyShare,
+            isTss: params.isTss,
+        })) {
+            return this.buildUnsignedSweepTxnTSS(params);
+        }
+        else {
+            const { userKeyShare, backupKeyShare, commonKeyChain } = await sdk_core_1.ECDSAUtils.getMpcV2RecoveryKeyShares(userPublicOrPrivateKeyShare, backupPrivateOrPublicKeyShare, params.walletPassphrase, this.bitgo);
+            const { gasLimit, gasPrice } = await this.getGasValues(params);
+            const MPC = new sdk_core_1.Ecdsa();
+            const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm/0');
+            const backupKeyPair = new lib_1.KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+            const baseAddress = backupKeyPair.getAddress();
+            const unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;
+            const messageHash = unsignedTx.getMessageToSign(true);
+            const signature = await sdk_core_1.ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);
+            const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);
+            const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, signature);
+            return {
+                id: (0, ethereumjs_util_1.addHexPrefix)(signedTx.hash().toString('hex')),
+                tx: (0, ethereumjs_util_1.addHexPrefix)(signedTx.serialize().toString('hex')),
+            };
+        }
+    }
+    async getGasValues(params) {
+        const gasLimit = new exports.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
+        const gasPrice = params.eip1559
+            ? new exports.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : new exports.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));
+        return { gasLimit, gasPrice };
+    }
+    async buildUnsignedSweepTxnTSS(params) {
+        const userPublicOrPrivateKeyShare = params.userKey.replace(/\s/g, '');
+        const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\s/g, '');
+        const { gasLimit, gasPrice } = await this.getGasValues(params);
+        const backupKeyPair = new lib_1.KeyPair({ pub: backupPrivateOrPublicKeyShare });
+        const baseAddress = backupKeyPair.getAddress();
+        const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);
+        return this.formatForOfflineVaultTSS(txInfo, tx, userPublicOrPrivateKeyShare, backupPrivateOrPublicKeyShare, gasPrice, gasLimit, nonce, params.eip1559, params.replayProtectionOptions);
+    }
+    async buildUnsignedSweepTxnMPCv2(params) {
+        const { gasLimit, gasPrice } = await this.getGasValues(params);
+        const recoverParams = params;
+        this.validateUnsignedSweepTSSParams(recoverParams);
+        const derivationPath = recoverParams.derivationSeed ? (0, sdk_lib_mpc_1.getDerivationPath)(recoverParams.derivationSeed) : 'm/0';
+        const MPC = new sdk_core_1.Ecdsa();
+        const derivedCommonKeyChain = MPC.deriveUnhardened(recoverParams.backupKey, derivationPath);
+        const backupKeyPair = new lib_1.KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+        const baseAddress = backupKeyPair.getAddress();
+        const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);
+        return this.buildTxRequestForOfflineVaultMPCv2(txInfo, tx, derivationPath, nonce, gasPrice, gasLimit, params.eip1559, params.replayProtectionOptions, recoverParams.backupKey);
+    }
+    async createBroadcastableSweepTransaction(params) {
+        const req = params.signatureShares;
+        const broadcastableTransactions = [];
+        let lastScanIndex = 0;
+        for (let i = 0; i < req.length; i++) {
+            const transaction = req[i]?.txRequest?.transactions?.[0]?.unsignedTx;
+            if (!req[i].ovc || !req[i].ovc[0].ecdsaSignature) {
+                throw new Error('Missing signature(s)');
+            }
+            if (!transaction.signableHex) {
+                throw new Error('Missing signable hex');
+            }
+            const signature = req[i].ovc[0].ecdsaSignature;
+            if (!signature) {
+                throw new Error('Signature is undefined');
+            }
+            const shares = signature.toString().split(':');
+            if (shares.length !== 4) {
+                throw new Error('Invalid signature');
+            }
+            const finalSignature = {
+                recid: Number(shares[0]),
+                r: shares[1],
+                s: shares[2],
+                y: shares[3],
+            };
+            if (!transaction.coinSpecific?.commonKeyChain) {
+                throw new Error(`Missing common keychain for transaction at index ${i}`);
+            }
+            const commonKeyChain = transaction.coinSpecific.commonKeyChain;
+            if (!transaction.derivationPath) {
+                throw new Error(`Missing derivation path for transaction at index ${i}`);
+            }
+            if (!commonKeyChain) {
+                throw new Error(`Missing common key chain for transaction at index ${i}`);
+            }
+            const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(transaction.eip1559, transaction.replayProtectionOptions);
+            let unsignedTx;
+            if (transaction.eip1559) {
+                unsignedTx = tx_1.FeeMarketEIP1559Transaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));
+            }
+            else {
+                unsignedTx = tx_1.Transaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));
+            }
+            const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, finalSignature);
+            broadcastableTransactions.push({
+                serializedTx: (0, ethereumjs_util_1.addHexPrefix)(signedTx.serialize().toString('hex')),
+            });
+            if (i === req.length - 1 && transaction.coinSpecific?.lastScanIndex) {
+                lastScanIndex = transaction.coinSpecific?.lastScanIndex;
+            }
+        }
+        return { transactions: broadcastableTransactions, lastScanIndex };
+    }
+    /**
+     * Method to validate recovery params
+     * @param {RecoverOptions} params
+     * @returns {void}
+     */
+    async validateUnsignedSweepTSSParams(params) {
+        if (lodash_1.default.isUndefined(params.backupKey) && params.backupKey === '') {
+            throw new Error('missing commonKeyChain');
+        }
+        if (!lodash_1.default.isUndefined(params.derivationSeed) && typeof params.derivationSeed !== 'string') {
+            throw new Error('invalid derivationSeed');
+        }
+        if (lodash_1.default.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('missing or invalid destinationAddress');
+        }
+    }
+    /**
+     * Helper function for recover()
+     * This transforms the unsigned transaction information into a format the BitGo offline vault expects
+     * @param {UnformattedTxInfo} txInfo - tx info
+     * @param {LegacyTransaction | FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object
+     * @param {string} derivationPath - the derivationPath
+     * @param {number} nonce - the nonce of the backup key address
+     * @param {Buffer} gasPrice - gas price for the tx
+     * @param {number} gasLimit - gas limit for the tx
+     * @param {EIP1559} eip1559 - eip1559 params
+     * @param replayProtectionOptions
+     * @param commonKeyChain
+     * @returns {Promise<OfflineVaultTxInfo>}
+     */
+    buildTxRequestForOfflineVaultMPCv2(txInfo, ethTx, derivationPath, nonce, gasPrice, gasLimit, eip1559, replayProtectionOptions, commonKeyChain) {
+        if (!ethTx.to) {
+            throw new Error('Eth tx must have a `to` address');
+        }
+        const fee = eip1559
+            ? gasLimit * eip1559.maxFeePerGas
+            : gasLimit * exports.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed();
+        const unsignedTx = {
+            serializedTxHex: ethTx.serialize().toString('hex'),
+            signableHex: ethTx instanceof tx_1.FeeMarketEIP1559Transaction
+                ? ethTx.getMessageToSign(false).toString('hex')
+                : Buffer.from(rlp_1.RLP.encode((0, ethereumjs_util_1.bufArrToArr)(ethTx.getMessageToSign(false)))).toString('hex'),
+            derivationPath: derivationPath,
+            feeInfo: {
+                fee: fee,
+                feeString: fee.toString(),
+            },
+            parsedTx: {
+                spendAmount: txInfo.recipient.amount,
+                outputs: [
+                    {
+                        coinName: this.getChain(),
+                        address: txInfo.recipient.address,
+                        valueString: txInfo.recipient.amount,
+                    },
+                ],
+            },
+            coinSpecific: {
+                commonKeyChain: commonKeyChain,
+            },
+            eip1559: eip1559,
+            replayProtectionOptions: replayProtectionOptions,
+        };
+        return {
+            txRequests: [
+                {
+                    walletCoin: this.getChain(),
+                    transactions: [
+                        {
+                            unsignedTx: unsignedTx,
+                            nonce: nonce,
+                            signatureShares: [],
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params) {
+        const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, params.apiKey);
+        const nonce = await this.getAddressNonce(baseAddress, params.apiKey);
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: txAmount.toString(10),
+            },
+        ];
+        const txInfo = {
+            recipient: recipients[0],
+            expireTime: this.getDefaultExpireTime(),
+            gasLimit: gasLimit.toString(10),
+        };
+        const txParams = {
+            to: params.recoveryDestination,
+            nonce: nonce,
+            value: txAmount,
+            gasPrice: gasPrice,
+            gasLimit: gasLimit,
+            data: Buffer.from('0x'),
+            eip1559: params.eip1559,
+            replayProtectionOptions: params.replayProtectionOptions,
+        };
+        const tx = AbstractEthLikeNewCoins.buildTransaction(txParams);
+        return { txInfo, tx, nonce };
+    }
+    async validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, apiKey) {
+        const baseAddressBalance = await this.queryAddressBalance(baseAddress, apiKey);
+        let totalGasNeeded = gasPrice.mul(gasLimit);
+        // On L2 chains with L1 data fees, add buffer for L1 fees
+        if (this.staticsCoin?.family !== undefined && lib_1.coinFamiliesWithL1Fees.includes(this.staticsCoin.family)) {
+            totalGasNeeded = totalGasNeeded.add(new exports.optionalDeps.ethUtil.BN(statics_1.ethGasConfigs.l1GasFeeBuffer));
+        }
+        const weiToGwei = new bn_js_1.default(10 ** 9);
+        if (baseAddressBalance.lt(totalGasNeeded)) {
+            throw new Error(`Backup key address ${baseAddress} has balance ${baseAddressBalance.div(weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${totalGasNeeded.div(weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some ETH to this address then retry.`);
+        }
+        const txAmount = baseAddressBalance.sub(totalGasNeeded);
+        return txAmount;
+    }
+    /**
+     * Make a query to blockchain explorer for information such as balance, token balance, solidity calls
+     * @param query {Object} key-value pairs of parameters to append after /api
+     * @param apiKey {string} optional API key to use instead of the one from the environment
+     * @returns {Object} response from the blockchain explorer
+     */
+    async recoveryBlockchainExplorerQuery(query, apiKey) {
+        throw new Error('method not implemented');
+    }
+    /**
+     * Creates the extra parameters needed to build a hop transaction
+     * @param buildParams The original build parameters
+     * @returns extra parameters object to merge with the original build parameters object and send to the platform
+     */
+    async createHopTransactionParams(buildParams) {
+        const wallet = buildParams.wallet;
+        const recipients = buildParams.recipients;
+        const walletPassphrase = buildParams.walletPassphrase;
+        const userKeychain = await this.keychains().get({ id: wallet.keyIds()[0] });
+        const userPrv = await wallet.getUserPrv({ keychain: userKeychain, walletPassphrase });
+        const userPrvBuffer = secp256k1_1.bip32.fromBase58(userPrv).privateKey;
+        if (!userPrvBuffer) {
+            throw new Error('invalid userPrv');
+        }
+        if (!recipients || !Array.isArray(recipients)) {
+            throw new Error('expecting array of recipients');
+        }
+        // Right now we only support 1 recipient
+        if (recipients.length !== 1) {
+            throw new Error('must send to exactly 1 recipient');
+        }
+        const recipientAddress = recipients[0].address;
+        const recipientAmount = recipients[0].amount;
+        const feeEstimateParams = {
+            recipient: recipientAddress,
+            amount: recipientAmount,
+            hop: true,
+        };
+        const feeEstimate = await this.feeEstimate(feeEstimateParams);
+        const gasLimit = feeEstimate.gasLimitEstimate;
+        const gasPrice = Math.round(feeEstimate.feeEstimate / gasLimit);
+        const gasPriceMax = gasPrice * 5;
+        // Payment id a random number so its different for every tx
+        const paymentId = Math.floor(Math.random() * 10000000000).toString();
+        const hopDigest = AbstractEthLikeNewCoins.getHopDigest([
+            recipientAddress,
+            recipientAmount,
+            gasPriceMax.toString(),
+            gasLimit.toString(),
+            paymentId,
+        ]);
+        const userReqSig = exports.optionalDeps.ethUtil.addHexPrefix(Buffer.from(secp256k1_2.default.ecdsaSign(hopDigest, userPrvBuffer).signature).toString('hex'));
+        return {
+            hopParams: {
+                gasPriceMax,
+                userReqSig,
+                paymentId,
+                gasLimit,
+            },
+        };
+    }
+    /**
+     * Validates that the hop prebuild from the HSM is valid and correct
+     * @param {IWallet} wallet - The wallet that the prebuild is for
+     * @param {HopPrebuild} hopPrebuild - The prebuild to validate
+     * @param {Object} originalParams - The original parameters passed to prebuildTransaction
+     * @param {Recipient[]} originalParams.recipients - The original recipients array
+     * @returns {void}
+     * @throws Error if The prebuild is invalid
+     */
+    async validateHopPrebuild(wallet, hopPrebuild, originalParams) {
+        const { tx, id, signature } = hopPrebuild;
+        // first, validate the HSM signature
+        const serverXpub = sdk_core_1.common.Environments[this.bitgo.getEnv()].hsmXpub;
+        const serverPubkeyBuffer = secp256k1_1.bip32.fromBase58(serverXpub).publicKey;
+        const signatureBuffer = Buffer.from(exports.optionalDeps.ethUtil.stripHexPrefix(signature), 'hex');
+        const messageBuffer = Buffer.from(exports.optionalDeps.ethUtil.padToEven(exports.optionalDeps.ethUtil.stripHexPrefix(id)), 'hex');
+        const sig = new Uint8Array(signatureBuffer.slice(1));
+        const isValidSignature = secp256k1_2.default.ecdsaVerify(sig, messageBuffer, serverPubkeyBuffer);
+        if (!isValidSignature) {
+            throw new Error(`Hop txid signature invalid - pub: ${serverXpub}, msg: ${messageBuffer?.toString()}, sig: ${signatureBuffer?.toString()}`);
+        }
+        const builtHopTx = exports.optionalDeps.EthTx.TransactionFactory.fromSerializedData(exports.optionalDeps.ethUtil.toBuffer(tx));
+        // If original params are given, we can check them against the transaction prebuild params
+        if (!lodash_1.default.isNil(originalParams)) {
+            const { recipients } = originalParams;
+            // Then validate that the tx params actually equal the requested params
+            const originalAmount = new bignumber_js_1.BigNumber(recipients[0].amount);
+            const originalDestination = recipients[0].address;
+            const hopAmount = new bignumber_js_1.BigNumber(exports.optionalDeps.ethUtil.bufferToHex(builtHopTx.value));
+            if (!builtHopTx.to) {
+                throw new Error(`Transaction does not have a destination address`);
+            }
+            const hopDestination = builtHopTx.to.toString();
+            if (!hopAmount.eq(originalAmount)) {
+                throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);
+            }
+            if (hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {
+                throw new Error(`Hop destination: ${hopDestination} does not equal original recipient: ${hopDestination}`);
+            }
+        }
+        if (!builtHopTx.verifySignature()) {
+            // We dont want to continue at all in this case, at risk of ETH being stuck on the hop address
+            throw new Error(`Invalid hop transaction signature, txid: ${id}`);
+        }
+        if (exports.optionalDeps.ethUtil.addHexPrefix(builtHopTx.hash().toString('hex')) !== id) {
+            throw new Error(`Signed hop txid does not equal actual txid`);
+        }
+    }
+    /**
+     * Gets the hop digest for the user to sign. This is validated in the HSM to prove that the user requested this tx
+     * @param {string[]} paramsArr - The parameters to hash together for the digest
+     * @returns {Buffer}
+     */
+    static getHopDigest(paramsArr) {
+        const hash = (0, keccak_1.default)('keccak256');
+        hash.update([AbstractEthLikeNewCoins.hopTransactionSalt, ...paramsArr].join('$'));
+        return hash.digest();
+    }
+    /**
+     * Modify prebuild before sending it to the server. Add things like hop transaction params
+     * @param {BuildOptions} buildParams - The whitelisted parameters for this prebuild
+     * @param {boolean} buildParams.hop - True if this should prebuild a hop tx, else false
+     * @param {Recipient[]} buildParams.recipients - The recipients array of this transaction
+     * @param {Wallet} buildParams.wallet - The wallet sending this tx
+     * @param {string} buildParams.walletPassphrase - the passphrase for this wallet
+     * @returns {Promise<BuildOptions>}
+     */
+    async getExtraPrebuildParams(buildParams) {
+        if (!lodash_1.default.isUndefined(buildParams.hop) &&
+            buildParams.hop &&
+            !lodash_1.default.isUndefined(buildParams.wallet) &&
+            !lodash_1.default.isUndefined(buildParams.recipients) &&
+            !lodash_1.default.isUndefined(buildParams.walletPassphrase)) {
+            if (this instanceof ethLikeToken_1.EthLikeToken) {
+                throw new Error(`Hop transactions are not enabled for ERC-20 tokens, nor are they necessary. Please remove the 'hop' parameter and try again.`);
+            }
+            return (await this.createHopTransactionParams({
+                wallet: buildParams.wallet,
+                recipients: buildParams.recipients,
+                walletPassphrase: buildParams.walletPassphrase,
+            }));
+        }
+        return {};
+    }
+    /**
+     * Modify prebuild after receiving it from the server. Add things like nlocktime
+     * @param {TransactionPrebuild} params - The prebuild to modify
+     * @returns {TransactionPrebuild} The modified prebuild
+     */
+    async postProcessPrebuild(params) {
+        if (!lodash_1.default.isUndefined(params.hopTransaction) && !lodash_1.default.isUndefined(params.wallet) && !lodash_1.default.isUndefined(params.buildParams)) {
+            await this.validateHopPrebuild(params.wallet, params.hopTransaction, params.buildParams);
+        }
+        return params;
+    }
+    /**
+     * Coin-specific things done before signing a transaction, i.e. verification
+     * @param {PresignTransactionOptions} params
+     * @returns {Promise<PresignTransactionOptions>}
+     */
+    async presignTransaction(params) {
+        if (!lodash_1.default.isUndefined(params.hopTransaction) && !lodash_1.default.isUndefined(params.wallet) && !lodash_1.default.isUndefined(params.buildParams)) {
+            await this.validateHopPrebuild(params.wallet, params.hopTransaction);
+        }
+        return params;
+    }
+    /**
+     * Fetch fee estimate information from the server
+     * @param {Object} params - The params passed into the function
+     * @param {boolean} [params.hop] - True if we should estimate fee for a hop transaction
+     * @param {string} [params.recipient] - The recipient of the transaction to estimate a send to
+     * @param {string} [params.data] - The ETH tx data to estimate a send for
+     * @returns {Object} The fee info returned from the server
+     */
+    async feeEstimate(params) {
+        const query = {};
+        if (params && params.hop) {
+            query.hop = params.hop;
+        }
+        if (params && params.recipient) {
+            query.recipient = params.recipient;
+        }
+        if (params && params.data) {
+            query.data = params.data;
+        }
+        if (params && params.amount) {
+            query.amount = params.amount;
+        }
+        return await this.bitgo.get(this.url('/tx/fee')).query(query).result();
+    }
+    /**
+     * Generate secp256k1 key pair
+     *
+     * @param {Buffer} seed
+     * @returns {KeyPair} object with generated pub and prv
+     */
+    generateKeyPair(seed) {
+        if (!seed) {
+            // An extended private key has both a normal 256 bit private key and a 256
+            // bit chain code, both of which must be random. 512 bits is therefore the
+            // maximum entropy and gives us maximum security against cracking.
+            seed = (0, crypto_1.randomBytes)(512 / 8);
+        }
+        const extendedKey = secp256k1_1.bip32.fromSeed(seed);
+        const xpub = extendedKey.neutered().toBase58();
+        return {
+            pub: xpub,
+            prv: extendedKey.toBase58(),
+        };
+    }
+    async parseTransaction(params) {
+        return {};
+    }
+    /**
+     * Get forwarder factory and implementation addresses for deposit address verification.
+     * Forwarders are smart contracts that forward funds to the base wallet address.
+     *
+     * @param {number | undefined} forwarderVersion - The wallet version
+     * @returns {object} Factory and implementation addresses for forwarders
+     */
+    getForwarderFactoryAddressesAndForwarderImplementationAddress(forwarderVersion) {
+        const ethNetwork = this.getNetwork();
+        switch (forwarderVersion) {
+            case 1:
+                if (!ethNetwork?.forwarderFactoryAddress || !ethNetwork?.forwarderImplementationAddress) {
+                    throw new Error('Forwarder factory addresses not configured for this network');
+                }
+                return {
+                    forwarderFactoryAddress: ethNetwork.forwarderFactoryAddress,
+                    forwarderImplementationAddress: ethNetwork.forwarderImplementationAddress,
+                };
+            case 2:
+                if (!ethNetwork?.walletV2ForwarderFactoryAddress || !ethNetwork?.walletV2ForwarderImplementationAddress) {
+                    throw new Error('Wallet v2 factory addresses not configured for this network');
+                }
+                return {
+                    forwarderFactoryAddress: ethNetwork.walletV2ForwarderFactoryAddress,
+                    forwarderImplementationAddress: ethNetwork.walletV2ForwarderImplementationAddress,
+                };
+            case 4:
+            case 5:
+                if (!ethNetwork?.walletV4ForwarderFactoryAddress || !ethNetwork?.walletV4ForwarderImplementationAddress) {
+                    throw new Error(`Forwarder v${forwarderVersion} factory addresses not configured for this network`);
+                }
+                return {
+                    forwarderFactoryAddress: ethNetwork.walletV4ForwarderFactoryAddress,
+                    forwarderImplementationAddress: ethNetwork.walletV4ForwarderImplementationAddress,
+                };
+            default:
+                throw new Error(`Forwarder version ${forwarderVersion} not supported`);
+        }
+    }
+    /**
+     * Get wallet base address factory and implementation addresses.
+     * This is used for base address verification for V1, V2, V4, and V5 wallets.
+     * The base address is the main wallet contract deployed via CREATE2.
+     *
+     * @param {number} walletVersion - The wallet version (1, 2, 4, or 5)
+     * @returns {object} Factory and implementation addresses for the wallet base address
+     * @throws {Error} if wallet version addresses are not configured
+     */
+    getWalletAddressFactoryAddressesAndImplementationAddress(walletVersion) {
+        const ethNetwork = this.getNetwork();
+        switch (walletVersion) {
+            case 1:
+                if (!ethNetwork?.walletFactoryAddress || !ethNetwork?.walletImplementationAddress) {
+                    throw new Error('Wallet v1 factory addresses not configured for this network');
+                }
+                return {
+                    walletFactoryAddress: ethNetwork.walletFactoryAddress,
+                    walletImplementationAddress: ethNetwork.walletImplementationAddress,
+                };
+            case 2:
+                if (!ethNetwork?.walletV2FactoryAddress || !ethNetwork?.walletV2ImplementationAddress) {
+                    throw new Error('Wallet v2 factory addresses not configured for this network');
+                }
+                return {
+                    walletFactoryAddress: ethNetwork.walletV2FactoryAddress,
+                    walletImplementationAddress: ethNetwork.walletV2ImplementationAddress,
+                };
+            case 4:
+            case 5:
+                if (!ethNetwork?.walletV4ForwarderFactoryAddress || !ethNetwork?.walletV4ForwarderImplementationAddress) {
+                    throw new Error(`Wallet v${walletVersion} factory addresses not configured for this network`);
+                }
+                return {
+                    walletFactoryAddress: ethNetwork.walletV4ForwarderFactoryAddress,
+                    walletImplementationAddress: ethNetwork.walletV4ForwarderImplementationAddress,
+                };
+            default:
+                throw new Error(`Wallet version ${walletVersion} not supported`);
+        }
+    }
+    /**
+     * Helper method to create a salt buffer from hex string.
+     * Converts a hex salt string to a 32-byte buffer.
+     *
+     * @param {string} salt - The hex salt string
+     * @returns {Buffer} 32-byte salt buffer
+     */
+    createSaltBuffer(salt) {
+        const ethUtil = exports.optionalDeps.ethUtil;
+        return ethUtil.setLengthLeft(Buffer.from(ethUtil.padToEven(ethUtil.stripHexPrefix(salt || '')), 'hex'), 32);
+    }
+    /**
+     * Verify BIP32 wallet base address (V1, V2, V4).
+     * These wallets use a wallet factory to deploy base addresses with CREATE2.
+     * The address is derived from the keychains' ethAddresses and a salt.
+     *
+     * @param {VerifyBip32BaseAddressOptions} params - Verification parameters
+     * @returns {object} Expected and actual addresses for comparison
+     */
+    verifyCreate2BaseAddress(params) {
+        const { address, coinSpecific, keychains, walletVersion } = params;
+        if (!coinSpecific.salt) {
+            throw new Error(`missing salt for v${walletVersion} base address verification`);
+        }
+        // Get wallet factory and implementation addresses for the wallet version
+        const { walletFactoryAddress, walletImplementationAddress } = this.getWalletAddressFactoryAddressesAndImplementationAddress(walletVersion);
+        const initcode = (0, lib_1.getProxyInitcode)(walletImplementationAddress);
+        // Convert the wallet salt to a buffer, pad to 32 bytes
+        const saltBuffer = this.createSaltBuffer(coinSpecific.salt);
+        // Reconstruct calculationSalt using keychains' ethAddresses and wallet salt
+        const ethAddresses = keychains.map((kc) => {
+            if (!kc.ethAddress) {
+                throw new Error(`keychain missing ethAddress for v${walletVersion} base address verification`);
+            }
+            return kc.ethAddress;
+        });
+        const calculationSalt = exports.optionalDeps.ethUtil.bufferToHex(exports.optionalDeps.ethAbi.soliditySHA3(['address[]', 'bytes32'], [ethAddresses, saltBuffer]));
+        const expectedAddress = (0, lib_1.calculateForwarderV1Address)(walletFactoryAddress, calculationSalt, initcode);
+        if (expectedAddress !== address) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);
+        }
+        return true;
+    }
+    /**
+     * Verify forwarder receive address (deposit address).
+     * Forwarder addresses are derived using CREATE2 from the base address and salt.
+     *
+     * @param {VerifyEthAddressOptions} params - Verification parameters
+     * @param {number} forwarderVersion - The forwarder version
+     * @returns {object} Expected and actual addresses for comparison
+     */
+    verifyForwarderAddress(params, forwarderVersion) {
+        const { address, coinSpecific, baseAddress } = params;
+        const { forwarderFactoryAddress, forwarderImplementationAddress } = this.getForwarderFactoryAddressesAndForwarderImplementationAddress(forwarderVersion);
+        const initcode = (0, lib_1.getProxyInitcode)(forwarderImplementationAddress);
+        const saltBuffer = this.createSaltBuffer(coinSpecific.salt || '');
+        const { createForwarderParams, createForwarderTypes } = forwarderVersion === 4
+            ? (0, lib_1.getCreateForwarderParamsAndTypes)(baseAddress, saltBuffer, coinSpecific.feeAddress)
+            : (0, lib_1.getCreateForwarderParamsAndTypes)(baseAddress, saltBuffer);
+        const calculationSalt = exports.optionalDeps.ethUtil.bufferToHex(exports.optionalDeps.ethAbi.soliditySHA3(createForwarderTypes, createForwarderParams));
+        const expectedAddress = (0, lib_1.calculateForwarderV1Address)(forwarderFactoryAddress, calculationSalt, initcode);
+        if (expectedAddress !== address) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);
+        }
+        return true;
+    }
+    /**
+     * 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 { address, impliedForwarderVersion, coinSpecific, baseAddress } = params;
+        const forwarderVersion = impliedForwarderVersion ?? coinSpecific?.forwarderVersion;
+        // Validate address format
+        if (address && !this.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        // Forwarder version 0 addresses cannot be verified because we do not store the nonce value required for address derivation.
+        if (forwarderVersion === 0) {
+            return true;
+        }
+        // Determine if we are verifying a base address
+        const isVerifyingBaseAddress = baseAddress && address === baseAddress;
+        // TSS/MPC wallet address verification (V3, V5, V6)
+        // V5 base addresses use TSS, but V5 forwarders use the regular forwarder verification
+        const isTssWalletVersion = params.walletVersion === 3 || params.walletVersion === 5 || params.walletVersion === 6;
+        const shouldUseTssVerification = (0, sdk_core_1.isTssVerifyAddressOptions)(params) && isTssWalletVersion && (params.walletVersion !== 5 || isVerifyingBaseAddress);
+        if (shouldUseTssVerification) {
+            if (isVerifyingBaseAddress) {
+                const index = typeof params.index === 'string' ? parseInt(params.index, 10) : params.index;
+                if (index !== 0) {
+                    throw new Error(`Base address verification requires index 0, but got index ${params.index}. ` +
+                        `The base address is always derived at index 0.`);
+                }
+            }
+            return (0, sdk_core_1.verifyMPCWalletAddress)({ ...params, keyCurve: 'secp256k1' }, this.isValidAddress, (pubKey) => {
+                return new lib_1.KeyPair({ pub: pubKey }).getAddress();
+            });
+        }
+        // From here on, we need baseAddress and coinSpecific for non-TSS verifications
+        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');
+        }
+        // BIP32 wallet base address verification (V1, V2, V4)
+        if (isVerifyingBaseAddress && isVerifyContractBaseAddressOptions(params)) {
+            return this.verifyCreate2BaseAddress(params);
+        }
+        // Forwarder receive address verification (deposit addresses)
+        if (!isVerifyingBaseAddress) {
+            return this.verifyForwarderAddress(params, forwarderVersion);
+        }
+        // If we reach here, it's a base address verification for an unsupported wallet version
+        throw new Error(`Base address verification not supported for wallet version ${params.walletVersion}`);
+    }
+    /**
+     * Locally derive an ETH wallet receive address from a derivation path, using the wallet's
+     * commonKeychain only (no private keys, no network access). The inverse of
+     * {@link isWalletAddress}: it *produces* the address via the same secp256k1 MPC derivation
+     * that isWalletAddress checks against (`deriveMPCWalletAddress` + `KeyPair.getAddress()`),
+     * so derive and verify can never diverge.
+     *
+     * Supports MPC/TSS wallets only (wallet versions 3, 5, 6). Legacy BIP32 forwarder wallets
+     * (versions 1, 2, 4) derive per-index forwarder contract addresses and are handled separately.
+     * @param params keychains (commonKeychain), derivation index, walletVersion, and optional SMC seed
+     * @returns the derived address, the index used, and the HD derivation path
+     */
+    async deriveAddress(params) {
+        const { walletVersion, index } = params;
+        const forwarderVersion = params.coinSpecific?.forwarderVersion;
+        // Mirrors isWalletAddress's branching:
+        // - MPC/TSS receive addresses: v3 & v6 (every index), and the v5 *base* address (index 0).
+        // - Forwarder (CREATE2) receive addresses: legacy v1/v2/v4 wallets, and v5 forwarders (index > 0).
+        const useMpc = walletVersion === 3 || walletVersion === 6 || (walletVersion === 5 && index === 0);
+        if (useMpc) {
+            const { address, derivationPath } = await (0, sdk_core_1.deriveMPCWalletAddress)({
+                // extractCommonKeychain validates the commonKeychain is present at runtime
+                keychains: (params.keychains ?? []),
+                index,
+                derivedFromParentWithSeed: params.derivedFromParentWithSeed,
+                multisigTypeVersion: params.multisigTypeVersion,
+                keyCurve: 'secp256k1',
+            }, (pubKey) => new lib_1.KeyPair({ pub: pubKey }).getAddress());
+            return { address, index, derivationPath };
+        }
+        // Forwarder (CREATE2) derivation for legacy multisig / v5 forwarder receive addresses.
+        if (forwarderVersion === 0) {
+            throw new Error('Forwarder version 0 addresses cannot be derived: the nonce required for address derivation is not stored.');
+        }
+        if (forwarderVersion === 1 || forwarderVersion === 2 || forwarderVersion === 4) {
+            const { baseAddress, coinSpecific } = params;
+            if (!baseAddress) {
+                throw new Error('baseAddress is required to derive a forwarder address');
+            }
+            const feeAddress = coinSpecific?.feeAddress ?? '';
+            if (forwarderVersion === 4 && !feeAddress) {
+                throw new Error('coinSpecific.feeAddress is required to derive a v4 forwarder address');
+            }
+            const { forwarderFactoryAddress, forwarderImplementationAddress } = this.getForwarderFactoryAddressesAndForwarderImplementationAddress(forwarderVersion);
+            // For BitGo forwarders the per-address salt is the derivation index, so the forwarder
+            // address is reproducible from (baseAddress, index) plus the network factory/implementation.
+            const address = this.generateForwarderAddress(baseAddress, feeAddress, forwarderFactoryAddress, forwarderImplementationAddress, index);
+            return { address, index, coinSpecific: { forwarderVersion } };
+        }
+        throw new Error(`deriveAddress: could not determine an ETH derivation strategy. Provide an MPC wallet ` +
+            `(walletVersion 3/5/6 with commonKeychain), or a legacy forwarder (coinSpecific.forwarderVersion ` +
+            `1/2/4 with baseAddress). Got walletVersion=${walletVersion}, forwarderVersion=${forwarderVersion}.`);
+    }
+    /**
+     *
+     * @param {TransactionPrebuild} txPrebuild
+     * @returns {boolean}
+     */
+    verifyCoin(txPrebuild) {
+        const nativeCoin = this.getChain().split(':')[0];
+        return txPrebuild.coin === nativeCoin;
+    }
+    /**
+     * Generate transaction explanation for error reporting
+     * @param txPrebuild - Transaction prebuild containing txHex and fee info
+     * @returns Stringified JSON explanation
+     */
+    async getTxExplanation(txPrebuild) {
+        if (!txPrebuild?.txHex || !txPrebuild?.gasPrice) {
+            return undefined;
+        }
+        try {
+            const explanation = await this.explainTransaction({
+                txHex: txPrebuild.txHex,
+                feeInfo: {
+                    fee: txPrebuild.gasPrice.toString(),
+                },
+            });
+            return JSON.stringify(explanation, null, 2);
+        }
+        catch (e) {
+            const errorDetails = {
+                error: 'Failed to parse transaction explanation',
+                txHex: txPrebuild.txHex,
+                details: e instanceof Error ? e.message : String(e),
+            };
+            return JSON.stringify(errorDetails, null, 2);
+        }
+    }
+    /**
+     * Verify if a tss transaction is valid
+     *
+    /** @inheritdoc CoinWithSignableConsistency */
+    assertSignableConsistency(serializedTxHex, signableHex) {
+        const common = AbstractEthLikeNewCoins.getCustomChainCommon(this.getChainId());
+        // getCustomChainCommon defaults to the london hardfork, which is only valid for chains
+        // that activated EIP-1559. Chains without it (e.g. BSC, XDC) sign under petersburg.
+        if (!this.staticsCoin?.features.includes(statics_1.CoinFeature.EIP1559)) {
+            common.setHardfork(exports.optionalDeps.EthCommon.Hardfork.Petersburg);
+        }
+        const ethTx = tx_1.TransactionFactory.fromSerializedData((0, ethereumjs_util_1.toBuffer)((0, ethereumjs_util_1.addHexPrefix)(serializedTxHex)), { common });
+        const derivedSignableHex = ethTx instanceof tx_1.FeeMarketEIP1559Transaction
+            ? ethTx.getMessageToSign(false).toString('hex')
+            : Buffer.from(rlp_1.RLP.encode((0, ethereumjs_util_1.bufArrToArr)(ethTx.getMessageToSign(false)))).toString('hex');
+        if (derivedSignableHex !== signableHex) {
+            throw new sdk_core_1.InvalidTransactionError('signableHex is inconsistent with serializedTxHex: possible server tampering');
+        }
+    }
+    /**
+     * Decode-and-assert for the ERC-7984 shield approve leg (defense-in-depth).
+     *
+     * The approve is signed through the chain coin, whose generic checks never parse calldata.
+     * WP builds the bytes server-side; re-parse them here so the client signs only
+     * `approve(wrapper, amount)` on the pair's underlying ERC-20 with the amount from the intent.
+     * Fails closed on any deviation.
+     *
+     * Scope: this runs when the declared type is `wrapApprove`, and {@link assertWrapperApproveIsDeclared} also
+     * forces any approve whose spender is a registered wrapper through it. Deliberately NOT covered: an approve
+     * of a registered underlying to a third-party spender under another declared type (tokenApproval, defiApprove,
+     * customTx) is indistinguishable from a legitimate approval, so a server that relabels the intent of such a
+     * tx still skips this check on signing paths that carry no caller txParams (pendingApproval re-sign).
+     */
+    async verifyWrapApproveTransaction(params, throwRecipientMismatch) {
+        const { txParams, txPrebuild } = params;
+        if (!txPrebuild?.txHex) {
+            throw new Error('missing txHex in txPrebuild');
+        }
+        const wrapParams = txParams.wrapParams;
+        if (!wrapParams?.tokenName || !wrapParams.amount) {
+            return throwRecipientMismatch('wrapApprove transaction requires wrapParams with tokenName and amount', []);
+        }
+        let wrapper;
+        try {
+            const staticsCoin = statics_1.coins.get(wrapParams.tokenName);
+            if (!(staticsCoin instanceof statics_1.Erc7984Coin) || !staticsCoin.underlyingErc20Address) {
+                throw new Error('not an ERC-7984 pair');
+            }
+            wrapper = staticsCoin;
+        }
+        catch {
+            return throwRecipientMismatch(`wrapApprove: '${wrapParams.tokenName}' is not a registered ERC-7984 shield pair`, []);
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txPrebuild.txHex);
+        const txJson = (await txBuilder.build()).toJson();
+        const mismatch = (message, address = txJson.to, amount = txJson.value) => throwRecipientMismatch(message, [{ address: address || '', amount: amount || '' }]);
+        if (!txJson.to || txJson.to.toLowerCase() !== wrapper.underlyingErc20Address) {
+            await mismatch('wrapApprove transaction must target the underlying ERC-20 of the wrapper');
+        }
+        if (txJson.value !== undefined && String(txJson.value) !== '0') {
+            await mismatch('wrapApprove transaction must not carry native value');
+        }
+        let decoded;
+        try {
+            decoded = (0, lib_1.decodeApproveCalldata)(txJson.data || '');
+        }
+        catch (e) {
+            return mismatch(`wrapApprove transaction must use ERC-20 approve(address,uint256) calldata — ${e.message}`);
+        }
+        if (decoded.spender.toLowerCase() !== wrapper.contractAddress.toLowerCase()) {
+            await mismatch('wrapApprove transaction spender does not match the wrapper contract', decoded.spender);
+        }
+        if (decoded.amount !== wrapParams.amount) {
+            await mismatch('wrapApprove transaction amount does not match the requested amount', txJson.to, decoded.amount);
+        }
+    }
+    /**
+     * Content-based guard for the ERC-7984 shield approve leg, for txs NOT declared `wrapApprove`.
+     *
+     * On signing paths that carry no caller txParams (pendingApproval re-sign) the declared type is the
+     * server-persisted `intent.intentType`, so a compromised or buggy WP could relabel a mutated
+     * `approve(wrapper, amount)` as another type and skip `verifyWrapApproveTransaction`. So an
+     * `approve(address,uint256)` sent to a registered ERC-7984 underlying whose spender is that pair's wrapper
+     * MUST be declared `wrapApprove` (and so pass the spender/amount check).
+     *
+     * A tx is rejected only when ALL of these hold:
+     *   1. the tx targets a registered ERC-7984 underlying (`to` is in `getErc7984WrappersByUnderlying()`);
+     *   2. the calldata is `approve(address,uint256)` (selector match);
+     *   3. the spender (first ABI word) is that underlying's wrapper;
+     *   4. the declared type is not `wrapApprove` (enforced by the caller, which only invokes this method then).
+     *
+     * Scoped to wrapper-directed approvals only: approvals of the same token to any other spender, transfers,
+     * and every other call are untouched. Known exceptions to "only the shield journey approves the wrapper":
+     * a dApp (WalletConnect) approving the wrapper directly would be rejected here, and the unbuilt Phase-2
+     * `approve(0)` allowance-reset leg must be declared `wrapApprove` (or get its own branch).
+     *
+     * Parsing is best-effort: if the tx cannot be parsed by this coin's builder the check is skipped, so it can
+     * never introduce a new failure for a tx that was verifiable before.
+     */
+    async assertWrapperApproveIsDeclared(params, throwRecipientMismatch) {
+        const { txPrebuild } = params;
+        if (!txPrebuild?.txHex) {
+            return;
+        }
+        const wrappersByUnderlying = getErc7984WrappersByUnderlying();
+        if (wrappersByUnderlying.size === 0) {
+            return;
+        }
+        // Cheap prefilter: calldata is serialized as literal bytes, so an approve can only be present if the
+        // 4-byte selector appears in the hex. Nearly every other tx returns here without touching the builder.
+        if (!txPrebuild.txHex.toLowerCase().includes(lib_1.approveMethodId.slice(2).toLowerCase())) {
+            return;
+        }
+        let txJson;
+        try {
+            const txBuilder = this.getTransactionBuilder();
+            txBuilder.from(txPrebuild.txHex);
+            txJson = (await txBuilder.build()).toJson();
+        }
+        catch {
+            // Not parseable by this builder: leave it to the type-specific checks and the signer.
+            return;
+        }
+        const wrappers = txJson.to ? wrappersByUnderlying.get(txJson.to.toLowerCase()) : undefined;
+        const data = (txJson.data || '').toLowerCase();
+        // Read the spender leniently (first ABI word after the selector) rather than via the strict decoder: an
+        // ERC-20 ignores trailing bytes, so approve(wrapper, amount) + junk would otherwise slip past a strict parse.
+        if (!wrappers || !data.startsWith(lib_1.approveMethodId.toLowerCase()) || data.length < 10 + 64) {
+            return;
+        }
+        const spender = `0x${data.slice(10 + 24, 10 + 64)}`;
+        if (wrappers.has(spender)) {
+            await throwRecipientMismatch('approve() of an ERC-7984 wrapper must be declared as a wrapApprove intent', [
+                { address: spender, amount: txJson.value || '' },
+            ]);
+        }
+    }
+    /**
+     * @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}
+     * @throws {TxIntentMismatchRecipientError} if transaction recipients don't match user intent
+     */
+    async verifyTssTransaction(params) {
+        const { txParams, txPrebuild, wallet } = params;
+        // Helper to throw TxIntentMismatchRecipientError with recipient details
+        const throwRecipientMismatch = async (message, mismatchedRecipients) => {
+            const txExplanation = await this.getTxExplanation(txPrebuild);
+            throw new sdk_core_1.TxIntentMismatchRecipientError(message, undefined, [txParams], txPrebuild?.txHex, mismatchedRecipients, txExplanation);
+        };
+        if (!txParams?.recipients &&
+            !(txParams.prebuildTx?.consolidateId ||
+                txPrebuild?.consolidateId ||
+                txParams.stakingRequestId ||
+                txParams.prebuildTx?.stakingRequestId ||
+                (txParams.type && sdk_core_1.NO_RECIPIENT_TX_TYPES.has(txParams.type)))) {
+            throw new Error('missing txParams');
+        }
+        if (!wallet || !txPrebuild) {
+            throw new Error('missing params');
+        }
+        if (txParams.hop && txParams.recipients && txParams.recipients.length > 1) {
+            throw new Error('tx cannot be both a batch and hop transaction');
+        }
+        if (txParams.type && ['transfer'].includes(txParams.type)) {
+            if (txParams.recipients && txParams.recipients.length === 1) {
+                const recipients = txParams.recipients;
+                const expectedAmount = recipients[0].amount.toString();
+                const expectedDestination = recipients[0].address;
+                const txBuilder = this.getTransactionBuilder();
+                txBuilder.from(txPrebuild.txHex);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                if (txJson.data === '0x') {
+                    if (expectedAmount !== txJson.value) {
+                        await throwRecipientMismatch('the transaction amount in txPrebuild does not match the value given by client', [{ address: txJson.to, amount: txJson.value }]);
+                    }
+                    if (expectedDestination.toLowerCase() !== txJson.to.toLowerCase()) {
+                        await throwRecipientMismatch('destination address does not match with the recipient address', [
+                            { address: txJson.to, amount: txJson.value },
+                        ]);
+                    }
+                }
+                else if (txJson.data.startsWith('0xa9059cbb')) {
+                    const [recipientAddress, amount] = (0, lib_1.getRawDecoded)(['address', 'uint256'], (0, lib_1.getBufferedByteCode)('0xa9059cbb', txJson.data));
+                    // Check if recipients[0].data exists (WalletConnect flow)
+                    let expectedRecipientAddress;
+                    let expectedTokenAmount;
+                    const recipientData = recipients[0].data;
+                    if (recipientData && recipientData.startsWith('0xa9059cbb')) {
+                        // WalletConnect: decode expected recipient and amount from recipients[0].data
+                        const [expectedRecipient, expectedAmount] = (0, lib_1.getRawDecoded)(['address', 'uint256'], (0, lib_1.getBufferedByteCode)('0xa9059cbb', recipientData));
+                        expectedRecipientAddress = (0, ethereumjs_util_1.addHexPrefix)(expectedRecipient.toString()).toLowerCase();
+                        expectedTokenAmount = expectedAmount.toString();
+                    }
+                    else {
+                        // Normal flow: use recipients[0].address and recipients[0].amount
+                        expectedRecipientAddress = expectedDestination.toLowerCase();
+                        expectedTokenAmount = expectedAmount;
+                    }
+                    if (expectedTokenAmount !== amount.toString()) {
+                        await throwRecipientMismatch('the transaction amount in txPrebuild does not match the value given by client', [{ address: (0, ethereumjs_util_1.addHexPrefix)(recipientAddress.toString()), amount: amount.toString() }]);
+                    }
+                    if (expectedRecipientAddress !== (0, ethereumjs_util_1.addHexPrefix)(recipientAddress.toString()).toLowerCase()) {
+                        await throwRecipientMismatch('destination address does not match with the recipient address', [
+                            { address: (0, ethereumjs_util_1.addHexPrefix)(recipientAddress.toString()), amount: amount.toString() },
+                        ]);
+                    }
+                }
+            }
+        }
+        if (txParams.type && ['defiApprove', 'defiDeposit', 'defiWithdraw'].includes(txParams.type)) {
+            if (!txPrebuild.txHex) {
+                throw new Error('missing txHex in txPrebuild');
+            }
+            const baseAddress = wallet.coinSpecific()?.baseAddress;
+            const defiParams = txParams.defiParams;
+            if (!baseAddress || !defiParams) {
+                await throwRecipientMismatch('DeFi transaction is missing required intent parameters', []);
+                return false;
+            }
+            const validatedBaseAddress = baseAddress;
+            const validatedDefiParams = defiParams;
+            const txBuilder = this.getTransactionBuilder();
+            txBuilder.from(txPrebuild.txHex);
+            const txJson = (await txBuilder.build()).toJson();
+            const mismatch = async (message, address = txJson.to, amount = txJson.value) => throwRecipientMismatch(message, [{ address: address || '', amount: amount || '' }]);
+            const data = txJson.data || '';
+            if (txParams.type === 'defiApprove') {
+                const selector = (0, ethereumjs_util_1.addHexPrefix)(exports.optionalDeps.ethAbi.methodID('approve', ['address', 'uint256']).toString('hex'));
+                if (!data.startsWith(selector)) {
+                    await mismatch('defiApprove transaction must use ERC-20 approve(address,uint256) calldata');
+                }
+                const [, amount] = (0, lib_1.getRawDecoded)(['address', 'uint256'], (0, lib_1.getBufferedByteCode)(selector, data));
+                if (amount.toString() !== validatedDefiParams.amount) {
+                    await mismatch('defiApprove transaction amount does not match the requested amount', txJson.to, amount.toString());
+                }
+            }
+            else if (txParams.type === 'defiDeposit') {
+                const selector = (0, ethereumjs_util_1.addHexPrefix)(exports.optionalDeps.ethAbi.methodID('deposit', ['uint256', 'address']).toString('hex'));
+                if (!data.startsWith(selector)) {
+                    await mismatch('defiDeposit transaction must use deposit(uint256,address) calldata');
+                }
+                const [amount, receiver] = (0, lib_1.getRawDecoded)(['uint256', 'address'], (0, lib_1.getBufferedByteCode)(selector, data));
+                const decodedReceiver = (0, ethereumjs_util_1.addHexPrefix)(receiver.toString()).toLowerCase();
+                if (decodedReceiver !== validatedBaseAddress.toLowerCase()) {
+                    await mismatch('defiDeposit transaction receiver does not match wallet base address', decodedReceiver, amount.toString());
+                }
+                if (amount.toString() !== validatedDefiParams.amount) {
+                    await mismatch('defiDeposit transaction amount does not match the requested amount', decodedReceiver, amount.toString());
+                }
+            }
+            else {
+                const selector = (0, ethereumjs_util_1.addHexPrefix)(exports.optionalDeps.ethAbi.methodID('redeem', ['uint256', 'address', 'address']).toString('hex'));
+                if (!data.startsWith(selector)) {
+                    await mismatch('defiWithdraw transaction must use redeem(uint256,address,address) calldata');
+                }
+                const [shares, receiver, owner] = (0, lib_1.getRawDecoded)(['uint256', 'address', 'address'], (0, lib_1.getBufferedByteCode)(selector, data));
+                const decodedReceiver = (0, ethereumjs_util_1.addHexPrefix)(receiver.toString()).toLowerCase();
+                const decodedOwner = (0, ethereumjs_util_1.addHexPrefix)(owner.toString()).toLowerCase();
+                if (decodedReceiver !== validatedBaseAddress.toLowerCase() ||
+                    decodedOwner !== validatedBaseAddress.toLowerCase()) {
+                    await mismatch('defiWithdraw transaction receiver and owner must match wallet base address', decodedReceiver, shares.toString());
+                }
+                if (shares.toString() !== validatedDefiParams.amount) {
+                    await mismatch('defiWithdraw transaction shares do not match the requested amount', decodedReceiver, shares.toString());
+                }
+            }
+        }
+        if (txParams.type === 'wrapApprove') {
+            await this.verifyWrapApproveTransaction(params, throwRecipientMismatch);
+        }
+        else {
+            // Declared as anything else: only an approve of a registered wrapper is rejected (see the method doc);
+            // for every other tx this returns without parsing or after one best-effort parse.
+            await this.assertWrapperApproveIsDeclared(params, throwRecipientMismatch);
+        }
+        // Verify consolidation transactions send to base address
+        if (params.verification?.consolidationToBaseAddress) {
+            const coinSpecific = wallet.coinSpecific();
+            if (!coinSpecific || !coinSpecific.baseAddress) {
+                throw new Error('Unable to determine base address for consolidation');
+            }
+            const baseAddress = coinSpecific.baseAddress;
+            if (!txPrebuild.txHex) {
+                throw new Error('missing txHex in txPrebuild');
+            }
+            const txBuilder = this.getTransactionBuilder();
+            txBuilder.from(txPrebuild.txHex);
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            // Verify the transaction recipient matches the base address
+            if (!txJson.to) {
+                throw new Error('Consolidation transaction is missing recipient address');
+            }
+            const erc20TransferSelector = (0, ethereumjs_util_1.addHexPrefix)(exports.optionalDeps.ethAbi.methodID('transfer', ['address', 'uint256']).toString('hex'));
+            if (txJson.data && txJson.data.startsWith(erc20TransferSelector)) {
+                // For ERC20 token consolidations, txJson.to is the token contract address,
+                // not the actual transfer recipient. The real recipient is encoded in the
+                // transfer(address,uint256) calldata. Decode it and verify against baseAddress.
+                const [recipientAddress] = (0, lib_1.getRawDecoded)(['address', 'uint256'], (0, lib_1.getBufferedByteCode)(erc20TransferSelector, txJson.data));
+                const decodedRecipient = (0, ethereumjs_util_1.addHexPrefix)(recipientAddress.toString()).toLowerCase();
+                if (decodedRecipient !== baseAddress.toLowerCase()) {
+                    await throwRecipientMismatch('Consolidation transaction recipient does not match wallet base address', [
+                        { address: decodedRecipient, amount: txJson.value },
+                    ]);
+                }
+            }
+            else if (txJson.to.toLowerCase() !== baseAddress.toLowerCase()) {
+                // Native coin consolidation: txJson.to is the actual recipient
+                await throwRecipientMismatch('Consolidation transaction recipient does not match wallet base address', [
+                    { address: txJson.to, amount: txJson.value },
+                ]);
+            }
+        }
+        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}
+     * @throws {TxIntentMismatchError} if transaction validation fails
+     * @throws {TxIntentMismatchRecipientError} if transaction recipients don't match user intent
+     */
+    async verifyTransaction(params) {
+        const ethNetwork = this.getNetwork();
+        const { txParams, txPrebuild, wallet, walletType } = params;
+        if (walletType === 'tss') {
+            return this.verifyTssTransaction(params);
+        }
+        // Helper to throw TxIntentMismatchRecipientError with recipient details
+        const throwRecipientMismatch = async (message, mismatchedRecipients) => {
+            const txExplanation = await this.getTxExplanation(txPrebuild);
+            throw new sdk_core_1.TxIntentMismatchRecipientError(message, undefined, [txParams], txPrebuild?.txHex, mismatchedRecipients, txExplanation);
+        };
+        if (!txParams?.recipients || !txPrebuild?.recipients || !wallet) {
+            throw new Error('missing params');
+        }
+        const recipients = txParams.recipients;
+        if (txParams.hop && recipients.length > 1) {
+            throw new Error('tx cannot be both a batch and hop transaction');
+        }
+        if (txPrebuild.recipients.length > 1) {
+            throw new Error(`${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`);
+        }
+        if (txParams.type === 'enabletoken') {
+            // ERC-7984 token enablement: intercept before hop/batch/single routing.
+            // Handles both base-address (txPrebuild → ACL) and forwarder (txPrebuild → forwarder) wallets,
+            // for single or multiple tokens at once.
+            await this.verifyMultisigEnableTokenTransaction(params, throwRecipientMismatch);
+        }
+        else if (txParams.hop && txPrebuild.hopTransaction) {
+            // Check recipient amount for hop transaction
+            if (recipients.length !== 1) {
+                throw new Error(`hop transaction only supports 1 recipient but ${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()) {
+                await throwRecipientMismatch('recipient address of txPrebuild does not match hop address', [
+                    { address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() },
+                ]);
+            }
+            // Convert TransactionRecipient array to Recipient array
+            const hopRecipients = 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: hopRecipients });
+        }
+        else if (recipients.length > 1) {
+            // Check total amount for batch transaction
+            if (txParams.tokenName) {
+                const expectedTotalAmount = new bignumber_js_1.BigNumber(0);
+                if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                    await throwRecipientMismatch('batch token transaction amount in txPrebuild should be zero for token transfers', [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]);
+                }
+            }
+            else {
+                let expectedTotalAmount = new bignumber_js_1.BigNumber(0);
+                for (let i = 0; i < recipients.length; i++) {
+                    expectedTotalAmount = expectedTotalAmount.plus(recipients[i].amount);
+                }
+                if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                    await throwRecipientMismatch('batch transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client', [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]);
+                }
+            }
+            // Check batch transaction is sent to the batcher contract address for the chain
+            const batcherContractAddress = ethNetwork?.batcherContractAddress;
+            if (!batcherContractAddress ||
+                batcherContractAddress.toLowerCase() !== txPrebuild.recipients[0].address.toLowerCase()) {
+                await throwRecipientMismatch('recipient address of txPrebuild does not match batcher address', [
+                    { address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() },
+                ]);
+            }
+        }
+        else {
+            // Check recipient address and amount for normal transaction
+            if (recipients.length !== 1) {
+                throw new Error(`normal transaction only supports 1 recipient but ${recipients.length} found`);
+            }
+            const expectedAmount = new bignumber_js_1.BigNumber(recipients[0].amount);
+            if (!expectedAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                await throwRecipientMismatch('normal transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client', [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]);
+            }
+            if (this.isETHAddress(recipients[0].address) && recipients[0].address !== txPrebuild.recipients[0].address) {
+                await throwRecipientMismatch('destination address in normal txPrebuild does not match that in txParams supplied by client', [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]);
+            }
+        }
+        // Check coin is correct for all transaction types
+        if (!this.verifyCoin(txPrebuild)) {
+            const txExplanation = await this.getTxExplanation(txPrebuild);
+            throw new sdk_core_1.TxIntentMismatchError('coin in txPrebuild did not match that in txParams supplied by client', undefined, [txParams], txPrebuild?.txHex, txExplanation);
+        }
+        return true;
+    }
+    /**
+     * Check if address is valid eth address
+     * @param address
+     * @returns {boolean}
+     */
+    /**
+     * Verifies an ERC-7984 token enablement (decryption delegation) transaction for multisig wallets.
+     *
+     * Two wallet shapes are supported:
+     *
+     *  Base-address wallet — txPrebuild targets the Zama ACL contract directly:
+     *    txParams.recipients  : one entry per token, all with the wallet base address, amount '0'
+     *    txPrebuild.recipients[0] : the Zama ACL contract address
+     *
+     *  Forwarder wallet — txPrebuild targets the forwarder which calls the ACL via callFromParent:
+     *    txParams.recipients  : one entry per token, all with the forwarder address, amount '0'
+     *    txPrebuild.recipients[0] : the forwarder address (matches txParams recipients)
+     *
+     * In both cases all amounts must be 0 and all txParams recipients must share the same address.
+     */
+    async verifyMultisigEnableTokenTransaction(params, throwRecipientMismatch) {
+        const { txParams, txPrebuild } = params;
+        const recipients = txParams.recipients;
+        if (!recipients || recipients.length === 0) {
+            throw new Error('token enablement transaction must have at least one recipient in txParams');
+        }
+        // All txParams recipients must have amount 0
+        for (const r of recipients) {
+            if (!new bignumber_js_1.BigNumber(r.amount).isEqualTo(0)) {
+                await throwRecipientMismatch('token enablement txParams recipients must all have amount 0', [
+                    { address: r.address, amount: String(r.amount) },
+                ]);
+            }
+        }
+        // txPrebuild recipient amount must be 0
+        if (!new bignumber_js_1.BigNumber(txPrebuild.recipients[0].amount).isEqualTo(0)) {
+            await throwRecipientMismatch('token enablement transaction expected amount 0 in txPrebuild', [
+                { address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() },
+            ]);
+        }
+        // All txParams recipients must share the same address —
+        // a single delegation tx covers one wallet, not multiple wallets simultaneously.
+        const firstAddress = recipients[0].address.toLowerCase();
+        for (const r of recipients) {
+            if (r.address.toLowerCase() !== firstAddress) {
+                await throwRecipientMismatch('token enablement txParams recipients must all have the same address', [
+                    { address: r.address, amount: String(r.amount) },
+                ]);
+            }
+        }
+        const prebuildAddress = txPrebuild.recipients[0].address.toLowerCase();
+        const zamaAclContractAddress = this.getNetwork()?.zamaAclContractAddress;
+        // Base-address wallet: txPrebuild targets the Zama ACL contract directly.
+        // txParams recipients carry the wallet base address — the intentional address mismatch is expected.
+        if (zamaAclContractAddress && prebuildAddress === zamaAclContractAddress.toLowerCase()) {
+            return;
+        }
+        // Forwarder wallet: txPrebuild targets the forwarder address, which must match txParams recipients.
+        if (prebuildAddress === firstAddress) {
+            return;
+        }
+        // Neither recognised shape — txPrebuild address is not the ACL contract and doesn't match txParams
+        await throwRecipientMismatch('token enablement txPrebuild recipient must be the Zama ACL contract (base-address wallet) or match txParams recipients (forwarder wallet)', [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]);
+    }
+    isETHAddress(address) {
+        return !!address.match(/0x[a-fA-F0-9]{40}/);
+    }
+    /**
+     * Transform message to accommodate specific blockchain requirements.
+     * @param {string} message - the message to prepare
+     * @return {string} the prepared message as a hex encoded string.
+     */
+    encodeMessage(message) {
+        const prefix = `\u0019Ethereum Signed Message:\n${message.length}`;
+        return Buffer.from(prefix.concat(message)).toString('hex');
+    }
+    /**
+     * Transform the Typed data to accomodate the blockchain requirements (EIP-712)
+     * @param {TypedData} typedData - the typed data to prepare
+     * @return {Buffer} a buffer of the result
+     */
+    encodeTypedData(typedData) {
+        const version = typedData.version;
+        if (version === eth_sig_util_1.SignTypedDataVersion.V1) {
+            throw new Error('SignTypedData v1 is not supported due to security concerns');
+        }
+        const typedDataRaw = JSON.parse(typedData.typedDataRaw);
+        const sanitizedData = eth_sig_util_1.TypedDataUtils.sanitizeData(typedDataRaw);
+        const parts = [Buffer.from('1901', 'hex')];
+        const eip712Domain = 'EIP712Domain';
+        parts.push(eth_sig_util_1.TypedDataUtils.hashStruct(eip712Domain, sanitizedData.domain, sanitizedData.types, version));
+        if (sanitizedData.primaryType !== eip712Domain) {
+            parts.push(eth_sig_util_1.TypedDataUtils.hashStruct(sanitizedData.primaryType, sanitizedData.message, sanitizedData.types, version));
+        }
+        return Buffer.concat(parts);
+    }
+    /**
+     * Build the data to transfer an ERC-721 or ERC-1155 token to another address
+     * @param params
+     */
+    buildNftTransferData(params) {
+        const { tokenContractAddress, recipientAddress, fromAddress } = params;
+        switch (params.type) {
+            case 'ERC721': {
+                const tokenId = params.tokenId;
+                const contractData = new lib_1.ERC721TransferBuilder()
+                    .tokenContractAddress(tokenContractAddress)
+                    .to(recipientAddress)
+                    .from(fromAddress)
+                    .tokenId(tokenId)
+                    .build();
+                return contractData;
+            }
+            case 'ERC1155': {
+                const entries = params.entries;
+                const transferBuilder = new lib_1.ERC1155TransferBuilder()
+                    .tokenContractAddress(tokenContractAddress)
+                    .to(recipientAddress)
+                    .from(fromAddress);
+                for (const entry of entries) {
+                    transferBuilder.entry(parseInt(entry.tokenId, 10), entry.amount);
+                }
+                return transferBuilder.build();
+            }
+            default:
+                throw new Error(`Unsupported NFT type: ${params.type}`);
+        }
+    }
+    /**
+     * Fetch the gas price from the explorer
+     * @param {string} wrongChainCoin - the coin that we're getting gas price for
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     */
+    async getGasPriceFromExternalAPI(wrongChainCoin, apiKey) {
+        try {
+            const res = await this.recoveryBlockchainExplorerQuery({
+                chainid: this.getChainId().toString(),
+                module: 'proxy',
+                action: 'eth_gasPrice',
+            }, apiKey);
+            const gasPrice = new bn_js_1.default(res.result.slice(2), 16);
+            console.log(` Got gas price: ${gasPrice}`);
+            return gasPrice;
+        }
+        catch (e) {
+            if (e instanceof sdk_core_1.RecoveryProviderError) {
+                throw e;
+            }
+            throw new Error(`Failed to get gas price. Please make sure to use the api key of ${wrongChainCoin}`);
+        }
+    }
+    /**
+     * Fetch the gas limit from the explorer
+     * @param intendedChain
+     * @param from
+     * @param to
+     * @param data
+     * @param {string} apiKey - optional API key to use instead of the one from the environment
+     */
+    async getGasLimitFromExternalAPI(intendedChain, from, to, data, apiKey) {
+        try {
+            const res = await this.recoveryBlockchainExplorerQuery({
+                chainid: this.getChainId().toString(),
+                module: 'proxy',
+                action: 'eth_estimateGas',
+                from,
+                to,
+                data,
+            }, apiKey);
+            const gasLimit = new bn_js_1.default(res.result.slice(2), 16);
+            console.log(`Got gas limit: ${gasLimit}`);
+            return gasLimit;
+        }
+        catch (e) {
+            if (e instanceof sdk_core_1.RecoveryProviderError) {
+                throw e;
+            }
+            throw new Error(`Failed to get gas limit. Please make sure to use the privateKey aka userKey of ${intendedChain} wallet ${to}`);
+        }
+    }
+    /**
+     * Get the balance of bitgoFeeAddress to ensure funds are available to pay fees
+     * @param bitgoFeeAddress
+     * @param gasPrice
+     * @param gasLimit
+     * @param apiKey - optional API key to use instead of the one from the environment
+     */
+    async ensureSufficientBalance(bitgoFeeAddress, gasPrice, gasLimit, apiKey) {
+        const bitgoFeeAddressBalance = await this.queryAddressBalance(bitgoFeeAddress, apiKey);
+        const totalGasNeeded = Number(gasPrice.mul(gasLimit));
+        const weiToGwei = 10 ** 9;
+        if (bitgoFeeAddressBalance.lt(totalGasNeeded)) {
+            throw new Error(`Fee address ${bitgoFeeAddress} has balance ${(bitgoFeeAddressBalance / weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some ${this.getChain()} to this address then retry.`);
+        }
+    }
+}
+exports.AbstractEthLikeNewCoins = AbstractEthLikeNewCoins;
+AbstractEthLikeNewCoins.hopTransactionSalt = 'bitgoHopAddressRequestSalt';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractEthLikeNewCoins.js","sourceRoot":"","sources":["../../src/abstractEthLikeNewCoins.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport {\n  AddressCoinSpecific,\n  BitGoBase,\n  BuildNftTransferDataOptions,\n  common,\n  DefiIntentParams,\n  Ecdsa,\n  ECDSAMethodTypes,\n  ECDSAUtils,\n  ErrorNoInputToRecover,\n  EthereumLibraryUnavailableError,\n  FeeEstimateOptions,\n  FullySignedTransaction,\n  getIsUnsignedSweep,\n  HalfSignedTransaction,\n  InvalidAddressError,\n  InvalidAddressVerificationObjectPropertyError,\n  InvalidTransactionError,\n  IWallet,\n  KeyPair,\n  MPCSweepRecoveryOptions,\n  MPCSweepTxs,\n  MPCTx,\n  MPCTxs,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  PrebuildTransactionResult,\n  PresignTransactionOptions as BasePresignTransactionOptions,\n  Recipient,\n  RecoveryProviderError,\n  SignTransactionOptions as BaseSignTransactionOptions,\n  TxIntentMismatchError,\n  TxIntentMismatchRecipientError,\n  TransactionParams,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  TransactionRecipient,\n  TypedData,\n  UnexpectedAddressError,\n  UnsignedTransactionTss,\n  Util,\n  VerifyAddressOptions as BaseVerifyAddressOptions,\n  VerifyTransactionOptions,\n  Wallet,\n  verifyMPCWalletAddress,\n  deriveMPCWalletAddress,\n  TssVerifyAddressOptions,\n  isTssVerifyAddressOptions,\n  DeriveAddressOptions,\n  DeriveAddressResult,\n  NO_RECIPIENT_TX_TYPES,\n  CoinWithSignableConsistency,\n} from '@bitgo-beta/sdk-core';\nimport { getDerivationPath } from '@bitgo-beta/sdk-lib-mpc';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport {\n  BaseCoin as StaticsBaseCoin,\n  ChainIdNotFoundError,\n  CoinFeature,\n  coins,\n  Erc7984Coin,\n  EthereumNetwork as EthLikeNetwork,\n  ethGasConfigs,\n} from '@bitgo-beta/statics';\nimport type * as EthLikeCommon from '@ethereumjs/common';\nimport type * as EthLikeTxLib from '@ethereumjs/tx';\nimport { FeeMarketEIP1559Transaction, Transaction as LegacyTransaction, TransactionFactory } from '@ethereumjs/tx';\nimport { RLP } from '@ethereumjs/rlp';\nimport { SignTypedDataVersion, TypedDataUtils, TypedMessage } from '@metamask/eth-sig-util';\nimport { BigNumber } from 'bignumber.js';\nimport BN from 'bn.js';\nimport { randomBytes } from 'crypto';\nimport debugLib from 'debug';\nimport { addHexPrefix, bufArrToArr, stripHexPrefix, bufferToHex, setLengthLeft, toBuffer } from 'ethereumjs-util';\nimport Keccak from 'keccak';\nimport _ from 'lodash';\nimport secp256k1 from 'secp256k1';\n\nimport { AbstractEthLikeCoin } from './abstractEthLikeCoin';\nimport { EthLikeToken } from './ethLikeToken';\nimport {\n  calculateForwarderV1Address,\n  coinFamiliesWithL1Fees,\n  approveMethodId,\n  decodeApproveCalldata,\n  decodeTransferData,\n  ERC1155TransferBuilder,\n  ERC721TransferBuilder,\n  getBufferedByteCode,\n  getCommon,\n  getCreateForwarderParamsAndTypes,\n  getProxyInitcode,\n  getRawDecoded,\n  getToken,\n  KeyPair as KeyPairLib,\n  TransactionBuilder,\n  TransferBuilder,\n} from './lib';\nimport { SendCrossChainRecoveryOptions } from './types';\n\n/**\n * The prebuilt hop transaction returned from the HSM\n */\ninterface HopPrebuild {\n  tx: string;\n  id: string;\n  signature: string;\n  paymentId: string;\n  gasPrice: number;\n  gasLimit: number;\n  amount: number;\n  recipient: string;\n  nonce: number;\n  userReqSig: string;\n  gasPriceMax: number;\n}\n\n/**\n * The extra parameters to send to platform build route for hop transactions\n */\ninterface HopParams {\n  hopParams: {\n    gasPriceMax: number;\n    userReqSig: string;\n    paymentId: string;\n    gasLimit: number;\n  };\n}\n\nexport interface EIP1559 {\n  maxPriorityFeePerGas: number;\n  maxFeePerGas: number;\n}\n\nexport interface ReplayProtectionOptions {\n  chain: string | number;\n  hardfork: string;\n}\n\nexport interface TransactionPrebuild extends BaseTransactionPrebuild {\n  hopTransaction?: HopPrebuild;\n  buildParams: {\n    recipients: Recipient[];\n  };\n  recipients: TransactionRecipient[];\n  nextContractSequenceId: number;\n  gasPrice: number;\n  gasLimit: number;\n  isBatch: boolean;\n  coin: string;\n  token?: string;\n  txInfo?: {\n    recipients?: TransactionRecipient[];\n    nextContractSequenceId?: number;\n    eip1559?: EIP1559;\n    isBatch?: boolean;\n  };\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    txInfo?: {\n      recipients?: TransactionRecipient[];\n      nextContractSequenceId?: number;\n      eip1559?: EIP1559;\n      isBatch?: boolean;\n    };\n  };\n  signingKeyNonce?: number;\n  walletContractAddress?: string;\n  prv: string;\n  recipients?: Recipient[];\n  common?: EthLikeCommon.default;\n}\n\nexport interface SignTransactionOptions extends BaseSignTransactionOptions, SignFinalOptions {\n  isLastSignature?: boolean;\n  expireTime?: number;\n  sequenceId?: number;\n  gasLimit?: number;\n  gasPrice?: number;\n  custodianTransactionId?: string;\n  common?: EthLikeCommon.default;\n  walletVersion?: number;\n}\n\nexport type SignedTransaction = HalfSignedTransaction | FullySignedTransaction;\n\nexport interface FeesUsed {\n  gasPrice: number;\n  gasLimit: number;\n}\n\ninterface PrecreateBitGoOptions {\n  enterprise?: string;\n  newFeeAddress?: string;\n}\n\nexport interface OfflineVaultTxInfo {\n  nextContractSequenceId?: string;\n  contractSequenceId?: string;\n  tx?: string;\n  txHex?: string;\n  userKey?: string;\n  backupKey?: string;\n  coin: string;\n  gasPrice: number;\n  gasLimit: number;\n  recipients: Recipient[];\n  walletContractAddress: string;\n  amount: string;\n  backupKeyNonce: number;\n  // For Eth Specific Coins\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n  // For Hot Wallet EvmBasedCrossChainRecovery Specific\n  halfSigned?: HalfSignedTransaction;\n  feesUsed?: FeesUsed;\n  isEvmBasedCrossChainRecovery?: boolean;\n  walletVersion?: number;\n}\n\ninterface UnformattedTxInfo {\n  recipient: Recipient;\n}\n\nexport type UnsignedSweepTxMPCv2 = {\n  txRequests: {\n    transactions: [\n      {\n        unsignedTx: UnsignedTransactionTss;\n        nonce: number;\n        signatureShares: [];\n      }\n    ];\n    walletCoin: string;\n  }[];\n};\n\nexport type UnsignedBuilConsolidation = {\n  transactions: MPCSweepTxs[] | UnsignedSweepTxMPCv2[] | RecoveryInfo[] | OfflineVaultTxInfo[];\n  lastScanIndex: number;\n};\n\nexport type RecoverOptionsWithBytes = {\n  isTss: true;\n  /**\n   * @deprecated this is no longer used\n   */\n  openSSLBytes?: Uint8Array;\n};\n\nexport type NonTSSRecoverOptions = {\n  isTss?: false | undefined;\n};\n\nexport type TSSRecoverOptions = RecoverOptionsWithBytes | NonTSSRecoverOptions;\n\nexport type RecoverOptions = {\n  userKey: string;\n  backupKey: string;\n  walletPassphrase?: string;\n  walletContractAddress: string; // use this as walletBaseAddress for TSS\n  recoveryDestination: string;\n  krsProvider?: string;\n  gasPrice?: number;\n  gasLimit?: number;\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n  bitgoFeeAddress?: string;\n  bitgoDestinationAddress?: string;\n  tokenContractAddress?: string;\n  intendedChain?: string;\n  common?: EthLikeCommon.default;\n  derivationSeed?: string;\n  apiKey?: string; // optional API key to use instead of the one from the environment\n  isUnsignedSweep?: boolean; // specify if this is an unsigned recovery\n  /** ERC-7984: skip auto-query and use this encrypted balance handle directly (bytes32, 0x-prefixed) */\n  encryptedHandle?: string;\n} & TSSRecoverOptions;\n\nexport type GetBatchExecutionInfoRT = {\n  values: [string[], string[]];\n  totalAmount: string;\n};\n\nexport interface BuildTransactionParams {\n  to: string;\n  nonce?: number;\n  value: number;\n  data?: Buffer;\n  gasPrice?: number;\n  gasLimit?: number;\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n}\n\nexport interface RecoveryInfo {\n  id: string;\n  tx: string;\n  backupKey?: string;\n  coin?: string;\n}\n\nexport interface RecoverTokenTransaction {\n  halfSigned: {\n    recipient: Recipient;\n    expireTime: number;\n    contractSequenceId: number;\n    operationHash: string;\n    signature: string;\n    gasLimit: number;\n    gasPrice: number;\n    tokenContractAddress: string;\n    walletId: string;\n  };\n}\n\nexport interface RecoverTokenOptions {\n  tokenContractAddress: string;\n  wallet: Wallet;\n  recipient: string;\n  broadcast?: boolean;\n  walletPassphrase?: string;\n  prv?: string;\n}\n\nexport interface GetSendMethodArgsOptions {\n  recipient: Recipient;\n  expireTime: number;\n  contractSequenceId: number;\n  signature: string;\n}\n\nexport interface SendMethodArgs {\n  name: string;\n  type: string;\n  value: any;\n}\n\ninterface HopTransactionBuildOptions {\n  wallet: Wallet;\n  recipients: Recipient[];\n  walletPassphrase: string;\n}\n\nexport interface BuildOptions {\n  hop?: boolean;\n  wallet?: Wallet;\n  recipients?: Recipient[];\n  walletPassphrase?: string;\n  [index: string]: unknown;\n}\n\ninterface FeeEstimate {\n  gasLimitEstimate: number;\n  feeEstimate: number;\n}\n\n// TODO: This interface will need to be updated for the new fee model introduced in the London Hard Fork\ninterface EthTransactionParams extends TransactionParams {\n  gasPrice?: number;\n  gasLimit?: number;\n  hopParams?: HopParams;\n  hop?: boolean;\n  prebuildTx?: PrebuildTransactionResult;\n  tokenName?: string;\n  feeToken?: string;\n  defiParams?: DefiIntentParams;\n  /** ERC-7984 shield intent (`type: 'wrapApprove' | 'wrap'`): wrapper coin name and exact amount. */\n  wrapParams?: { tokenName: string; amount: string };\n}\n\nexport interface VerifyEthTransactionOptions extends VerifyTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  txParams: EthTransactionParams;\n}\n\ninterface PresignTransactionOptions extends TransactionPrebuild, BasePresignTransactionOptions {\n  wallet: Wallet;\n}\n\ninterface EthAddressCoinSpecifics extends AddressCoinSpecific {\n  forwarderVersion: number;\n  salt?: string;\n  feeAddress?: string;\n}\n\nexport const DEFAULT_SCAN_FACTOR = 20;\nexport interface EthConsolidationRecoveryOptions {\n  coinName?: string;\n  walletContractAddress?: string;\n  apiKey?: string;\n  isTss?: boolean;\n  userKey?: string;\n  backupKey?: string;\n  walletPassphrase?: string;\n  recoveryDestination?: string;\n  krsProvider?: string;\n  gasPrice?: number;\n  gasLimit?: number;\n  eip1559?: EIP1559;\n  replayProtectionOptions?: ReplayProtectionOptions;\n  bitgoFeeAddress?: string;\n  bitgoDestinationAddress?: string;\n  tokenContractAddress?: string;\n  intendedChain?: string;\n  common?: EthLikeCommon.default;\n  derivationSeed?: string;\n  bitgoKey?: string;\n  startingScanIndex?: number;\n  endingScanIndex?: number;\n  ignoreAddressTypes?: unknown;\n}\n\nexport interface VerifyEthAddressOptions extends BaseVerifyAddressOptions {\n  baseAddress: string;\n  coinSpecific: EthAddressCoinSpecifics;\n  forwarderVersion?: number;\n  walletVersion?: number;\n}\n\nexport type TssVerifyEthAddressOptions = TssVerifyAddressOptions & VerifyEthAddressOptions;\n\n/**\n * Keychain with ethAddress for BIP32 wallet verification (V1, V2, V4)\n * Used for wallets that derive addresses using Ethereum addresses from keychains\n */\nexport interface KeychainWithEthAddress {\n  ethAddress: string;\n  pub: string;\n}\n\n/**\n * BIP32 wallet base address verification options\n * Supports V1, V2, and V4 wallets that use ethAddress-based derivation\n */\nexport interface VerifyContractBaseAddressOptions extends VerifyEthAddressOptions {\n  walletVersion: number;\n  keychains: KeychainWithEthAddress[];\n}\n\n/**\n * Type guard to check if params are for BIP32 base address verification (V1, V2, V4)\n * These wallet versions use ethAddress for address derivation\n */\nexport function isVerifyContractBaseAddressOptions(\n  params: VerifyEthAddressOptions | TssVerifyEthAddressOptions\n): params is VerifyContractBaseAddressOptions {\n  return (\n    (params.walletVersion === 1 || params.walletVersion === 2 || params.walletVersion === 4) &&\n    'keychains' in params &&\n    Array.isArray(params.keychains) &&\n    params.keychains.length === 3 &&\n    params.keychains.every((kc: any) => 'ethAddress' in kc && typeof kc.ethAddress === 'string')\n  );\n}\n\nconst debug = debugLib('bitgo:v2:ethlike');\n\nlet erc7984WrappersByUnderlying: ReadonlyMap<string, ReadonlySet<string>> | undefined;\n\n/**\n * Lowercased wrapper (spender) addresses of every registered ERC-7984 shield pair, keyed by the lowercased\n * address of the pair's underlying ERC-20. Statics is static for the lifetime of the process, so this is\n * computed once.\n */\nfunction getErc7984WrappersByUnderlying(): ReadonlyMap<string, ReadonlySet<string>> {\n  if (!erc7984WrappersByUnderlying) {\n    const byUnderlying = new Map<string, Set<string>>();\n    coins.forEach((coin) => {\n      if (coin instanceof Erc7984Coin && coin.underlyingErc20Address && coin.contractAddress) {\n        const underlying = coin.underlyingErc20Address.toLowerCase();\n        const wrappers = byUnderlying.get(underlying) ?? new Set<string>();\n        wrappers.add(coin.contractAddress.toLowerCase());\n        byUnderlying.set(underlying, wrappers);\n      }\n    });\n    erc7984WrappersByUnderlying = byUnderlying;\n  }\n  return erc7984WrappersByUnderlying;\n}\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 implements CoinWithSignableConsistency {\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  /** @inheritDoc */\n  supportsMessageSigning(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsSigningTypedData(): boolean {\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 = coins.coinNameFromChainId(chainId);\n    if (!coinName) {\n      throw new ChainIdNotFoundError(chainId);\n    }\n    const coin = coins.get(coinName);\n    const ethLikeCommon = getCommon(coin.network as EthLikeNetwork);\n    return ethLikeCommon;\n  }\n\n  /**\n   * Gets correct Eth Common object based on params from either recovery or tx building\n   * @param {EIP1559} eip1559 - configs that specify whether we should construct an eip1559 tx\n   * @param {ReplayProtectionOptions} replayProtectionOptions - check if chain id supports replay protection\n   * @returns {EthLikeCommon.default}\n   */\n  private static getEthLikeCommon(\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions\n  ): EthLikeCommon.default {\n    // if eip1559 params are specified, default to london hardfork, otherwise,\n    // default to petersburg to avoid replay protection issues\n    const defaultHardfork = !!eip1559 ? 'london' : optionalDeps.EthCommon.Hardfork.Petersburg;\n    const ethLikeCommon = AbstractEthLikeNewCoins.getCustomChainCommon(replayProtectionOptions?.chain as number);\n    ethLikeCommon.setHardfork(replayProtectionOptions?.hardfork ?? defaultHardfork);\n    return ethLikeCommon;\n  }\n\n  /**\n   * Method to build the tx object\n   * @param {BuildTransactionParams} params - params to build transaction\n   * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}\n   */\n  static buildTransaction(\n    params: BuildTransactionParams\n  ): EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction {\n    // if eip1559 params are specified, default to london hardfork, otherwise,\n    // default to tangerine whistle to avoid replay protection issues\n    const ethLikeCommon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);\n    const baseParams = {\n      to: params.to,\n      nonce: params.nonce,\n      value: params.value,\n      data: params.data,\n      gasLimit: new optionalDeps.ethUtil.BN(params.gasLimit),\n    };\n\n    const unsignedEthTx = !!params.eip1559\n      ? optionalDeps.EthTx.FeeMarketEIP1559Transaction.fromTxData(\n          {\n            ...baseParams,\n            maxFeePerGas: new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas),\n            maxPriorityFeePerGas: new optionalDeps.ethUtil.BN(params.eip1559.maxPriorityFeePerGas),\n          },\n          { common: ethLikeCommon }\n        )\n      : optionalDeps.EthTx.Transaction.fromTxData(\n          {\n            ...baseParams,\n            gasPrice: new optionalDeps.ethUtil.BN(params.gasPrice),\n          },\n          { common: ethLikeCommon }\n        );\n\n    return unsignedEthTx;\n  }\n\n  /**\n   * Query explorer for the balance of an address\n   * @param {String} address - the ETHLike address\n   * @param {String} apiKey - optional API key to use instead of the one from the environment\n   * @returns {BigNumber} address balance\n   */\n  async queryAddressBalance(address: string, apiKey?: string): Promise<any> {\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'account',\n        action: 'balance',\n        address: address,\n      },\n      apiKey\n    );\n    // throw if the result does not exist or the result is not a valid number\n    if (!result || !result.result || isNaN(result.result)) {\n      throw new RecoveryProviderError(\n        `Could not obtain address balance for ${address} from the explorer, got: ${result.result}`\n      );\n    }\n    return new optionalDeps.ethUtil.BN(result.result, 10);\n  }\n\n  /**\n   * @param {Recipient[]} recipients - the recipients of the transaction\n   * @param {number} expireTime - the expire time of the transaction\n   * @param {number} contractSequenceId - the contract sequence id of the transaction\n   * @returns {string}\n   */\n  getOperationSha3ForExecuteAndConfirm(\n    recipients: Recipient[],\n    expireTime: number,\n    contractSequenceId: number\n  ): string {\n    if (!recipients || !Array.isArray(recipients)) {\n      throw new Error('expecting array of recipients');\n    }\n\n    // Right now we only support 1 recipient\n    if (recipients.length !== 1) {\n      throw new Error('must send to exactly 1 recipient');\n    }\n\n    if (!_.isNumber(expireTime)) {\n      throw new Error('expireTime must be number of seconds since epoch');\n    }\n\n    if (!_.isNumber(contractSequenceId)) {\n      throw new Error('contractSequenceId must be number');\n    }\n\n    // Check inputs\n    recipients.forEach(function (recipient) {\n      if (\n        !_.isString(recipient.address) ||\n        !optionalDeps.ethUtil.isValidAddress(optionalDeps.ethUtil.addHexPrefix(recipient.address))\n      ) {\n        throw new Error('Invalid address: ' + recipient.address);\n      }\n\n      let amount: BigNumber;\n      try {\n        amount = new BigNumber(recipient.amount);\n      } catch (e) {\n        throw new Error('Invalid amount for: ' + recipient.address + ' - should be numeric');\n      }\n\n      recipient.amount = amount.toFixed(0);\n\n      if (recipient.data && !_.isString(recipient.data)) {\n        throw new Error('Data for recipient ' + recipient.address + ' - should be of type hex string');\n      }\n    });\n\n    const recipient = recipients[0];\n    return optionalDeps.ethUtil.bufferToHex(\n      optionalDeps.ethAbi.soliditySHA3(...this.getOperation(recipient, expireTime, contractSequenceId))\n    );\n  }\n\n  /**\n   * Get transfer operation for coin\n   * @param {Recipient} recipient - recipient info\n   * @param {number} expireTime - expiry time\n   * @param {number} contractSequenceId - sequence id\n   * @returns {Array} operation array\n   */\n  getOperation(recipient: Recipient, expireTime: number, contractSequenceId: number): (string | Buffer)[][] {\n    const network = this.getNetwork() as EthLikeNetwork;\n    return [\n      ['string', 'address', 'uint', 'bytes', 'uint', 'uint'],\n      [\n        network.nativeCoinOperationHashPrefix,\n        new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),\n        recipient.amount,\n        Buffer.from(optionalDeps.ethUtil.stripHexPrefix(optionalDeps.ethUtil.padToEven(recipient.data || '')), 'hex'),\n        expireTime,\n        contractSequenceId,\n      ],\n    ];\n  }\n\n  /**\n   * Queries the contract (via explorer API) for the next sequence ID\n   * @param {String} address - address of the contract\n   * @param {String} apiKey - optional API key to use instead of the one from the environment\n   * @returns {Promise<Number>} sequence ID\n   */\n  async querySequenceId(address: string, apiKey?: string): Promise<number> {\n    // Get sequence ID using contract call\n    const sequenceIdMethodSignature = optionalDeps.ethAbi.methodID('getNextSequenceId', []);\n    const sequenceIdArgs = optionalDeps.ethAbi.rawEncode([], []);\n    const sequenceIdData = Buffer.concat([sequenceIdMethodSignature, sequenceIdArgs]).toString('hex');\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'proxy',\n        action: 'eth_call',\n        to: address,\n        data: sequenceIdData,\n        tag: 'latest',\n      },\n      apiKey\n    );\n    if (!result || !result.result) {\n      throw new RecoveryProviderError('Could not obtain sequence ID from explorer, got: ' + result.result);\n    }\n    const sequenceIdHex = result.result;\n    return new optionalDeps.ethUtil.BN(sequenceIdHex.slice(2), 16).toNumber();\n  }\n\n  /**\n   * Recover an unsupported token from a BitGo multisig wallet\n   * This builds a half-signed transaction, for which there will be an admin route to co-sign and broadcast. Optionally\n   * the user can set params.broadcast = true and the half-signed tx will be sent to BitGo for cosigning and broadcasting\n   * @param {RecoverTokenOptions} params\n   * @param {Wallet} params.wallet - the wallet to recover the token from\n   * @param {string} params.tokenContractAddress - the contract address of the unsupported token\n   * @param {string} params.recipient - the destination address recovered tokens should be sent to\n   * @param {string} params.walletPassphrase - the wallet passphrase\n   * @param {string} params.prv - the xprv\n   * @param {boolean} params.broadcast - if true, we will automatically submit the half-signed tx to BitGo for cosigning and broadcasting\n   * @returns {Promise<RecoverTokenTransaction>}\n   */\n  async recoverToken(params: RecoverTokenOptions): Promise<RecoverTokenTransaction> {\n    const network = this.getNetwork() as EthLikeNetwork;\n    if (!_.isObject(params)) {\n      throw new Error(`recoverToken must be passed a params object. Got ${params} (type ${typeof params})`);\n    }\n\n    if (_.isUndefined(params.tokenContractAddress) || !_.isString(params.tokenContractAddress)) {\n      throw new Error(\n        `tokenContractAddress must be a string, got ${\n          params.tokenContractAddress\n        } (type ${typeof params.tokenContractAddress})`\n      );\n    }\n\n    if (!this.isValidAddress(params.tokenContractAddress)) {\n      throw new Error('tokenContractAddress not a valid address');\n    }\n\n    if (_.isUndefined(params.wallet) || !(params.wallet instanceof Wallet)) {\n      throw new Error(`wallet must be a wallet instance, got ${params.wallet} (type ${typeof params.wallet})`);\n    }\n\n    if (_.isUndefined(params.recipient) || !_.isString(params.recipient)) {\n      throw new Error(`recipient must be a string, got ${params.recipient} (type ${typeof params.recipient})`);\n    }\n\n    if (!this.isValidAddress(params.recipient)) {\n      throw new Error('recipient not a valid address');\n    }\n\n    if (!optionalDeps.ethUtil.bufferToHex || !optionalDeps.ethAbi.soliditySHA3) {\n      throw new Error('ethereum not fully supported in this environment');\n    }\n\n    // Get token balance from external API\n    const coinSpecific = params.wallet.coinSpecific();\n    if (!coinSpecific || !_.isString(coinSpecific.baseAddress)) {\n      throw new Error('missing required coin specific property baseAddress');\n    }\n    const recoveryAmount = await this.queryAddressTokenBalance(params.tokenContractAddress, coinSpecific.baseAddress);\n\n    if (params.broadcast) {\n      // We're going to create a normal ETH transaction that sends an amount of 0 ETH to the\n      // tokenContractAddress and encode the unsupported-token-send data in the data field\n      // #tricksy\n      const sendMethodArgs = [\n        {\n          name: '_to',\n          type: 'address',\n          value: params.recipient,\n        },\n        {\n          name: '_value',\n          type: 'uint256',\n          value: recoveryAmount.toString(10),\n        },\n      ];\n      const methodSignature = optionalDeps.ethAbi.methodID('transfer', _.map(sendMethodArgs, 'type'));\n      const encodedArgs = optionalDeps.ethAbi.rawEncode(_.map(sendMethodArgs, 'type'), _.map(sendMethodArgs, 'value'));\n      const sendData = Buffer.concat([methodSignature, encodedArgs]);\n\n      const broadcastParams: any = {\n        address: params.tokenContractAddress,\n        amount: '0',\n        data: sendData.toString('hex'),\n      };\n\n      if (params.walletPassphrase) {\n        broadcastParams.walletPassphrase = params.walletPassphrase;\n      } else if (params.prv) {\n        broadcastParams.prv = params.prv;\n      }\n\n      return await params.wallet.send(broadcastParams);\n    }\n\n    const recipient = {\n      address: params.recipient,\n      amount: recoveryAmount.toString(10),\n    };\n\n    // This signature will be valid for one week\n    const expireTime = Math.floor(new Date().getTime() / 1000) + 60 * 60 * 24 * 7;\n\n    // Get sequence ID. We do this by building a 'fake' eth transaction, so the platform will increment and return us the new sequence id\n    // This _does_ require the user to have a non-zero wallet balance\n    const { nextContractSequenceId, gasPrice, gasLimit } = (await params.wallet.prebuildTransaction({\n      recipients: [\n        {\n          address: params.recipient,\n          amount: '1',\n        },\n      ],\n    })) as any;\n\n    // these recoveries need to be processed by support, but if the customer sends any transactions before recovery is\n    // complete the sequence ID will be invalid. artificially inflate the sequence ID to allow more time for processing\n    const safeSequenceId = nextContractSequenceId + 1000;\n\n    // Build sendData for ethereum tx\n    const operationTypes = ['string', 'address', 'uint', 'address', 'uint', 'uint'];\n    const operationArgs = [\n      // Token operation has prefix has been added here so that ether operation hashes, signatures cannot be re-used for tokenSending\n      network.tokenOperationHashPrefix,\n      new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),\n      recipient.amount,\n      new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(params.tokenContractAddress), 16),\n      expireTime,\n      safeSequenceId,\n    ];\n\n    const operationHash = optionalDeps.ethUtil.bufferToHex(\n      optionalDeps.ethAbi.soliditySHA3(operationTypes, operationArgs)\n    );\n\n    const userPrv = await params.wallet.getPrv({\n      prv: params.prv,\n      walletPassphrase: params.walletPassphrase,\n    });\n\n    const signature = Util.ethSignMsgHash(operationHash, Util.xprvToEthPrivateKey(userPrv));\n\n    return {\n      halfSigned: {\n        recipient: recipient,\n        expireTime: expireTime,\n        contractSequenceId: safeSequenceId,\n        operationHash: operationHash,\n        signature: signature,\n        gasLimit: gasLimit,\n        gasPrice: gasPrice,\n        tokenContractAddress: params.tokenContractAddress,\n        walletId: params.wallet.id(),\n      },\n    };\n  }\n\n  /**\n   * Ensure either enterprise or newFeeAddress is passed, to know whether to create new key or use enterprise key\n   * @param {PrecreateBitGoOptions} params\n   * @param {string} params.enterprise {String} the enterprise id to associate with this key\n   * @param {string} params.newFeeAddress {Boolean} create a new fee address (enterprise not needed in this case)\n   * @returns {void}\n   */\n  preCreateBitGo(params: PrecreateBitGoOptions): void {\n    // We always need params object, since either enterprise or newFeeAddress is required\n    if (!_.isObject(params)) {\n      throw new Error(`preCreateBitGo must be passed a params object. Got ${params} (type ${typeof params})`);\n    }\n\n    if (_.isUndefined(params.enterprise) && _.isUndefined(params.newFeeAddress)) {\n      throw new Error(\n        'expecting enterprise when adding BitGo key. If you want to create a new ETH bitgo key, set the newFeeAddress parameter to true.'\n      );\n    }\n\n    // Check whether key should be an enterprise key or a BitGo key for a new fee address\n    if (!_.isUndefined(params.enterprise) && !_.isUndefined(params.newFeeAddress)) {\n      throw new Error(`Incompatible arguments - cannot pass both enterprise and newFeeAddress parameter.`);\n    }\n\n    if (!_.isUndefined(params.enterprise) && !_.isString(params.enterprise)) {\n      throw new Error(`enterprise should be a string - got ${params.enterprise} (type ${typeof params.enterprise})`);\n    }\n\n    if (!_.isUndefined(params.newFeeAddress) && !_.isBoolean(params.newFeeAddress)) {\n      throw new Error(\n        `newFeeAddress should be a boolean - got ${params.newFeeAddress} (type ${typeof params.newFeeAddress})`\n      );\n    }\n  }\n\n  /**\n   * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address\n   * @param {string} address\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   * @returns {Promise<number>}\n   */\n  async getAddressNonce(address: string, apiKey?: string): Promise<number> {\n    // Get nonce for backup key (should be 0)\n    let nonce = 0;\n\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'account',\n        action: 'txlist',\n        address,\n      },\n      apiKey\n    );\n\n    if (result && typeof result?.nonce === 'number') {\n      return Number(result.nonce);\n    }\n\n    if (!result || !Array.isArray(result.result)) {\n      throw new RecoveryProviderError('Unable to find next nonce from Etherscan, got: ' + JSON.stringify(result));\n    }\n    const backupKeyTxList = result.result;\n    if (backupKeyTxList.length > 0) {\n      // Calculate last nonce used\n      const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === address);\n      nonce = outgoingTxs.length;\n    }\n    return nonce;\n  }\n\n  /**\n   * Helper function for recover()\n   * This transforms the unsigned transaction information into a format the BitGo offline vault expects\n   * @param {UnformattedTxInfo} txInfo - tx info\n   * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object\n   * @param {string} userKey - the user's key\n   * @param {string} backupKey - the backup key\n   * @param {Buffer} gasPrice - gas price for the tx\n   * @param {number} gasLimit - gas limit for the tx\n   * @param {EIP1559} eip1559 - eip1559 params\n   * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options\n   * @param {apiKey} apiKey - optional apiKey to use when retrieving block chain data\n   * @returns {Promise<OfflineVaultTxInfo>}\n   */\n  async formatForOfflineVault(\n    txInfo: UnformattedTxInfo,\n    ethTx: EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction,\n    userKey: string,\n    backupKey: string,\n    gasPrice: Buffer,\n    gasLimit: number,\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions,\n    apiKey?: string\n  ): Promise<OfflineVaultTxInfo> {\n    if (!ethTx.to) {\n      throw new Error('Eth tx must have a `to` address');\n    }\n    const backupHDNode = bip32.fromBase58(backupKey);\n    const backupSigningKey = backupHDNode.publicKey;\n    const response: OfflineVaultTxInfo = {\n      tx: ethTx.serialize().toString('hex'),\n      userKey,\n      backupKey,\n      coin: this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: [txInfo.recipient],\n      walletContractAddress: ethTx.to.toString(),\n      amount: txInfo.recipient.amount as string,\n      backupKeyNonce: await this.getAddressNonce(\n        `0x${optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`,\n        apiKey\n      ),\n      eip1559,\n      replayProtectionOptions,\n    };\n    _.extend(response, txInfo);\n    response.nextContractSequenceId = response.contractSequenceId;\n    return response;\n  }\n\n  /**\n   * Helper function for recover()\n   * This transforms the unsigned transaction information into a format the BitGo offline vault expects\n   * @param {UnformattedTxInfo} txInfo - tx info\n   * @param {EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object\n   * @param {string} userKey - the user's key\n   * @param {string} backupKey - the backup key\n   * @param {Buffer} gasPrice - gas price for the tx\n   * @param {number} gasLimit - gas limit for the tx\n   * @param {number} backupKeyNonce - the nonce of the backup key address\n   * @param {EIP1559} eip1559 - eip1559 params\n   * @param {ReplayProtectionOptions} replayProtectionOptions - replay protection options\n   * @returns {Promise<OfflineVaultTxInfo>}\n   */\n  formatForOfflineVaultTSS(\n    txInfo: UnformattedTxInfo,\n    ethTx: EthLikeTxLib.Transaction | EthLikeTxLib.FeeMarketEIP1559Transaction,\n    userKey: string,\n    backupKey: string,\n    gasPrice: Buffer,\n    gasLimit: number,\n    backupKeyNonce: number,\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions\n  ): OfflineVaultTxInfo {\n    if (!ethTx.to) {\n      throw new Error('Eth tx must have a `to` address');\n    }\n    const response: OfflineVaultTxInfo = {\n      tx: ethTx.serialize().toString('hex'),\n      txHex: ethTx.getMessageToSign(false).toString(),\n      userKey,\n      backupKey,\n      coin: this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: [txInfo.recipient],\n      walletContractAddress: ethTx.to.toString(),\n      amount: txInfo.recipient.amount as string,\n      backupKeyNonce: backupKeyNonce,\n      eip1559,\n      replayProtectionOptions,\n    };\n    _.extend(response, txInfo);\n    return response;\n  }\n\n  /**\n   * Check whether the gas price passed in by user are within our max and min bounds\n   * If they are not set, set them to the defaults\n   * @param {number} userGasPrice - user defined gas price\n   * @returns {number} the gas price to use for this transaction\n   */\n  setGasPrice(userGasPrice?: number): number {\n    if (!userGasPrice) {\n      return ethGasConfigs.defaultGasPrice;\n    }\n\n    const gasPriceMax = ethGasConfigs.maximumGasPrice;\n    const gasPriceMin = ethGasConfigs.minimumGasPrice;\n    if (userGasPrice < gasPriceMin || userGasPrice > gasPriceMax) {\n      throw new Error(`Gas price must be between ${gasPriceMin} and ${gasPriceMax}`);\n    }\n    return userGasPrice;\n  }\n  /**\n   * Check whether gas limit passed in by user are within our max and min bounds\n   * If they are not set, set them to the defaults\n   * @param {number} userGasLimit user defined gas limit\n   * @returns {number} the gas limit to use for this transaction\n   */\n  setGasLimit(userGasLimit?: number): number {\n    if (!userGasLimit) {\n      return ethGasConfigs.defaultGasLimit;\n    }\n    const gasLimitMax = ethGasConfigs.maximumGasLimit;\n    const gasLimitMin = ethGasConfigs.minimumGasLimit;\n    if (userGasLimit < gasLimitMin || userGasLimit > gasLimitMax) {\n      throw new Error(`Gas limit must be between ${gasLimitMin} and ${gasLimitMax}`);\n    }\n    return userGasLimit;\n  }\n\n  /**\n   * Helper function for signTransaction for the rare case that SDK is doing the second signature\n   * Note: we are expecting this to be called from the offline vault\n   * @param {SignFinalOptions.txPrebuild} params.txPrebuild\n   * @param {string} params.prv\n   * @returns {{txHex: string}}\n   */\n  async signFinalEthLike(params: SignFinalOptions): Promise<FullySignedTransaction> {\n    const signingKey = new KeyPairLib({ prv: params.prv }).getKeys().prv;\n    if (_.isUndefined(signingKey)) {\n      throw new Error('missing private key');\n    }\n    const txBuilder = this.getTransactionBuilder(params.common);\n    try {\n      txBuilder.from(params.txPrebuild.halfSigned?.txHex);\n    } catch (e) {\n      throw new Error('invalid half-signed transaction');\n    }\n    txBuilder.sign({ key: signingKey });\n    const tx = await txBuilder.build();\n    return {\n      txHex: tx.toBroadcastFormat(),\n    };\n  }\n\n  /**\n   * Assemble half-sign prebuilt transaction\n   * @param {SignTransactionOptions} params\n   */\n  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    // Normally the SDK provides the first signature for an EthLike tx, but occasionally it provides the second and final one.\n    if (params.isLastSignature) {\n      // In this case when we're doing the second (final) signature, the logic is different.\n      return await this.signFinalEthLike(params);\n    }\n    const txBuilder = this.getTransactionBuilder(params.common);\n    txBuilder.from(params.txPrebuild.txHex);\n    txBuilder\n      .transfer()\n      .coin(this.staticsCoin?.name as string)\n      .key(new KeyPairLib({ prv: params.prv }).getKeys().prv!);\n    if (params.walletVersion) {\n      txBuilder.walletVersion(params.walletVersion);\n    }\n    const transaction = await txBuilder.build();\n\n    // In case of tx with contract data from a custodial wallet, we are running into an issue\n    // as halfSigned is not having the data field. So, we are adding the data field to the halfSigned tx\n    let recipients = params.txPrebuild.recipients || params.recipients;\n    if (recipients === undefined) {\n      recipients = transaction.outputs.map((output) => ({ address: output.address, amount: output.value }));\n    }\n\n    const txParams = {\n      eip1559: params.txPrebuild.eip1559,\n      txHex: transaction.toBroadcastFormat(),\n      recipients: recipients,\n      expiration: params.txPrebuild.expireTime,\n      hopTransaction: params.txPrebuild.hopTransaction,\n      custodianTransactionId: params.custodianTransactionId,\n      expireTime: params.expireTime,\n      contractSequenceId: params.txPrebuild.nextContractSequenceId as number,\n      sequenceId: params.sequenceId,\n      ...(params.txPrebuild.isBatch ? { isBatch: params.txPrebuild.isBatch } : {}),\n    };\n\n    return { halfSigned: txParams };\n  }\n\n  /**\n   * Method to validate recovery params\n   * @param {RecoverOptions} params\n   * @returns {void}\n   */\n  validateRecoveryParams(params: RecoverOptions): void {\n    if (params.userKey === undefined) {\n      throw new Error('missing userKey');\n    }\n\n    if (params.backupKey === undefined) {\n      throw new Error('missing backupKey');\n    }\n\n    if (\n      !params.isUnsignedSweep &&\n      params.walletPassphrase === undefined &&\n      !params.userKey.startsWith('xpub') &&\n      !params.isTss\n    ) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    if (params.walletContractAddress === undefined || !this.isValidAddress(params.walletContractAddress)) {\n      throw new Error('invalid walletContractAddress');\n    }\n\n    if (params.recoveryDestination === undefined || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n\n    if (!this.staticsCoin?.features.includes(CoinFeature.EIP1559)) {\n      if (params.eip1559) {\n        throw new Error('Invalid fee params. EIP1559 not supported');\n      }\n      if (params.replayProtectionOptions?.hardfork === 'london') {\n        throw new Error('Invalid replayProtection options. Cannot use the hardfork \"london\" for this chain');\n      }\n    }\n  }\n\n  /**\n   * Helper which Adds signatures to tx object and re-serializes tx\n   * @param {EthLikeCommon.default} ethCommon\n   * @param {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction} tx\n   * @param {ECDSAMethodTypes.Signature} signature\n   * @returns {EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction}\n   */\n  private getSignedTxFromSignature(\n    ethCommon: EthLikeCommon.default,\n    tx: EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction,\n    signature: ECDSAMethodTypes.Signature\n  ) {\n    // get signed Tx from signature\n    const txData = tx.toJSON();\n    const yParity = signature.recid;\n    const baseParams = {\n      to: txData.to,\n      nonce: new BN(stripHexPrefix(txData.nonce!), 'hex'),\n      value: new BN(stripHexPrefix(txData.value!), 'hex'),\n      gasLimit: new BN(stripHexPrefix(txData.gasLimit!), 'hex'),\n      data: txData.data,\n      r: addHexPrefix(signature.r),\n      s: addHexPrefix(signature.s),\n    };\n\n    let finalTx;\n    if (txData.maxFeePerGas && txData.maxPriorityFeePerGas) {\n      finalTx = FeeMarketEIP1559Transaction.fromTxData(\n        {\n          ...baseParams,\n          maxPriorityFeePerGas: new BN(stripHexPrefix(txData.maxPriorityFeePerGas!), 'hex'),\n          maxFeePerGas: new BN(stripHexPrefix(txData.maxFeePerGas!), 'hex'),\n          v: new BN(yParity.toString()),\n        },\n        { common: ethCommon }\n      );\n    } else if (txData.gasPrice) {\n      const v = BigInt(35) + BigInt(yParity) + BigInt(ethCommon.chainIdBN().toNumber()) * BigInt(2);\n      finalTx = LegacyTransaction.fromTxData(\n        {\n          ...baseParams,\n          v: new BN(v.toString()),\n          gasPrice: new BN(stripHexPrefix(txData.gasPrice!.toString()), 'hex'),\n        },\n        { common: ethCommon }\n      );\n    }\n\n    return finalTx;\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param params\n   * @param {string} params.userKey - [encrypted] xprv\n   * @param {string} params.backupKey - [encrypted] xprv or xpub if the xprv is held by a KRS provider\n   * @param {string} params.walletPassphrase - used to decrypt userKey and backupKey\n   * @param {string} params.walletContractAddress - the ETH address of the wallet contract\n   * @param {string} params.krsProvider - necessary if backup key is held by KRS\n   * @param {string} params.recoveryDestination - target address to send recovered funds to\n   * @param {string} params.bitgoFeeAddress - wrong chain wallet fee address for evm based cross chain recovery txn\n   * @param {string} params.bitgoDestinationAddress - target bitgo address where fee will be sent for evm based cross chain recovery txn\n   */\n  async recover(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    if (params.isTss === true) {\n      return this.recoverTSS(params);\n    }\n    return this.recoverEthLike(params);\n  }\n\n  generateForwarderAddress(\n    baseAddress: string,\n    feeAddress: string,\n    forwarderFactoryAddress: string,\n    forwarderImplementationAddress: string,\n    index: number\n  ): string {\n    const salt = addHexPrefix(index.toString(16));\n    const saltBuffer = setLengthLeft(toBuffer(salt), 32);\n\n    const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(\n      baseAddress,\n      saltBuffer,\n      feeAddress\n    );\n\n    const calculationSalt = bufferToHex(optionalDeps.ethAbi.soliditySHA3(createForwarderTypes, createForwarderParams));\n\n    const initCode = getProxyInitcode(forwarderImplementationAddress);\n    return calculateForwarderV1Address(forwarderFactoryAddress, calculationSalt, initCode);\n  }\n\n  deriveAddressFromPublicKey(commonKeychain: string, index: number): string {\n    const derivationPath = `m/${index}`;\n    const pubkeySize = 33;\n\n    const ecdsaMpc = new Ecdsa();\n    const derivedPublicKey = Buffer.from(ecdsaMpc.deriveUnhardened(commonKeychain, derivationPath), 'hex')\n      .subarray(0, pubkeySize)\n      .toString('hex');\n\n    const publicKey = Buffer.from(derivedPublicKey, 'hex').slice(0, 66).toString('hex');\n\n    const keyPair = new KeyPairLib({ pub: publicKey });\n    const address = keyPair.getAddress();\n    return address;\n  }\n\n  getConsolidationAddress(params: EthConsolidationRecoveryOptions, index: number): string[] {\n    const possibleConsolidationAddresses: string[] = [];\n    if (params.walletContractAddress && params.bitgoFeeAddress) {\n      const ethNetwork = this.getNetwork();\n      const forwarderFactoryAddress = ethNetwork?.walletV4ForwarderFactoryAddress as string;\n      const forwarderImplementationAddress = ethNetwork?.walletV4ForwarderImplementationAddress as string;\n      try {\n        const forwarderAddress = this.generateForwarderAddress(\n          params.walletContractAddress,\n          params.bitgoFeeAddress,\n          forwarderFactoryAddress,\n          forwarderImplementationAddress,\n          index\n        );\n        possibleConsolidationAddresses.push(forwarderAddress);\n      } catch (e) {\n        console.log(`Failed to generate forwarder address: ${e.message}`);\n      }\n    }\n\n    if (params.userKey) {\n      try {\n        const derivedAddress = this.deriveAddressFromPublicKey(params.userKey, index);\n        possibleConsolidationAddresses.push(derivedAddress);\n      } catch (e) {\n        console.log(`Failed to generate derived address: ${e}`);\n      }\n    }\n\n    if (possibleConsolidationAddresses.length === 0) {\n      throw new Error(\n        'Unable to generate consolidation address. Check that wallet contract address, fee address, or user key is valid.'\n      );\n    }\n    return possibleConsolidationAddresses;\n  }\n\n  async recoverConsolidations(params: EthConsolidationRecoveryOptions): Promise<UnsignedBuilConsolidation> {\n    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n    const startIdx = params.startingScanIndex || 1;\n    const endIdx = params.endingScanIndex || startIdx + DEFAULT_SCAN_FACTOR;\n\n    if (!params.walletContractAddress || params.walletContractAddress === '') {\n      throw new Error(`Invalid wallet contract address ${params.walletContractAddress}`);\n    }\n\n    if (!params.bitgoFeeAddress || params.bitgoFeeAddress === '') {\n      throw new Error(`Invalid fee address ${params.bitgoFeeAddress}`);\n    }\n\n    if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * DEFAULT_SCAN_FACTOR) {\n      throw new Error(\n        `Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`\n      );\n    }\n\n    const consolidatedTransactions: any[] = [];\n    let lastScanIndex = startIdx;\n\n    for (let i = startIdx; i < endIdx; i++) {\n      const consolidationAddress = this.getConsolidationAddress(params, i);\n      for (const address of consolidationAddress) {\n        const recoverParams = {\n          apiKey: params.apiKey,\n          backupKey: params.backupKey || '',\n          gasLimit: params.gasLimit,\n          recoveryDestination: params.recoveryDestination || '',\n          userKey: params.userKey || '',\n          walletContractAddress: address,\n          derivationSeed: '',\n          isTss: params.isTss,\n          eip1559: {\n            maxFeePerGas: params.eip1559?.maxFeePerGas || 20,\n            maxPriorityFeePerGas: params.eip1559?.maxPriorityFeePerGas || 200000,\n          },\n          replayProtectionOptions: {\n            chain: params.replayProtectionOptions?.chain || 0,\n            hardfork: params.replayProtectionOptions?.hardfork || 'london',\n          },\n          bitgoKey: '',\n          ignoreAddressTypes: [],\n        };\n        let recoveryTransaction;\n        try {\n          recoveryTransaction = await this.recover(recoverParams);\n        } catch (e) {\n          if (e instanceof ErrorNoInputToRecover) {\n            lastScanIndex = i;\n            continue;\n          }\n          throw e;\n        }\n        if (isUnsignedSweep) {\n          consolidatedTransactions.push((recoveryTransaction as MPCSweepTxs).txRequests[0]);\n        } else {\n          consolidatedTransactions.push(recoveryTransaction);\n        }\n      }\n      // To avoid rate limit for etherscan\n      await new Promise((resolve) => setTimeout(resolve, 1000));\n      // lastScanIndex = i;\n    }\n\n    if (consolidatedTransactions.length === 0) {\n      throw new Error(\n        `Did not find an address with sufficient funds to recover. Please start the next scan at address index ${\n          lastScanIndex + 1\n        }.`\n      );\n    }\n    return { transactions: consolidatedTransactions, lastScanIndex };\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo for non-TSS transaction\n   * @param params\n   * @param {string} params.userKey [encrypted] xprv or xpub\n   * @param {string} params.backupKey [encrypted] xprv or xpub if the xprv is held by a KRS provider\n   * @param {string} params.walletPassphrase used to decrypt userKey and backupKey\n   * @param {string} params.walletContractAddress the EthLike address of the wallet contract\n   * @param {string} params.krsProvider necessary if backup key is held by KRS\n   * @param {string} params.recoveryDestination target address to send recovered funds to\n   * @param {string} params.bitgoFeeAddress wrong chain wallet fee address for evm based cross chain recovery txn\n   * @param {string} params.bitgoDestinationAddress target bitgo address where fee will be sent for evm based cross chain recovery txn\n   * @returns {Promise<RecoveryInfo | OfflineVaultTxInfo>}\n   */\n  protected async recoverEthLike(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo> {\n    // bitgoFeeAddress is only defined when it is a evm cross chain recovery\n    // as we use fee from this wrong chain address for the recovery txn on the correct chain.\n    if (params.bitgoFeeAddress) {\n      return this.recoverEthLikeforEvmBasedRecovery(params);\n    }\n\n    this.validateRecoveryParams(params);\n    const isUnsignedSweep = params.isUnsignedSweep ?? getIsUnsignedSweep(params);\n\n    // Clean up whitespace from entered values\n    let userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n    const gasLimit = new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));\n\n    if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {\n      try {\n        userKey = await 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 = await this.bitgo.decrypt({\n          input: backupKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting backup keychain: ${e.message}`);\n      }\n\n      const keyPair = new KeyPairLib({ prv: backupPrv });\n      backupSigningKey = keyPair.getKeys().prv;\n      if (!backupSigningKey) {\n        throw new Error('no private key');\n      }\n      backupKeyAddress = keyPair.getAddress();\n    }\n\n    const backupKeyNonce = await this.getAddressNonce(backupKeyAddress, params.apiKey);\n    // get balance of backupKey to ensure funds are available to pay fees\n    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);\n    let totalGasNeeded = gasPrice.mul(gasLimit);\n\n    // On L2 chains with L1 data fees, add buffer for L1 fees\n    if (this.staticsCoin?.family !== undefined && coinFamiliesWithL1Fees.includes(this.staticsCoin.family)) {\n      totalGasNeeded = totalGasNeeded.add(new optionalDeps.ethUtil.BN(ethGasConfigs.l1GasFeeBuffer));\n    }\n\n    const weiToGwei = 10 ** 9;\n    if (backupKeyBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some funds to this address then retry.`\n      );\n    }\n\n    // get balance of wallet\n    const txAmount = await this.queryAddressBalance(params.walletContractAddress, params.apiKey);\n    if (new BigNumber(txAmount).isLessThanOrEqualTo(0)) {\n      throw new ErrorNoInputToRecover('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, params.apiKey);\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   * Extract recipients from transaction hex\n   * @param txHex - The transaction hex string\n   * @returns Array of recipients with address and amount\n   */\n  private async extractRecipientsFromTxHex(txHex: string): Promise<Array<{ address: string; amount: string }>> {\n    const txBuffer = optionalDeps.ethUtil.toBuffer(txHex);\n    const decodedTx = optionalDeps.EthTx.TransactionFactory.fromSerializedData(txBuffer);\n    const recipients: Array<{ address: string; amount: string }> = [];\n\n    if (decodedTx.data && decodedTx.data.length > 0) {\n      const dataHex = optionalDeps.ethUtil.bufferToHex(decodedTx.data);\n      const transferData = decodeTransferData(dataHex);\n      if (transferData.to) {\n        recipients.push({\n          address: transferData.to,\n          amount: transferData.amount,\n        });\n      }\n    }\n\n    return recipients;\n  }\n\n  async sendCrossChainRecoveryTransaction(\n    params: SendCrossChainRecoveryOptions\n  ): Promise<{ coin: string; txHex?: string; txid: string }> {\n    const buildResponse = await this.buildCrossChainRecoveryTransaction(params.recoveryId);\n    if (params.walletType === 'cold') {\n      return buildResponse;\n    }\n    if (!params.encryptedPrv) {\n      throw new Error('missing encryptedPrv');\n    }\n\n    let userKeyPrv;\n    try {\n      userKeyPrv = await this.bitgo.decrypt({\n        input: params.encryptedPrv,\n        password: params.walletPassphrase,\n      });\n    } catch (e) {\n      throw new Error(`Error decrypting user keychain: ${e.message}`);\n    }\n    const keyPair = new KeyPairLib({ prv: userKeyPrv });\n    const userSigningKey = keyPair.getKeys().prv;\n    if (!userSigningKey) {\n      throw new Error('no private key');\n    }\n\n    const txBuilder = this.getTransactionBuilder(params.common) as TransactionBuilder;\n    const txHex = buildResponse.txHex;\n    txBuilder.from(txHex);\n    if (buildResponse.walletVersion) {\n      // If walletVersion is provided, set it in the txBuilder\n      txBuilder.walletVersion(buildResponse.walletVersion);\n    }\n    txBuilder\n      .transfer()\n      .coin(this.staticsCoin?.name as string)\n      .key(userSigningKey);\n    const tx = await txBuilder.build();\n    const res = await this.bitgo\n      .post(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${params.recoveryId}/sign`))\n      .send({ txHex: tx.toBroadcastFormat() });\n    return {\n      coin: this.staticsCoin?.name as string,\n      txid: res.body.txid,\n    };\n  }\n\n  async buildCrossChainRecoveryTransaction(recoveryId: string): Promise<{\n    coin: string;\n    txHex: string;\n    txid: string;\n    walletVersion?: number;\n    recipients: Array<{ address: string; amount: string }>;\n  }> {\n    const res = await this.bitgo.get(this.bitgo.microservicesUrl(`/api/recovery/v1/crosschain/${recoveryId}/buildtx`));\n    // Extract recipients from the transaction hex\n    const recipients = await this.extractRecipientsFromTxHex(res.body.txHex);\n    return {\n      coin: res.body.coin,\n      txHex: res.body.txHex,\n      txid: res.body.txid,\n      walletVersion: res.body.walletVersion,\n      recipients,\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 = await this.bitgo.decrypt({\n            input: userKey,\n            password: params.walletPassphrase,\n          });\n        } catch (e) {\n          throw new Error(`Error decrypting user keychain: ${e.message}`);\n        }\n      }\n\n      const keyPair = new KeyPairLib({ prv: userKeyPrv });\n      userSigningKey = keyPair.getKeys().prv;\n      if (!userSigningKey) {\n        throw new Error('no private key');\n      }\n    }\n\n    // Use default gasLimit for cold and custody wallets\n    let gasLimit =\n      params.gasLimit || userKey.startsWith('xpub') || !userKey\n        ? new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit))\n        : new optionalDeps.ethUtil.BN(0);\n\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : params.gasPrice\n      ? new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice))\n      : await this.getGasPriceFromExternalAPI(this.staticsCoin?.name as string, params.apiKey);\n\n    const bitgoFeeAddressNonce = await this.getAddressNonce(bitgoFeeAddress, params.apiKey);\n\n    if (tokenContractAddress) {\n      return this.recoverEthLikeTokenforEvmBasedRecovery(\n        params,\n        bitgoFeeAddressNonce,\n        gasLimit,\n        gasPrice,\n        userKey,\n        userSigningKey,\n        params.apiKey\n      );\n    }\n\n    // get balance of wallet\n    const txAmount = await this.queryAddressBalance(walletContractAddress, params.apiKey);\n\n    const bitgoFeePercentage = 0; // TODO: BG-71912 can change the fee% here.\n    const bitgoFeeAmount = txAmount * (bitgoFeePercentage / 100);\n\n    // build recipients object\n    const recipients: Recipient[] = [\n      {\n        address: recoveryDestination,\n        amount: new BigNumber(txAmount).minus(bitgoFeeAmount).toFixed(),\n      },\n    ];\n\n    if (bitgoFeePercentage > 0) {\n      if (_.isUndefined(bitgoDestinationAddress) || !this.isValidAddress(bitgoDestinationAddress)) {\n        throw new Error('invalid bitgoDestinationAddress');\n      }\n\n      recipients.push({\n        address: bitgoDestinationAddress,\n        amount: bitgoFeeAmount.toString(10),\n      });\n    }\n\n    // calculate batch data\n    const BATCH_METHOD_NAME = 'batch';\n    const BATCH_METHOD_TYPES = ['address[]', 'uint256[]'];\n    const batchExecutionInfo = this.getBatchExecutionInfo(recipients);\n    const batchData = optionalDeps.ethUtil.addHexPrefix(\n      this.getMethodCallData(BATCH_METHOD_NAME, BATCH_METHOD_TYPES, batchExecutionInfo.values).toString('hex')\n    );\n\n    // Get sequence ID using contract call\n    // we need to wait between making two explorer api calls to avoid getting banned\n    await new Promise((resolve) => setTimeout(resolve, 1000));\n    const sequenceId = await this.querySequenceId(walletContractAddress, params.apiKey);\n\n    const network = this.getNetwork();\n    const batcherContractAddress = network?.batcherContractAddress as string;\n\n    const txBuilder = this.getTransactionBuilder(params.common) as TransactionBuilder;\n    txBuilder.counter(bitgoFeeAddressNonce);\n    txBuilder.contract(walletContractAddress);\n    let txFee;\n    if (params.eip1559) {\n      txFee = {\n        eip1559: {\n          maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,\n          maxFeePerGas: params.eip1559.maxFeePerGas,\n        },\n      };\n    } else {\n      txFee = { fee: gasPrice.toString() };\n    }\n    txBuilder.fee({\n      ...txFee,\n      gasLimit: gasLimit.toString(),\n    });\n\n    const transferBuilder = txBuilder.transfer() as TransferBuilder;\n    if (!batcherContractAddress) {\n      transferBuilder\n        .coin(this.staticsCoin?.name as string)\n        .amount(batchExecutionInfo.totalAmount)\n        .contractSequenceId(sequenceId)\n        .expirationTime(this.getDefaultExpireTime())\n        .to(recoveryDestination);\n    } else {\n      transferBuilder\n        .coin(this.staticsCoin?.name as string)\n        .amount(batchExecutionInfo.totalAmount)\n        .contractSequenceId(sequenceId)\n        .expirationTime(this.getDefaultExpireTime())\n        .to(batcherContractAddress)\n        .data(batchData);\n    }\n\n    if (params.walletPassphrase) {\n      transferBuilder.key(userSigningKey);\n    }\n\n    // If the intended chain is arbitrum or optimism, we need to use wallet version 4\n    // since these contracts construct operationHash differently\n    if (params.intendedChain && ['arbeth', 'opeth'].includes(coins.get(params.intendedChain).family)) {\n      txBuilder.walletVersion(4);\n    }\n\n    // If gasLimit was not passed as a param or if it is not cold/custody wallet, then fetch the gasLimit from Explorer\n    if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {\n      const sendData = txBuilder.getSendData();\n      gasLimit = await this.getGasLimitFromExternalAPI(\n        params.intendedChain as string,\n        params.bitgoFeeAddress as string,\n        params.walletContractAddress,\n        sendData,\n        params.apiKey\n      );\n      txBuilder.fee({\n        ...txFee,\n        gasLimit: gasLimit.toString(),\n      });\n    }\n\n    // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees\n    await this.ensureSufficientBalance(bitgoFeeAddress, gasPrice, gasLimit, params.apiKey);\n\n    const tx = await txBuilder.build();\n\n    const txInfo = {\n      recipients: recipients,\n      expireTime: this.getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      gasLimit: gasLimit.toString(10),\n      isEvmBasedCrossChainRecovery: true,\n    };\n\n    const response: OfflineVaultTxInfo = {\n      txHex: tx.toBroadcastFormat(),\n      userKey,\n      coin: this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: txInfo.recipients,\n      walletContractAddress: tx.toJson().to,\n      amount: batchExecutionInfo.totalAmount,\n      backupKeyNonce: bitgoFeeAddressNonce,\n      eip1559: params.eip1559,\n      ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),\n    };\n    _.extend(response, txInfo);\n    response.nextContractSequenceId = response.contractSequenceId;\n\n    if (params.walletPassphrase) {\n      const halfSignedTxn: HalfSignedTransaction = {\n        halfSigned: {\n          txHex: tx.toBroadcastFormat(),\n          recipients: txInfo.recipients,\n          expireTime: txInfo.expireTime,\n        },\n      };\n      _.extend(response, halfSignedTxn);\n\n      const feesUsed: FeesUsed = {\n        gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n        gasLimit: optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),\n      };\n      response['feesUsed'] = feesUsed;\n    }\n\n    return response;\n  }\n\n  /**\n   * Query explorer for the balance of an address for a token\n   * @param {string} tokenContractAddress - address where the token smart contract is hosted\n   * @param {string} walletContractAddress - address of the wallet\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   * @returns {BigNumber} token balaance in base units\n   */\n  async queryAddressTokenBalance(\n    tokenContractAddress: string,\n    walletContractAddress: string,\n    apiKey?: string\n  ): Promise<any> {\n    if (!optionalDeps.ethUtil.isValidAddress(tokenContractAddress)) {\n      throw new Error('cannot get balance for invalid token address');\n    }\n    if (!optionalDeps.ethUtil.isValidAddress(walletContractAddress)) {\n      throw new Error('cannot get token balance for invalid wallet address');\n    }\n\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'account',\n        action: 'tokenbalance',\n        contractaddress: tokenContractAddress,\n        address: walletContractAddress,\n        tag: 'latest',\n      },\n      apiKey\n    );\n    // throw if the result does not exist or the result is not a valid number\n    if (!result || !result.result || isNaN(result.result)) {\n      throw new RecoveryProviderError(\n        `Could not obtain token address balance for ${tokenContractAddress} from Etherscan, got: ${result.result}`\n      );\n    }\n    return new optionalDeps.ethUtil.BN(result.result, 10);\n  }\n\n  async recoverEthLikeTokenforEvmBasedRecovery(\n    params: RecoverOptions,\n    bitgoFeeAddressNonce: number,\n    gasLimit,\n    gasPrice,\n    userKey,\n    userSigningKey,\n    apiKey?: string\n  ) {\n    // get token balance of wallet\n    const txAmount = await this.queryAddressTokenBalance(\n      params.tokenContractAddress as string,\n      params.walletContractAddress,\n      apiKey\n    );\n\n    // build recipients object\n    const recipients: Recipient[] = [\n      {\n        address: params.recoveryDestination,\n        amount: new BigNumber(txAmount).toFixed(),\n      },\n    ];\n\n    // Get sequence ID using contract call\n    // we need to wait between making two explorer api calls to avoid getting banned\n    await new Promise((resolve) => setTimeout(resolve, 1000));\n    const sequenceId = await this.querySequenceId(params.walletContractAddress, params.apiKey);\n\n    const txBuilder = this.getTransactionBuilder(params.common) as TransactionBuilder;\n    txBuilder.counter(bitgoFeeAddressNonce);\n    txBuilder.contract(params.walletContractAddress as string);\n    let txFee;\n    if (params.eip1559) {\n      txFee = {\n        eip1559: {\n          maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,\n          maxFeePerGas: params.eip1559.maxFeePerGas,\n        },\n      };\n    } else {\n      txFee = { fee: gasPrice.toString() };\n    }\n    txBuilder.fee({\n      ...txFee,\n      gasLimit: gasLimit.toString(),\n    });\n\n    const transferBuilder = txBuilder.transfer() as TransferBuilder;\n\n    const network = this.getNetwork();\n    const token = getToken(\n      params.tokenContractAddress as string,\n      network as EthLikeNetwork,\n      this.staticsCoin?.family as string\n    )?.name as string;\n\n    transferBuilder\n      .amount(txAmount)\n      .contractSequenceId(sequenceId)\n      .expirationTime(this.getDefaultExpireTime())\n      .to(params.recoveryDestination);\n\n    if (token) {\n      transferBuilder.coin(token);\n    } else {\n      transferBuilder\n        .coin(this.staticsCoin?.name as string)\n        .tokenContractAddress(params.tokenContractAddress as string);\n    }\n\n    if (params.walletPassphrase) {\n      txBuilder.transfer().key(userSigningKey);\n    }\n    // If the intended chain is arbitrum or optimism, we need to use wallet version 4\n    // since these contracts construct operationHash differently\n    if (params.intendedChain && ['arbeth', 'opeth'].includes(coins.get(params.intendedChain).family)) {\n      txBuilder.walletVersion(4);\n    }\n\n    if (!params.gasLimit && userKey && !userKey.startsWith('xpub')) {\n      const sendData = txBuilder.getSendData();\n      gasLimit = await this.getGasLimitFromExternalAPI(\n        params.intendedChain as string,\n        params.bitgoFeeAddress as string,\n        params.walletContractAddress,\n        sendData,\n        apiKey\n      );\n      txBuilder.fee({\n        ...txFee,\n        gasLimit: gasLimit.toString(),\n      });\n    }\n\n    // Get the balance of bitgoFeeAddress to ensure funds are available to pay fees\n    await this.ensureSufficientBalance(params.bitgoFeeAddress as string, gasPrice, gasLimit, params.apiKey);\n\n    const tx = await txBuilder.build();\n\n    const txInfo = {\n      recipients: recipients,\n      expireTime: this.getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      gasLimit: gasLimit.toString(10),\n      isEvmBasedCrossChainRecovery: true,\n    };\n\n    const response: OfflineVaultTxInfo = {\n      txHex: tx.toBroadcastFormat(),\n      userKey,\n      coin: token ? token : this.getChain(),\n      gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n      gasLimit,\n      recipients: txInfo.recipients,\n      walletContractAddress: tx.toJson().to,\n      amount: txAmount.toString(),\n      backupKeyNonce: bitgoFeeAddressNonce,\n      eip1559: params.eip1559,\n      ...(txBuilder.getWalletVersion() === 4 ? { walletVersion: txBuilder.getWalletVersion() } : {}),\n    };\n    _.extend(response, txInfo);\n    response.nextContractSequenceId = response.contractSequenceId;\n\n    if (params.walletPassphrase) {\n      const halfSignedTxn: HalfSignedTransaction = {\n        halfSigned: {\n          txHex: tx.toBroadcastFormat(),\n          recipients: txInfo.recipients,\n          expireTime: txInfo.expireTime,\n        },\n      };\n      _.extend(response, halfSignedTxn);\n\n      const feesUsed: FeesUsed = {\n        gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n        gasLimit: optionalDeps.ethUtil.bufferToInt(gasLimit).toFixed(),\n      };\n      response['feesUsed'] = feesUsed;\n    }\n\n    return response;\n  }\n\n  /**\n   * Validate evm based cross chain recovery params\n   * @param params {RecoverOptions}\n   * @returns {void}\n   */\n  validateEvmBasedRecoveryParams(params: RecoverOptions): void {\n    if (_.isUndefined(params.bitgoFeeAddress) || !this.isValidAddress(params.bitgoFeeAddress)) {\n      throw new Error('invalid bitgoFeeAddress');\n    }\n\n    if (_.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {\n      throw new Error('invalid walletContractAddress');\n    }\n\n    if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n  }\n\n  /**\n   * Return types, values, and total amount in wei to send in a batch transaction, using the method signature\n   * `distributeBatch(address[], uint256[])`\n   * @param {Recipient[]} recipients - transaction recipients\n   * @returns {GetBatchExecutionInfoRT} information needed to execute the batch transaction\n   */\n  getBatchExecutionInfo(recipients: Recipient[]): GetBatchExecutionInfoRT {\n    const addresses: string[] = [];\n    const amounts: string[] = [];\n    let sum = new BigNumber('0');\n    _.forEach(recipients, ({ address, amount }) => {\n      addresses.push(address);\n      amounts.push(amount as string);\n      sum = sum.plus(amount);\n    });\n\n    return {\n      values: [addresses, amounts],\n      totalAmount: sum.toFixed(),\n    };\n  }\n\n  /**\n   * Get the data required to make an ETH function call defined by the given types and values\n   *\n   * @param {string} functionName - The name of the function being called, e.g. transfer\n   * @param types The types of the function call in order\n   * @param values The values of the function call in order\n   * @return {Buffer} The combined data for the function call\n   */\n  getMethodCallData = (functionName, types, values) => {\n    return Buffer.concat([\n      // function signature\n      optionalDeps.ethAbi.methodID(functionName, types),\n      // function arguments\n      optionalDeps.ethAbi.rawEncode(types, values),\n    ]);\n  };\n\n  /**\n   * Build arguments to call the send method on the wallet contract\n   * @param txInfo\n   */\n  getSendMethodArgs(txInfo: GetSendMethodArgsOptions): SendMethodArgs[] {\n    // Method signature is\n    // sendMultiSig(address toAddress, uint value, bytes data, uint expireTime, uint sequenceId, bytes signature)\n    return [\n      {\n        name: 'toAddress',\n        type: 'address',\n        value: txInfo.recipient.address,\n      },\n      {\n        name: 'value',\n        type: 'uint',\n        value: txInfo.recipient.amount,\n      },\n      {\n        name: 'data',\n        type: 'bytes',\n        value: optionalDeps.ethUtil.toBuffer(optionalDeps.ethUtil.addHexPrefix(txInfo.recipient.data || '')),\n      },\n      {\n        name: 'expireTime',\n        type: 'uint',\n        value: txInfo.expireTime,\n      },\n      {\n        name: 'sequenceId',\n        type: 'uint',\n        value: txInfo.contractSequenceId,\n      },\n      {\n        name: 'signature',\n        type: 'bytes',\n        value: optionalDeps.ethUtil.toBuffer(optionalDeps.ethUtil.addHexPrefix(txInfo.signature)),\n      },\n    ];\n  }\n\n  /**\n   * Recovers a tx with TSS key shares\n   * same expected arguments as recover method, but with TSS key shares\n   */\n  protected async recoverTSS(\n    params: RecoverOptions\n  ): Promise<RecoveryInfo | OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    this.validateRecoveryParams(params);\n    // Clean up whitespace from entered values\n    const userPublicOrPrivateKeyShare = params.userKey.replace(/\\s/g, '');\n    const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\\s/g, '');\n\n    if (\n      getIsUnsignedSweep({\n        userKey: userPublicOrPrivateKeyShare,\n        backupKey: backupPrivateOrPublicKeyShare,\n        isTss: params.isTss,\n      })\n    ) {\n      return this.buildUnsignedSweepTxnTSS(params);\n    } else {\n      const { userKeyShare, backupKeyShare, commonKeyChain } = await ECDSAUtils.getMpcV2RecoveryKeyShares(\n        userPublicOrPrivateKeyShare,\n        backupPrivateOrPublicKeyShare,\n        params.walletPassphrase,\n        this.bitgo\n      );\n\n      const { gasLimit, gasPrice } = await this.getGasValues(params);\n\n      const MPC = new Ecdsa();\n      const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm/0');\n      const backupKeyPair = new KeyPairLib({ pub: derivedCommonKeyChain.slice(0, 66) });\n      const baseAddress = backupKeyPair.getAddress();\n      const unsignedTx = (await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params)).tx;\n      const messageHash = unsignedTx.getMessageToSign(true);\n      const signature = await ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);\n      const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(params.eip1559, params.replayProtectionOptions);\n      const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, signature);\n\n      return {\n        id: addHexPrefix(signedTx.hash().toString('hex')),\n        tx: addHexPrefix(signedTx.serialize().toString('hex')),\n      };\n    }\n  }\n\n  private async getGasValues(params: RecoverOptions): Promise<{ gasLimit: number; gasPrice: Buffer }> {\n    const gasLimit = new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));\n    return { gasLimit, gasPrice };\n  }\n\n  protected async buildUnsignedSweepTxnTSS(params: RecoverOptions): Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    const userPublicOrPrivateKeyShare = params.userKey.replace(/\\s/g, '');\n    const backupPrivateOrPublicKeyShare = params.backupKey.replace(/\\s/g, '');\n\n    const { gasLimit, gasPrice } = await this.getGasValues(params);\n\n    const backupKeyPair = new KeyPairLib({ pub: backupPrivateOrPublicKeyShare });\n    const baseAddress = backupKeyPair.getAddress();\n    const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);\n    return this.formatForOfflineVaultTSS(\n      txInfo,\n      tx,\n      userPublicOrPrivateKeyShare,\n      backupPrivateOrPublicKeyShare,\n      gasPrice,\n      gasLimit,\n      nonce,\n      params.eip1559,\n      params.replayProtectionOptions\n    );\n  }\n\n  protected async buildUnsignedSweepTxnMPCv2(params: RecoverOptions): Promise<UnsignedSweepTxMPCv2> {\n    const { gasLimit, gasPrice } = await this.getGasValues(params);\n\n    const recoverParams = params as RecoverOptions;\n    this.validateUnsignedSweepTSSParams(recoverParams);\n\n    const derivationPath = recoverParams.derivationSeed ? getDerivationPath(recoverParams.derivationSeed) : 'm/0';\n    const MPC = new Ecdsa();\n    const derivedCommonKeyChain = MPC.deriveUnhardened(recoverParams.backupKey as string, derivationPath);\n    const backupKeyPair = new KeyPairLib({ pub: derivedCommonKeyChain.slice(0, 66) });\n    const baseAddress = backupKeyPair.getAddress();\n    const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, params);\n    return this.buildTxRequestForOfflineVaultMPCv2(\n      txInfo,\n      tx,\n      derivationPath,\n      nonce,\n      gasPrice,\n      gasLimit,\n      params.eip1559,\n      params.replayProtectionOptions,\n      recoverParams.backupKey as string\n    );\n  }\n\n  async createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs> {\n    const req = params.signatureShares;\n    const broadcastableTransactions: MPCTx[] = [];\n    let lastScanIndex = 0;\n\n    for (let i = 0; i < req.length; i++) {\n      const transaction = req[i]?.txRequest?.transactions?.[0]?.unsignedTx as unknown as UnsignedTransactionTss;\n      if (!req[i].ovc || !req[i].ovc[0].ecdsaSignature) {\n        throw new Error('Missing signature(s)');\n      }\n      if (!transaction.signableHex) {\n        throw new Error('Missing signable hex');\n      }\n      const signature = req[i].ovc[0].ecdsaSignature;\n      if (!signature) {\n        throw new Error('Signature is undefined');\n      }\n      const shares: string[] = signature.toString().split(':');\n      if (shares.length !== 4) {\n        throw new Error('Invalid signature');\n      }\n      const finalSignature: ECDSAMethodTypes.Signature = {\n        recid: Number(shares[0]),\n        r: shares[1],\n        s: shares[2],\n        y: shares[3],\n      } as unknown as ECDSAMethodTypes.Signature;\n\n      if (!transaction.coinSpecific?.commonKeyChain) {\n        throw new Error(`Missing common keychain for transaction at index ${i}`);\n      }\n      const commonKeyChain = transaction.coinSpecific.commonKeyChain;\n      if (!transaction.derivationPath) {\n        throw new Error(`Missing derivation path for transaction at index ${i}`);\n      }\n      if (!commonKeyChain) {\n        throw new Error(`Missing common key chain for transaction at index ${i}`);\n      }\n\n      const ethCommmon = AbstractEthLikeNewCoins.getEthLikeCommon(\n        transaction.eip1559,\n        transaction.replayProtectionOptions\n      );\n      let unsignedTx: EthLikeTxLib.FeeMarketEIP1559Transaction | EthLikeTxLib.Transaction;\n      if (transaction.eip1559) {\n        unsignedTx = FeeMarketEIP1559Transaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));\n      } else {\n        unsignedTx = LegacyTransaction.fromSerializedTx(Buffer.from(transaction.serializedTxHex, 'hex'));\n      }\n      const signedTx = this.getSignedTxFromSignature(ethCommmon, unsignedTx, finalSignature);\n      broadcastableTransactions.push({\n        serializedTx: addHexPrefix(signedTx.serialize().toString('hex')),\n      });\n\n      if (i === req.length - 1 && transaction.coinSpecific?.lastScanIndex) {\n        lastScanIndex = transaction.coinSpecific?.lastScanIndex as number;\n      }\n    }\n\n    return { transactions: broadcastableTransactions, lastScanIndex };\n  }\n\n  /**\n   * Method to validate recovery params\n   * @param {RecoverOptions} params\n   * @returns {void}\n   */\n  private async validateUnsignedSweepTSSParams(params: RecoverOptions): Promise<void> {\n    if (_.isUndefined(params.backupKey) && params.backupKey === '') {\n      throw new Error('missing commonKeyChain');\n    }\n    if (!_.isUndefined(params.derivationSeed) && typeof params.derivationSeed !== 'string') {\n      throw new Error('invalid derivationSeed');\n    }\n    if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('missing or invalid destinationAddress');\n    }\n  }\n\n  /**\n   * Helper function for recover()\n   * This transforms the unsigned transaction information into a format the BitGo offline vault expects\n   * @param {UnformattedTxInfo} txInfo - tx info\n   * @param {LegacyTransaction | FeeMarketEIP1559Transaction} ethTx - the ethereumjs tx object\n   * @param {string} derivationPath - the derivationPath\n   * @param {number} nonce - the nonce of the backup key address\n   * @param {Buffer} gasPrice - gas price for the tx\n   * @param {number} gasLimit - gas limit for the tx\n   * @param {EIP1559} eip1559 - eip1559 params\n   * @param replayProtectionOptions\n   * @param commonKeyChain\n   * @returns {Promise<OfflineVaultTxInfo>}\n   */\n  private buildTxRequestForOfflineVaultMPCv2(\n    txInfo: UnformattedTxInfo,\n    ethTx: LegacyTransaction | FeeMarketEIP1559Transaction,\n    derivationPath: string,\n    nonce: number,\n    gasPrice: Buffer,\n    gasLimit: number,\n    eip1559?: EIP1559,\n    replayProtectionOptions?: ReplayProtectionOptions,\n    commonKeyChain?: string\n  ): UnsignedSweepTxMPCv2 {\n    if (!ethTx.to) {\n      throw new Error('Eth tx must have a `to` address');\n    }\n\n    const fee = eip1559\n      ? gasLimit * eip1559.maxFeePerGas\n      : gasLimit * optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed();\n\n    const unsignedTx: UnsignedTransactionTss = {\n      serializedTxHex: ethTx.serialize().toString('hex'),\n      signableHex:\n        ethTx instanceof FeeMarketEIP1559Transaction\n          ? ethTx.getMessageToSign(false).toString('hex')\n          : Buffer.from(RLP.encode(bufArrToArr(ethTx.getMessageToSign(false)))).toString('hex'),\n      derivationPath: derivationPath,\n      feeInfo: {\n        fee: fee,\n        feeString: fee.toString(),\n      },\n      parsedTx: {\n        spendAmount: txInfo.recipient.amount,\n        outputs: [\n          {\n            coinName: this.getChain(),\n            address: txInfo.recipient.address,\n            valueString: txInfo.recipient.amount,\n          },\n        ],\n      },\n      coinSpecific: {\n        commonKeyChain: commonKeyChain,\n      },\n      eip1559: eip1559,\n      replayProtectionOptions: replayProtectionOptions,\n    };\n\n    return {\n      txRequests: [\n        {\n          walletCoin: this.getChain(),\n          transactions: [\n            {\n              unsignedTx: unsignedTx,\n              nonce: nonce,\n              signatureShares: [],\n            },\n          ],\n        },\n      ],\n    };\n  }\n\n  private async buildTssRecoveryTxn(baseAddress: string, gasPrice: any, gasLimit: any, params: RecoverOptions) {\n    const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, params.apiKey);\n    const nonce = await this.getAddressNonce(baseAddress, params.apiKey);\n    const recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: txAmount.toString(10),\n      },\n    ];\n\n    const txInfo = {\n      recipient: recipients[0],\n      expireTime: this.getDefaultExpireTime(),\n      gasLimit: gasLimit.toString(10),\n    };\n\n    const txParams = {\n      to: params.recoveryDestination,\n      nonce: nonce,\n      value: txAmount,\n      gasPrice: gasPrice,\n      gasLimit: gasLimit,\n      data: Buffer.from('0x'),\n      eip1559: params.eip1559,\n      replayProtectionOptions: params.replayProtectionOptions,\n    };\n\n    const tx = AbstractEthLikeNewCoins.buildTransaction(txParams);\n    return { txInfo, tx, nonce };\n  }\n\n  async validateBalanceAndGetTxAmount(baseAddress: string, gasPrice: BN, gasLimit: BN, apiKey?: string) {\n    const baseAddressBalance = await this.queryAddressBalance(baseAddress, apiKey);\n    let totalGasNeeded = gasPrice.mul(gasLimit);\n    // On L2 chains with L1 data fees, add buffer for L1 fees\n    if (this.staticsCoin?.family !== undefined && coinFamiliesWithL1Fees.includes(this.staticsCoin.family)) {\n      totalGasNeeded = totalGasNeeded.add(new optionalDeps.ethUtil.BN(ethGasConfigs.l1GasFeeBuffer));\n    }\n    const weiToGwei = new BN(10 ** 9);\n    if (baseAddressBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Backup key address ${baseAddress} has balance ${baseAddressBalance.div(weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${totalGasNeeded.div(weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some ETH to this address then retry.`\n      );\n    }\n    const txAmount = baseAddressBalance.sub(totalGasNeeded);\n    return txAmount;\n  }\n\n  /**\n   * Make a query to blockchain explorer for information such as balance, token balance, solidity calls\n   * @param query {Object} key-value pairs of parameters to append after /api\n   * @param apiKey {string} optional API key to use instead of the one from the environment\n   * @returns {Object} response from the blockchain explorer\n   */\n  async recoveryBlockchainExplorerQuery(query: Record<string, string>, apiKey?: string): Promise<any> {\n    throw new Error('method not implemented');\n  }\n\n  /**\n   * Creates the extra parameters needed to build a hop transaction\n   * @param buildParams The original build parameters\n   * @returns extra parameters object to merge with the original build parameters object and send to the platform\n   */\n  async createHopTransactionParams(buildParams: HopTransactionBuildOptions): Promise<HopParams> {\n    const wallet = buildParams.wallet;\n    const recipients = buildParams.recipients;\n    const walletPassphrase = buildParams.walletPassphrase;\n\n    const userKeychain = await this.keychains().get({ id: wallet.keyIds()[0] });\n    const userPrv = await wallet.getUserPrv({ keychain: userKeychain, walletPassphrase });\n    const userPrvBuffer = bip32.fromBase58(userPrv).privateKey;\n    if (!userPrvBuffer) {\n      throw new Error('invalid userPrv');\n    }\n    if (!recipients || !Array.isArray(recipients)) {\n      throw new Error('expecting array of recipients');\n    }\n\n    // Right now we only support 1 recipient\n    if (recipients.length !== 1) {\n      throw new Error('must send to exactly 1 recipient');\n    }\n    const recipientAddress = recipients[0].address;\n    const recipientAmount = recipients[0].amount as string;\n    const feeEstimateParams = {\n      recipient: recipientAddress,\n      amount: recipientAmount,\n      hop: true,\n    };\n    const feeEstimate: FeeEstimate = await this.feeEstimate(feeEstimateParams);\n\n    const gasLimit = feeEstimate.gasLimitEstimate;\n    const gasPrice = Math.round(feeEstimate.feeEstimate / gasLimit);\n    const gasPriceMax = gasPrice * 5;\n    // Payment id a random number so its different for every tx\n    const paymentId = Math.floor(Math.random() * 10000000000).toString();\n    const hopDigest: Buffer = AbstractEthLikeNewCoins.getHopDigest([\n      recipientAddress,\n      recipientAmount,\n      gasPriceMax.toString(),\n      gasLimit.toString(),\n      paymentId,\n    ]);\n\n    const userReqSig = optionalDeps.ethUtil.addHexPrefix(\n      Buffer.from(secp256k1.ecdsaSign(hopDigest, userPrvBuffer).signature).toString('hex')\n    );\n\n    return {\n      hopParams: {\n        gasPriceMax,\n        userReqSig,\n        paymentId,\n        gasLimit,\n      },\n    };\n  }\n\n  /**\n   * Validates that the hop prebuild from the HSM is valid and correct\n   * @param {IWallet} wallet - The wallet that the prebuild is for\n   * @param {HopPrebuild} hopPrebuild - The prebuild to validate\n   * @param {Object} originalParams - The original parameters passed to prebuildTransaction\n   * @param {Recipient[]} originalParams.recipients - The original recipients array\n   * @returns {void}\n   * @throws Error if The prebuild is invalid\n   */\n  async validateHopPrebuild(\n    wallet: IWallet,\n    hopPrebuild: HopPrebuild,\n    originalParams?: { recipients: Recipient[] }\n  ): Promise<void> {\n    const { tx, id, signature } = hopPrebuild;\n\n    // first, validate the HSM signature\n    const serverXpub = common.Environments[this.bitgo.getEnv()].hsmXpub;\n    const serverPubkeyBuffer: Buffer = bip32.fromBase58(serverXpub).publicKey;\n    const signatureBuffer: Buffer = Buffer.from(optionalDeps.ethUtil.stripHexPrefix(signature), 'hex');\n    const messageBuffer: Buffer = Buffer.from(\n      optionalDeps.ethUtil.padToEven(optionalDeps.ethUtil.stripHexPrefix(id)),\n      'hex'\n    );\n\n    const sig = new Uint8Array(signatureBuffer.slice(1));\n    const isValidSignature: boolean = secp256k1.ecdsaVerify(sig, messageBuffer, serverPubkeyBuffer);\n    if (!isValidSignature) {\n      throw new Error(\n        `Hop txid signature invalid - pub: ${serverXpub}, msg: ${messageBuffer?.toString()}, sig: ${signatureBuffer?.toString()}`\n      );\n    }\n\n    const builtHopTx = optionalDeps.EthTx.TransactionFactory.fromSerializedData(optionalDeps.ethUtil.toBuffer(tx));\n    // If original params are given, we can check them against the transaction prebuild params\n    if (!_.isNil(originalParams)) {\n      const { recipients } = originalParams;\n\n      // Then validate that the tx params actually equal the requested params\n      const originalAmount = new BigNumber(recipients[0].amount);\n      const originalDestination: string = recipients[0].address;\n\n      const hopAmount = new BigNumber(optionalDeps.ethUtil.bufferToHex(builtHopTx.value));\n      if (!builtHopTx.to) {\n        throw new Error(`Transaction does not have a destination address`);\n      }\n      const hopDestination = builtHopTx.to.toString();\n      if (!hopAmount.eq(originalAmount)) {\n        throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);\n      }\n      if (hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {\n        throw new Error(`Hop destination: ${hopDestination} does not equal original recipient: ${hopDestination}`);\n      }\n    }\n\n    if (!builtHopTx.verifySignature()) {\n      // We dont want to continue at all in this case, at risk of ETH being stuck on the hop address\n      throw new Error(`Invalid hop transaction signature, txid: ${id}`);\n    }\n    if (optionalDeps.ethUtil.addHexPrefix(builtHopTx.hash().toString('hex')) !== id) {\n      throw new Error(`Signed hop txid does not equal actual txid`);\n    }\n  }\n\n  /**\n   * Gets the hop digest for the user to sign. This is validated in the HSM to prove that the user requested this tx\n   * @param {string[]} paramsArr - The parameters to hash together for the digest\n   * @returns {Buffer}\n   */\n  public static getHopDigest(paramsArr: string[]): Buffer {\n    const hash = Keccak('keccak256');\n    hash.update([AbstractEthLikeNewCoins.hopTransactionSalt, ...paramsArr].join('$'));\n    return hash.digest();\n  }\n\n  /**\n   * Modify prebuild before sending it to the server. Add things like hop transaction params\n   * @param {BuildOptions} buildParams - The whitelisted parameters for this prebuild\n   * @param {boolean} buildParams.hop - True if this should prebuild a hop tx, else false\n   * @param {Recipient[]} buildParams.recipients - The recipients array of this transaction\n   * @param {Wallet} buildParams.wallet - The wallet sending this tx\n   * @param {string} buildParams.walletPassphrase - the passphrase for this wallet\n   * @returns {Promise<BuildOptions>}\n   */\n  async getExtraPrebuildParams(buildParams: BuildOptions): Promise<BuildOptions> {\n    if (\n      !_.isUndefined(buildParams.hop) &&\n      buildParams.hop &&\n      !_.isUndefined(buildParams.wallet) &&\n      !_.isUndefined(buildParams.recipients) &&\n      !_.isUndefined(buildParams.walletPassphrase)\n    ) {\n      if (this instanceof EthLikeToken) {\n        throw new Error(\n          `Hop transactions are not enabled for ERC-20 tokens, nor are they necessary. Please remove the 'hop' parameter and try again.`\n        );\n      }\n      return (await this.createHopTransactionParams({\n        wallet: buildParams.wallet,\n        recipients: buildParams.recipients,\n        walletPassphrase: buildParams.walletPassphrase,\n      })) as any;\n    }\n    return {};\n  }\n\n  /**\n   * Modify prebuild after receiving it from the server. Add things like nlocktime\n   * @param {TransactionPrebuild} params - The prebuild to modify\n   * @returns {TransactionPrebuild} The modified prebuild\n   */\n  async postProcessPrebuild(params: TransactionPrebuild): Promise<TransactionPrebuild> {\n    if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {\n      await this.validateHopPrebuild(params.wallet, params.hopTransaction, params.buildParams);\n    }\n    return params;\n  }\n\n  /**\n   * Coin-specific things done before signing a transaction, i.e. verification\n   * @param {PresignTransactionOptions} params\n   * @returns {Promise<PresignTransactionOptions>}\n   */\n  async presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions> {\n    if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {\n      await this.validateHopPrebuild(params.wallet, params.hopTransaction);\n    }\n    return params;\n  }\n\n  /**\n   * Fetch fee estimate information from the server\n   * @param {Object} params - The params passed into the function\n   * @param {boolean} [params.hop] - True if we should estimate fee for a hop transaction\n   * @param {string} [params.recipient] - The recipient of the transaction to estimate a send to\n   * @param {string} [params.data] - The ETH tx data to estimate a send for\n   * @returns {Object} The fee info returned from the server\n   */\n  async feeEstimate(params: FeeEstimateOptions): Promise<FeeEstimate> {\n    const query: FeeEstimateOptions = {};\n    if (params && params.hop) {\n      query.hop = params.hop;\n    }\n    if (params && params.recipient) {\n      query.recipient = params.recipient;\n    }\n    if (params && params.data) {\n      query.data = params.data;\n    }\n    if (params && params.amount) {\n      query.amount = params.amount;\n    }\n\n    return await this.bitgo.get(this.url('/tx/fee')).query(query).result();\n  }\n\n  /**\n   * Generate secp256k1 key pair\n   *\n   * @param {Buffer} seed\n   * @returns {KeyPair} object with generated pub and prv\n   */\n  generateKeyPair(seed: Buffer): KeyPair {\n    if (!seed) {\n      // An extended private key has both a normal 256 bit private key and a 256\n      // bit chain code, both of which must be random. 512 bits is therefore the\n      // maximum entropy and gives us maximum security against cracking.\n      seed = randomBytes(512 / 8);\n    }\n    const extendedKey = bip32.fromSeed(seed);\n    const xpub = extendedKey.neutered().toBase58();\n    return {\n      pub: xpub,\n      prv: extendedKey.toBase58(),\n    };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Get forwarder factory and implementation addresses for deposit address verification.\n   * Forwarders are smart contracts that forward funds to the base wallet address.\n   *\n   * @param {number | undefined} forwarderVersion - The wallet version\n   * @returns {object} Factory and implementation addresses for forwarders\n   */\n  getForwarderFactoryAddressesAndForwarderImplementationAddress(forwarderVersion: number | undefined): {\n    forwarderFactoryAddress: string;\n    forwarderImplementationAddress: string;\n  } {\n    const ethNetwork = this.getNetwork();\n\n    switch (forwarderVersion) {\n      case 1:\n        if (!ethNetwork?.forwarderFactoryAddress || !ethNetwork?.forwarderImplementationAddress) {\n          throw new Error('Forwarder factory addresses not configured for this network');\n        }\n        return {\n          forwarderFactoryAddress: ethNetwork.forwarderFactoryAddress,\n          forwarderImplementationAddress: ethNetwork.forwarderImplementationAddress,\n        };\n      case 2:\n        if (!ethNetwork?.walletV2ForwarderFactoryAddress || !ethNetwork?.walletV2ForwarderImplementationAddress) {\n          throw new Error('Wallet v2 factory addresses not configured for this network');\n        }\n        return {\n          forwarderFactoryAddress: ethNetwork.walletV2ForwarderFactoryAddress,\n          forwarderImplementationAddress: ethNetwork.walletV2ForwarderImplementationAddress,\n        };\n      case 4:\n      case 5:\n        if (!ethNetwork?.walletV4ForwarderFactoryAddress || !ethNetwork?.walletV4ForwarderImplementationAddress) {\n          throw new Error(`Forwarder v${forwarderVersion} factory addresses not configured for this network`);\n        }\n        return {\n          forwarderFactoryAddress: ethNetwork.walletV4ForwarderFactoryAddress,\n          forwarderImplementationAddress: ethNetwork.walletV4ForwarderImplementationAddress,\n        };\n      default:\n        throw new Error(`Forwarder version ${forwarderVersion} not supported`);\n    }\n  }\n\n  /**\n   * Get wallet base address factory and implementation addresses.\n   * This is used for base address verification for V1, V2, V4, and V5 wallets.\n   * The base address is the main wallet contract deployed via CREATE2.\n   *\n   * @param {number} walletVersion - The wallet version (1, 2, 4, or 5)\n   * @returns {object} Factory and implementation addresses for the wallet base address\n   * @throws {Error} if wallet version addresses are not configured\n   */\n  getWalletAddressFactoryAddressesAndImplementationAddress(walletVersion: number): {\n    walletFactoryAddress: string;\n    walletImplementationAddress: string;\n  } {\n    const ethNetwork = this.getNetwork();\n\n    switch (walletVersion) {\n      case 1:\n        if (!ethNetwork?.walletFactoryAddress || !ethNetwork?.walletImplementationAddress) {\n          throw new Error('Wallet v1 factory addresses not configured for this network');\n        }\n        return {\n          walletFactoryAddress: ethNetwork.walletFactoryAddress,\n          walletImplementationAddress: ethNetwork.walletImplementationAddress,\n        };\n      case 2:\n        if (!ethNetwork?.walletV2FactoryAddress || !ethNetwork?.walletV2ImplementationAddress) {\n          throw new Error('Wallet v2 factory addresses not configured for this network');\n        }\n        return {\n          walletFactoryAddress: ethNetwork.walletV2FactoryAddress,\n          walletImplementationAddress: ethNetwork.walletV2ImplementationAddress,\n        };\n      case 4:\n      case 5:\n        if (!ethNetwork?.walletV4ForwarderFactoryAddress || !ethNetwork?.walletV4ForwarderImplementationAddress) {\n          throw new Error(`Wallet v${walletVersion} factory addresses not configured for this network`);\n        }\n        return {\n          walletFactoryAddress: ethNetwork.walletV4ForwarderFactoryAddress,\n          walletImplementationAddress: ethNetwork.walletV4ForwarderImplementationAddress,\n        };\n      default:\n        throw new Error(`Wallet version ${walletVersion} not supported`);\n    }\n  }\n\n  /**\n   * Helper method to create a salt buffer from hex string.\n   * Converts a hex salt string to a 32-byte buffer.\n   *\n   * @param {string} salt - The hex salt string\n   * @returns {Buffer} 32-byte salt buffer\n   */\n  private createSaltBuffer(salt: string): Buffer {\n    const ethUtil = optionalDeps.ethUtil;\n    return ethUtil.setLengthLeft(Buffer.from(ethUtil.padToEven(ethUtil.stripHexPrefix(salt || '')), 'hex'), 32);\n  }\n\n  /**\n   * Verify BIP32 wallet base address (V1, V2, V4).\n   * These wallets use a wallet factory to deploy base addresses with CREATE2.\n   * The address is derived from the keychains' ethAddresses and a salt.\n   *\n   * @param {VerifyBip32BaseAddressOptions} params - Verification parameters\n   * @returns {object} Expected and actual addresses for comparison\n   */\n  private verifyCreate2BaseAddress(params: VerifyContractBaseAddressOptions): boolean {\n    const { address, coinSpecific, keychains, walletVersion } = params;\n\n    if (!coinSpecific.salt) {\n      throw new Error(`missing salt for v${walletVersion} base address verification`);\n    }\n\n    // Get wallet factory and implementation addresses for the wallet version\n    const { walletFactoryAddress, walletImplementationAddress } =\n      this.getWalletAddressFactoryAddressesAndImplementationAddress(walletVersion);\n    const initcode = getProxyInitcode(walletImplementationAddress);\n\n    // Convert the wallet salt to a buffer, pad to 32 bytes\n    const saltBuffer = this.createSaltBuffer(coinSpecific.salt);\n\n    // Reconstruct calculationSalt using keychains' ethAddresses and wallet salt\n    const ethAddresses = keychains.map((kc) => {\n      if (!kc.ethAddress) {\n        throw new Error(`keychain missing ethAddress for v${walletVersion} base address verification`);\n      }\n      return kc.ethAddress;\n    });\n\n    const calculationSalt = optionalDeps.ethUtil.bufferToHex(\n      optionalDeps.ethAbi.soliditySHA3(['address[]', 'bytes32'], [ethAddresses, saltBuffer])\n    );\n\n    const expectedAddress = calculateForwarderV1Address(walletFactoryAddress, calculationSalt, initcode);\n\n    if (expectedAddress !== address) {\n      throw new UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Verify forwarder receive address (deposit address).\n   * Forwarder addresses are derived using CREATE2 from the base address and salt.\n   *\n   * @param {VerifyEthAddressOptions} params - Verification parameters\n   * @param {number} forwarderVersion - The forwarder version\n   * @returns {object} Expected and actual addresses for comparison\n   */\n  private verifyForwarderAddress(params: VerifyEthAddressOptions, forwarderVersion: number): boolean {\n    const { address, coinSpecific, baseAddress } = params;\n\n    const { forwarderFactoryAddress, forwarderImplementationAddress } =\n      this.getForwarderFactoryAddressesAndForwarderImplementationAddress(forwarderVersion);\n    const initcode = getProxyInitcode(forwarderImplementationAddress);\n    const saltBuffer = this.createSaltBuffer(coinSpecific.salt || '');\n\n    const { createForwarderParams, createForwarderTypes } =\n      forwarderVersion === 4\n        ? getCreateForwarderParamsAndTypes(baseAddress, saltBuffer, coinSpecific.feeAddress)\n        : getCreateForwarderParamsAndTypes(baseAddress, saltBuffer);\n\n    const calculationSalt = optionalDeps.ethUtil.bufferToHex(\n      optionalDeps.ethAbi.soliditySHA3(createForwarderTypes, createForwarderParams)\n    );\n\n    const expectedAddress = calculateForwarderV1Address(forwarderFactoryAddress, calculationSalt, initcode);\n\n    if (expectedAddress !== address) {\n      throw new UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);\n    }\n\n    return true;\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 | TssVerifyEthAddressOptions): Promise<boolean> {\n    const { address, impliedForwarderVersion, coinSpecific, baseAddress } = params;\n    const forwarderVersion = impliedForwarderVersion ?? coinSpecific?.forwarderVersion;\n\n    // Validate address format\n    if (address && !this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    // Forwarder version 0 addresses cannot be verified because we do not store the nonce value required for address derivation.\n    if (forwarderVersion === 0) {\n      return true;\n    }\n\n    // Determine if we are verifying a base address\n    const isVerifyingBaseAddress = baseAddress && address === baseAddress;\n\n    // TSS/MPC wallet address verification (V3, V5, V6)\n    // V5 base addresses use TSS, but V5 forwarders use the regular forwarder verification\n    const isTssWalletVersion = params.walletVersion === 3 || params.walletVersion === 5 || params.walletVersion === 6;\n    const shouldUseTssVerification =\n      isTssVerifyAddressOptions(params) && isTssWalletVersion && (params.walletVersion !== 5 || isVerifyingBaseAddress);\n\n    if (shouldUseTssVerification) {\n      if (isVerifyingBaseAddress) {\n        const index = typeof params.index === 'string' ? parseInt(params.index, 10) : params.index;\n        if (index !== 0) {\n          throw new Error(\n            `Base address verification requires index 0, but got index ${params.index}. ` +\n              `The base address is always derived at index 0.`\n          );\n        }\n      }\n\n      return verifyMPCWalletAddress({ ...params, keyCurve: 'secp256k1' }, this.isValidAddress, (pubKey) => {\n        return new KeyPairLib({ pub: pubKey }).getAddress();\n      });\n    }\n\n    // From here on, we need baseAddress and coinSpecific for non-TSS verifications\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    // BIP32 wallet base address verification (V1, V2, V4)\n    if (isVerifyingBaseAddress && isVerifyContractBaseAddressOptions(params)) {\n      return this.verifyCreate2BaseAddress(params);\n    }\n\n    // Forwarder receive address verification (deposit addresses)\n    if (!isVerifyingBaseAddress) {\n      return this.verifyForwarderAddress(params, forwarderVersion);\n    }\n\n    // If we reach here, it's a base address verification for an unsupported wallet version\n    throw new Error(`Base address verification not supported for wallet version ${params.walletVersion}`);\n  }\n\n  /**\n   * Locally derive an ETH wallet receive address from a derivation path, using the wallet's\n   * commonKeychain only (no private keys, no network access). The inverse of\n   * {@link isWalletAddress}: it *produces* the address via the same secp256k1 MPC derivation\n   * that isWalletAddress checks against (`deriveMPCWalletAddress` + `KeyPair.getAddress()`),\n   * so derive and verify can never diverge.\n   *\n   * Supports MPC/TSS wallets only (wallet versions 3, 5, 6). Legacy BIP32 forwarder wallets\n   * (versions 1, 2, 4) derive per-index forwarder contract addresses and are handled separately.\n   * @param params keychains (commonKeychain), derivation index, walletVersion, and optional SMC seed\n   * @returns the derived address, the index used, and the HD derivation path\n   */\n  async deriveAddress(params: DeriveAddressOptions): Promise<DeriveAddressResult> {\n    const { walletVersion, index } = params;\n    const forwarderVersion = params.coinSpecific?.forwarderVersion;\n\n    // Mirrors isWalletAddress's branching:\n    // - MPC/TSS receive addresses: v3 & v6 (every index), and the v5 *base* address (index 0).\n    // - Forwarder (CREATE2) receive addresses: legacy v1/v2/v4 wallets, and v5 forwarders (index > 0).\n    const useMpc = walletVersion === 3 || walletVersion === 6 || (walletVersion === 5 && index === 0);\n    if (useMpc) {\n      const { address, derivationPath } = await deriveMPCWalletAddress(\n        {\n          // extractCommonKeychain validates the commonKeychain is present at runtime\n          keychains: (params.keychains ?? []) as TssVerifyAddressOptions['keychains'],\n          index,\n          derivedFromParentWithSeed: params.derivedFromParentWithSeed,\n          multisigTypeVersion: params.multisigTypeVersion,\n          keyCurve: 'secp256k1',\n        },\n        (pubKey) => new KeyPairLib({ pub: pubKey }).getAddress()\n      );\n\n      return { address, index, derivationPath };\n    }\n\n    // Forwarder (CREATE2) derivation for legacy multisig / v5 forwarder receive addresses.\n    if (forwarderVersion === 0) {\n      throw new Error(\n        'Forwarder version 0 addresses cannot be derived: the nonce required for address derivation is not stored.'\n      );\n    }\n    if (forwarderVersion === 1 || forwarderVersion === 2 || forwarderVersion === 4) {\n      const { baseAddress, coinSpecific } = params;\n      if (!baseAddress) {\n        throw new Error('baseAddress is required to derive a forwarder address');\n      }\n      const feeAddress = coinSpecific?.feeAddress ?? '';\n      if (forwarderVersion === 4 && !feeAddress) {\n        throw new Error('coinSpecific.feeAddress is required to derive a v4 forwarder address');\n      }\n\n      const { forwarderFactoryAddress, forwarderImplementationAddress } =\n        this.getForwarderFactoryAddressesAndForwarderImplementationAddress(forwarderVersion);\n      // For BitGo forwarders the per-address salt is the derivation index, so the forwarder\n      // address is reproducible from (baseAddress, index) plus the network factory/implementation.\n      const address = this.generateForwarderAddress(\n        baseAddress,\n        feeAddress,\n        forwarderFactoryAddress,\n        forwarderImplementationAddress,\n        index\n      );\n\n      return { address, index, coinSpecific: { forwarderVersion } };\n    }\n\n    throw new Error(\n      `deriveAddress: could not determine an ETH derivation strategy. Provide an MPC wallet ` +\n        `(walletVersion 3/5/6 with commonKeychain), or a legacy forwarder (coinSpecific.forwarderVersion ` +\n        `1/2/4 with baseAddress). Got walletVersion=${walletVersion}, forwarderVersion=${forwarderVersion}.`\n    );\n  }\n\n  /**\n   *\n   * @param {TransactionPrebuild} txPrebuild\n   * @returns {boolean}\n   */\n  verifyCoin(txPrebuild: TransactionPrebuild): boolean {\n    const nativeCoin = this.getChain().split(':')[0];\n    return txPrebuild.coin === nativeCoin;\n  }\n\n  /**\n   * Generate transaction explanation for error reporting\n   * @param txPrebuild - Transaction prebuild containing txHex and fee info\n   * @returns Stringified JSON explanation\n   */\n  private async getTxExplanation(txPrebuild?: TransactionPrebuild): Promise<string | undefined> {\n    if (!txPrebuild?.txHex || !txPrebuild?.gasPrice) {\n      return undefined;\n    }\n\n    try {\n      const explanation = await this.explainTransaction({\n        txHex: txPrebuild.txHex,\n        feeInfo: {\n          fee: txPrebuild.gasPrice.toString(),\n        },\n      });\n      return JSON.stringify(explanation, null, 2);\n    } catch (e) {\n      const errorDetails = {\n        error: 'Failed to parse transaction explanation',\n        txHex: txPrebuild.txHex,\n        details: e instanceof Error ? e.message : String(e),\n      };\n      return JSON.stringify(errorDetails, null, 2);\n    }\n  }\n\n  /**\n   * Verify if a tss transaction is valid\n   *\n  /** @inheritdoc CoinWithSignableConsistency */\n  assertSignableConsistency(serializedTxHex: string, signableHex: string): void {\n    const common = AbstractEthLikeNewCoins.getCustomChainCommon(this.getChainId());\n    // getCustomChainCommon defaults to the london hardfork, which is only valid for chains\n    // that activated EIP-1559. Chains without it (e.g. BSC, XDC) sign under petersburg.\n    if (!this.staticsCoin?.features.includes(CoinFeature.EIP1559)) {\n      common.setHardfork(optionalDeps.EthCommon.Hardfork.Petersburg);\n    }\n    const ethTx = TransactionFactory.fromSerializedData(toBuffer(addHexPrefix(serializedTxHex)), { common });\n    const derivedSignableHex =\n      ethTx instanceof FeeMarketEIP1559Transaction\n        ? ethTx.getMessageToSign(false).toString('hex')\n        : Buffer.from(RLP.encode(bufArrToArr((ethTx as LegacyTransaction).getMessageToSign(false)))).toString('hex');\n    if (derivedSignableHex !== signableHex) {\n      throw new InvalidTransactionError('signableHex is inconsistent with serializedTxHex: possible server tampering');\n    }\n  }\n\n  /**\n   * Decode-and-assert for the ERC-7984 shield approve leg (defense-in-depth).\n   *\n   * The approve is signed through the chain coin, whose generic checks never parse calldata.\n   * WP builds the bytes server-side; re-parse them here so the client signs only\n   * `approve(wrapper, amount)` on the pair's underlying ERC-20 with the amount from the intent.\n   * Fails closed on any deviation.\n   *\n   * Scope: this runs when the declared type is `wrapApprove`, and {@link assertWrapperApproveIsDeclared} also\n   * forces any approve whose spender is a registered wrapper through it. Deliberately NOT covered: an approve\n   * of a registered underlying to a third-party spender under another declared type (tokenApproval, defiApprove,\n   * customTx) is indistinguishable from a legitimate approval, so a server that relabels the intent of such a\n   * tx still skips this check on signing paths that carry no caller txParams (pendingApproval re-sign).\n   */\n  private async verifyWrapApproveTransaction(\n    params: VerifyEthTransactionOptions,\n    throwRecipientMismatch: (message: string, mismatchedRecipients: Recipient[]) => Promise<never>\n  ): Promise<void> {\n    const { txParams, txPrebuild } = params;\n    if (!txPrebuild?.txHex) {\n      throw new Error('missing txHex in txPrebuild');\n    }\n    const wrapParams = txParams.wrapParams;\n    if (!wrapParams?.tokenName || !wrapParams.amount) {\n      return throwRecipientMismatch('wrapApprove transaction requires wrapParams with tokenName and amount', []);\n    }\n\n    let wrapper: Erc7984Coin;\n    try {\n      const staticsCoin = coins.get(wrapParams.tokenName);\n      if (!(staticsCoin instanceof Erc7984Coin) || !staticsCoin.underlyingErc20Address) {\n        throw new Error('not an ERC-7984 pair');\n      }\n      wrapper = staticsCoin;\n    } catch {\n      return throwRecipientMismatch(\n        `wrapApprove: '${wrapParams.tokenName}' is not a registered ERC-7984 shield pair`,\n        []\n      );\n    }\n\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txPrebuild.txHex);\n    const txJson = (await txBuilder.build()).toJson();\n    const mismatch = (message: string, address = txJson.to, amount = txJson.value): Promise<never> =>\n      throwRecipientMismatch(message, [{ address: address || '', amount: amount || '' }]);\n\n    if (!txJson.to || txJson.to.toLowerCase() !== wrapper.underlyingErc20Address) {\n      await mismatch('wrapApprove transaction must target the underlying ERC-20 of the wrapper');\n    }\n    if (txJson.value !== undefined && String(txJson.value) !== '0') {\n      await mismatch('wrapApprove transaction must not carry native value');\n    }\n\n    let decoded: { spender: string; amount: string };\n    try {\n      decoded = decodeApproveCalldata(txJson.data || '');\n    } catch (e) {\n      return mismatch(\n        `wrapApprove transaction must use ERC-20 approve(address,uint256) calldata — ${(e as Error).message}`\n      );\n    }\n    if (decoded.spender.toLowerCase() !== wrapper.contractAddress.toLowerCase()) {\n      await mismatch('wrapApprove transaction spender does not match the wrapper contract', decoded.spender);\n    }\n    if (decoded.amount !== wrapParams.amount) {\n      await mismatch('wrapApprove transaction amount does not match the requested amount', txJson.to, decoded.amount);\n    }\n  }\n\n  /**\n   * Content-based guard for the ERC-7984 shield approve leg, for txs NOT declared `wrapApprove`.\n   *\n   * On signing paths that carry no caller txParams (pendingApproval re-sign) the declared type is the\n   * server-persisted `intent.intentType`, so a compromised or buggy WP could relabel a mutated\n   * `approve(wrapper, amount)` as another type and skip `verifyWrapApproveTransaction`. So an\n   * `approve(address,uint256)` sent to a registered ERC-7984 underlying whose spender is that pair's wrapper\n   * MUST be declared `wrapApprove` (and so pass the spender/amount check).\n   *\n   * A tx is rejected only when ALL of these hold:\n   *   1. the tx targets a registered ERC-7984 underlying (`to` is in `getErc7984WrappersByUnderlying()`);\n   *   2. the calldata is `approve(address,uint256)` (selector match);\n   *   3. the spender (first ABI word) is that underlying's wrapper;\n   *   4. the declared type is not `wrapApprove` (enforced by the caller, which only invokes this method then).\n   *\n   * Scoped to wrapper-directed approvals only: approvals of the same token to any other spender, transfers,\n   * and every other call are untouched. Known exceptions to \"only the shield journey approves the wrapper\":\n   * a dApp (WalletConnect) approving the wrapper directly would be rejected here, and the unbuilt Phase-2\n   * `approve(0)` allowance-reset leg must be declared `wrapApprove` (or get its own branch).\n   *\n   * Parsing is best-effort: if the tx cannot be parsed by this coin's builder the check is skipped, so it can\n   * never introduce a new failure for a tx that was verifiable before.\n   */\n  private async assertWrapperApproveIsDeclared(\n    params: VerifyEthTransactionOptions,\n    throwRecipientMismatch: (message: string, mismatchedRecipients: Recipient[]) => Promise<never>\n  ): Promise<void> {\n    const { txPrebuild } = params;\n    if (!txPrebuild?.txHex) {\n      return;\n    }\n    const wrappersByUnderlying = getErc7984WrappersByUnderlying();\n    if (wrappersByUnderlying.size === 0) {\n      return;\n    }\n\n    // Cheap prefilter: calldata is serialized as literal bytes, so an approve can only be present if the\n    // 4-byte selector appears in the hex. Nearly every other tx returns here without touching the builder.\n    if (!txPrebuild.txHex.toLowerCase().includes(approveMethodId.slice(2).toLowerCase())) {\n      return;\n    }\n\n    let txJson: { to?: string; data?: string; value?: string };\n    try {\n      const txBuilder = this.getTransactionBuilder();\n      txBuilder.from(txPrebuild.txHex);\n      txJson = (await txBuilder.build()).toJson();\n    } catch {\n      // Not parseable by this builder: leave it to the type-specific checks and the signer.\n      return;\n    }\n\n    const wrappers = txJson.to ? wrappersByUnderlying.get(txJson.to.toLowerCase()) : undefined;\n    const data = (txJson.data || '').toLowerCase();\n    // Read the spender leniently (first ABI word after the selector) rather than via the strict decoder: an\n    // ERC-20 ignores trailing bytes, so approve(wrapper, amount) + junk would otherwise slip past a strict parse.\n    if (!wrappers || !data.startsWith(approveMethodId.toLowerCase()) || data.length < 10 + 64) {\n      return;\n    }\n    const spender = `0x${data.slice(10 + 24, 10 + 64)}`;\n    if (wrappers.has(spender)) {\n      await throwRecipientMismatch('approve() of an ERC-7984 wrapper must be declared as a wrapApprove intent', [\n        { address: spender, amount: txJson.value || '' },\n      ]);\n    }\n  }\n\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   * @throws {TxIntentMismatchRecipientError} if transaction recipients don't match user intent\n   */\n  async verifyTssTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild, wallet } = params;\n\n    // Helper to throw TxIntentMismatchRecipientError with recipient details\n    const throwRecipientMismatch = async (message: string, mismatchedRecipients: Recipient[]): Promise<never> => {\n      const txExplanation = await this.getTxExplanation(txPrebuild);\n      throw new TxIntentMismatchRecipientError(\n        message,\n        undefined,\n        [txParams],\n        txPrebuild?.txHex,\n        mismatchedRecipients,\n        txExplanation\n      );\n    };\n\n    if (\n      !txParams?.recipients &&\n      !(\n        txParams.prebuildTx?.consolidateId ||\n        txPrebuild?.consolidateId ||\n        txParams.stakingRequestId ||\n        txParams.prebuildTx?.stakingRequestId ||\n        (txParams.type && NO_RECIPIENT_TX_TYPES.has(txParams.type))\n      )\n    ) {\n      throw new Error('missing txParams');\n    }\n    if (!wallet || !txPrebuild) {\n      throw new Error('missing params');\n    }\n\n    if (txParams.hop && txParams.recipients && txParams.recipients.length > 1) {\n      throw new Error('tx cannot be both a batch and hop transaction');\n    }\n\n    if (txParams.type && ['transfer'].includes(txParams.type)) {\n      if (txParams.recipients && txParams.recipients.length === 1) {\n        const recipients = txParams.recipients;\n        const expectedAmount = recipients[0].amount.toString();\n        const expectedDestination = recipients[0].address;\n\n        const txBuilder = this.getTransactionBuilder();\n        txBuilder.from(txPrebuild.txHex);\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n        if (txJson.data === '0x') {\n          if (expectedAmount !== txJson.value) {\n            await throwRecipientMismatch(\n              'the transaction amount in txPrebuild does not match the value given by client',\n              [{ address: txJson.to, amount: txJson.value }]\n            );\n          }\n          if (expectedDestination.toLowerCase() !== txJson.to.toLowerCase()) {\n            await throwRecipientMismatch('destination address does not match with the recipient address', [\n              { address: txJson.to, amount: txJson.value },\n            ]);\n          }\n        } else if (txJson.data.startsWith('0xa9059cbb')) {\n          const [recipientAddress, amount] = getRawDecoded(\n            ['address', 'uint256'],\n            getBufferedByteCode('0xa9059cbb', txJson.data)\n          );\n\n          // Check if recipients[0].data exists (WalletConnect flow)\n          let expectedRecipientAddress: string;\n          let expectedTokenAmount: string;\n          const recipientData = (recipients[0] as any).data;\n\n          if (recipientData && recipientData.startsWith('0xa9059cbb')) {\n            // WalletConnect: decode expected recipient and amount from recipients[0].data\n            const [expectedRecipient, expectedAmount] = getRawDecoded(\n              ['address', 'uint256'],\n              getBufferedByteCode('0xa9059cbb', recipientData)\n            );\n            expectedRecipientAddress = addHexPrefix(expectedRecipient.toString()).toLowerCase();\n            expectedTokenAmount = expectedAmount.toString();\n          } else {\n            // Normal flow: use recipients[0].address and recipients[0].amount\n            expectedRecipientAddress = expectedDestination.toLowerCase();\n            expectedTokenAmount = expectedAmount;\n          }\n\n          if (expectedTokenAmount !== amount.toString()) {\n            await throwRecipientMismatch(\n              'the transaction amount in txPrebuild does not match the value given by client',\n              [{ address: addHexPrefix(recipientAddress.toString()), amount: amount.toString() }]\n            );\n          }\n\n          if (expectedRecipientAddress !== addHexPrefix(recipientAddress.toString()).toLowerCase()) {\n            await throwRecipientMismatch('destination address does not match with the recipient address', [\n              { address: addHexPrefix(recipientAddress.toString()), amount: amount.toString() },\n            ]);\n          }\n        }\n      }\n    }\n\n    if (txParams.type && ['defiApprove', 'defiDeposit', 'defiWithdraw'].includes(txParams.type)) {\n      if (!txPrebuild.txHex) {\n        throw new Error('missing txHex in txPrebuild');\n      }\n\n      const baseAddress = wallet.coinSpecific()?.baseAddress;\n      const defiParams = txParams.defiParams;\n      if (!baseAddress || !defiParams) {\n        await throwRecipientMismatch('DeFi transaction is missing required intent parameters', []);\n        return false;\n      }\n\n      const validatedBaseAddress = baseAddress as string;\n      const validatedDefiParams = defiParams;\n      const txBuilder = this.getTransactionBuilder();\n      txBuilder.from(txPrebuild.txHex);\n      const txJson = (await txBuilder.build()).toJson();\n      const mismatch = async (message: string, address = txJson.to, amount = txJson.value): Promise<never> =>\n        throwRecipientMismatch(message, [{ address: address || '', amount: amount || '' }]);\n      const data = txJson.data || '';\n\n      if (txParams.type === 'defiApprove') {\n        const selector = addHexPrefix(optionalDeps.ethAbi.methodID('approve', ['address', 'uint256']).toString('hex'));\n        if (!data.startsWith(selector)) {\n          await mismatch('defiApprove transaction must use ERC-20 approve(address,uint256) calldata');\n        }\n        const [, amount] = getRawDecoded(['address', 'uint256'], getBufferedByteCode(selector, data));\n        if (amount.toString() !== validatedDefiParams.amount) {\n          await mismatch(\n            'defiApprove transaction amount does not match the requested amount',\n            txJson.to,\n            amount.toString()\n          );\n        }\n      } else if (txParams.type === 'defiDeposit') {\n        const selector = addHexPrefix(optionalDeps.ethAbi.methodID('deposit', ['uint256', 'address']).toString('hex'));\n        if (!data.startsWith(selector)) {\n          await mismatch('defiDeposit transaction must use deposit(uint256,address) calldata');\n        }\n        const [amount, receiver] = getRawDecoded(['uint256', 'address'], getBufferedByteCode(selector, data));\n        const decodedReceiver = addHexPrefix(receiver.toString()).toLowerCase();\n        if (decodedReceiver !== validatedBaseAddress.toLowerCase()) {\n          await mismatch(\n            'defiDeposit transaction receiver does not match wallet base address',\n            decodedReceiver,\n            amount.toString()\n          );\n        }\n        if (amount.toString() !== validatedDefiParams.amount) {\n          await mismatch(\n            'defiDeposit transaction amount does not match the requested amount',\n            decodedReceiver,\n            amount.toString()\n          );\n        }\n      } else {\n        const selector = addHexPrefix(\n          optionalDeps.ethAbi.methodID('redeem', ['uint256', 'address', 'address']).toString('hex')\n        );\n        if (!data.startsWith(selector)) {\n          await mismatch('defiWithdraw transaction must use redeem(uint256,address,address) calldata');\n        }\n        const [shares, receiver, owner] = getRawDecoded(\n          ['uint256', 'address', 'address'],\n          getBufferedByteCode(selector, data)\n        );\n        const decodedReceiver = addHexPrefix(receiver.toString()).toLowerCase();\n        const decodedOwner = addHexPrefix(owner.toString()).toLowerCase();\n        if (\n          decodedReceiver !== validatedBaseAddress.toLowerCase() ||\n          decodedOwner !== validatedBaseAddress.toLowerCase()\n        ) {\n          await mismatch(\n            'defiWithdraw transaction receiver and owner must match wallet base address',\n            decodedReceiver,\n            shares.toString()\n          );\n        }\n        if (shares.toString() !== validatedDefiParams.amount) {\n          await mismatch(\n            'defiWithdraw transaction shares do not match the requested amount',\n            decodedReceiver,\n            shares.toString()\n          );\n        }\n      }\n    }\n\n    if (txParams.type === 'wrapApprove') {\n      await this.verifyWrapApproveTransaction(params, throwRecipientMismatch);\n    } else {\n      // Declared as anything else: only an approve of a registered wrapper is rejected (see the method doc);\n      // for every other tx this returns without parsing or after one best-effort parse.\n      await this.assertWrapperApproveIsDeclared(params, throwRecipientMismatch);\n    }\n\n    // Verify consolidation transactions send to base address\n    if (params.verification?.consolidationToBaseAddress) {\n      const coinSpecific = wallet.coinSpecific();\n      if (!coinSpecific || !coinSpecific.baseAddress) {\n        throw new Error('Unable to determine base address for consolidation');\n      }\n      const baseAddress = coinSpecific.baseAddress;\n\n      if (!txPrebuild.txHex) {\n        throw new Error('missing txHex in txPrebuild');\n      }\n\n      const txBuilder = this.getTransactionBuilder();\n      txBuilder.from(txPrebuild.txHex);\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n\n      // Verify the transaction recipient matches the base address\n      if (!txJson.to) {\n        throw new Error('Consolidation transaction is missing recipient address');\n      }\n\n      const erc20TransferSelector = addHexPrefix(\n        optionalDeps.ethAbi.methodID('transfer', ['address', 'uint256']).toString('hex')\n      );\n\n      if (txJson.data && txJson.data.startsWith(erc20TransferSelector)) {\n        // For ERC20 token consolidations, txJson.to is the token contract address,\n        // not the actual transfer recipient. The real recipient is encoded in the\n        // transfer(address,uint256) calldata. Decode it and verify against baseAddress.\n        const [recipientAddress] = getRawDecoded(\n          ['address', 'uint256'],\n          getBufferedByteCode(erc20TransferSelector, txJson.data)\n        );\n        const decodedRecipient = addHexPrefix(recipientAddress.toString()).toLowerCase();\n        if (decodedRecipient !== baseAddress.toLowerCase()) {\n          await throwRecipientMismatch('Consolidation transaction recipient does not match wallet base address', [\n            { address: decodedRecipient, amount: txJson.value },\n          ]);\n        }\n      } else if (txJson.to.toLowerCase() !== baseAddress.toLowerCase()) {\n        // Native coin consolidation: txJson.to is the actual recipient\n        await throwRecipientMismatch('Consolidation transaction recipient does not match wallet base address', [\n          { address: txJson.to, amount: txJson.value },\n        ]);\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Verify that a transaction prebuild complies with the original intention\n   *\n   * @param {VerifyEthTransactionOptions} params\n   * @param {TransactionParams} params.txParams - params object passed to send\n   * @param {TransactionPrebuild} params.txPrebuild - prebuild object returned by server\n   * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against\n   * @returns {boolean}\n   * @throws {TxIntentMismatchError} if transaction validation fails\n   * @throws {TxIntentMismatchRecipientError} if transaction recipients don't match user intent\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    // Helper to throw TxIntentMismatchRecipientError with recipient details\n    const throwRecipientMismatch = async (message: string, mismatchedRecipients: Recipient[]): Promise<never> => {\n      const txExplanation = await this.getTxExplanation(txPrebuild);\n      throw new TxIntentMismatchRecipientError(\n        message,\n        undefined,\n        [txParams],\n        txPrebuild?.txHex,\n        mismatchedRecipients,\n        txExplanation\n      );\n    };\n\n    if (!txParams?.recipients || !txPrebuild?.recipients || !wallet) {\n      throw new Error('missing params');\n    }\n\n    const recipients = txParams.recipients!;\n\n    if (txParams.hop && recipients.length > 1) {\n      throw new Error('tx cannot be both a batch and hop transaction');\n    }\n    if (txPrebuild.recipients.length > 1) {\n      throw new Error(\n        `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n      );\n    }\n    if (txParams.type === 'enabletoken') {\n      // ERC-7984 token enablement: intercept before hop/batch/single routing.\n      // Handles both base-address (txPrebuild → ACL) and forwarder (txPrebuild → forwarder) wallets,\n      // for single or multiple tokens at once.\n      await this.verifyMultisigEnableTokenTransaction(params, throwRecipientMismatch);\n    } else if (txParams.hop && txPrebuild.hopTransaction) {\n      // Check recipient amount for hop transaction\n      if (recipients.length !== 1) {\n        throw new Error(`hop transaction only supports 1 recipient but ${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        await throwRecipientMismatch('recipient address of txPrebuild does not match hop address', [\n          { address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() },\n        ]);\n      }\n\n      // Convert TransactionRecipient array to Recipient array\n      const hopRecipients: Recipient[] = 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: hopRecipients });\n    } else if (recipients.length > 1) {\n      // Check total amount for batch transaction\n      if (txParams.tokenName) {\n        const expectedTotalAmount = new BigNumber(0);\n        if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n          await throwRecipientMismatch(\n            'batch token transaction amount in txPrebuild should be zero for token transfers',\n            [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]\n          );\n        }\n      } else {\n        let expectedTotalAmount = new BigNumber(0);\n        for (let i = 0; i < recipients.length; i++) {\n          expectedTotalAmount = expectedTotalAmount.plus(recipients[i].amount);\n        }\n        if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n          await throwRecipientMismatch(\n            'batch transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client',\n            [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]\n          );\n        }\n      }\n\n      // Check batch transaction is sent to the batcher contract address for the chain\n      const batcherContractAddress = ethNetwork?.batcherContractAddress;\n      if (\n        !batcherContractAddress ||\n        batcherContractAddress.toLowerCase() !== txPrebuild.recipients[0].address.toLowerCase()\n      ) {\n        await throwRecipientMismatch('recipient address of txPrebuild does not match batcher address', [\n          { address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() },\n        ]);\n      }\n    } else {\n      // Check recipient address and amount for normal transaction\n      if (recipients.length !== 1) {\n        throw new Error(`normal transaction only supports 1 recipient but ${recipients.length} found`);\n      }\n      const expectedAmount = new BigNumber(recipients[0].amount);\n      if (!expectedAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n        await throwRecipientMismatch(\n          'normal transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client',\n          [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]\n        );\n      }\n      if (this.isETHAddress(recipients[0].address) && recipients[0].address !== txPrebuild.recipients[0].address) {\n        await throwRecipientMismatch(\n          'destination address in normal txPrebuild does not match that in txParams supplied by client',\n          [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]\n        );\n      }\n    }\n    // Check coin is correct for all transaction types\n    if (!this.verifyCoin(txPrebuild)) {\n      const txExplanation = await this.getTxExplanation(txPrebuild);\n      throw new TxIntentMismatchError(\n        'coin in txPrebuild did not match that in txParams supplied by client',\n        undefined,\n        [txParams],\n        txPrebuild?.txHex,\n        txExplanation\n      );\n    }\n    return true;\n  }\n\n  /**\n   * Check if address is valid eth address\n   * @param address\n   * @returns {boolean}\n   */\n  /**\n   * Verifies an ERC-7984 token enablement (decryption delegation) transaction for multisig wallets.\n   *\n   * Two wallet shapes are supported:\n   *\n   *  Base-address wallet — txPrebuild targets the Zama ACL contract directly:\n   *    txParams.recipients  : one entry per token, all with the wallet base address, amount '0'\n   *    txPrebuild.recipients[0] : the Zama ACL contract address\n   *\n   *  Forwarder wallet — txPrebuild targets the forwarder which calls the ACL via callFromParent:\n   *    txParams.recipients  : one entry per token, all with the forwarder address, amount '0'\n   *    txPrebuild.recipients[0] : the forwarder address (matches txParams recipients)\n   *\n   * In both cases all amounts must be 0 and all txParams recipients must share the same address.\n   */\n  private async verifyMultisigEnableTokenTransaction(\n    params: VerifyEthTransactionOptions,\n    throwRecipientMismatch: (message: string, mismatchedRecipients: Recipient[]) => Promise<never>\n  ): Promise<void> {\n    const { txParams, txPrebuild } = params;\n    const recipients = txParams.recipients!;\n\n    if (!recipients || recipients.length === 0) {\n      throw new Error('token enablement transaction must have at least one recipient in txParams');\n    }\n\n    // All txParams recipients must have amount 0\n    for (const r of recipients) {\n      if (!new BigNumber(r.amount).isEqualTo(0)) {\n        await throwRecipientMismatch('token enablement txParams recipients must all have amount 0', [\n          { address: r.address, amount: String(r.amount) },\n        ]);\n      }\n    }\n\n    // txPrebuild recipient amount must be 0\n    if (!new BigNumber(txPrebuild.recipients[0].amount).isEqualTo(0)) {\n      await throwRecipientMismatch('token enablement transaction expected amount 0 in txPrebuild', [\n        { address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() },\n      ]);\n    }\n\n    // All txParams recipients must share the same address —\n    // a single delegation tx covers one wallet, not multiple wallets simultaneously.\n    const firstAddress = recipients[0].address.toLowerCase();\n    for (const r of recipients) {\n      if (r.address.toLowerCase() !== firstAddress) {\n        await throwRecipientMismatch('token enablement txParams recipients must all have the same address', [\n          { address: r.address, amount: String(r.amount) },\n        ]);\n      }\n    }\n\n    const prebuildAddress = txPrebuild.recipients[0].address.toLowerCase();\n    const zamaAclContractAddress = (this.getNetwork() as EthLikeNetwork)?.zamaAclContractAddress;\n\n    // Base-address wallet: txPrebuild targets the Zama ACL contract directly.\n    // txParams recipients carry the wallet base address — the intentional address mismatch is expected.\n    if (zamaAclContractAddress && prebuildAddress === zamaAclContractAddress.toLowerCase()) {\n      return;\n    }\n\n    // Forwarder wallet: txPrebuild targets the forwarder address, which must match txParams recipients.\n    if (prebuildAddress === firstAddress) {\n      return;\n    }\n\n    // Neither recognised shape — txPrebuild address is not the ACL contract and doesn't match txParams\n    await throwRecipientMismatch(\n      'token enablement txPrebuild recipient must be the Zama ACL contract (base-address wallet) or match txParams recipients (forwarder wallet)',\n      [{ address: txPrebuild.recipients[0].address, amount: txPrebuild.recipients[0].amount.toString() }]\n    );\n  }\n\n  private isETHAddress(address: string): boolean {\n    return !!address.match(/0x[a-fA-F0-9]{40}/);\n  }\n\n  /**\n   * Transform message to accommodate specific blockchain requirements.\n   * @param {string} message - the message to prepare\n   * @return {string} the prepared message as a hex encoded string.\n   */\n  encodeMessage(message: string): string {\n    const prefix = `\\u0019Ethereum Signed Message:\\n${message.length}`;\n    return Buffer.from(prefix.concat(message)).toString('hex');\n  }\n\n  /**\n   * Transform the Typed data to accomodate the blockchain requirements (EIP-712)\n   * @param {TypedData} typedData - the typed data to prepare\n   * @return {Buffer} a buffer of the result\n   */\n  encodeTypedData(typedData: TypedData): Buffer {\n    const version = typedData.version;\n    if (version === SignTypedDataVersion.V1) {\n      throw new Error('SignTypedData v1 is not supported due to security concerns');\n    }\n    const typedDataRaw = JSON.parse(typedData.typedDataRaw);\n    const sanitizedData = TypedDataUtils.sanitizeData(typedDataRaw as unknown as TypedMessage<any>);\n    const parts: Buffer[] = [Buffer.from('1901', 'hex')];\n    const eip712Domain = 'EIP712Domain';\n    parts.push(TypedDataUtils.hashStruct(eip712Domain, sanitizedData.domain, sanitizedData.types, version));\n\n    if (sanitizedData.primaryType !== eip712Domain) {\n      parts.push(\n        TypedDataUtils.hashStruct(\n          sanitizedData.primaryType as string,\n          sanitizedData.message,\n          sanitizedData.types,\n          version\n        )\n      );\n    }\n    return Buffer.concat(parts);\n  }\n\n  /**\n   * Build the data to transfer an ERC-721 or ERC-1155 token to another address\n   * @param params\n   */\n  buildNftTransferData(params: BuildNftTransferDataOptions): string {\n    const { tokenContractAddress, recipientAddress, fromAddress } = params;\n    switch (params.type) {\n      case 'ERC721': {\n        const tokenId = params.tokenId;\n        const contractData = new ERC721TransferBuilder()\n          .tokenContractAddress(tokenContractAddress)\n          .to(recipientAddress)\n          .from(fromAddress)\n          .tokenId(tokenId)\n          .build();\n        return contractData;\n      }\n\n      case 'ERC1155': {\n        const entries = params.entries;\n        const transferBuilder = new ERC1155TransferBuilder()\n          .tokenContractAddress(tokenContractAddress)\n          .to(recipientAddress)\n          .from(fromAddress);\n\n        for (const entry of entries) {\n          transferBuilder.entry(parseInt(entry.tokenId, 10), entry.amount);\n        }\n\n        return transferBuilder.build();\n      }\n\n      default:\n        throw new Error(`Unsupported NFT type: ${params.type}`);\n    }\n  }\n\n  /**\n   * Fetch the gas price from the explorer\n   * @param {string} wrongChainCoin - the coin that we're getting gas price for\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   */\n  async getGasPriceFromExternalAPI(wrongChainCoin: string, apiKey?: string): Promise<BN> {\n    try {\n      const res = await this.recoveryBlockchainExplorerQuery(\n        {\n          chainid: this.getChainId().toString(),\n          module: 'proxy',\n          action: 'eth_gasPrice',\n        },\n        apiKey\n      );\n      const gasPrice = new BN(res.result.slice(2), 16);\n      console.log(` Got gas price: ${gasPrice}`);\n      return gasPrice;\n    } catch (e) {\n      if (e instanceof RecoveryProviderError) {\n        throw e;\n      }\n      throw new Error(`Failed to get gas price. Please make sure to use the api key of ${wrongChainCoin}`);\n    }\n  }\n\n  /**\n   * Fetch the gas limit from the explorer\n   * @param intendedChain\n   * @param from\n   * @param to\n   * @param data\n   * @param {string} apiKey - optional API key to use instead of the one from the environment\n   */\n  async getGasLimitFromExternalAPI(\n    intendedChain: string,\n    from: string,\n    to: string,\n    data: string,\n    apiKey?: string\n  ): Promise<BN> {\n    try {\n      const res = await this.recoveryBlockchainExplorerQuery(\n        {\n          chainid: this.getChainId().toString(),\n          module: 'proxy',\n          action: 'eth_estimateGas',\n          from,\n          to,\n          data,\n        },\n        apiKey\n      );\n      const gasLimit = new BN(res.result.slice(2), 16);\n      console.log(`Got gas limit: ${gasLimit}`);\n      return gasLimit;\n    } catch (e) {\n      if (e instanceof RecoveryProviderError) {\n        throw e;\n      }\n      throw new Error(\n        `Failed to get gas limit. Please make sure to use the privateKey aka userKey of ${intendedChain} wallet ${to}`\n      );\n    }\n  }\n\n  /**\n   * Get the balance of bitgoFeeAddress to ensure funds are available to pay fees\n   * @param bitgoFeeAddress\n   * @param gasPrice\n   * @param gasLimit\n   * @param apiKey - optional API key to use instead of the one from the environment\n   */\n  async ensureSufficientBalance(bitgoFeeAddress: string, gasPrice: BN, gasLimit: BN, apiKey?: string): Promise<void> {\n    const bitgoFeeAddressBalance = await this.queryAddressBalance(bitgoFeeAddress, apiKey);\n    const totalGasNeeded = Number(gasPrice.mul(gasLimit));\n    const weiToGwei = 10 ** 9;\n    if (bitgoFeeAddressBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Fee address ${bitgoFeeAddress} has balance ${(bitgoFeeAddressBalance / weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some ${this.getChain()} to this address then retry.`\n      );\n    }\n  }\n}\n"]}