@bitgo-beta/sdk-coin-vet 1.0.1-beta.64 → 1.0.1-beta.640

package/dist/src/vet.js

@@ -39,18 +39,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vet = void 0;
 const _ = __importStar(require("lodash"));
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const blake2b_1 = __importDefault(require("@bitgo-beta/blake2b"));
+const assert_1 = __importDefault(require("assert"));
+const axios_1 = __importDefault(require("axios"));
+const sdk_core_1 = require("@vechain/sdk-core");
+const sdk_core_2 = require("@bitgo-beta/sdk-core");
+const mpc = __importStar(require("@bitgo-beta/sdk-lib-mpc"));
+const statics_1 = require("@bitgo-beta/statics");
 const utils_1 = __importDefault(require("./lib/utils"));
 const secp256k1_1 = require("@bitgo-beta/secp256k1");
 const crypto_1 = require("crypto");
 const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
 const lib_1 = require("./lib");
+const constants_1 = require("./lib/constants");
 /**
  * Full Name: Vechain
  * Docs: https://docs.vechain.org/
  * GitHub : https://github.com/vechain
  */
-class Vet extends sdk_core_1.BaseCoin {
+class Vet extends sdk_core_2.BaseCoin {
     constructor(bitgo, staticsCoin) {
         super(bitgo);
         if (!staticsCoin) {
@@ -76,13 +83,16 @@ class Vet extends sdk_core_1.BaseCoin {
     getFullName() {
         return 'VeChain';
     }
+    valuelessTransferAllowed() {
+        return true;
+    }
     /** @inheritDoc */
     supportsTss() {
         return true;
     }
     /** inherited doc */
     getDefaultMultisigType() {
-        return sdk_core_1.multisigTypes.tss;
+        return sdk_core_2.multisigTypes.tss;
     }
     getMPCAlgorithm() {
         return 'ecdsa';
@@ -100,16 +110,16 @@ class Vet extends sdk_core_1.BaseCoin {
         if (!explainedTx) {
             throw new Error('failed to explain transaction');
         }
-        if (txParams.recipients !== undefined) {
+        if (txParams.recipients !== undefined && txParams.recipients.length > 0) {
             const filteredRecipients = txParams.recipients?.map((recipient) => {
                 return {
-                    address: recipient.address,
+                    address: recipient.address.toLowerCase(),
                     amount: BigInt(recipient.amount),
                 };
             });
             const filteredOutputs = explainedTx.outputs.map((output) => {
                 return {
-                    address: output.address,
+                    address: output.address.toLowerCase(),
                     amount: BigInt(output.amount),
                 };
             });
@@ -126,10 +136,35 @@ class Vet extends sdk_core_1.BaseCoin {
         }
         return true;
     }
+    /**
+     * Verify that an address belongs to this wallet.
+     *
+     * @param {TssVerifyVetAddressOptions} params - Verification parameters
+     * @returns {Promise<boolean>} True if address belongs to wallet
+     * @throws {InvalidAddressError} If address format is invalid
+     * @throws {Error} If invalid wallet version or missing parameters
+     */
     async isWalletAddress(params) {
-        const { address: newAddress } = params;
-        if (!this.isValidAddress(newAddress)) {
-            throw new sdk_core_1.InvalidAddressError(`invalid address: ${newAddress}`);
+        const { address, baseAddress, walletVersion } = params;
+        if (address && !this.isValidAddress(address)) {
+            throw new sdk_core_2.InvalidAddressError(`invalid address: ${address}`);
+        }
+        if (walletVersion !== 6) {
+            throw new Error(`VET only supports wallet version 6, but got version ${walletVersion}`);
+        }
+        const isVerifyingBaseAddress = baseAddress && address.toLowerCase() === baseAddress.toLowerCase();
+        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}.`);
+            }
+        }
+        const result = await (0, sdk_core_2.verifyMPCWalletAddress)({ ...params, keyCurve: 'secp256k1' }, this.isValidAddress.bind(this), (pubKey) => {
+            const keyPair = new abstract_eth_1.KeyPair({ pub: pubKey });
+            return keyPair.getAddress();
+        });
+        if (!result) {
+            throw new sdk_core_2.InvalidAddressError(`invalid address: ${address}`);
         }
         return true;
     }
@@ -215,6 +250,466 @@ class Vet extends sdk_core_1.BaseCoin {
         /** https://bitgoinc.atlassian.net/browse/COIN-4213 */
         throw new Error('Method not implemented.');
     }
+    /**
+     * Function to get coin specific hash function used to generate transaction digests.
+     * @returns {@see Hash} hash function if implemented, otherwise throws exception
+     */
+    getHashFunction() {
+        const blake = (0, blake2b_1.default)(32);
+        // We return an object that mimics the Hash interface
+        return {
+            update(data) {
+                blake.update(data);
+                return this;
+            },
+            digest() {
+                const uint8Result = blake.digest();
+                return Buffer.from(uint8Result);
+            },
+        };
+    }
+    buildNftTransferData(params) {
+        const { recipientAddress, fromAddress, tokenContractAddress } = params;
+        if (!utils_1.default.isValidAddress(recipientAddress)) {
+            throw new sdk_core_2.InvalidAddressError('Invalid recipient address');
+        }
+        if (!utils_1.default.isValidAddress(fromAddress)) {
+            throw new sdk_core_2.InvalidAddressError('Invalid from address');
+        }
+        if (!utils_1.default.isValidAddress(tokenContractAddress)) {
+            throw new sdk_core_2.InvalidAddressError('Invalid NFT contract address address');
+        }
+        switch (params.type) {
+            case 'ERC721': {
+                const tokenId = params.tokenId;
+                return {
+                    tokenType: sdk_core_2.TokenType.ERC721,
+                    tokenQuantity: '1', // This NFT standard will always have quantity of 1
+                    tokenContractAddress,
+                    tokenId,
+                };
+            }
+            default:
+                throw new sdk_core_2.NotImplementedError(`NFT type ${params.type} not supported on ${this.getChain()}`);
+        }
+    }
+    /**
+     * Broadcasts a signed transaction to the VeChain network.
+     *
+     * @param {BaseBroadcastTransactionOptions} payload - The payload containing the serialized signed transaction.
+     * @param {string} payload.serializedSignedTransaction - The serialized signed transaction to broadcast.
+     * @returns {Promise<BaseBroadcastTransactionResult>} A promise that resolves to an empty object if the broadcast is successful.
+     * @throws {Error} If the broadcast fails, an error is thrown with the failure message.
+     */
+    async broadcastTransaction(payload) {
+        const baseUrl = this.getPublicNodeUrl();
+        const url = `${baseUrl}/transactions`;
+        // The body should be a JSON object with a 'raw' key
+        const requestBody = {
+            raw: payload.serializedSignedTransaction,
+        };
+        try {
+            await axios_1.default.post(url, requestBody);
+            return {};
+        }
+        catch (error) {
+            throw new Error(`Failed to broadcast transaction: ${error.message}`);
+        }
+    }
+    /** @inheritDoc */
+    async recover(params) {
+        if (params.tokenContractAddress) {
+            return this.recoverTokens(params);
+        }
+        try {
+            if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+                throw new Error('invalid recoveryDestination');
+            }
+            const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+            let publicKey;
+            let userKeyShare, backupKeyShare, commonKeyChain;
+            const MPC = new sdk_core_2.Ecdsa();
+            if (isUnsignedSweep) {
+                const bitgoKey = params.bitgoKey;
+                if (!bitgoKey) {
+                    throw new Error('missing bitgoKey');
+                }
+                const hdTree = new mpc.Secp256k1Bip32HdTree();
+                const derivationPath = 'm/0';
+                const derivedPub = hdTree.publicDerive({
+                    pk: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(0, 66), 'hex')),
+                    chaincode: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(66), 'hex')),
+                }, derivationPath);
+                publicKey = mpc.bigIntToBufferBE(derivedPub.pk).toString('hex');
+            }
+            else {
+                if (!params.userKey) {
+                    throw new Error('missing userKey');
+                }
+                if (!params.backupKey) {
+                    throw new Error('missing backupKey');
+                }
+                if (!params.walletPassphrase) {
+                    throw new Error('missing wallet passphrase');
+                }
+                const userKey = params.userKey.replace(/\s/g, '');
+                const backupKey = params.backupKey.replace(/\s/g, '');
+                ({ userKeyShare, backupKeyShare, commonKeyChain } = await sdk_core_2.ECDSAUtils.getMpcV2RecoveryKeyShares(userKey, backupKey, params.walletPassphrase));
+                publicKey = MPC.deriveUnhardened(commonKeyChain, 'm/0').slice(0, 66);
+            }
+            if (!publicKey) {
+                throw new Error('failed to derive public key');
+            }
+            const backupKeyPair = new abstract_eth_1.KeyPair({ pub: publicKey });
+            const baseAddress = backupKeyPair.getAddress();
+            const tx = await this.buildRecoveryTransaction({
+                baseAddress,
+                params,
+            });
+            const signableHex = await tx.signablePayload;
+            const serializedTxHex = await tx.toBroadcastFormat();
+            if (isUnsignedSweep) {
+                return {
+                    txHex: serializedTxHex,
+                    coin: this.getChain(),
+                };
+            }
+            const signableMessage = this.getHashFunction().update(signableHex).digest();
+            const signatureObj = await sdk_core_2.ECDSAUtils.signRecoveryMpcV2(signableMessage, userKeyShare, backupKeyShare, commonKeyChain);
+            const signature = Buffer.from(signatureObj.r + signatureObj.s + (signatureObj.recid === 0 ? '00' : '01'), 'hex');
+            const txBuilder = this.getTxBuilderFactory().getTransferBuilder();
+            await txBuilder.from(serializedTxHex);
+            txBuilder.isRecovery(true);
+            await txBuilder.addSenderSignature(signature);
+            const signedTx = await txBuilder.build();
+            return {
+                id: signedTx.id,
+                tx: signedTx.toBroadcastFormat(),
+            };
+        }
+        catch (error) {
+            throw new Error(`Error during Vechain recovery: ${error.message || error}`);
+        }
+    }
+    /**
+     * Returns the public node URL for the VeChain network.
+     * @returns {string} The URL of the public VeChain node.
+     */
+    getPublicNodeUrl() {
+        return sdk_core_2.Environments[this.bitgo.getEnv()].vetNodeUrl;
+    }
+    /**
+     * Calculates the transaction fee based on the estimated gas limit and fee estimate data.
+     * @param {FeeEstimateData} feeEstimateData - The fee estimate data.
+     * @param {BigNumber} estimatedGasLimit - The estimated gas limit for the transaction.
+     * @returns {BigNumber} The calculated transaction fee.
+     */
+    calculateFee(feeEstimateData, estimatedGasLimit) {
+        const gasLimit = estimatedGasLimit;
+        const adjustmentFactor = new bignumber_js_1.default(1).plus(new bignumber_js_1.default(feeEstimateData.gasPriceCoef)
+            .dividedBy(new bignumber_js_1.default(feeEstimateData.coefDivisor))
+            .decimalPlaces(18, bignumber_js_1.default.ROUND_DOWN));
+        const adjustedGasPrice = new bignumber_js_1.default(feeEstimateData.gasUnitPrice).times(adjustmentFactor);
+        return gasLimit.times(adjustedGasPrice).integerValue(bignumber_js_1.default.ROUND_CEIL);
+    }
+    /**
+     * Ensures that the given address has sufficient VTHO balance to cover the transaction fee.
+     * @param {string} baseAddress - The address to check for VTHO balance.
+     * @param {BigNumber} requiredGasUnits - The required gas units for the transaction.
+     * @throws {Error} If the VTHO balance is insufficient or if there's an error checking the balance.
+     */
+    async ensureVthoBalanceForFee(baseAddress, requiredGasUnits) {
+        const vthoTokenAddress = '0x0000000000000000000000000000456E65726779'; // VTHO token contract address
+        try {
+            const vthoBalance = await this.getBalance(baseAddress, vthoTokenAddress);
+            const requiredFee = this.calculateFee(constants_1.feeEstimateData, requiredGasUnits);
+            if (vthoBalance.isLessThan(requiredFee)) {
+                throw new Error(`Insufficient VTHO balance for fees. Required: ${requiredFee.toString()}, Available: ${vthoBalance.toString()}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to ensure VTHO balance: ${error.message}`);
+        }
+    }
+    /**
+     * Fetches the balance for a given Vechain address.
+     *
+     * @param address The Vechain address (e.g., "0x...") to check.
+     * @param tokenContractAddress (Optional) The contract address of a VIP180 token.
+     * @returns A Promise that resolves to a BigNumber instance of the balance.
+     */
+    async getBalance(address, tokenContractAddress) {
+        const baseUrl = this.getPublicNodeUrl();
+        if (!tokenContractAddress) {
+            const url = `${baseUrl}/accounts/${address}`;
+            try {
+                const response = await axios_1.default.get(url);
+                // The 'balance' is returned as a hex string.
+                const balance = new bignumber_js_1.default(response.data.balance);
+                return balance;
+            }
+            catch (error) {
+                throw new Error('Failed to get native balance.');
+            }
+        }
+        const url = `${baseUrl}/accounts/*`;
+        // Construct the ABI-encoded data for the 'balanceOf(address)' call
+        // 1. Function selector for 'balanceOf(address)': '0x70a08231'
+        // 2. Padded address: The address, stripped of '0x', left-padded with zeros to 64 chars
+        const paddedAddress = address.startsWith('0x') ? address.substring(2).padStart(64, '0') : address.padStart(64, '0');
+        const data = `0x70a08231${paddedAddress}`;
+        const requestBody = {
+            clauses: [
+                {
+                    to: tokenContractAddress, // The token contract address
+                    value: '0x0',
+                    data: data, // The 'balanceOf' call
+                },
+            ],
+        };
+        try {
+            const response = await axios_1.default.post(url, requestBody);
+            const simResponse = response.data;
+            // Validate response and extract the balance data
+            if (!simResponse || !Array.isArray(simResponse) || simResponse.length === 0 || !simResponse[0].data) {
+                throw new Error('Invalid simulation response from VeChain node');
+            }
+            // The returned data is the hex-encoded balance
+            return new bignumber_js_1.default(simResponse[0].data);
+        }
+        catch (error) {
+            console.error('Error fetching token balance:', error);
+            throw new Error(`Failed to get token balance: ${error.message}`);
+        }
+    }
+    /**
+     * Retrieves the block reference from the VeChain network.
+     * @returns {Promise<string>} A promise that resolves to the block reference string.
+     * @throws {Error} If there's an error fetching the block reference or if the response is invalid.
+     */
+    async getBlockRef() {
+        const baseUrl = this.getPublicNodeUrl();
+        const url = `${baseUrl}/blocks/best`;
+        try {
+            const response = await axios_1.default.get(url);
+            const data = response.data;
+            // Validate the response data
+            if (!data || !data.id) {
+                throw new Error('Invalid response from the VeChain node');
+            }
+            // Return the first 18 characters of the block ID
+            return data.id.slice(0, 18);
+        }
+        catch (error) {
+            // Rethrow or return a sensible default
+            throw new Error('Failed to get block ref: ');
+        }
+    }
+    /**
+     * Generates a random nonce for use in transactions.
+     * @returns {string} A hexadecimal string representing the random nonce.
+     */
+    getRandomNonce() {
+        return '0x' + (0, crypto_1.randomBytes)(8).toString('hex');
+    }
+    /**
+     * Estimates the gas required for a set of transaction clauses.
+     * @param {TransactionClause[]} clauses - An array of transaction clauses.
+     * @param {string} caller - The address of the transaction caller.
+     * @returns {Promise<BigNumber>} A promise that resolves to the estimated gas amount.
+     * @throws {Error} If the clauses are invalid, the caller is not provided, or if there's an error in gas estimation.
+     */
+    async estimateGas(clauses, caller) {
+        if (!clauses || !Array.isArray(clauses) || clauses.length === 0) {
+            throw new Error('Clauses must be a non-empty array');
+        }
+        if (!caller) {
+            throw new Error('Caller address is required');
+        }
+        const baseUrl = this.getPublicNodeUrl();
+        const url = `${baseUrl}/accounts/*`;
+        const requestBody = {
+            clauses: clauses,
+            caller: caller,
+        };
+        try {
+            const response = await axios_1.default.post(url, requestBody);
+            const simResponse = response.data;
+            if (!simResponse || !Array.isArray(simResponse)) {
+                throw new Error('Invalid simulation response from VeChain node');
+            }
+            const totalSimulatedGas = simResponse.reduce((sum, result) => sum + (result.gasUsed || 0), 0);
+            const intrinsicGas = Number(sdk_core_1.Transaction.intrinsicGas(clauses).wei);
+            const totalGas = Math.ceil(intrinsicGas + (totalSimulatedGas !== 0 ? totalSimulatedGas + 15000 : 0));
+            return new bignumber_js_1.default(totalGas);
+        }
+        catch (error) {
+            throw new Error(`Failed to estimate gas: ${error.message}`);
+        }
+    }
+    /**
+     * Builds a recovery transaction for the given address.
+     * @param {Object} buildParams - The parameters for building the recovery transaction.
+     * @param {string} buildParams.baseAddress - The address to recover funds from.
+     * @param {RecoverOptions} buildParams.params - The recovery options.
+     * @returns {Promise<Transaction>} A promise that resolves to the built recovery transaction.
+     * @throws {Error} If there's no VET balance to recover or if there's an error building the transaction.
+     */
+    async buildRecoveryTransaction(buildParams) {
+        const { baseAddress, params } = buildParams;
+        const balance = await this.getBalance(baseAddress);
+        if (balance.isLessThanOrEqualTo(0)) {
+            throw new Error(`no VET balance to recover for address ${baseAddress}`);
+        }
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: balance.toString(),
+            },
+        ];
+        const blockRef = await this.getBlockRef();
+        const txBuilder = this.getTxBuilderFactory().getTransferBuilder();
+        txBuilder.chainTag(this.bitgo.getEnv() === 'prod' ? 0x4a : 0x27);
+        txBuilder.recipients(recipients);
+        txBuilder.sender(baseAddress);
+        txBuilder.addFeePayerAddress(baseAddress);
+        txBuilder.gas(Number(constants_1.AVG_GAS_UNITS));
+        txBuilder.blockRef(blockRef);
+        txBuilder.expiration(constants_1.EXPIRATION);
+        txBuilder.gasPriceCoef(Number(constants_1.GAS_PRICE_COEF));
+        txBuilder.nonce(this.getRandomNonce());
+        txBuilder.isRecovery(true);
+        let tx = (await txBuilder.build());
+        const clauses = tx.clauses;
+        const actualGasUnits = await this.estimateGas(clauses, baseAddress);
+        await this.ensureVthoBalanceForFee(baseAddress, actualGasUnits);
+        txBuilder.gas(actualGasUnits.toNumber());
+        tx = (await txBuilder.build());
+        return tx;
+    }
+    async recoverTokens(params) {
+        try {
+            if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+                throw new Error('invalid recoveryDestination');
+            }
+            if (!params.tokenContractAddress || !this.isValidAddress(params.tokenContractAddress)) {
+                throw new Error('invalid tokenContractAddress');
+            }
+            const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+            let publicKey;
+            let userKeyShare, backupKeyShare, commonKeyChain;
+            const MPC = new sdk_core_2.Ecdsa();
+            if (isUnsignedSweep) {
+                const bitgoKey = params.bitgoKey;
+                if (!bitgoKey) {
+                    throw new Error('missing bitgoKey');
+                }
+                const hdTree = new mpc.Secp256k1Bip32HdTree();
+                const derivationPath = 'm/0';
+                const derivedPub = hdTree.publicDerive({
+                    pk: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(0, 66), 'hex')),
+                    chaincode: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(66), 'hex')),
+                }, derivationPath);
+                publicKey = mpc.bigIntToBufferBE(derivedPub.pk).toString('hex');
+            }
+            else {
+                if (!params.userKey) {
+                    throw new Error('missing userKey');
+                }
+                if (!params.backupKey) {
+                    throw new Error('missing backupKey');
+                }
+                if (!params.walletPassphrase) {
+                    throw new Error('missing wallet passphrase');
+                }
+                const userKey = params.userKey.replace(/\s/g, '');
+                const backupKey = params.backupKey.replace(/\s/g, '');
+                ({ userKeyShare, backupKeyShare, commonKeyChain } = await sdk_core_2.ECDSAUtils.getMpcV2RecoveryKeyShares(userKey, backupKey, params.walletPassphrase));
+                publicKey = MPC.deriveUnhardened(commonKeyChain, 'm/0').slice(0, 66);
+            }
+            if (!publicKey) {
+                throw new Error('failed to derive public key');
+            }
+            const backupKeyPair = new abstract_eth_1.KeyPair({ pub: publicKey });
+            const baseAddress = backupKeyPair.getAddress();
+            const tx = await this.buildTokenRecoveryTransaction({
+                baseAddress,
+                params,
+            });
+            const signableHex = await tx.signablePayload;
+            const serializedTxHex = await tx.toBroadcastFormat();
+            if (isUnsignedSweep) {
+                return {
+                    txHex: serializedTxHex,
+                    coin: this.getChain(),
+                };
+            }
+            const signableMessage = this.getHashFunction().update(signableHex).digest();
+            const signatureObj = await sdk_core_2.ECDSAUtils.signRecoveryMpcV2(signableMessage, userKeyShare, backupKeyShare, commonKeyChain);
+            const signature = Buffer.from(signatureObj.r + signatureObj.s + (signatureObj.recid === 0 ? '00' : '01'), 'hex');
+            const tokenTransaction = new lib_1.TokenTransaction(statics_1.coins.get(this.getChain()));
+            const txBuilder = this.getTxBuilderFactory().getTokenTransactionBuilder(tokenTransaction);
+            await txBuilder.from(serializedTxHex);
+            txBuilder.isRecovery(true);
+            await txBuilder.addSenderSignature(signature);
+            const signedTx = await txBuilder.build();
+            return {
+                id: signedTx.id,
+                tx: signedTx.toBroadcastFormat(),
+            };
+        }
+        catch (error) {
+            throw new Error(`Error during Vechain token recovery: ${error.message || error}`);
+        }
+    }
+    async buildTokenRecoveryTransaction(buildParams) {
+        const { baseAddress, params } = buildParams;
+        const tokenContractAddress = params.tokenContractAddress;
+        (0, assert_1.default)(tokenContractAddress, 'tokenContractAddress is required for token recovery');
+        const balance = await this.getBalance(baseAddress, tokenContractAddress);
+        //replace with get balance function
+        if (balance.isLessThanOrEqualTo(0)) {
+            throw new Error(`no token balance to recover for address ${baseAddress} contract address ${tokenContractAddress}`);
+        }
+        // create the recipients here so that we can build the clauses for gas estimation
+        const roughFeeEstimate = this.calculateFee(constants_1.feeEstimateData, new bignumber_js_1.default(51390));
+        let recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: balance.minus(roughFeeEstimate).toString(),
+            },
+        ];
+        const blockRef = await this.getBlockRef();
+        const tokenTransaction = new lib_1.TokenTransaction(statics_1.coins.get(this.getChain()));
+        const txBuilder = this.getTxBuilderFactory().getTokenTransactionBuilder(tokenTransaction);
+        txBuilder.tokenAddress(tokenContractAddress);
+        txBuilder.chainTag(this.bitgo.getEnv() === 'prod' ? 0x4a : 0x27);
+        txBuilder.recipients(recipients);
+        txBuilder.sender(baseAddress);
+        txBuilder.addFeePayerAddress(baseAddress);
+        txBuilder.gas(Number(constants_1.AVG_GAS_UNITS));
+        txBuilder.blockRef(blockRef);
+        txBuilder.expiration(constants_1.EXPIRATION);
+        txBuilder.gasPriceCoef(Number(constants_1.GAS_PRICE_COEF));
+        txBuilder.nonce(this.getRandomNonce());
+        txBuilder.isRecovery(true);
+        let tx = (await txBuilder.build());
+        const clauses = tx.clauses;
+        const actualGasUnits = await this.estimateGas(clauses, baseAddress);
+        await this.ensureVthoBalanceForFee(baseAddress, actualGasUnits);
+        const requiredFee = this.calculateFee(constants_1.feeEstimateData, actualGasUnits);
+        // create the final recipients with the fee deducted
+        recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: balance.minus(requiredFee).toString(),
+            },
+        ];
+        txBuilder.recipients(recipients);
+        txBuilder.gas(actualGasUnits.toNumber());
+        tx = (await txBuilder.build());
+        return tx;
+    }
 }
 exports.Vet = Vet;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vet.js","sourceRoot":"","sources":["../../src/vet.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _ from 'lodash';\nimport BigNumber from 'bignumber.js';\nimport {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BaseTransaction,\n  BitGoBase,\n  InvalidAddressError,\n  KeyPair,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  SignedTransaction,\n  SignTransactionOptions,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';\nimport utils from './lib/utils';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport { randomBytes } from 'crypto';\nimport { KeyPair as EthKeyPair } from '@bitgo-beta/abstract-eth';\nimport { TransactionBuilderFactory } from './lib';\nimport { ExplainTransactionOptions, VetParseTransactionOptions } from './lib/types';\nimport { VetTransactionExplanation } from './lib/iface';\n\n/**\n * Full Name: Vechain\n * Docs: https://docs.vechain.org/\n * GitHub : https://github.com/vechain\n */\nexport class Vet extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Vet(bitgo, staticsCoin);\n  }\n\n  /**\n   * Factor between the coin's base unit and its smallest sub division\n   */\n  public getBaseFactor(): number {\n    return 1e18;\n  }\n\n  public getChain(): string {\n    return 'vet';\n  }\n\n  public getFamily(): string {\n    return 'vet';\n  }\n\n  public getFullName(): string {\n    return 'VeChain';\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txPrebuild: txPrebuild, txParams: txParams } = params;\n    const txHex = txPrebuild.txHex;\n    if (!txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    const explainedTx = await this.explainTransaction({ txHex });\n    if (!explainedTx) {\n      throw new Error('failed to explain transaction');\n    }\n    if (txParams.recipients !== undefined) {\n      const filteredRecipients = txParams.recipients?.map((recipient) => {\n        return {\n          address: recipient.address,\n          amount: BigInt(recipient.amount),\n        };\n      });\n      const filteredOutputs = explainedTx.outputs.map((output) => {\n        return {\n          address: output.address,\n          amount: BigInt(output.amount),\n        };\n      });\n      if (!_.isEqual(filteredOutputs, filteredRecipients)) {\n        throw new Error('Tx outputs does not match with expected txParams recipients');\n      }\n      let totalAmount = new BigNumber(0);\n      for (const recipients of txParams.recipients) {\n        totalAmount = totalAmount.plus(recipients.amount);\n      }\n      if (!totalAmount.isEqualTo(explainedTx.outputAmount)) {\n        throw new Error('Tx total amount does not match with expected total amount field');\n      }\n    }\n    return true;\n  }\n\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address: newAddress } = params;\n\n    if (!this.isValidAddress(newAddress)) {\n      throw new InvalidAddressError(`invalid address: ${newAddress}`);\n    }\n    return true;\n  }\n\n  async parseTransaction(params: VetParseTransactionOptions): Promise<ParsedTransaction> {\n    const transactionExplanation = await this.explainTransaction({ txHex: params.txHex });\n    if (!transactionExplanation) {\n      throw new Error('Invalid transaction');\n    }\n    return {\n      inputs: [\n        {\n          address: transactionExplanation.sender,\n          amount: transactionExplanation.outputAmount,\n        },\n      ],\n      outputs: [\n        {\n          address: transactionExplanation.outputs[0].address,\n          amount: transactionExplanation.outputs[0].amount,\n        },\n      ],\n    };\n  }\n\n  /**\n   * Explain a Vechain transaction\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<VetTransactionExplanation | undefined> {\n    let rebuiltTransaction: BaseTransaction;\n    try {\n      rebuiltTransaction = await this.rebuildTransaction(params.txHex);\n    } catch {\n      return undefined;\n    }\n    return rebuiltTransaction.explainTransaction();\n  }\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  isValidPub(pub: string): boolean {\n    let valid = true;\n    try {\n      new EthKeyPair({ pub });\n    } catch (e) {\n      valid = false;\n    }\n    return valid;\n  }\n\n  isValidAddress(address: string): boolean {\n    return utils.isValidAddress(address);\n  }\n\n  signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new Error('Method not implemented.');\n  }\n\n  protected getTxBuilderFactory(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(this._staticsCoin);\n  }\n\n  protected async rebuildTransaction(txHex: string): Promise<BaseTransaction> {\n    const txBuilderFactory = this.getTxBuilderFactory();\n    try {\n      const txBuilder = txBuilderFactory.from(txHex);\n      return txBuilder.transaction;\n    } catch {\n      throw new Error('Failed to rebuild transaction');\n    }\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey(params: AuditDecryptedKeyParams): void {\n    /** https://bitgoinc.atlassian.net/browse/COIN-4213 */\n    throw new Error('Method not implemented.');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vet.js","sourceRoot":"","sources":["../../src/vet.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _ from 'lodash';\nimport BigNumber from 'bignumber.js';\nimport blake2b from '@bitgo-beta/blake2b';\nimport assert from 'assert';\nimport axios from 'axios';\nimport { TransactionClause, Transaction as VetTransaction } from '@vechain/sdk-core';\nimport {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BaseTransaction,\n  BitGoBase,\n  BuildNftTransferDataOptions,\n  InvalidAddressError,\n  KeyPair,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  NotImplementedError,\n  ParsedTransaction,\n  SignedTransaction,\n  SignTransactionOptions,\n  TokenTransferRecipientParams,\n  TssVerifyAddressOptions,\n  VerifyTransactionOptions,\n  TokenType,\n  Ecdsa,\n  ECDSAUtils,\n  Environments,\n  BaseBroadcastTransactionOptions,\n  BaseBroadcastTransactionResult,\n  verifyMPCWalletAddress,\n} from '@bitgo-beta/sdk-core';\nimport * as mpc from '@bitgo-beta/sdk-lib-mpc';\nimport { BaseCoin as StaticsBaseCoin, coins } from '@bitgo-beta/statics';\nimport utils from './lib/utils';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport { randomBytes, Hash } from 'crypto';\nimport { KeyPair as EthKeyPair } from '@bitgo-beta/abstract-eth';\nimport { TokenTransaction, Transaction, TransactionBuilderFactory } from './lib';\nimport {\n  ExplainTransactionOptions,\n  RecoverOptions,\n  RecoveryTransaction,\n  UnsignedSweepRecoveryTransaction,\n  VetParseTransactionOptions,\n} from './lib/types';\nimport { VetTransactionExplanation } from './lib/iface';\nimport { AVG_GAS_UNITS, EXPIRATION, GAS_PRICE_COEF, feeEstimateData } from './lib/constants';\n\ninterface FeeEstimateData {\n  gas: string;\n  gasUnitPrice: string;\n  gasPriceCoef: string;\n  coefDivisor: string;\n}\n\nexport interface TssVerifyVetAddressOptions extends TssVerifyAddressOptions {\n  address: string;\n  baseAddress?: string;\n  walletVersion?: number;\n}\n\n/**\n * Full Name: Vechain\n * Docs: https://docs.vechain.org/\n * GitHub : https://github.com/vechain\n */\nexport class Vet extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Vet(bitgo, staticsCoin);\n  }\n\n  /**\n   * Factor between the coin's base unit and its smallest sub division\n   */\n  public getBaseFactor(): number {\n    return 1e18;\n  }\n\n  public getChain(): string {\n    return 'vet';\n  }\n\n  public getFamily(): string {\n    return 'vet';\n  }\n\n  public getFullName(): string {\n    return 'VeChain';\n  }\n\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txPrebuild: txPrebuild, txParams: txParams } = params;\n    const txHex = txPrebuild.txHex;\n    if (!txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    const explainedTx = await this.explainTransaction({ txHex });\n    if (!explainedTx) {\n      throw new Error('failed to explain transaction');\n    }\n    if (txParams.recipients !== undefined && txParams.recipients.length > 0) {\n      const filteredRecipients = txParams.recipients?.map((recipient) => {\n        return {\n          address: recipient.address.toLowerCase(),\n          amount: BigInt(recipient.amount),\n        };\n      });\n      const filteredOutputs = explainedTx.outputs.map((output) => {\n        return {\n          address: output.address.toLowerCase(),\n          amount: BigInt(output.amount),\n        };\n      });\n\n      if (!_.isEqual(filteredOutputs, filteredRecipients)) {\n        throw new Error('Tx outputs does not match with expected txParams recipients');\n      }\n      let totalAmount = new BigNumber(0);\n      for (const recipients of txParams.recipients) {\n        totalAmount = totalAmount.plus(recipients.amount);\n      }\n      if (!totalAmount.isEqualTo(explainedTx.outputAmount)) {\n        throw new Error('Tx total amount does not match with expected total amount field');\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Verify that an address belongs to this wallet.\n   *\n   * @param {TssVerifyVetAddressOptions} params - Verification parameters\n   * @returns {Promise<boolean>} True if address belongs to wallet\n   * @throws {InvalidAddressError} If address format is invalid\n   * @throws {Error} If invalid wallet version or missing parameters\n   */\n  async isWalletAddress(params: TssVerifyVetAddressOptions): Promise<boolean> {\n    const { address, baseAddress, walletVersion } = params;\n\n    if (address && !this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    if (walletVersion !== 6) {\n      throw new Error(`VET only supports wallet version 6, but got version ${walletVersion}`);\n    }\n\n    const isVerifyingBaseAddress = baseAddress && address.toLowerCase() === baseAddress.toLowerCase();\n    if (isVerifyingBaseAddress) {\n      const index = typeof params.index === 'string' ? parseInt(params.index, 10) : params.index;\n      if (index !== 0) {\n        throw new Error(`Base address verification requires index 0, but got index ${params.index}.`);\n      }\n    }\n\n    const result = await verifyMPCWalletAddress(\n      { ...params, keyCurve: 'secp256k1' },\n      this.isValidAddress.bind(this),\n      (pubKey) => {\n        const keyPair = new EthKeyPair({ pub: pubKey });\n        return keyPair.getAddress();\n      }\n    );\n\n    if (!result) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    return true;\n  }\n\n  async parseTransaction(params: VetParseTransactionOptions): Promise<ParsedTransaction> {\n    const transactionExplanation = await this.explainTransaction({ txHex: params.txHex });\n    if (!transactionExplanation) {\n      throw new Error('Invalid transaction');\n    }\n    return {\n      inputs: [\n        {\n          address: transactionExplanation.sender,\n          amount: transactionExplanation.outputAmount,\n        },\n      ],\n      outputs: [\n        {\n          address: transactionExplanation.outputs[0].address,\n          amount: transactionExplanation.outputs[0].amount,\n        },\n      ],\n    };\n  }\n\n  /**\n   * Explain a Vechain transaction\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<VetTransactionExplanation | undefined> {\n    let rebuiltTransaction: BaseTransaction;\n    try {\n      rebuiltTransaction = await this.rebuildTransaction(params.txHex);\n    } catch {\n      return undefined;\n    }\n    return rebuiltTransaction.explainTransaction();\n  }\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  isValidPub(pub: string): boolean {\n    let valid = true;\n    try {\n      new EthKeyPair({ pub });\n    } catch (e) {\n      valid = false;\n    }\n    return valid;\n  }\n\n  isValidAddress(address: string): boolean {\n    return utils.isValidAddress(address);\n  }\n\n  signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new Error('Method not implemented.');\n  }\n\n  protected getTxBuilderFactory(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(this._staticsCoin);\n  }\n\n  protected async rebuildTransaction(txHex: string): Promise<BaseTransaction> {\n    const txBuilderFactory = this.getTxBuilderFactory();\n    try {\n      const txBuilder = txBuilderFactory.from(txHex);\n      return txBuilder.transaction;\n    } catch {\n      throw new Error('Failed to rebuild transaction');\n    }\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey(params: AuditDecryptedKeyParams): void {\n    /** https://bitgoinc.atlassian.net/browse/COIN-4213 */\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Function to get coin specific hash function used to generate transaction digests.\n   * @returns {@see Hash} hash function if implemented, otherwise throws exception\n   */\n  getHashFunction(): Hash {\n    const blake = blake2b(32);\n\n    // We return an object that mimics the Hash interface\n    return {\n      update(data: Buffer | Uint8Array) {\n        blake.update(data);\n        return this;\n      },\n      digest() {\n        const uint8Result = blake.digest();\n        return Buffer.from(uint8Result);\n      },\n    } as unknown as Hash;\n  }\n\n  buildNftTransferData(params: BuildNftTransferDataOptions): TokenTransferRecipientParams {\n    const { recipientAddress, fromAddress, tokenContractAddress } = params;\n    if (!utils.isValidAddress(recipientAddress)) {\n      throw new InvalidAddressError('Invalid recipient address');\n    }\n    if (!utils.isValidAddress(fromAddress)) {\n      throw new InvalidAddressError('Invalid from address');\n    }\n    if (!utils.isValidAddress(tokenContractAddress)) {\n      throw new InvalidAddressError('Invalid NFT contract address address');\n    }\n    switch (params.type) {\n      case 'ERC721': {\n        const tokenId = params.tokenId;\n        return {\n          tokenType: TokenType.ERC721,\n          tokenQuantity: '1', // This NFT standard will always have quantity of 1\n          tokenContractAddress,\n          tokenId,\n        };\n      }\n      default:\n        throw new NotImplementedError(`NFT type ${params.type} not supported on ${this.getChain()}`);\n    }\n  }\n\n  /**\n   * Broadcasts a signed transaction to the VeChain network.\n   *\n   * @param {BaseBroadcastTransactionOptions} payload - The payload containing the serialized signed transaction.\n   * @param {string} payload.serializedSignedTransaction - The serialized signed transaction to broadcast.\n   * @returns {Promise<BaseBroadcastTransactionResult>} A promise that resolves to an empty object if the broadcast is successful.\n   * @throws {Error} If the broadcast fails, an error is thrown with the failure message.\n   */\n  public async broadcastTransaction(payload: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult> {\n    const baseUrl = this.getPublicNodeUrl();\n    const url = `${baseUrl}/transactions`;\n\n    // The body should be a JSON object with a 'raw' key\n    const requestBody = {\n      raw: payload.serializedSignedTransaction,\n    };\n\n    try {\n      await axios.post(url, requestBody);\n      return {};\n    } catch (error) {\n      throw new Error(`Failed to broadcast transaction: ${error.message}`);\n    }\n  }\n\n  /** @inheritDoc */\n  async recover(params: RecoverOptions): Promise<RecoveryTransaction | UnsignedSweepRecoveryTransaction> {\n    if (params.tokenContractAddress) {\n      return this.recoverTokens(params);\n    }\n    try {\n      if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n        throw new Error('invalid recoveryDestination');\n      }\n\n      const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n\n      let publicKey: string | undefined;\n      let userKeyShare, backupKeyShare, commonKeyChain;\n      const MPC = new Ecdsa();\n\n      if (isUnsignedSweep) {\n        const bitgoKey = params.bitgoKey;\n        if (!bitgoKey) {\n          throw new Error('missing bitgoKey');\n        }\n\n        const hdTree = new mpc.Secp256k1Bip32HdTree();\n        const derivationPath = 'm/0';\n        const derivedPub = hdTree.publicDerive(\n          {\n            pk: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(0, 66), 'hex')),\n            chaincode: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(66), 'hex')),\n          },\n          derivationPath\n        );\n\n        publicKey = mpc.bigIntToBufferBE(derivedPub.pk).toString('hex');\n      } else {\n        if (!params.userKey) {\n          throw new Error('missing userKey');\n        }\n\n        if (!params.backupKey) {\n          throw new Error('missing backupKey');\n        }\n\n        if (!params.walletPassphrase) {\n          throw new Error('missing wallet passphrase');\n        }\n\n        const userKey = params.userKey.replace(/\\s/g, '');\n        const backupKey = params.backupKey.replace(/\\s/g, '');\n\n        ({ userKeyShare, backupKeyShare, commonKeyChain } = await ECDSAUtils.getMpcV2RecoveryKeyShares(\n          userKey,\n          backupKey,\n          params.walletPassphrase\n        ));\n        publicKey = MPC.deriveUnhardened(commonKeyChain, 'm/0').slice(0, 66);\n      }\n\n      if (!publicKey) {\n        throw new Error('failed to derive public key');\n      }\n\n      const backupKeyPair = new EthKeyPair({ pub: publicKey });\n      const baseAddress = backupKeyPair.getAddress();\n\n      const tx = await this.buildRecoveryTransaction({\n        baseAddress,\n        params,\n      });\n\n      const signableHex = await tx.signablePayload;\n      const serializedTxHex = await tx.toBroadcastFormat();\n\n      if (isUnsignedSweep) {\n        return {\n          txHex: serializedTxHex,\n          coin: this.getChain(),\n        };\n      }\n\n      const signableMessage = this.getHashFunction().update(signableHex).digest();\n\n      const signatureObj = await ECDSAUtils.signRecoveryMpcV2(\n        signableMessage,\n        userKeyShare,\n        backupKeyShare,\n        commonKeyChain\n      );\n      const signature = Buffer.from(signatureObj.r + signatureObj.s + (signatureObj.recid === 0 ? '00' : '01'), 'hex');\n      const txBuilder = this.getTxBuilderFactory().getTransferBuilder();\n      await txBuilder.from(serializedTxHex);\n      txBuilder.isRecovery(true);\n      await txBuilder.addSenderSignature(signature);\n\n      const signedTx = await txBuilder.build();\n\n      return {\n        id: signedTx.id,\n        tx: signedTx.toBroadcastFormat(),\n      };\n    } catch (error) {\n      throw new Error(`Error during Vechain recovery: ${error.message || error}`);\n    }\n  }\n\n  /**\n   * Returns the public node URL for the VeChain network.\n   * @returns {string} The URL of the public VeChain node.\n   */\n  private getPublicNodeUrl(): string {\n    return Environments[this.bitgo.getEnv()].vetNodeUrl;\n  }\n\n  /**\n   * Calculates the transaction fee based on the estimated gas limit and fee estimate data.\n   * @param {FeeEstimateData} feeEstimateData - The fee estimate data.\n   * @param {BigNumber} estimatedGasLimit - The estimated gas limit for the transaction.\n   * @returns {BigNumber} The calculated transaction fee.\n   */\n  private calculateFee(feeEstimateData: FeeEstimateData, estimatedGasLimit: BigNumber): BigNumber {\n    const gasLimit = estimatedGasLimit;\n    const adjustmentFactor = new BigNumber(1).plus(\n      new BigNumber(feeEstimateData.gasPriceCoef)\n        .dividedBy(new BigNumber(feeEstimateData.coefDivisor))\n        .decimalPlaces(18, BigNumber.ROUND_DOWN)\n    );\n    const adjustedGasPrice = new BigNumber(feeEstimateData.gasUnitPrice).times(adjustmentFactor);\n    return gasLimit.times(adjustedGasPrice).integerValue(BigNumber.ROUND_CEIL);\n  }\n\n  /**\n   * Ensures that the given address has sufficient VTHO balance to cover the transaction fee.\n   * @param {string} baseAddress - The address to check for VTHO balance.\n   * @param {BigNumber} requiredGasUnits - The required gas units for the transaction.\n   * @throws {Error} If the VTHO balance is insufficient or if there's an error checking the balance.\n   */\n  async ensureVthoBalanceForFee(baseAddress: string, requiredGasUnits: BigNumber): Promise<void> {\n    const vthoTokenAddress = '0x0000000000000000000000000000456E65726779'; // VTHO token contract address\n    try {\n      const vthoBalance = await this.getBalance(baseAddress, vthoTokenAddress);\n\n      const requiredFee = this.calculateFee(feeEstimateData, requiredGasUnits);\n\n      if (vthoBalance.isLessThan(requiredFee)) {\n        throw new Error(\n          `Insufficient VTHO balance for fees. Required: ${requiredFee.toString()}, Available: ${vthoBalance.toString()}`\n        );\n      }\n    } catch (error) {\n      throw new Error(`Failed to ensure VTHO balance: ${error.message}`);\n    }\n  }\n\n  /**\n   * Fetches the balance for a given Vechain address.\n   *\n   * @param address The Vechain address (e.g., \"0x...\") to check.\n   * @param tokenContractAddress (Optional) The contract address of a VIP180 token.\n   * @returns A Promise that resolves to a BigNumber instance of the balance.\n   */\n  async getBalance(address: string, tokenContractAddress?: string): Promise<BigNumber> {\n    const baseUrl = this.getPublicNodeUrl();\n\n    if (!tokenContractAddress) {\n      const url = `${baseUrl}/accounts/${address}`;\n\n      try {\n        const response = await axios.get(url);\n\n        // The 'balance' is returned as a hex string.\n        const balance = new BigNumber(response.data.balance);\n\n        return balance;\n      } catch (error) {\n        throw new Error('Failed to get native balance.');\n      }\n    }\n\n    const url = `${baseUrl}/accounts/*`;\n\n    // Construct the ABI-encoded data for the 'balanceOf(address)' call\n    // 1. Function selector for 'balanceOf(address)': '0x70a08231'\n    // 2. Padded address: The address, stripped of '0x', left-padded with zeros to 64 chars\n    const paddedAddress = address.startsWith('0x') ? address.substring(2).padStart(64, '0') : address.padStart(64, '0');\n    const data = `0x70a08231${paddedAddress}`;\n\n    const requestBody = {\n      clauses: [\n        {\n          to: tokenContractAddress, // The token contract address\n          value: '0x0',\n          data: data, // The 'balanceOf' call\n        },\n      ],\n    };\n\n    try {\n      const response = await axios.post(url, requestBody);\n\n      const simResponse = response.data;\n\n      // Validate response and extract the balance data\n      if (!simResponse || !Array.isArray(simResponse) || simResponse.length === 0 || !simResponse[0].data) {\n        throw new Error('Invalid simulation response from VeChain node');\n      }\n\n      // The returned data is the hex-encoded balance\n      return new BigNumber(simResponse[0].data);\n    } catch (error) {\n      console.error('Error fetching token balance:', error);\n      throw new Error(`Failed to get token balance: ${error.message}`);\n    }\n  }\n\n  /**\n   * Retrieves the block reference from the VeChain network.\n   * @returns {Promise<string>} A promise that resolves to the block reference string.\n   * @throws {Error} If there's an error fetching the block reference or if the response is invalid.\n   */\n  public async getBlockRef(): Promise<string> {\n    const baseUrl = this.getPublicNodeUrl();\n    const url = `${baseUrl}/blocks/best`;\n\n    try {\n      const response = await axios.get(url);\n\n      const data = response.data;\n\n      // Validate the response data\n      if (!data || !data.id) {\n        throw new Error('Invalid response from the VeChain node');\n      }\n\n      // Return the first 18 characters of the block ID\n      return data.id.slice(0, 18);\n    } catch (error) {\n      // Rethrow or return a sensible default\n      throw new Error('Failed to get block ref: ');\n    }\n  }\n\n  /**\n   * Generates a random nonce for use in transactions.\n   * @returns {string} A hexadecimal string representing the random nonce.\n   */\n  getRandomNonce(): string {\n    return '0x' + randomBytes(8).toString('hex');\n  }\n\n  /**\n   * Estimates the gas required for a set of transaction clauses.\n   * @param {TransactionClause[]} clauses - An array of transaction clauses.\n   * @param {string} caller - The address of the transaction caller.\n   * @returns {Promise<BigNumber>} A promise that resolves to the estimated gas amount.\n   * @throws {Error} If the clauses are invalid, the caller is not provided, or if there's an error in gas estimation.\n   */\n  public async estimateGas(clauses: TransactionClause[], caller: string): Promise<BigNumber> {\n    if (!clauses || !Array.isArray(clauses) || clauses.length === 0) {\n      throw new Error('Clauses must be a non-empty array');\n    }\n\n    if (!caller) {\n      throw new Error('Caller address is required');\n    }\n\n    const baseUrl = this.getPublicNodeUrl();\n    const url = `${baseUrl}/accounts/*`;\n\n    const requestBody = {\n      clauses: clauses,\n      caller: caller,\n    };\n\n    try {\n      const response = await axios.post(url, requestBody);\n\n      const simResponse = response.data;\n\n      if (!simResponse || !Array.isArray(simResponse)) {\n        throw new Error('Invalid simulation response from VeChain node');\n      }\n\n      const totalSimulatedGas = simResponse.reduce((sum, result) => sum + (result.gasUsed || 0), 0);\n\n      const intrinsicGas = Number(VetTransaction.intrinsicGas(clauses).wei);\n\n      const totalGas = Math.ceil(intrinsicGas + (totalSimulatedGas !== 0 ? totalSimulatedGas + 15000 : 0));\n\n      return new BigNumber(totalGas);\n    } catch (error) {\n      throw new Error(`Failed to estimate gas: ${error.message}`);\n    }\n  }\n\n  /**\n   * Builds a recovery transaction for the given address.\n   * @param {Object} buildParams - The parameters for building the recovery transaction.\n   * @param {string} buildParams.baseAddress - The address to recover funds from.\n   * @param {RecoverOptions} buildParams.params - The recovery options.\n   * @returns {Promise<Transaction>} A promise that resolves to the built recovery transaction.\n   * @throws {Error} If there's no VET balance to recover or if there's an error building the transaction.\n   */\n  private async buildRecoveryTransaction(buildParams: {\n    baseAddress: string;\n    params: RecoverOptions;\n  }): Promise<Transaction> {\n    const { baseAddress, params } = buildParams;\n    const balance = await this.getBalance(baseAddress);\n\n    if (balance.isLessThanOrEqualTo(0)) {\n      throw new Error(`no VET balance to recover for address ${baseAddress}`);\n    }\n\n    const recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: balance.toString(),\n      },\n    ];\n\n    const blockRef = await this.getBlockRef();\n\n    const txBuilder = this.getTxBuilderFactory().getTransferBuilder();\n\n    txBuilder.chainTag(this.bitgo.getEnv() === 'prod' ? 0x4a : 0x27);\n    txBuilder.recipients(recipients);\n    txBuilder.sender(baseAddress);\n    txBuilder.addFeePayerAddress(baseAddress);\n    txBuilder.gas(Number(AVG_GAS_UNITS));\n    txBuilder.blockRef(blockRef);\n    txBuilder.expiration(EXPIRATION);\n    txBuilder.gasPriceCoef(Number(GAS_PRICE_COEF));\n    txBuilder.nonce(this.getRandomNonce());\n    txBuilder.isRecovery(true);\n\n    let tx = (await txBuilder.build()) as Transaction;\n\n    const clauses = tx.clauses;\n\n    const actualGasUnits = await this.estimateGas(clauses, baseAddress);\n\n    await this.ensureVthoBalanceForFee(baseAddress, actualGasUnits);\n\n    txBuilder.gas(actualGasUnits.toNumber());\n\n    tx = (await txBuilder.build()) as Transaction;\n\n    return tx;\n  }\n\n  async recoverTokens(params: RecoverOptions): Promise<RecoveryTransaction | UnsignedSweepRecoveryTransaction> {\n    try {\n      if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n        throw new Error('invalid recoveryDestination');\n      }\n      if (!params.tokenContractAddress || !this.isValidAddress(params.tokenContractAddress)) {\n        throw new Error('invalid tokenContractAddress');\n      }\n\n      const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n\n      let publicKey: string | undefined;\n      let userKeyShare, backupKeyShare, commonKeyChain;\n      const MPC = new Ecdsa();\n\n      if (isUnsignedSweep) {\n        const bitgoKey = params.bitgoKey;\n        if (!bitgoKey) {\n          throw new Error('missing bitgoKey');\n        }\n\n        const hdTree = new mpc.Secp256k1Bip32HdTree();\n        const derivationPath = 'm/0';\n        const derivedPub = hdTree.publicDerive(\n          {\n            pk: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(0, 66), 'hex')),\n            chaincode: mpc.bigIntFromBufferBE(Buffer.from(bitgoKey.slice(66), 'hex')),\n          },\n          derivationPath\n        );\n\n        publicKey = mpc.bigIntToBufferBE(derivedPub.pk).toString('hex');\n      } else {\n        if (!params.userKey) {\n          throw new Error('missing userKey');\n        }\n\n        if (!params.backupKey) {\n          throw new Error('missing backupKey');\n        }\n\n        if (!params.walletPassphrase) {\n          throw new Error('missing wallet passphrase');\n        }\n\n        const userKey = params.userKey.replace(/\\s/g, '');\n        const backupKey = params.backupKey.replace(/\\s/g, '');\n\n        ({ userKeyShare, backupKeyShare, commonKeyChain } = await ECDSAUtils.getMpcV2RecoveryKeyShares(\n          userKey,\n          backupKey,\n          params.walletPassphrase\n        ));\n        publicKey = MPC.deriveUnhardened(commonKeyChain, 'm/0').slice(0, 66);\n      }\n\n      if (!publicKey) {\n        throw new Error('failed to derive public key');\n      }\n\n      const backupKeyPair = new EthKeyPair({ pub: publicKey });\n      const baseAddress = backupKeyPair.getAddress();\n\n      const tx = await this.buildTokenRecoveryTransaction({\n        baseAddress,\n        params,\n      });\n\n      const signableHex = await tx.signablePayload;\n      const serializedTxHex = await tx.toBroadcastFormat();\n\n      if (isUnsignedSweep) {\n        return {\n          txHex: serializedTxHex,\n          coin: this.getChain(),\n        };\n      }\n\n      const signableMessage = this.getHashFunction().update(signableHex).digest();\n\n      const signatureObj = await ECDSAUtils.signRecoveryMpcV2(\n        signableMessage,\n        userKeyShare,\n        backupKeyShare,\n        commonKeyChain\n      );\n      const signature = Buffer.from(signatureObj.r + signatureObj.s + (signatureObj.recid === 0 ? '00' : '01'), 'hex');\n      const tokenTransaction = new TokenTransaction(coins.get(this.getChain()));\n      const txBuilder = this.getTxBuilderFactory().getTokenTransactionBuilder(tokenTransaction);\n      await txBuilder.from(serializedTxHex);\n      txBuilder.isRecovery(true);\n      await txBuilder.addSenderSignature(signature);\n\n      const signedTx = await txBuilder.build();\n\n      return {\n        id: signedTx.id,\n        tx: signedTx.toBroadcastFormat(),\n      };\n    } catch (error) {\n      throw new Error(`Error during Vechain token recovery: ${error.message || error}`);\n    }\n  }\n\n  private async buildTokenRecoveryTransaction(buildParams: {\n    baseAddress: string;\n    params: RecoverOptions;\n  }): Promise<Transaction> {\n    const { baseAddress, params } = buildParams;\n    const tokenContractAddress = params.tokenContractAddress;\n    assert(tokenContractAddress, 'tokenContractAddress is required for token recovery');\n\n    const balance = await this.getBalance(baseAddress, tokenContractAddress);\n    //replace with get balance function\n\n    if (balance.isLessThanOrEqualTo(0)) {\n      throw new Error(\n        `no token balance to recover for address ${baseAddress} contract address ${tokenContractAddress}`\n      );\n    }\n\n    // create the recipients here so that we can build the clauses for gas estimation\n    const roughFeeEstimate = this.calculateFee(feeEstimateData, new BigNumber(51390));\n    let recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: balance.minus(roughFeeEstimate).toString(),\n      },\n    ];\n\n    const blockRef = await this.getBlockRef();\n\n    const tokenTransaction = new TokenTransaction(coins.get(this.getChain()));\n    const txBuilder = this.getTxBuilderFactory().getTokenTransactionBuilder(tokenTransaction);\n\n    txBuilder.tokenAddress(tokenContractAddress);\n    txBuilder.chainTag(this.bitgo.getEnv() === 'prod' ? 0x4a : 0x27);\n    txBuilder.recipients(recipients);\n    txBuilder.sender(baseAddress);\n    txBuilder.addFeePayerAddress(baseAddress);\n    txBuilder.gas(Number(AVG_GAS_UNITS));\n    txBuilder.blockRef(blockRef);\n    txBuilder.expiration(EXPIRATION);\n    txBuilder.gasPriceCoef(Number(GAS_PRICE_COEF));\n    txBuilder.nonce(this.getRandomNonce());\n    txBuilder.isRecovery(true);\n\n    let tx = (await txBuilder.build()) as Transaction;\n\n    const clauses = tx.clauses;\n\n    const actualGasUnits = await this.estimateGas(clauses, baseAddress);\n\n    await this.ensureVthoBalanceForFee(baseAddress, actualGasUnits);\n\n    const requiredFee = this.calculateFee(feeEstimateData, actualGasUnits);\n\n    // create the final recipients with the fee deducted\n    recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: balance.minus(requiredFee).toString(),\n      },\n    ];\n\n    txBuilder.recipients(recipients);\n    txBuilder.gas(actualGasUnits.toNumber());\n\n    tx = (await txBuilder.build()) as Transaction;\n\n    return tx;\n  }\n}\n"]}