@bitgo-beta/sdk-coin-trx 1.0.2-beta.20 → 1.0.2-beta.2000

package/dist/src/trx.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -11,31 +15,54 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Trx = exports.NodeTypes = exports.MINIMUM_TRON_MSIG_TRANSACTION_FEE = void 0;
+exports.Trx = exports.NodeTypes = exports.DEFAULT_SCAN_FACTOR = exports.RECOVER_TRANSACTION_EXPIRY = exports.SAFE_TRON_TOKEN_TRANSACTION_FEE = exports.SAFE_TRON_TRANSACTION_FEE = exports.MINIMUM_TRON_MSIG_TRANSACTION_FEE = void 0;
 /**
  * @prettier
  */
 const secp256k1 = __importStar(require("secp256k1"));
 const crypto_1 = require("crypto");
-const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
 const request = __importStar(require("superagent"));
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
 const lib_1 = require("./lib");
 const builder_1 = require("./lib/builder");
+const lodash_1 = require("lodash");
 exports.MINIMUM_TRON_MSIG_TRANSACTION_FEE = 1e6;
+exports.SAFE_TRON_TRANSACTION_FEE = 2.1 * 1e6; // TRON foundation recommends 2.1 TRX as fees for guaranteed transaction
+exports.SAFE_TRON_TOKEN_TRANSACTION_FEE = 100 * 1e6; // TRON foundation recommends 100 TRX as fees for guaranteed transaction
+exports.RECOVER_TRANSACTION_EXPIRY = 86400000; // 24 hour
+exports.DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds
 var NodeTypes;
 (function (NodeTypes) {
     NodeTypes[NodeTypes["Full"] = 0] = "Full";
     NodeTypes[NodeTypes["Solidity"] = 1] = "Solidity";
-})(NodeTypes = exports.NodeTypes || (exports.NodeTypes = {}));
+})(NodeTypes || (exports.NodeTypes = NodeTypes = {}));
+function isTrxVerifyAddressOptions(params) {
+    return ('index' in params ||
+        'chain' in params ||
+        ('coinSpecific' in params &&
+            params.coinSpecific !== undefined &&
+            ('index' in params.coinSpecific || 'chain' in params.coinSpecific)));
+}
 class Trx extends sdk_core_1.BaseCoin {
     constructor(bitgo, staticsCoin) {
         super(bitgo);
@@ -60,6 +87,22 @@ class Trx extends sdk_core_1.BaseCoin {
     transactionDataAllowed() {
         return true;
     }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.onchain;
+    }
+    /** @inheritDoc */
+    supportsTss() {
+        return true;
+    }
+    /** @inheritDoc */
+    getMPCAlgorithm() {
+        return 'ecdsa';
+    }
+    /** @inheritDoc */
+    getHashFunction() {
+        return (0, crypto_1.createHash)('sha256');
+    }
     static createInstance(bitgo, staticsCoin) {
         return new Trx(bitgo, staticsCoin);
     }
@@ -70,22 +113,30 @@ class Trx extends sdk_core_1.BaseCoin {
     valuelessTransferAllowed() {
         return true;
     }
+    /** @inheritDoc */
+    allowsAccountConsolidations() {
+        return true;
+    }
+    /** @inheritDoc */
+    supportsResourceDelegation() {
+        return true;
+    }
     /**
-     * Checks if this is a valid base58 or hex address
+     * Checks if this is a valid base58
      * @param address
      */
     isValidAddress(address) {
         if (!address) {
             return false;
         }
-        return this.isValidHexAddress(address) || lib_1.Utils.isBase58Address(address);
+        return lib_1.Utils.isBase58Address(address);
     }
     /**
      * Checks if this is a valid hex address
      * @param address hex address
      */
     isValidHexAddress(address) {
-        return address.length === 42 && /^(0x)?([0-9a-f]{2})+$/i.test(address);
+        return /^41[0-9a-f]{40}$/i.test(address);
     }
     /**
      * Generate ed25519 key pair
@@ -98,9 +149,9 @@ class Trx extends sdk_core_1.BaseCoin {
         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 = crypto_1.randomBytes(512 / 8);
+            seed = (0, crypto_1.randomBytes)(512 / 8);
         }
-        const hd = utxo_lib_1.bip32.fromSeed(seed);
+        const hd = secp256k1_1.bip32.fromSeed(seed);
         return {
             pub: hd.neutered().toBase58(),
             prv: hd.toBase58(),
@@ -108,7 +159,7 @@ class Trx extends sdk_core_1.BaseCoin {
     }
     isValidXpub(xpub) {
         try {
-            return utxo_lib_1.bip32.fromBase58(xpub).isNeutered();
+            return secp256k1_1.bip32.fromBase58(xpub).isNeutered();
         }
         catch (e) {
             return false;
@@ -124,24 +175,212 @@ class Trx extends sdk_core_1.BaseCoin {
     async parseTransaction(params) {
         return {};
     }
-    isWalletAddress(params) {
-        throw new sdk_core_1.MethodNotImplementedError();
+    async isWalletAddress(params) {
+        const { address, keychains } = params;
+        if ((0, sdk_core_1.isTssVerifyAddressOptions)(params)) {
+            return (0, sdk_core_1.verifyMPCWalletAddress)({ ...params, keyCurve: 'secp256k1' }, this.isValidAddress.bind(this), (pubKey) => new lib_1.KeyPair({ pub: pubKey }).getAddress());
+        }
+        if (!isTrxVerifyAddressOptions(params)) {
+            throw new Error('Invalid or missing index for address verification');
+        }
+        const rawIndex = params.index ?? params.coinSpecific?.index;
+        const index = Number(rawIndex);
+        if (isNaN(index)) {
+            throw new Error('Invalid index. index must be a number.');
+        }
+        const chain = Number(params.chain ?? params.coinSpecific?.chain ?? 0);
+        if (!this.isValidAddress(address)) {
+            throw new Error(`Invalid address: ${address}`);
+        }
+        // Root address verification (Index 0)
+        if (index === 0) {
+            const bitgoPub = keychains && keychains.length > sdk_core_1.KeyIndices.BITGO ? keychains[sdk_core_1.KeyIndices.BITGO].pub : undefined;
+            if (!bitgoPub) {
+                throw new Error('BitGo public key required for root address verification');
+            }
+            return this.verifyRootAddress(address, bitgoPub);
+        }
+        // Receive address verification (Index > 0)
+        if (index > 0) {
+            const userPub = keychains && keychains.length > sdk_core_1.KeyIndices.USER ? keychains[sdk_core_1.KeyIndices.USER].pub : undefined;
+            if (!userPub) {
+                throw new Error('User public key required for receive address verification');
+            }
+            return this.verifyReceiveAddress(address, userPub, index, chain);
+        }
+        throw new Error('Invalid index for address verification');
+    }
+    /**
+     * Cryptographically verify that an address is the root address derived from BitGo's public key
+     */
+    verifyRootAddress(address, bitgoPub) {
+        if (!this.isValidXpub(bitgoPub)) {
+            throw new Error('Invalid bitgo public key');
+        }
+        const uncompressedPub = this.xpubToUncompressedPub(bitgoPub);
+        const byteArrayAddr = lib_1.Utils.getByteArrayFromHexAddress(uncompressedPub);
+        const rawAddress = lib_1.Utils.getRawAddressFromPubKey(byteArrayAddr);
+        const derivedAddress = lib_1.Utils.getBase58AddressFromByteArray(rawAddress);
+        return derivedAddress === address;
+    }
+    /**
+     * Cryptographically verify that an address is a receive address derived from user's key
+     */
+    verifyReceiveAddress(address, userPub, index, chain) {
+        if (!this.isValidXpub(userPub)) {
+            throw new Error('Invalid user public key');
+        }
+        const derivationPath = `0/0/${chain}/${index}`;
+        const parentKey = secp256k1_1.bip32.fromBase58(userPub);
+        const childKey = parentKey.derivePath(derivationPath);
+        const derivedPubKeyHex = childKey.publicKey.toString('hex');
+        const keypair = new lib_1.KeyPair({ pub: derivedPubKeyHex });
+        const derivedAddress = keypair.getAddress();
+        return derivedAddress === address;
     }
     async verifyTransaction(params) {
+        const { txParams, txPrebuild, walletType } = params;
+        if (!txParams) {
+            throw new Error('missing txParams');
+        }
+        if (!txPrebuild) {
+            throw new Error('missing txPrebuild');
+        }
+        if (!txPrebuild.txHex) {
+            throw new Error('missing txHex in txPrebuild');
+        }
+        if (walletType === 'tss') {
+            // For TSS wallets, verifyTransaction is called from two places:
+            // 1. prebuildAndSignTransaction (wallet.ts) — txHex is serializedTxHex, a full JSON string
+            //    containing { txID, raw_data, raw_data_hex }.
+            // 2. ECDSA signing flow (ecdsa.ts) — txHex is signableHex, the raw protobuf bytes (raw_data_hex).
+            // We need to extract the raw_data_hex in case 1 before decoding.
+            const rawDataHex = this.extractRawDataHex(txPrebuild.txHex);
+            const decodedTx = lib_1.Utils.decodeTransaction(rawDataHex);
+            // decodedTx uses a numeric enum for contract type (from protobuf decoding),
+            // unlike the multisig path which checks the string 'TransferContract' from node JSON.
+            if (decodedTx.contractType === lib_1.Enum.ContractType.Transfer) {
+                // For Transfer contracts, decoded contract is an array with one element.
+                // Addresses from decodeTransaction are already in base58 format (converted by decodeTransferContract).
+                if (!Array.isArray(decodedTx.contract) || decodedTx.contract.length !== 1) {
+                    throw new Error('Invalid Transfer contract structure.');
+                }
+                return this.validateTransferContract(decodedTx.contract[0], txParams, true);
+            }
+            if (decodedTx.contractType === lib_1.Enum.ContractType.TriggerSmartContract) {
+                // TRC20 token transfers (TriggerSmartContract) must be verified via TrxToken.verifyTransaction,
+                // not here. Fail closed to prevent unvalidated token transfers from being silently signed.
+                throw new Error('TriggerSmartContract verification is not supported by native TRX. ' +
+                    'TRC20 token transfers must be verified via TrxToken.verifyTransaction.');
+            }
+            return true;
+        }
+        // On-chain multisig path: txHex is a full transaction JSON string (with txID, raw_data, raw_data_hex).
+        // The builder parses this JSON and addresses remain in hex format from the node response.
+        const rawTx = txPrebuild.txHex;
+        const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(rawTx);
+        const tx = await txBuilder.build();
+        const txJson = tx.toJson();
+        if (!txJson.raw_data || !txJson.raw_data.contract || txJson.raw_data.contract.length !== 1) {
+            throw new Error('Number of contracts is greater than 1.');
+        }
+        const contract = txJson.raw_data.contract[0];
+        if (contract.type === 'TransferContract') {
+            return this.validateTransferContract(contract, txParams);
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Extract the raw protobuf hex (raw_data_hex) from a TSS txHex.
+     *
+     * TSS verifyTransaction is called from two places:
+     *   1. prebuildAndSignTransaction — txHex is a full JSON string containing raw_data_hex.
+     *   2. ECDSA signing flow — txHex is already the raw protobuf hex (raw_data_hex).
+     *
+     * This helper handles both formats so callers don't duplicate the try/catch.
+     */
+    extractRawDataHex(txHex) {
+        try {
+            return JSON.parse(txHex).raw_data_hex;
+        }
+        catch {
+            console.debug(`Could not parse txHex as JSON for coin ${this.getChain()}, using txHex directly`);
+            return txHex;
+        }
+    }
+    /**
+     * Validate Transfer contract (native TRX transfer).
+     * Shared by both on-chain multisig and TSS wallet verification paths.
+     *
+     * @param contract The contract object from the transaction
+     * @param txParams The original transaction parameters
+     * @param addressesInBase58 When true, addresses are already in base58 format (TSS path via protobuf decoding).
+     *   When false (default), addresses are in hex and need conversion (on-chain multisig path via builder JSON).
+     */
+    validateTransferContract(contract, txParams, addressesInBase58 = false) {
+        if (!('parameter' in contract) || !contract.parameter?.value) {
+            throw new Error('Invalid Transfer contract structure');
+        }
+        const value = contract.parameter.value;
+        // Validate amount
+        if (!value.amount || value.amount < 0) {
+            throw new Error('Invalid transfer amount');
+        }
+        // If txParams has recipients, validate against expected values
+        if (txParams.recipients && txParams.recipients.length === 1) {
+            const recipient = txParams.recipients[0];
+            const expectedAmount = recipient.amount.toString();
+            const expectedDestination = recipient.address;
+            const actualAmount = value.amount.toString();
+            const actualDestination = addressesInBase58 ? value.to_address : lib_1.Utils.getBase58AddressFromHex(value.to_address);
+            if (expectedAmount !== actualAmount) {
+                throw new Error('transaction amount in txPrebuild does not match the value given by client');
+            }
+            if (expectedDestination.toLowerCase() !== actualDestination.toLowerCase()) {
+                throw new Error('destination address does not match with the recipient address');
+            }
+        }
         return true;
     }
+    /** @inheritDoc */
+    async getSignablePayload(serializedTx) {
+        const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(serializedTx);
+        const rebuiltTransaction = await txBuilder.build();
+        return rebuiltTransaction.signablePayload;
+    }
+    /**
+     * Derive a user key using the chain path of the address
+     * @param key
+     * @param path
+     * @returns {string} derived private key
+     */
+    deriveKeyWithPath({ key, path }) {
+        const keychain = secp256k1_1.bip32.fromBase58(key);
+        const derivedKeyNode = keychain.derivePath(path);
+        return derivedKeyNode.toBase58();
+    }
     /**
      * Assemble keychain and half-sign prebuilt transaction
      *
      * @param params
      * @param params.txPrebuild {Object} prebuild object returned by platform
      * @param params.prv {String} user prv
-     * @param params.wallet.addressVersion {String} this is the version of the Algorand multisig address generation format
      * @returns Bluebird<SignedTransaction>
      */
     async signTransaction(params) {
-        const txBuilder = builder_1.getBuilder(this.getChain()).from(params.txPrebuild.txHex);
-        txBuilder.sign({ key: params.prv });
+        const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(params.txPrebuild.txHex);
+        let key;
+        const { chain, index } = params.txPrebuild?.addressInfo ?? { chain: 0, index: 0 };
+        if (chain === 0 && index === 0) {
+            key = params.prv;
+        }
+        else {
+            const derivationPath = `0/0/${chain}/${index}`;
+            key = this.deriveKeyWithPath({ key: params.prv, path: derivationPath });
+        }
+        txBuilder.sign({ key });
         const transaction = await txBuilder.build();
         const response = {
             txHex: JSON.stringify(transaction.toJson()),
@@ -161,7 +400,7 @@ class Trx extends sdk_core_1.BaseCoin {
      */
     isValidXprv(prv) {
         try {
-            return !utxo_lib_1.bip32.fromBase58(prv).isNeutered();
+            return !secp256k1_1.bip32.fromBase58(prv).isNeutered();
         }
         catch {
             return false;
@@ -191,11 +430,10 @@ class Trx extends sdk_core_1.BaseCoin {
      * @param message
      */
     async signMessage(key, message) {
-        var _a;
         const toSign = this.toHexString(message);
         let prv = key.prv;
         if (this.isValidXprv(prv)) {
-            prv = (_a = utxo_lib_1.bip32.fromBase58(prv).privateKey) === null || _a === void 0 ? void 0 : _a.toString('hex');
+            prv = secp256k1_1.bip32.fromBase58(prv).privateKey?.toString('hex');
         }
         if (!prv) {
             throw new Error('no privateKey');
@@ -213,7 +451,7 @@ class Trx extends sdk_core_1.BaseCoin {
         if (!this.isValidXpub(xpub)) {
             throw new Error('invalid xpub');
         }
-        const publicKey = utxo_lib_1.bip32.fromBase58(xpub, utxo_lib_1.networks.bitcoin).publicKey;
+        const publicKey = secp256k1_1.bip32.fromBase58(xpub).publicKey;
         return Buffer.from(secp256k1.publicKeyConvert(publicKey, false /* compressed */)).toString('hex');
     }
     /**
@@ -234,29 +472,29 @@ class Trx extends sdk_core_1.BaseCoin {
         if (!this.isValidXprv(xprv)) {
             throw new Error('invalid xprv');
         }
-        const hdNode = utxo_lib_1.bip32.fromBase58(xprv, utxo_lib_1.networks.bitcoin);
+        const hdNode = secp256k1_1.bip32.fromBase58(xprv);
         if (!hdNode.privateKey) {
             throw new Error('no privateKey');
         }
         return hdNode.privateKey.toString('hex');
     }
+    getNodeUrl(node) {
+        switch (node) {
+            case NodeTypes.Full:
+                return sdk_core_1.common.Environments[this.bitgo.getEnv()].tronNodes.full;
+            case NodeTypes.Solidity:
+                return sdk_core_1.common.Environments[this.bitgo.getEnv()].tronNodes.solidity;
+            default:
+                throw new Error('node type not found');
+        }
+    }
     /**
      * Make a query to Trongrid for information such as balance, token balance, solidity calls
      * @param query {Object} key-value pairs of parameters to append after /api
      * @returns {Object} response from Trongrid
      */
     async recoveryPost(query) {
-        let nodeUri = '';
-        switch (query.node) {
-            case NodeTypes.Full:
-                nodeUri = sdk_core_1.common.Environments[this.bitgo.getEnv()].tronNodes.full;
-                break;
-            case NodeTypes.Solidity:
-                nodeUri = sdk_core_1.common.Environments[this.bitgo.getEnv()].tronNodes.solidity;
-                break;
-            default:
-                throw new Error('node type not found');
-        }
+        const nodeUri = this.getNodeUrl(query.node);
         const response = await request
             .post(nodeUri + query.path)
             .type('json')
@@ -267,16 +505,33 @@ class Trx extends sdk_core_1.BaseCoin {
         // unfortunately, it doesn't look like most TRON nodes return valid json as body
         return JSON.parse(response.text);
     }
+    /**
+     * Make a query to Trongrid for information such as balance, token balance, solidity calls
+     * @param query {Object} key-value pairs of parameters to append after /api
+     * @returns {Object} response from Trongrid
+     */
+    async recoveryGet(query) {
+        const nodeUri = this.getNodeUrl(query.node);
+        const response = await request
+            .get(nodeUri + query.path)
+            .type('json')
+            .send(query.jsonObj);
+        if (!response.ok) {
+            throw new Error('could not reach Tron node');
+        }
+        // unfortunately, it doesn't look like most TRON nodes return valid json as body
+        return JSON.parse(response.text);
+    }
     /**
      * Query our explorer for the balance of an address
      * @param address {String} the address encoded in hex
      * @returns {BigNumber} address balance
      */
-    async getAccountFromNode(address) {
-        return await this.recoveryPost({
-            path: '/walletsolidity/getaccount',
-            jsonObj: { address },
-            node: NodeTypes.Solidity,
+    async getAccountBalancesFromNode(address) {
+        return await this.recoveryGet({
+            path: '/v1/accounts/' + address,
+            jsonObj: {},
+            node: NodeTypes.Full,
         });
     }
     /**
@@ -297,6 +552,29 @@ class Trx extends sdk_core_1.BaseCoin {
             node: NodeTypes.Full,
         });
     }
+    /**
+     * Retrieves our build transaction from a node.
+     * @param toAddr hex-encoded address
+     * @param fromAddr hex-encoded address
+     * @param amount
+     */
+    async getTriggerSmartContractTransaction(toAddr, fromAddr, amount, contractAddr) {
+        const functionSelector = 'transfer(address,uint256)';
+        const types = ['address', 'uint256'];
+        const values = [toAddr, amount];
+        const parameter = lib_1.Utils.encodeDataParams(types, values, '');
+        return await this.recoveryPost({
+            path: '/wallet/triggersmartcontract',
+            jsonObj: {
+                owner_address: fromAddr,
+                contract_address: contractAddr,
+                function_selector: functionSelector,
+                parameter: parameter,
+                fee_limit: 100000000,
+            },
+            node: NodeTypes.Full,
+        });
+    }
     /**
      * Throws an error if any keys in the ownerKeys collection don't match the keys array we pass
      * @param ownerKeys
@@ -314,67 +592,294 @@ class Trx extends sdk_core_1.BaseCoin {
             }
         });
     }
+    /**
+     * Format for offline vault signing
+     * @param {BaseTransaction} tx
+     * @param {number} fee
+     * @param {number} recoveryAmount
+     * @returns {RecoveryTransaction}
+     */
+    formatForOfflineVault(tx, fee, recoveryAmount, addressInfo) {
+        const txJSON = tx.toJson();
+        const format = {
+            txHex: JSON.stringify(txJSON),
+            recoveryAmount,
+            feeInfo: {
+                fee: `${fee}`,
+            },
+            tx: txJSON, // Leaving it as txJSON for backwards compatibility
+            coin: this.getChain(),
+        };
+        return addressInfo ? { ...format, addressInfo } : format;
+    }
     /**
      * Builds a funds recovery transaction without BitGo.
      * We need to do three queries during this:
      * 1) Node query - how much money is in the account
      * 2) Build transaction - build our transaction for the amount
      * 3) Send signed build - send our signed build to a public node
+     *
+     * Note 1: for base address recoveries, fund will be recovered to recovery destination if base address balance is
+     * more than 2.1 TRX for native TRX recovery and 100 TRX for token recover. For receive addresses, fund will be
+     * recovered to base address first then swept to base address(decided as the universal pattern in team meeting).
+     *
+     * Note 2: the function supports token sweep from base address.
+     * TODO: support token sweep from receive address.
+     *
      * @param params
      */
     async recover(params) {
-        const isKrsRecovery = sdk_core_1.getIsKrsRecovery(params);
-        const isUnsignedSweep = sdk_core_1.getIsUnsignedSweep(params);
+        const isKrsRecovery = (0, sdk_core_1.getIsKrsRecovery)(params);
+        const isUnsignedSweep = (0, sdk_core_1.getIsUnsignedSweep)(params);
         if (!this.isValidAddress(params.recoveryDestination)) {
             throw new Error('Invalid destination address!');
         }
+        let startIdx = params.startingScanIndex;
+        if ((0, lodash_1.isUndefined)(startIdx)) {
+            startIdx = 1;
+        }
+        else if (!(0, lodash_1.isInteger)(startIdx) || startIdx < 0) {
+            throw new Error('Invalid starting index to scan for addresses');
+        }
+        let numIteration = params.scan;
+        if ((0, lodash_1.isUndefined)(numIteration)) {
+            numIteration = 20;
+        }
+        else if (typeof numIteration === 'string') {
+            numIteration = parseInt(numIteration, 10);
+        }
+        if (!(0, lodash_1.isInteger)(numIteration) || numIteration <= 0) {
+            throw new Error('Invalid scanning factor');
+        }
         // get our user, backup keys
-        const keys = sdk_core_1.getBip32Keys(this.bitgo, params, { requireBitGoXpub: false });
+        const keys = (0, sdk_core_1.getBip32Keys)(this.bitgo, params, { requireBitGoXpub: false });
         // we need to decode our bitgoKey to a base58 address
         const bitgoHexAddr = this.pubToHexAddress(this.xpubToUncompressedPub(params.bitgoKey));
-        const recoveryAddressHex = lib_1.Utils.getHexAddressFromBase58Address(params.recoveryDestination);
-        // call the node to get our account balance
-        const account = await this.getAccountFromNode(bitgoHexAddr);
-        const recoveryAmount = account.balance;
-        const userXPub = keys[0].neutered().toBase58();
-        const userXPrv = keys[0].toBase58();
-        const backupXPub = keys[1].neutered().toBase58();
-        // construct the tx -
-        // there's an assumption here being made about fees: for a wallet that hasn't been used in awhile, the implication is
-        // it has maximum bandwidth. thus, a recovery should cost the minimum amount (1e6 sun or 1 Tron)
-        if (exports.MINIMUM_TRON_MSIG_TRANSACTION_FEE > recoveryAmount) {
-            throw new Error('Amount of funds to recover wouldnt be able to fund a send');
-        }
-        const recoveryAmountMinusFees = recoveryAmount - exports.MINIMUM_TRON_MSIG_TRANSACTION_FEE;
-        const buildTx = await this.getBuildTransaction(recoveryAddressHex, bitgoHexAddr, recoveryAmountMinusFees);
-        const keyHexAddresses = [
-            this.pubToHexAddress(this.xpubToUncompressedPub(userXPub)),
-            this.pubToHexAddress(this.xpubToUncompressedPub(backupXPub)),
-            bitgoHexAddr,
-        ];
-        // run checks to ensure this is a valid tx - permissions match our signer keys
-        this.checkPermissions(account.owner_permission.keys, keyHexAddresses);
-        this.checkPermissions(account.active_permission[0].keys, keyHexAddresses);
+        let recoveryFromAddrHex = bitgoHexAddr;
+        let recoveryToAddressHex = lib_1.Utils.getHexAddressFromBase58Address(params.recoveryDestination);
+        // call the node to get our account balance for base address
+        let account = await this.getAccountBalancesFromNode(lib_1.Utils.getBase58AddressFromHex(recoveryFromAddrHex));
+        let recoveryAmount = account.data[0].balance;
+        let userXPrv = keys[0].toBase58();
+        let isReceiveAddress = false;
+        let addressInfo;
+        const tokenContractAddr = params.tokenContractAddress;
+        // check for possible token recovery, recover the token provide by user
+        if (tokenContractAddr) {
+            let rawTokenTxn;
+            for (const token of account.data[0].trc20) {
+                if (token[tokenContractAddr]) {
+                    const amount = token[tokenContractAddr];
+                    const tokenContractAddrHex = lib_1.Utils.getHexAddressFromBase58Address(tokenContractAddr);
+                    rawTokenTxn = (await this.getTriggerSmartContractTransaction(recoveryToAddressHex, recoveryFromAddrHex, amount, tokenContractAddrHex)).transaction;
+                    recoveryAmount = parseInt(amount, 10);
+                    break;
+                }
+            }
+            // build and sign token txns
+            if (rawTokenTxn) {
+                // Check there is sufficient of the native asset to cover fees
+                const trxBalance = account.data[0].balance;
+                if (trxBalance < exports.SAFE_TRON_TOKEN_TRANSACTION_FEE) {
+                    throw new Error(`Amount of funds to recover ${trxBalance} is less than ${exports.SAFE_TRON_TOKEN_TRANSACTION_FEE} and wouldn't be able to fund a trc20 send`);
+                }
+                const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(rawTokenTxn);
+                // Default expiry is 1 minute which is too short for recovery purposes
+                // extend the expiry to 1 day
+                txBuilder.extendValidTo(exports.RECOVER_TRANSACTION_EXPIRY);
+                // this tx should be enough to drop into a node
+                if (isUnsignedSweep) {
+                    return this.formatForOfflineVault(await txBuilder.build(), exports.SAFE_TRON_TOKEN_TRANSACTION_FEE, recoveryAmount);
+                }
+                const userPrv = this.xprvToCompressedPrv(userXPrv);
+                txBuilder.sign({ key: userPrv });
+                // krs recoveries don't get signed
+                if (!isKrsRecovery && !isReceiveAddress) {
+                    const backupXPrv = keys[1].toBase58();
+                    const backupPrv = this.xprvToCompressedPrv(backupXPrv);
+                    txBuilder.sign({ key: backupPrv });
+                }
+                return this.formatForOfflineVault(await txBuilder.build(), exports.SAFE_TRON_TOKEN_TRANSACTION_FEE, recoveryAmount);
+            }
+            else {
+                throw Error('Not found token to recover, please check token balance');
+            }
+        }
+        // let us recover the native Tron
+        if (recoveryAmount > exports.SAFE_TRON_TRANSACTION_FEE) {
+            const userXPub = keys[0].neutered().toBase58();
+            const backupXPub = keys[1].neutered().toBase58();
+            // check multisig permissions
+            const keyHexAddresses = [
+                this.pubToHexAddress(this.xpubToUncompressedPub(userXPub)),
+                this.pubToHexAddress(this.xpubToUncompressedPub(backupXPub)),
+                bitgoHexAddr,
+            ];
+            // run checks to ensure this is a valid tx - permissions match our signer keys
+            const ownerKeys = [];
+            for (const key of account.data[0].owner_permission.keys) {
+                const address = lib_1.Utils.getHexAddressFromBase58Address(key.address);
+                const weight = key.weight;
+                ownerKeys.push({ address, weight });
+            }
+            const activePermissionKeys = [];
+            for (const key of account.data[0].active_permission[0].keys) {
+                const address = lib_1.Utils.getHexAddressFromBase58Address(key.address);
+                const weight = key.weight;
+                activePermissionKeys.push({ address, weight });
+            }
+            this.checkPermissions(ownerKeys, keyHexAddresses);
+            this.checkPermissions(activePermissionKeys, keyHexAddresses);
+        }
+        else {
+            // Check receive addresses for funds
+            // Check for first derived wallet with funds
+            // Receive addresses are derived from the user key
+            for (let i = startIdx; i < numIteration + startIdx; i++) {
+                const derivationPath = `0/0/0/${i}`;
+                const userKey = keys[0].derivePath(derivationPath);
+                const xpub = userKey.neutered();
+                const receiveAddress = this.pubToHexAddress(this.xpubToUncompressedPub(xpub.toBase58()));
+                const address = lib_1.Utils.getBase58AddressFromHex(receiveAddress);
+                // call the node to get our account balance
+                const accountInfo = await this.getAccountBalancesFromNode(address);
+                if (accountInfo.data[0] && accountInfo.data[0].balance > exports.SAFE_TRON_TRANSACTION_FEE) {
+                    account = accountInfo;
+                    recoveryAmount = accountInfo.data[0].balance;
+                    userXPrv = userKey.toBase58(); // assign derived userXPrx
+                    isReceiveAddress = true;
+                    recoveryFromAddrHex = receiveAddress;
+                    recoveryToAddressHex = bitgoHexAddr;
+                    addressInfo = {
+                        address,
+                        chain: 0,
+                        index: i,
+                    };
+                    break;
+                }
+            }
+        }
+        // a sweep potentially needs to pay for multi-sig transfer, destination account activation and bandwidth
+        // TRON foundation recommends 2.1 TRX for guaranteed confirmation
+        if (!recoveryAmount || exports.SAFE_TRON_TRANSACTION_FEE >= recoveryAmount) {
+            throw new Error(`Amount of funds to recover ${recoveryAmount} is less than ${exports.SAFE_TRON_TRANSACTION_FEE} and wouldn't be able to fund a send`);
+        }
+        const recoveryAmountMinusFees = recoveryAmount - exports.SAFE_TRON_TRANSACTION_FEE;
+        const buildTx = await this.getBuildTransaction(recoveryToAddressHex, recoveryFromAddrHex, recoveryAmountMinusFees);
         // construct our tx
-        const txBuilder = builder_1.getBuilder(this.getChain()).from(buildTx);
+        const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(buildTx);
+        // Default expiry is 1 minute which is too short for recovery purposes
+        // extend the expiry to 1 day
+        txBuilder.extendValidTo(exports.RECOVER_TRANSACTION_EXPIRY);
+        const tx = await txBuilder.build();
         // this tx should be enough to drop into a node
         if (isUnsignedSweep) {
-            return {
-                tx: (await txBuilder.build()).toJson(),
-                recoveryAmount: recoveryAmountMinusFees,
-            };
+            return this.formatForOfflineVault(tx, exports.SAFE_TRON_TRANSACTION_FEE, recoveryAmountMinusFees, addressInfo);
         }
         const userPrv = this.xprvToCompressedPrv(userXPrv);
         txBuilder.sign({ key: userPrv });
         // krs recoveries don't get signed
-        if (!isKrsRecovery) {
+        if (!isKrsRecovery && !isReceiveAddress) {
             const backupXPrv = keys[1].toBase58();
             const backupPrv = this.xprvToCompressedPrv(backupXPrv);
             txBuilder.sign({ key: backupPrv });
         }
+        const txSigned = await txBuilder.build();
+        return this.formatForOfflineVault(txSigned, exports.SAFE_TRON_TRANSACTION_FEE, recoveryAmountMinusFees, addressInfo);
+    }
+    /**
+     * Builds native TRX recoveries of receive addresses in batch without BitGo.
+     * Funds will be recovered to base address first. You need to initiate another sweep txn after that.
+     * Note: there will be another recoverTokenConsolidations function to support token recover from receive addresses.
+     *
+     * @param {ConsolidationRecoveryOptions} params - options for consolidation recovery.
+     * @param {string} [params.startingScanIndex] - receive address index to start scanning from. default to 1 (inclusive).
+     * @param {string} [params.endingScanIndex] - receive address index to end scanning at. default to startingScanIndex + 20 (exclusive).
+     */
+    async recoverConsolidations(params) {
+        const isUnsignedConsolidations = (0, sdk_core_1.getIsUnsignedSweep)(params);
+        const startIdx = params.startingScanIndex || 1;
+        const endIdx = params.endingScanIndex || startIdx + exports.DEFAULT_SCAN_FACTOR;
+        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 keys = (0, sdk_core_1.getBip32Keys)(this.bitgo, params, { requireBitGoXpub: false });
+        const baseAddrHex = this.pubToHexAddress(this.xpubToUncompressedPub(params.bitgoKey));
+        const txnsBatch = [];
+        for (let i = startIdx; i < endIdx; i++) {
+            const derivationPath = `0/0/0/${i}`;
+            const userKey = keys[0].derivePath(derivationPath);
+            const userKeyXPub = userKey.neutered();
+            const receiveAddressHex = this.pubToHexAddress(this.xpubToUncompressedPub(userKeyXPub.toBase58()));
+            const receiveAddress = lib_1.Utils.getBase58AddressFromHex(receiveAddressHex);
+            // call the node to get our account balance
+            const accountInfo = await this.getAccountBalancesFromNode(receiveAddress);
+            if (accountInfo.data[0] && accountInfo.data[0].balance > exports.SAFE_TRON_TRANSACTION_FEE) {
+                let recoveryAmount = 0;
+                // Tokens must be consolidate before the native asset. First construct token txns
+                let rawTokenTxn;
+                // check for possible token recovery, recover the token provide by user
+                if (params.tokenContractAddress) {
+                    if (accountInfo.data[0].balance > exports.SAFE_TRON_TOKEN_TRANSACTION_FEE && accountInfo.data[0].trc20[0]) {
+                        const tokenDataArray = accountInfo.data[0].trc20;
+                        for (const tokenData of tokenDataArray) {
+                            const contractAddress = Object.keys(tokenData);
+                            if (params.tokenContractAddress === contractAddress[0]) {
+                                const amount = tokenData[contractAddress[0]];
+                                const tokenContractAddrHex = lib_1.Utils.getHexAddressFromBase58Address(contractAddress[0]);
+                                rawTokenTxn = (await this.getTriggerSmartContractTransaction(baseAddrHex, receiveAddressHex, amount, tokenContractAddrHex)).transaction;
+                                recoveryAmount = parseInt(amount, 10);
+                                break;
+                            }
+                        }
+                    }
+                    // build and sign token txns
+                    if (rawTokenTxn) {
+                        const addressInfo = {
+                            address: receiveAddress,
+                            chain: 0,
+                            index: i,
+                        };
+                        const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(rawTokenTxn);
+                        // Default expiry is 1 minute which is too short for recovery purposes
+                        // extend the expiry to 1 day
+                        txBuilder.extendValidTo(exports.RECOVER_TRANSACTION_EXPIRY);
+                        // this tx should be enough to drop into a node
+                        if (!isUnsignedConsolidations) {
+                            const userPrv = this.xprvToCompressedPrv(userKey.toBase58());
+                            // receive address only needs to be signed by user key
+                            txBuilder.sign({ key: userPrv });
+                        }
+                        const tx = await txBuilder.build();
+                        txnsBatch.push(this.formatForOfflineVault(tx, exports.SAFE_TRON_TOKEN_TRANSACTION_FEE, recoveryAmount, addressInfo));
+                    }
+                }
+                else {
+                    const addressBalance = accountInfo.data[0].balance;
+                    const addressInfo = {
+                        address: receiveAddress,
+                        chain: 0,
+                        index: i,
+                    };
+                    const recoveryAmount = addressBalance - exports.SAFE_TRON_TRANSACTION_FEE;
+                    const buildTx = await this.getBuildTransaction(baseAddrHex, receiveAddressHex, recoveryAmount);
+                    // construct our tx
+                    const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(buildTx);
+                    // Default expiry is 1 minute which is too short for recovery purposes
+                    // extend the expiry to 1 day
+                    txBuilder.extendValidTo(exports.RECOVER_TRANSACTION_EXPIRY);
+                    if (!isUnsignedConsolidations) {
+                        const userPrv = this.xprvToCompressedPrv(userKey.toBase58());
+                        // receive address only needs to be signed by user key
+                        txBuilder.sign({ key: userPrv });
+                    }
+                    const tx = await txBuilder.build();
+                    txnsBatch.push(this.formatForOfflineVault(tx, exports.SAFE_TRON_TRANSACTION_FEE, recoveryAmount, addressInfo));
+                }
+            }
+        }
         return {
-            tx: (await txBuilder.build()).toJson(),
-            recoveryAmount: recoveryAmountMinusFees,
+            transactions: txnsBatch,
         };
     }
     /**
@@ -386,7 +891,7 @@ class Trx extends sdk_core_1.BaseCoin {
         if (!txHex || !params.feeInfo) {
             throw new Error('missing explain tx parameters');
         }
-        const txBuilder = builder_1.getBuilder(this.getChain()).from(txHex);
+        const txBuilder = (0, builder_1.getBuilder)(this.getChain()).from(txHex);
         const tx = await txBuilder.build();
         const outputs = [
             {
@@ -409,13 +914,22 @@ class Trx extends sdk_core_1.BaseCoin {
             id: tx.id,
             outputs,
             outputAmount: outputs[0].amount,
-            changeOutputs: [],
-            changeAmount: '0',
+            changeOutputs: [], // account based does not use change outputs
+            changeAmount: '0', // account base does not make change
             fee: params.feeInfo,
             timestamp: tx.validFrom,
             expiration: tx.validTo,
         };
     }
+    /** @inheritDoc */
+    auditDecryptedKey({ multiSigType, publicKey, prv }) {
+        if (multiSigType === 'tss') {
+            (0, sdk_lib_mpc_1.auditEcdsaPrivateKey)(prv, publicKey);
+        }
+        else {
+            throw new sdk_core_1.MethodNotImplementedError();
+        }
+    }
 }
 exports.Trx = Trx;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trx.js","sourceRoot":"","sources":["../../src/trx.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,qDAAuC;AACvC,mCAAqC;AAErC,mDAAuD;AACvD,oDAAsC;AACtC,mDAmB8B;AAC9B,+BAAyD;AACzD,2CAA2C;AAE9B,QAAA,iCAAiC,GAAG,GAAG,CAAC;AA8CrD,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,iDAAQ,CAAA;AACV,CAAC,EAHW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAGpB;AAcD,MAAa,GAAI,SAAQ,mBAAQ;IAG/B,YAAY,KAAgB,EAAE,WAAuC;QACnE,KAAK,CAAC,KAAK,CAAC,CAAC;QAEb,IAAI,CAAC,WAAW,EAAE;YAChB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;SACvE;QAED,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;IAChC,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;IAClC,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;IACpC,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC;IAED,kBAAkB;IAClB,sBAAsB;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,KAAgB,EAAE,WAAuC;QAC7E,OAAO,IAAI,GAAG,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,wBAAwB;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,OAAe;QAC5B,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,KAAK,CAAC;SACd;QACD,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,WAAK,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IAC3E,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,OAAe;QAC/B,OAAO,OAAO,CAAC,MAAM,KAAK,EAAE,IAAI,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzE,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,IAAa;QAC3B,4DAA4D;QAC5D,IAAI,CAAC,IAAI,EAAE;YACT,gHAAgH;YAChH,oGAAoG;YACpG,IAAI,GAAG,oBAAW,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;SAC7B;QACD,MAAM,EAAE,GAAG,gBAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAChC,OAAO;YACL,GAAG,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;YAC7B,GAAG,EAAE,EAAE,CAAC,QAAQ,EAAE;SACnB,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,IAAY;QACtB,IAAI;YACF,OAAO,gBAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC;SAC5C;QAAC,OAAO,CAAC,EAAE;YACV,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED,UAAU,CAAC,GAAW;QACpB,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE;YACzB,6EAA6E;YAC7E,OAAO,IAAI,CAAC;SACb;QACD,OAAO,IAAI,MAAM,CAAC,sBAAsB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,MAA+B;QACpD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe,CAAC,MAA4B;QAC1C,MAAM,IAAI,oCAAyB,EAAE,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,MAAgC;QACtD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,eAAe,CAAC,MAAkC;QACtD,MAAM,SAAS,GAAG,oBAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC5E,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;QACpC,MAAM,WAAW,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QAC5C,MAAM,QAAQ,GAAG;YACf,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC;SAC5C,CAAC;QACF,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,EAAE;YAC9C,OAAO,QAAQ,CAAC;SACjB;QACD,0BAA0B;QAC1B,OAAO;YACL,UAAU,EAAE,QAAQ;SACrB,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,GAAW;QACrB,IAAI;YACF,OAAO,CAAC,gBAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC;SAC5C;QAAC,MAAM;YACN,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,OAAwB;QAClC,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YAC/B,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SAC7C;aAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;YACnC,OAAO,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SAChC;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;SAC3D;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,WAAW,CAAC,GAAY,EAAE,OAAwB;;QACtD,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAEzC,IAAI,GAAG,GAAuB,GAAG,CAAC,GAAG,CAAC;QACtC,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE;YACzB,GAAG,GAAG,MAAA,gBAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,UAAU,0CAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;SACzD;QAED,IAAI,CAAC,GAAG,EAAE;YACR,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;SAClC;QACD,IAAI,GAAG,GAAG,WAAK,CAAC,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QAE9C,0BAA0B;QAC1B,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAE7B,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,qBAAqB,CAAC,IAAY;QAChC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;SACjC;QAED,MAAM,SAAS,GAAG,gBAAK,CAAC,UAAU,CAAC,IAAI,EAAE,mBAAQ,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC;QACrE,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpG,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,sBAAsB,CAAC,WAAgB;QAC3C,IAAI,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,WAAW,CAAC,QAAQ,EAAE;YAC1D,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;SAC3D;IACH,CAAC;IAED,eAAe,CAAC,GAAW;QACzB,MAAM,aAAa,GAAG,WAAK,CAAC,0BAA0B,CAAC,GAAG,CAAC,CAAC;QAC5D,MAAM,UAAU,GAAG,WAAK,CAAC,uBAAuB,CAAC,aAAa,CAAC,CAAC;QAChE,OAAO,WAAK,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IAED,mBAAmB,CAAC,IAAY;QAC9B,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;SACjC;QAED,MAAM,MAAM,GAAG,gBAAK,CAAC,UAAU,CAAC,IAAI,EAAE,mBAAQ,CAAC,OAAO,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;YACtB,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;SAClC;QACD,OAAO,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,YAAY,CAAC,KAAsD;QAC/E,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,QAAQ,KAAK,CAAC,IAAI,EAAE;YAClB,KAAK,SAAS,CAAC,IAAI;gBACjB,OAAO,GAAG,iBAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC;gBAClE,MAAM;YACR,KAAK,SAAS,CAAC,QAAQ;gBACrB,OAAO,GAAG,iBAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC;gBACtE,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;SAC1C;QAED,MAAM,QAAQ,GAAG,MAAM,OAAO;aAC3B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC;aAC1B,IAAI,CAAC,MAAM,CAAC;aACZ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEvB,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE;YAChB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;SAC9C;QAED,gFAAgF;QAChF,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,kBAAkB,CAAC,OAAe;QAC9C,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC;YAC7B,IAAI,EAAE,4BAA4B;YAClC,OAAO,EAAE,EAAE,OAAO,EAAE;YACpB,IAAI,EAAE,SAAS,CAAC,QAAQ;SACzB,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,mBAAmB,CAC/B,MAAc,EACd,QAAgB,EAChB,MAAc;QAEd,8DAA8D;QAC9D,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC;YAC7B,IAAI,EAAE,2BAA2B;YACjC,OAAO,EAAE;gBACP,UAAU,EAAE,MAAM;gBAClB,aAAa,EAAE,QAAQ;gBACvB,MAAM;aACP;YACD,IAAI,EAAE,SAAS,CAAC,IAAI;SACrB,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,SAAgD,EAAE,IAAc;QAC/E,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QAExC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YACpB,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;gBAC1B,MAAM,IAAI,KAAK,CAAC,eAAe,MAAM,uBAAuB,CAAC,CAAC;aAC/D;YAED,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;gBACpB,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;aACnE;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,OAAO,CAAC,MAAuB;QACnC,MAAM,aAAa,GAAG,2BAAgB,CAAC,MAAM,CAAC,CAAC;QAC/C,MAAM,eAAe,GAAG,6BAAkB,CAAC,MAAM,CAAC,CAAC;QAEnD,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,mBAAmB,CAAC,EAAE;YACpD,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;SACjD;QAED,4BAA4B;QAC5B,MAAM,IAAI,GAAG,uBAAY,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,CAAC;QAE3E,qDAAqD;QACrD,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QACvF,MAAM,kBAAkB,GAAG,WAAK,CAAC,8BAA8B,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;QAE5F,2CAA2C;QAC3C,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;QAC5D,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;QAEvC,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;QACpC,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC;QAEjD,qBAAqB;QACrB,qHAAqH;QACrH,gGAAgG;QAChG,IAAI,yCAAiC,GAAG,cAAc,EAAE;YACtD,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;SAC9E;QACD,MAAM,uBAAuB,GAAG,cAAc,GAAG,yCAAiC,CAAC;QACnF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,YAAY,EAAE,uBAAuB,CAAC,CAAC;QAE1G,MAAM,eAAe,GAAG;YACtB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;YAC1D,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;YAC5D,YAAY;SACb,CAAC;QAEF,8EAA8E;QAC9E,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QACtE,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAE1E,mBAAmB;QACnB,MAAM,SAAS,GAAI,oBAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhF,+CAA+C;QAC/C,IAAI,eAAe,EAAE;YACnB,OAAO;gBACL,EAAE,EAAE,CAAC,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;gBACtC,cAAc,EAAE,uBAAuB;aACxC,CAAC;SACH;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;QAEnD,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;QAEjC,kCAAkC;QAClC,IAAI,CAAC,aAAa,EAAE;YAClB,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YACtC,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;YAEvD,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC;SACpC;QAED,OAAO;YACL,EAAE,EAAE,CAAC,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;YACtC,cAAc,EAAE,uBAAuB;SACxC,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,kBAAkB,CAAC,MAAiC;QACxD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7E,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;SAClD;QACD,MAAM,SAAS,GAAG,oBAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1D,MAAM,EAAE,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QACnC,MAAM,OAAO,GAAG;YACd;gBACE,MAAM,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE;gBACtC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,oDAAoD;aACrF;SACF,CAAC;QAEF,MAAM,YAAY,GAAG;YACnB,IAAI;YACJ,cAAc;YACd,cAAc;YACd,SAAS;YACT,eAAe;YACf,KAAK;YACL,WAAW;YACX,YAAY;SACb,CAAC;QAEF,OAAO;YACL,YAAY;YACZ,EAAE,EAAE,EAAE,CAAC,EAAE;YACT,OAAO;YACP,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM;YAC/B,aAAa,EAAE,EAAE;YACjB,YAAY,EAAE,GAAG;YACjB,GAAG,EAAE,MAAM,CAAC,OAAO;YACnB,SAAS,EAAE,EAAE,CAAC,SAAS;YACvB,UAAU,EAAE,EAAE,CAAC,OAAO;SACvB,CAAC;IACJ,CAAC;CACF;AAxbD,kBAwbC","sourcesContent":["/**\n * @prettier\n */\nimport * as secp256k1 from 'secp256k1';\nimport { randomBytes } from 'crypto';\nimport { CoinFamily, BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';\nimport { bip32, networks } from '@bitgo-beta/utxo-lib';\nimport * as request from 'superagent';\nimport {\n  BaseCoin,\n  BitGoBase,\n  common,\n  getBip32Keys,\n  getIsKrsRecovery,\n  getIsUnsignedSweep,\n  KeyPair,\n  MethodNotImplementedError,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SignTransactionOptions,\n  TransactionExplanation,\n  TransactionFee,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  TransactionRecipient as Recipient,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n} from '@bitgo-beta/sdk-core';\nimport { Interface, Utils, WrappedBuilder } from './lib';\nimport { getBuilder } from './lib/builder';\n\nexport const MINIMUM_TRON_MSIG_TRANSACTION_FEE = 1e6;\n\nexport interface TronSignTransactionOptions extends SignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string;\n}\n\nexport interface TxInfo {\n  recipients: Recipient[];\n  from: string;\n  txid: string;\n}\n\nexport interface TronTransactionExplanation extends TransactionExplanation {\n  expiration: number;\n  timestamp: number;\n}\n\nexport interface TransactionPrebuild extends BaseTransactionPrebuild {\n  txHex: string;\n  txInfo: TxInfo;\n  feeInfo: TransactionFee;\n}\n\nexport interface ExplainTransactionOptions {\n  txHex?: string; // txHex is poorly named here; it is just a wrapped JSON object\n  halfSigned?: {\n    txHex: string; // txHex is poorly named here; it is just a wrapped JSON object\n  };\n  feeInfo: TransactionFee;\n}\n\nexport interface RecoveryOptions {\n  userKey: string; // Box A\n  backupKey: string; // Box B\n  bitgoKey: string; // Box C - this is bitgo's xpub and will be used to derive their root address\n  recoveryDestination: string; // base58 address\n  krsProvider?: string;\n  walletPassphrase?: string;\n}\n\nexport interface RecoveryTransaction {\n  tx: TransactionPrebuild;\n  recoveryAmount: number;\n}\n\nexport enum NodeTypes {\n  Full,\n  Solidity,\n}\n\n/**\n * This structure is not a complete model of the AccountResponse from a node.\n */\nexport interface AccountResponse {\n  address: string;\n  balance: number;\n  owner_permission: {\n    keys: [Interface.PermissionKey];\n  };\n  active_permission: [{ keys: [Interface.PermissionKey] }];\n}\n\nexport class Trx extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  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  getChain() {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName() {\n    return this._staticsCoin.fullName;\n  }\n\n  getBaseFactor() {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  /** @inheritdoc */\n  transactionDataAllowed() {\n    return true;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Trx(bitgo, staticsCoin);\n  }\n\n  /**\n   * Flag for sending value of 0\n   * @returns {boolean} True if okay to send 0 value, false otherwise\n   */\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /**\n   * Checks if this is a valid base58 or hex address\n   * @param address\n   */\n  isValidAddress(address: string): boolean {\n    if (!address) {\n      return false;\n    }\n    return this.isValidHexAddress(address) || Utils.isBase58Address(address);\n  }\n\n  /**\n   * Checks if this is a valid hex address\n   * @param address hex address\n   */\n  isValidHexAddress(address: string): boolean {\n    return address.length === 42 && /^(0x)?([0-9a-f]{2})+$/i.test(address);\n  }\n\n  /**\n   * Generate ed25519 key pair\n   *\n   * @param seed\n   * @returns {Object} object with generated pub, prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    // TODO: move this and address creation logic to account-lib\n    if (!seed) {\n      // An extended private key has both a normal 256 bit private key and a 256 bit chain code, both of which must be\n      // random. 512 bits is therefore the maximum entropy and gives us maximum security against cracking.\n      seed = randomBytes(512 / 8);\n    }\n    const hd = bip32.fromSeed(seed);\n    return {\n      pub: hd.neutered().toBase58(),\n      prv: hd.toBase58(),\n    };\n  }\n\n  isValidXpub(xpub: string): boolean {\n    try {\n      return bip32.fromBase58(xpub).isNeutered();\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidPub(pub: string): boolean {\n    if (this.isValidXpub(pub)) {\n      // xpubs can be converted into regular pubs, so technically it is a valid pub\n      return true;\n    }\n    return new RegExp('^04[a-zA-Z0-9]{128}$').test(pub);\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  isWalletAddress(params: VerifyAddressOptions): boolean {\n    throw new MethodNotImplementedError();\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    return true;\n  }\n\n  /**\n   * Assemble keychain and half-sign prebuilt transaction\n   *\n   * @param params\n   * @param params.txPrebuild {Object} prebuild object returned by platform\n   * @param params.prv {String} user prv\n   * @param params.wallet.addressVersion {String} this is the version of the Algorand multisig address generation format\n   * @returns Bluebird<SignedTransaction>\n   */\n  async signTransaction(params: TronSignTransactionOptions): Promise<SignedTransaction> {\n    const txBuilder = getBuilder(this.getChain()).from(params.txPrebuild.txHex);\n    txBuilder.sign({ key: params.prv });\n    const transaction = await txBuilder.build();\n    const response = {\n      txHex: JSON.stringify(transaction.toJson()),\n    };\n    if (transaction.toJson().signature.length >= 2) {\n      return response;\n    }\n    // Half signed transaction\n    return {\n      halfSigned: response,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid seed for the coin\n   *\n   * @param prv - the prv to be checked\n   */\n  isValidXprv(prv: string): boolean {\n    try {\n      return !bip32.fromBase58(prv).isNeutered();\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Convert a message to string in hexadecimal format.\n   *\n   * @param message {Buffer|String} message to sign\n   * @return the message as a hexadecimal string\n   */\n  toHexString(message: string | Buffer): string {\n    if (typeof message === 'string') {\n      return Buffer.from(message).toString('hex');\n    } else if (Buffer.isBuffer(message)) {\n      return message.toString('hex');\n    } else {\n      throw new Error('Invalid messaged passed to signMessage');\n    }\n  }\n\n  /**\n   * Sign message with private key\n   *\n   * @param key\n   * @param message\n   */\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const toSign = this.toHexString(message);\n\n    let prv: string | undefined = key.prv;\n    if (this.isValidXprv(prv)) {\n      prv = bip32.fromBase58(prv).privateKey?.toString('hex');\n    }\n\n    if (!prv) {\n      throw new Error('no privateKey');\n    }\n    let sig = Utils.signString(toSign, prv, true);\n\n    // remove the preceding 0x\n    sig = sig.replace(/^0x/, '');\n\n    return Buffer.from(sig, 'hex');\n  }\n\n  /**\n   * Converts an xpub to a uncompressed pub\n   * @param xpub\n   */\n  xpubToUncompressedPub(xpub: string): string {\n    if (!this.isValidXpub(xpub)) {\n      throw new Error('invalid xpub');\n    }\n\n    const publicKey = bip32.fromBase58(xpub, networks.bitcoin).publicKey;\n    return Buffer.from(secp256k1.publicKeyConvert(publicKey, false /* compressed */)).toString('hex');\n  }\n\n  /**\n   * Modify prebuild before sending it to the server.\n   * @param buildParams The whitelisted parameters for this prebuild\n   */\n  async getExtraPrebuildParams(buildParams: any): Promise<any> {\n    if (buildParams.recipients[0].data && buildParams.feeLimit) {\n      buildParams.recipients[0].feeLimit = buildParams.feeLimit;\n    }\n  }\n\n  pubToHexAddress(pub: string): string {\n    const byteArrayAddr = Utils.getByteArrayFromHexAddress(pub);\n    const rawAddress = Utils.getRawAddressFromPubKey(byteArrayAddr);\n    return Utils.getHexAddressFromByteArray(rawAddress);\n  }\n\n  xprvToCompressedPrv(xprv: string): string {\n    if (!this.isValidXprv(xprv)) {\n      throw new Error('invalid xprv');\n    }\n\n    const hdNode = bip32.fromBase58(xprv, networks.bitcoin);\n    if (!hdNode.privateKey) {\n      throw new Error('no privateKey');\n    }\n    return hdNode.privateKey.toString('hex');\n  }\n\n  /**\n   * Make a query to Trongrid for information such as balance, token balance, solidity calls\n   * @param query {Object} key-value pairs of parameters to append after /api\n   * @returns {Object} response from Trongrid\n   */\n  private async recoveryPost(query: { path: string; jsonObj: any; node: NodeTypes }): Promise<any> {\n    let nodeUri = '';\n    switch (query.node) {\n      case NodeTypes.Full:\n        nodeUri = common.Environments[this.bitgo.getEnv()].tronNodes.full;\n        break;\n      case NodeTypes.Solidity:\n        nodeUri = common.Environments[this.bitgo.getEnv()].tronNodes.solidity;\n        break;\n      default:\n        throw new Error('node type not found');\n    }\n\n    const response = await request\n      .post(nodeUri + query.path)\n      .type('json')\n      .send(query.jsonObj);\n\n    if (!response.ok) {\n      throw new Error('could not reach Tron node');\n    }\n\n    // unfortunately, it doesn't look like most TRON nodes return valid json as body\n    return JSON.parse(response.text);\n  }\n\n  /**\n   * Query our explorer for the balance of an address\n   * @param address {String} the address encoded in hex\n   * @returns {BigNumber} address balance\n   */\n  private async getAccountFromNode(address: string): Promise<AccountResponse> {\n    return await this.recoveryPost({\n      path: '/walletsolidity/getaccount',\n      jsonObj: { address },\n      node: NodeTypes.Solidity,\n    });\n  }\n\n  /**\n   * Retrieves our build transaction from a node.\n   * @param toAddr hex-encoded address\n   * @param fromAddr hex-encoded address\n   * @param amount\n   */\n  private async getBuildTransaction(\n    toAddr: string,\n    fromAddr: string,\n    amount: number\n  ): Promise<Interface.TransactionReceipt> {\n    // our addresses should be base58, we'll have to encode to hex\n    return await this.recoveryPost({\n      path: '/wallet/createtransaction',\n      jsonObj: {\n        to_address: toAddr,\n        owner_address: fromAddr,\n        amount,\n      },\n      node: NodeTypes.Full,\n    });\n  }\n\n  /**\n   * Throws an error if any keys in the ownerKeys collection don't match the keys array we pass\n   * @param ownerKeys\n   * @param keys\n   */\n  checkPermissions(ownerKeys: { address: string; weight: number }[], keys: string[]) {\n    keys = keys.map((k) => k.toUpperCase());\n\n    ownerKeys.map((key) => {\n      const hexKey = key.address.toUpperCase();\n      if (!keys.includes(hexKey)) {\n        throw new Error(`pub address ${hexKey} not found in account`);\n      }\n\n      if (key.weight !== 1) {\n        throw new Error('owner permission is invalid for this structure');\n      }\n    });\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo.\n   * We need to do three queries during this:\n   * 1) Node query - how much money is in the account\n   * 2) Build transaction - build our transaction for the amount\n   * 3) Send signed build - send our signed build to a public node\n   * @param params\n   */\n  async recover(params: RecoveryOptions): Promise<RecoveryTransaction> {\n    const isKrsRecovery = getIsKrsRecovery(params);\n    const isUnsignedSweep = getIsUnsignedSweep(params);\n\n    if (!this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('Invalid destination address!');\n    }\n\n    // get our user, backup keys\n    const keys = getBip32Keys(this.bitgo, params, { requireBitGoXpub: false });\n\n    // we need to decode our bitgoKey to a base58 address\n    const bitgoHexAddr = this.pubToHexAddress(this.xpubToUncompressedPub(params.bitgoKey));\n    const recoveryAddressHex = Utils.getHexAddressFromBase58Address(params.recoveryDestination);\n\n    // call the node to get our account balance\n    const account = await this.getAccountFromNode(bitgoHexAddr);\n    const recoveryAmount = account.balance;\n\n    const userXPub = keys[0].neutered().toBase58();\n    const userXPrv = keys[0].toBase58();\n    const backupXPub = keys[1].neutered().toBase58();\n\n    // construct the tx -\n    // there's an assumption here being made about fees: for a wallet that hasn't been used in awhile, the implication is\n    // it has maximum bandwidth. thus, a recovery should cost the minimum amount (1e6 sun or 1 Tron)\n    if (MINIMUM_TRON_MSIG_TRANSACTION_FEE > recoveryAmount) {\n      throw new Error('Amount of funds to recover wouldnt be able to fund a send');\n    }\n    const recoveryAmountMinusFees = recoveryAmount - MINIMUM_TRON_MSIG_TRANSACTION_FEE;\n    const buildTx = await this.getBuildTransaction(recoveryAddressHex, bitgoHexAddr, recoveryAmountMinusFees);\n\n    const keyHexAddresses = [\n      this.pubToHexAddress(this.xpubToUncompressedPub(userXPub)),\n      this.pubToHexAddress(this.xpubToUncompressedPub(backupXPub)),\n      bitgoHexAddr,\n    ];\n\n    // run checks to ensure this is a valid tx - permissions match our signer keys\n    this.checkPermissions(account.owner_permission.keys, keyHexAddresses);\n    this.checkPermissions(account.active_permission[0].keys, keyHexAddresses);\n\n    // construct our tx\n    const txBuilder = (getBuilder(this.getChain()) as WrappedBuilder).from(buildTx);\n\n    // this tx should be enough to drop into a node\n    if (isUnsignedSweep) {\n      return {\n        tx: (await txBuilder.build()).toJson(),\n        recoveryAmount: recoveryAmountMinusFees,\n      };\n    }\n\n    const userPrv = this.xprvToCompressedPrv(userXPrv);\n\n    txBuilder.sign({ key: userPrv });\n\n    // krs recoveries don't get signed\n    if (!isKrsRecovery) {\n      const backupXPrv = keys[1].toBase58();\n      const backupPrv = this.xprvToCompressedPrv(backupXPrv);\n\n      txBuilder.sign({ key: backupPrv });\n    }\n\n    return {\n      tx: (await txBuilder.build()).toJson(),\n      recoveryAmount: recoveryAmountMinusFees,\n    };\n  }\n\n  /**\n   * Explain a Tron transaction from txHex\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TronTransactionExplanation> {\n    const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);\n    if (!txHex || !params.feeInfo) {\n      throw new Error('missing explain tx parameters');\n    }\n    const txBuilder = getBuilder(this.getChain()).from(txHex);\n    const tx = await txBuilder.build();\n    const outputs = [\n      {\n        amount: tx.outputs[0].value.toString(),\n        address: tx.outputs[0].address, // Should turn it into a readable format, aka base58\n      },\n    ];\n\n    const displayOrder = [\n      'id',\n      'outputAmount',\n      'changeAmount',\n      'outputs',\n      'changeOutputs',\n      'fee',\n      'timestamp',\n      'expiration',\n    ];\n\n    return {\n      displayOrder,\n      id: tx.id,\n      outputs,\n      outputAmount: outputs[0].amount,\n      changeOutputs: [], // account based does not use change outputs\n      changeAmount: '0', // account base does not make change\n      fee: params.feeInfo,\n      timestamp: tx.validFrom,\n      expiration: tx.validTo,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trx.js","sourceRoot":"","sources":["../../src/trx.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport * as secp256k1 from 'secp256k1';\nimport { createHash, Hash, randomBytes } from 'crypto';\nimport { CoinFamily, BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport * as request from 'superagent';\nimport {\n  BaseCoin,\n  BitGoBase,\n  common,\n  getBip32Keys,\n  getIsKrsRecovery,\n  getIsUnsignedSweep,\n  KeyPair,\n  KeyIndices,\n  MethodNotImplementedError,\n  MPCAlgorithm,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SignTransactionOptions,\n  TransactionExplanation,\n  TransactionFee,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  TransactionRecipient as Recipient,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n  BaseTransaction,\n  MultisigType,\n  multisigTypes,\n  AuditDecryptedKeyParams,\n  AddressCoinSpecific,\n  verifyMPCWalletAddress,\n  isTssVerifyAddressOptions,\n} from '@bitgo-beta/sdk-core';\nimport { auditEcdsaPrivateKey } from '@bitgo-beta/sdk-lib-mpc';\nimport { Enum, Interface, Utils, WrappedBuilder, KeyPair as TronKeyPair } from './lib';\nimport { ValueFields, TransactionReceipt } from './lib/iface';\nimport { getBuilder } from './lib/builder';\nimport { isInteger, isUndefined } from 'lodash';\n\nexport const MINIMUM_TRON_MSIG_TRANSACTION_FEE = 1e6;\nexport const SAFE_TRON_TRANSACTION_FEE = 2.1 * 1e6; // TRON foundation recommends 2.1 TRX as fees for guaranteed transaction\nexport const SAFE_TRON_TOKEN_TRANSACTION_FEE = 100 * 1e6; // TRON foundation recommends 100 TRX as fees for guaranteed transaction\nexport const RECOVER_TRANSACTION_EXPIRY = 86400000; // 24 hour\nexport const DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds\n\nexport interface TronSignTransactionOptions extends SignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string;\n}\n\nexport interface TxInfo {\n  recipients: Recipient[];\n  from: string;\n  txid: string;\n}\n\nexport interface AddressInfo {\n  address: string;\n  chain: number;\n  index: number;\n}\n\nexport interface TronTransactionExplanation extends TransactionExplanation {\n  expiration: number;\n  timestamp: number;\n}\n\nexport interface TransactionPrebuild extends BaseTransactionPrebuild {\n  txHex: string;\n  txInfo: TxInfo;\n  addressInfo?: AddressInfo;\n  feeInfo: TransactionFee;\n}\n\nexport interface ExplainTransactionOptions {\n  txHex?: string; // txHex is poorly named here; it is just a wrapped JSON object\n  halfSigned?: {\n    txHex: string; // txHex is poorly named here; it is just a wrapped JSON object\n  };\n  feeInfo: TransactionFee;\n}\n\nexport interface RecoveryOptions {\n  userKey: string; // Box A\n  backupKey: string; // Box B\n  bitgoKey: string; // Box C - this is bitgo's xpub and will be used to derive their root address\n  recoveryDestination: string; // base58 address\n  krsProvider?: string;\n  tokenContractAddress?: string;\n  walletPassphrase?: string;\n  startingScanIndex?: number;\n  scan?: number;\n}\n\nexport interface ConsolidationRecoveryOptions {\n  userKey: string;\n  backupKey: string;\n  bitgoKey: string;\n  tokenContractAddress?: string;\n  startingScanIndex?: number; // default to 1 (inclusive)\n  endingScanIndex?: number; // default to startingScanIndex + 20 (exclusive)\n}\n\nexport interface ConsolidationRecoveryBatch {\n  transactions: RecoveryTransaction[];\n}\n\nexport interface FeeInfo {\n  fee: string;\n}\n\nexport interface RecoveryTransaction {\n  txHex?: string;\n  feeInfo?: FeeInfo;\n  coin?: string;\n  tx?: TransactionPrebuild;\n  recoveryAmount?: number;\n  tokenTxs?: TransactionReceipt[];\n  addressInfo?: AddressInfo;\n}\n\nexport enum NodeTypes {\n  Full,\n  Solidity,\n}\n\n/**\n * This structure is not a complete model of the AccountResponse from a node.\n */\nexport interface AccountResponse {\n  data: [Interface.AccountInfo];\n}\n\nexport interface TrxVerifyAddressOptions extends VerifyAddressOptions {\n  index?: number | string;\n  chain?: number;\n  coinSpecific?: AddressCoinSpecific & {\n    index?: number | string;\n    chain?: number;\n  };\n}\n\nfunction isTrxVerifyAddressOptions(params: VerifyAddressOptions): params is TrxVerifyAddressOptions {\n  return (\n    'index' in params ||\n    'chain' in params ||\n    ('coinSpecific' in params &&\n      params.coinSpecific !== undefined &&\n      ('index' in params.coinSpecific || 'chain' in params.coinSpecific))\n  );\n}\n\nexport class Trx extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  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  getChain() {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName() {\n    return this._staticsCoin.fullName;\n  }\n\n  getBaseFactor() {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  /** @inheritdoc */\n  transactionDataAllowed() {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  /** @inheritDoc */\n  getHashFunction(): Hash {\n    return createHash('sha256');\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Trx(bitgo, staticsCoin);\n  }\n\n  /**\n   * Flag for sending value of 0\n   * @returns {boolean} True if okay to send 0 value, false otherwise\n   */\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsResourceDelegation(): boolean {\n    return true;\n  }\n\n  /**\n   * Checks if this is a valid base58\n   * @param address\n   */\n  isValidAddress(address: string): boolean {\n    if (!address) {\n      return false;\n    }\n\n    return Utils.isBase58Address(address);\n  }\n\n  /**\n   * Checks if this is a valid hex address\n   * @param address hex address\n   */\n  isValidHexAddress(address: string): boolean {\n    return /^41[0-9a-f]{40}$/i.test(address);\n  }\n\n  /**\n   * Generate ed25519 key pair\n   *\n   * @param seed\n   * @returns {Object} object with generated pub, prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    // TODO: move this and address creation logic to account-lib\n    if (!seed) {\n      // An extended private key has both a normal 256 bit private key and a 256 bit chain code, both of which must be\n      // random. 512 bits is therefore the maximum entropy and gives us maximum security against cracking.\n      seed = randomBytes(512 / 8);\n    }\n    const hd = bip32.fromSeed(seed);\n    return {\n      pub: hd.neutered().toBase58(),\n      prv: hd.toBase58(),\n    };\n  }\n\n  isValidXpub(xpub: string): boolean {\n    try {\n      return bip32.fromBase58(xpub).isNeutered();\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidPub(pub: string): boolean {\n    if (this.isValidXpub(pub)) {\n      // xpubs can be converted into regular pubs, so technically it is a valid pub\n      return true;\n    }\n    return new RegExp('^04[a-zA-Z0-9]{128}$').test(pub);\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address, keychains } = params;\n\n    if (isTssVerifyAddressOptions(params)) {\n      return verifyMPCWalletAddress(\n        { ...params, keyCurve: 'secp256k1' },\n        this.isValidAddress.bind(this),\n        (pubKey: string) => new TronKeyPair({ pub: pubKey }).getAddress()\n      );\n    }\n\n    if (!isTrxVerifyAddressOptions(params)) {\n      throw new Error('Invalid or missing index for address verification');\n    }\n\n    const rawIndex = params.index ?? params.coinSpecific?.index;\n    const index = Number(rawIndex);\n    if (isNaN(index)) {\n      throw new Error('Invalid index. index must be a number.');\n    }\n\n    const chain = Number(params.chain ?? params.coinSpecific?.chain ?? 0);\n\n    if (!this.isValidAddress(address)) {\n      throw new Error(`Invalid address: ${address}`);\n    }\n\n    // Root address verification (Index 0)\n    if (index === 0) {\n      const bitgoPub = keychains && keychains.length > KeyIndices.BITGO ? keychains[KeyIndices.BITGO].pub : undefined;\n      if (!bitgoPub) {\n        throw new Error('BitGo public key required for root address verification');\n      }\n      return this.verifyRootAddress(address, bitgoPub);\n    }\n\n    // Receive address verification (Index > 0)\n    if (index > 0) {\n      const userPub = keychains && keychains.length > KeyIndices.USER ? keychains[KeyIndices.USER].pub : undefined;\n      if (!userPub) {\n        throw new Error('User public key required for receive address verification');\n      }\n      return this.verifyReceiveAddress(address, userPub, index, chain);\n    }\n\n    throw new Error('Invalid index for address verification');\n  }\n\n  /**\n   * Cryptographically verify that an address is the root address derived from BitGo's public key\n   */\n  private verifyRootAddress(address: string, bitgoPub: string): boolean {\n    if (!this.isValidXpub(bitgoPub)) {\n      throw new Error('Invalid bitgo public key');\n    }\n    const uncompressedPub = this.xpubToUncompressedPub(bitgoPub);\n    const byteArrayAddr = Utils.getByteArrayFromHexAddress(uncompressedPub);\n    const rawAddress = Utils.getRawAddressFromPubKey(byteArrayAddr);\n    const derivedAddress = Utils.getBase58AddressFromByteArray(rawAddress);\n    return derivedAddress === address;\n  }\n\n  /**\n   * Cryptographically verify that an address is a receive address derived from user's key\n   */\n  private verifyReceiveAddress(address: string, userPub: string, index: number, chain: number): boolean {\n    if (!this.isValidXpub(userPub)) {\n      throw new Error('Invalid user public key');\n    }\n    const derivationPath = `0/0/${chain}/${index}`;\n    const parentKey = bip32.fromBase58(userPub);\n    const childKey = parentKey.derivePath(derivationPath);\n    const derivedPubKeyHex = childKey.publicKey.toString('hex');\n    const keypair = new TronKeyPair({ pub: derivedPubKeyHex });\n    const derivedAddress = keypair.getAddress();\n    return derivedAddress === address;\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild, walletType } = params;\n\n    if (!txParams) {\n      throw new Error('missing txParams');\n    }\n\n    if (!txPrebuild) {\n      throw new Error('missing txPrebuild');\n    }\n\n    if (!txPrebuild.txHex) {\n      throw new Error('missing txHex in txPrebuild');\n    }\n\n    if (walletType === 'tss') {\n      // For TSS wallets, verifyTransaction is called from two places:\n      // 1. prebuildAndSignTransaction (wallet.ts) — txHex is serializedTxHex, a full JSON string\n      //    containing { txID, raw_data, raw_data_hex }.\n      // 2. ECDSA signing flow (ecdsa.ts) — txHex is signableHex, the raw protobuf bytes (raw_data_hex).\n      // We need to extract the raw_data_hex in case 1 before decoding.\n      const rawDataHex = this.extractRawDataHex(txPrebuild.txHex);\n      const decodedTx = Utils.decodeTransaction(rawDataHex);\n\n      // decodedTx uses a numeric enum for contract type (from protobuf decoding),\n      // unlike the multisig path which checks the string 'TransferContract' from node JSON.\n      if (decodedTx.contractType === Enum.ContractType.Transfer) {\n        // For Transfer contracts, decoded contract is an array with one element.\n        // Addresses from decodeTransaction are already in base58 format (converted by decodeTransferContract).\n        if (!Array.isArray(decodedTx.contract) || decodedTx.contract.length !== 1) {\n          throw new Error('Invalid Transfer contract structure.');\n        }\n        return this.validateTransferContract(decodedTx.contract[0], txParams, true);\n      }\n\n      if (decodedTx.contractType === Enum.ContractType.TriggerSmartContract) {\n        // TRC20 token transfers (TriggerSmartContract) must be verified via TrxToken.verifyTransaction,\n        // not here. Fail closed to prevent unvalidated token transfers from being silently signed.\n        throw new Error(\n          'TriggerSmartContract verification is not supported by native TRX. ' +\n            'TRC20 token transfers must be verified via TrxToken.verifyTransaction.'\n        );\n      }\n\n      return true;\n    }\n\n    // On-chain multisig path: txHex is a full transaction JSON string (with txID, raw_data, raw_data_hex).\n    // The builder parses this JSON and addresses remain in hex format from the node response.\n    const rawTx = txPrebuild.txHex;\n    const txBuilder = getBuilder(this.getChain()).from(rawTx);\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    if (!txJson.raw_data || !txJson.raw_data.contract || txJson.raw_data.contract.length !== 1) {\n      throw new Error('Number of contracts is greater than 1.');\n    }\n\n    const contract = txJson.raw_data.contract[0];\n\n    if (contract.type === 'TransferContract') {\n      return this.validateTransferContract(contract, txParams);\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * Extract the raw protobuf hex (raw_data_hex) from a TSS txHex.\n   *\n   * TSS verifyTransaction is called from two places:\n   *   1. prebuildAndSignTransaction — txHex is a full JSON string containing raw_data_hex.\n   *   2. ECDSA signing flow — txHex is already the raw protobuf hex (raw_data_hex).\n   *\n   * This helper handles both formats so callers don't duplicate the try/catch.\n   */\n  protected extractRawDataHex(txHex: string): string {\n    try {\n      return JSON.parse(txHex).raw_data_hex;\n    } catch {\n      console.debug(`Could not parse txHex as JSON for coin ${this.getChain()}, using txHex directly`);\n      return txHex;\n    }\n  }\n\n  /**\n   * Validate Transfer contract (native TRX transfer).\n   * Shared by both on-chain multisig and TSS wallet verification paths.\n   *\n   * @param contract The contract object from the transaction\n   * @param txParams The original transaction parameters\n   * @param addressesInBase58 When true, addresses are already in base58 format (TSS path via protobuf decoding).\n   *   When false (default), addresses are in hex and need conversion (on-chain multisig path via builder JSON).\n   */\n  private validateTransferContract(contract: any, txParams: any, addressesInBase58 = false): boolean {\n    if (!('parameter' in contract) || !contract.parameter?.value) {\n      throw new Error('Invalid Transfer contract structure');\n    }\n\n    const value = contract.parameter.value as ValueFields;\n\n    // Validate amount\n    if (!value.amount || value.amount < 0) {\n      throw new Error('Invalid transfer amount');\n    }\n\n    // If txParams has recipients, validate against expected values\n    if (txParams.recipients && txParams.recipients.length === 1) {\n      const recipient = txParams.recipients[0];\n      const expectedAmount = recipient.amount.toString();\n      const expectedDestination = recipient.address;\n      const actualAmount = value.amount.toString();\n      const actualDestination = addressesInBase58 ? value.to_address : Utils.getBase58AddressFromHex(value.to_address);\n\n      if (expectedAmount !== actualAmount) {\n        throw new Error('transaction amount in txPrebuild does not match the value given by client');\n      }\n\n      if (expectedDestination.toLowerCase() !== actualDestination.toLowerCase()) {\n        throw new Error('destination address does not match with the recipient address');\n      }\n    }\n\n    return true;\n  }\n\n  /** @inheritDoc */\n  async getSignablePayload(serializedTx: string): Promise<Buffer> {\n    const txBuilder = getBuilder(this.getChain()).from(serializedTx);\n    const rebuiltTransaction = await txBuilder.build();\n    return rebuiltTransaction.signablePayload;\n  }\n\n  /**\n   * Derive a user key using the chain path of the address\n   * @param key\n   * @param path\n   * @returns {string} derived private key\n   */\n  deriveKeyWithPath({ key, path }: { key: string; path: string }): string {\n    const keychain = bip32.fromBase58(key);\n    const derivedKeyNode = keychain.derivePath(path);\n    return derivedKeyNode.toBase58();\n  }\n\n  /**\n   * Assemble keychain and half-sign prebuilt transaction\n   *\n   * @param params\n   * @param params.txPrebuild {Object} prebuild object returned by platform\n   * @param params.prv {String} user prv\n   * @returns Bluebird<SignedTransaction>\n   */\n  async signTransaction(params: TronSignTransactionOptions): Promise<SignedTransaction> {\n    const txBuilder = getBuilder(this.getChain()).from(params.txPrebuild.txHex);\n\n    let key;\n    const { chain, index } = params.txPrebuild?.addressInfo ?? { chain: 0, index: 0 };\n    if (chain === 0 && index === 0) {\n      key = params.prv;\n    } else {\n      const derivationPath = `0/0/${chain}/${index}`;\n      key = this.deriveKeyWithPath({ key: params.prv, path: derivationPath });\n    }\n    txBuilder.sign({ key });\n\n    const transaction = await txBuilder.build();\n    const response = {\n      txHex: JSON.stringify(transaction.toJson()),\n    };\n    if (transaction.toJson().signature.length >= 2) {\n      return response;\n    }\n    // Half signed transaction\n    return {\n      halfSigned: response,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid seed for the coin\n   *\n   * @param prv - the prv to be checked\n   */\n  isValidXprv(prv: string): boolean {\n    try {\n      return !bip32.fromBase58(prv).isNeutered();\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Convert a message to string in hexadecimal format.\n   *\n   * @param message {Buffer|String} message to sign\n   * @return the message as a hexadecimal string\n   */\n  toHexString(message: string | Buffer): string {\n    if (typeof message === 'string') {\n      return Buffer.from(message).toString('hex');\n    } else if (Buffer.isBuffer(message)) {\n      return message.toString('hex');\n    } else {\n      throw new Error('Invalid messaged passed to signMessage');\n    }\n  }\n\n  /**\n   * Sign message with private key\n   *\n   * @param key\n   * @param message\n   */\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const toSign = this.toHexString(message);\n\n    let prv: string | undefined = key.prv;\n    if (this.isValidXprv(prv)) {\n      prv = bip32.fromBase58(prv).privateKey?.toString('hex');\n    }\n\n    if (!prv) {\n      throw new Error('no privateKey');\n    }\n    let sig = Utils.signString(toSign, prv, true);\n\n    // remove the preceding 0x\n    sig = sig.replace(/^0x/, '');\n\n    return Buffer.from(sig, 'hex');\n  }\n\n  /**\n   * Converts an xpub to a uncompressed pub\n   * @param xpub\n   */\n  xpubToUncompressedPub(xpub: string): string {\n    if (!this.isValidXpub(xpub)) {\n      throw new Error('invalid xpub');\n    }\n\n    const publicKey = bip32.fromBase58(xpub).publicKey;\n    return Buffer.from(secp256k1.publicKeyConvert(publicKey, false /* compressed */)).toString('hex');\n  }\n\n  /**\n   * Modify prebuild before sending it to the server.\n   * @param buildParams The whitelisted parameters for this prebuild\n   */\n  async getExtraPrebuildParams(buildParams: any): Promise<any> {\n    if (buildParams.recipients[0].data && buildParams.feeLimit) {\n      buildParams.recipients[0].feeLimit = buildParams.feeLimit;\n    }\n  }\n\n  pubToHexAddress(pub: string): string {\n    const byteArrayAddr = Utils.getByteArrayFromHexAddress(pub);\n    const rawAddress = Utils.getRawAddressFromPubKey(byteArrayAddr);\n    return Utils.getHexAddressFromByteArray(rawAddress);\n  }\n\n  xprvToCompressedPrv(xprv: string): string {\n    if (!this.isValidXprv(xprv)) {\n      throw new Error('invalid xprv');\n    }\n\n    const hdNode = bip32.fromBase58(xprv);\n    if (!hdNode.privateKey) {\n      throw new Error('no privateKey');\n    }\n    return hdNode.privateKey.toString('hex');\n  }\n\n  private getNodeUrl(node: NodeTypes): string {\n    switch (node) {\n      case NodeTypes.Full:\n        return common.Environments[this.bitgo.getEnv()].tronNodes.full;\n      case NodeTypes.Solidity:\n        return common.Environments[this.bitgo.getEnv()].tronNodes.solidity;\n      default:\n        throw new Error('node type not found');\n    }\n  }\n  /**\n   * Make a query to Trongrid for information such as balance, token balance, solidity calls\n   * @param query {Object} key-value pairs of parameters to append after /api\n   * @returns {Object} response from Trongrid\n   */\n  private async recoveryPost(query: { path: string; jsonObj: any; node: NodeTypes }): Promise<any> {\n    const nodeUri = this.getNodeUrl(query.node);\n\n    const response = await request\n      .post(nodeUri + query.path)\n      .type('json')\n      .send(query.jsonObj);\n\n    if (!response.ok) {\n      throw new Error('could not reach Tron node');\n    }\n\n    // unfortunately, it doesn't look like most TRON nodes return valid json as body\n    return JSON.parse(response.text);\n  }\n\n  /**\n   * Make a query to Trongrid for information such as balance, token balance, solidity calls\n   * @param query {Object} key-value pairs of parameters to append after /api\n   * @returns {Object} response from Trongrid\n   */\n  private async recoveryGet(query: { path: string; jsonObj: any; node: NodeTypes }): Promise<any> {\n    const nodeUri = this.getNodeUrl(query.node);\n\n    const response = await request\n      .get(nodeUri + query.path)\n      .type('json')\n      .send(query.jsonObj);\n\n    if (!response.ok) {\n      throw new Error('could not reach Tron node');\n    }\n\n    // unfortunately, it doesn't look like most TRON nodes return valid json as body\n    return JSON.parse(response.text);\n  }\n\n  /**\n   * Query our explorer for the balance of an address\n   * @param address {String} the address encoded in hex\n   * @returns {BigNumber} address balance\n   */\n  private async getAccountBalancesFromNode(address: string): Promise<AccountResponse> {\n    return await this.recoveryGet({\n      path: '/v1/accounts/' + address,\n      jsonObj: {},\n      node: NodeTypes.Full,\n    });\n  }\n\n  /**\n   * Retrieves our build transaction from a node.\n   * @param toAddr hex-encoded address\n   * @param fromAddr hex-encoded address\n   * @param amount\n   */\n  private async getBuildTransaction(\n    toAddr: string,\n    fromAddr: string,\n    amount: number\n  ): Promise<Interface.TransactionReceipt> {\n    // our addresses should be base58, we'll have to encode to hex\n    return await this.recoveryPost({\n      path: '/wallet/createtransaction',\n      jsonObj: {\n        to_address: toAddr,\n        owner_address: fromAddr,\n        amount,\n      },\n      node: NodeTypes.Full,\n    });\n  }\n\n  /**\n   * Retrieves our build transaction from a node.\n   * @param toAddr hex-encoded address\n   * @param fromAddr hex-encoded address\n   * @param amount\n   */\n  private async getTriggerSmartContractTransaction(\n    toAddr: string,\n    fromAddr: string,\n    amount: string,\n    contractAddr: string\n  ): Promise<{ transaction: Interface.TransactionReceipt }> {\n    const functionSelector = 'transfer(address,uint256)';\n    const types = ['address', 'uint256'];\n    const values = [toAddr, amount];\n    const parameter = Utils.encodeDataParams(types, values, '');\n    return await this.recoveryPost({\n      path: '/wallet/triggersmartcontract',\n      jsonObj: {\n        owner_address: fromAddr,\n        contract_address: contractAddr,\n        function_selector: functionSelector,\n        parameter: parameter,\n        fee_limit: 100000000,\n      },\n      node: NodeTypes.Full,\n    });\n  }\n\n  /**\n   * Throws an error if any keys in the ownerKeys collection don't match the keys array we pass\n   * @param ownerKeys\n   * @param keys\n   */\n  checkPermissions(ownerKeys: { address: string; weight: number }[], keys: string[]) {\n    keys = keys.map((k) => k.toUpperCase());\n\n    ownerKeys.map((key) => {\n      const hexKey = key.address.toUpperCase();\n      if (!keys.includes(hexKey)) {\n        throw new Error(`pub address ${hexKey} not found in account`);\n      }\n\n      if (key.weight !== 1) {\n        throw new Error('owner permission is invalid for this structure');\n      }\n    });\n  }\n\n  /**\n   * Format for offline vault signing\n   * @param {BaseTransaction} tx\n   * @param {number} fee\n   * @param {number} recoveryAmount\n   * @returns {RecoveryTransaction}\n   */\n  formatForOfflineVault(\n    tx: BaseTransaction,\n    fee: number,\n    recoveryAmount: number,\n    addressInfo?: AddressInfo\n  ): RecoveryTransaction {\n    const txJSON = tx.toJson();\n    const format = {\n      txHex: JSON.stringify(txJSON),\n      recoveryAmount,\n      feeInfo: {\n        fee: `${fee}`,\n      },\n      tx: txJSON, // Leaving it as txJSON for backwards compatibility\n      coin: this.getChain(),\n    };\n    return addressInfo ? { ...format, addressInfo } : format;\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo.\n   * We need to do three queries during this:\n   * 1) Node query - how much money is in the account\n   * 2) Build transaction - build our transaction for the amount\n   * 3) Send signed build - send our signed build to a public node\n   *\n   * Note 1: for base address recoveries, fund will be recovered to recovery destination if base address balance is\n   * more than 2.1 TRX for native TRX recovery and 100 TRX for token recover. For receive addresses, fund will be\n   * recovered to base address first then swept to base address(decided as the universal pattern in team meeting).\n   *\n   * Note 2: the function supports token sweep from base address.\n   * TODO: support token sweep from receive address.\n   *\n   * @param params\n   */\n  async recover(params: RecoveryOptions): Promise<RecoveryTransaction> {\n    const isKrsRecovery = getIsKrsRecovery(params);\n    const isUnsignedSweep = getIsUnsignedSweep(params);\n\n    if (!this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('Invalid destination address!');\n    }\n\n    let startIdx = params.startingScanIndex;\n    if (isUndefined(startIdx)) {\n      startIdx = 1;\n    } else if (!isInteger(startIdx) || startIdx < 0) {\n      throw new Error('Invalid starting index to scan for addresses');\n    }\n\n    let numIteration = params.scan;\n    if (isUndefined(numIteration)) {\n      numIteration = 20;\n    } else if (typeof numIteration === 'string') {\n      numIteration = parseInt(numIteration, 10);\n    }\n\n    if (!isInteger(numIteration) || numIteration <= 0) {\n      throw new Error('Invalid scanning factor');\n    }\n\n    // get our user, backup keys\n    const keys = getBip32Keys(this.bitgo, params, { requireBitGoXpub: false });\n\n    // we need to decode our bitgoKey to a base58 address\n    const bitgoHexAddr = this.pubToHexAddress(this.xpubToUncompressedPub(params.bitgoKey));\n    let recoveryFromAddrHex = bitgoHexAddr;\n    let recoveryToAddressHex = Utils.getHexAddressFromBase58Address(params.recoveryDestination);\n\n    // call the node to get our account balance for base address\n    let account = await this.getAccountBalancesFromNode(Utils.getBase58AddressFromHex(recoveryFromAddrHex));\n    let recoveryAmount = account.data[0].balance;\n\n    let userXPrv = keys[0].toBase58();\n    let isReceiveAddress = false;\n    let addressInfo: AddressInfo | undefined;\n    const tokenContractAddr = params.tokenContractAddress;\n    // check for possible token recovery, recover the token provide by user\n    if (tokenContractAddr) {\n      let rawTokenTxn: any | undefined;\n      for (const token of account.data[0].trc20) {\n        if (token[tokenContractAddr]) {\n          const amount = token[tokenContractAddr];\n          const tokenContractAddrHex = Utils.getHexAddressFromBase58Address(tokenContractAddr);\n          rawTokenTxn = (\n            await this.getTriggerSmartContractTransaction(\n              recoveryToAddressHex,\n              recoveryFromAddrHex,\n              amount,\n              tokenContractAddrHex\n            )\n          ).transaction;\n          recoveryAmount = parseInt(amount, 10);\n          break;\n        }\n      }\n\n      // build and sign token txns\n      if (rawTokenTxn) {\n        // Check there is sufficient of the native asset to cover fees\n        const trxBalance = account.data[0].balance;\n        if (trxBalance < SAFE_TRON_TOKEN_TRANSACTION_FEE) {\n          throw new Error(\n            `Amount of funds to recover ${trxBalance} is less than ${SAFE_TRON_TOKEN_TRANSACTION_FEE} and wouldn't be able to fund a trc20 send`\n          );\n        }\n\n        const txBuilder = getBuilder(this.getChain()).from(rawTokenTxn);\n        // Default expiry is 1 minute which is too short for recovery purposes\n        // extend the expiry to 1 day\n        txBuilder.extendValidTo(RECOVER_TRANSACTION_EXPIRY);\n        // this tx should be enough to drop into a node\n        if (isUnsignedSweep) {\n          return this.formatForOfflineVault(await txBuilder.build(), SAFE_TRON_TOKEN_TRANSACTION_FEE, recoveryAmount);\n        }\n\n        const userPrv = this.xprvToCompressedPrv(userXPrv);\n\n        txBuilder.sign({ key: userPrv });\n\n        // krs recoveries don't get signed\n        if (!isKrsRecovery && !isReceiveAddress) {\n          const backupXPrv = keys[1].toBase58();\n          const backupPrv = this.xprvToCompressedPrv(backupXPrv);\n\n          txBuilder.sign({ key: backupPrv });\n        }\n        return this.formatForOfflineVault(await txBuilder.build(), SAFE_TRON_TOKEN_TRANSACTION_FEE, recoveryAmount);\n      } else {\n        throw Error('Not found token to recover, please check token balance');\n      }\n    }\n    // let us recover the native Tron\n    if (recoveryAmount > SAFE_TRON_TRANSACTION_FEE) {\n      const userXPub = keys[0].neutered().toBase58();\n      const backupXPub = keys[1].neutered().toBase58();\n\n      // check multisig permissions\n      const keyHexAddresses = [\n        this.pubToHexAddress(this.xpubToUncompressedPub(userXPub)),\n        this.pubToHexAddress(this.xpubToUncompressedPub(backupXPub)),\n        bitgoHexAddr,\n      ];\n      // run checks to ensure this is a valid tx - permissions match our signer keys\n      const ownerKeys: { address: string; weight: number }[] = [];\n      for (const key of account.data[0].owner_permission.keys) {\n        const address = Utils.getHexAddressFromBase58Address(key.address);\n        const weight = key.weight;\n        ownerKeys.push({ address, weight });\n      }\n      const activePermissionKeys: { address: string; weight: number }[] = [];\n      for (const key of account.data[0].active_permission[0].keys) {\n        const address = Utils.getHexAddressFromBase58Address(key.address);\n        const weight = key.weight;\n        activePermissionKeys.push({ address, weight });\n      }\n      this.checkPermissions(ownerKeys, keyHexAddresses);\n      this.checkPermissions(activePermissionKeys, keyHexAddresses);\n    } else {\n      // Check receive addresses for funds\n      // Check for first derived wallet with funds\n      // Receive addresses are derived from the user key\n      for (let i = startIdx; i < numIteration + startIdx; i++) {\n        const derivationPath = `0/0/0/${i}`;\n        const userKey = keys[0].derivePath(derivationPath);\n        const xpub = userKey.neutered();\n        const receiveAddress = this.pubToHexAddress(this.xpubToUncompressedPub(xpub.toBase58()));\n        const address = Utils.getBase58AddressFromHex(receiveAddress);\n        // call the node to get our account balance\n        const accountInfo = await this.getAccountBalancesFromNode(address);\n\n        if (accountInfo.data[0] && accountInfo.data[0].balance > SAFE_TRON_TRANSACTION_FEE) {\n          account = accountInfo;\n          recoveryAmount = accountInfo.data[0].balance;\n          userXPrv = userKey.toBase58(); // assign derived userXPrx\n          isReceiveAddress = true;\n          recoveryFromAddrHex = receiveAddress;\n          recoveryToAddressHex = bitgoHexAddr;\n          addressInfo = {\n            address,\n            chain: 0,\n            index: i,\n          };\n          break;\n        }\n      }\n    }\n\n    // a sweep potentially needs to pay for multi-sig transfer, destination account activation and bandwidth\n    // TRON foundation recommends 2.1 TRX for guaranteed confirmation\n    if (!recoveryAmount || SAFE_TRON_TRANSACTION_FEE >= recoveryAmount) {\n      throw new Error(\n        `Amount of funds to recover ${recoveryAmount} is less than ${SAFE_TRON_TRANSACTION_FEE} and wouldn't be able to fund a send`\n      );\n    }\n\n    const recoveryAmountMinusFees = recoveryAmount - SAFE_TRON_TRANSACTION_FEE;\n    const buildTx = await this.getBuildTransaction(recoveryToAddressHex, recoveryFromAddrHex, recoveryAmountMinusFees);\n\n    // construct our tx\n    const txBuilder = (getBuilder(this.getChain()) as WrappedBuilder).from(buildTx);\n    // Default expiry is 1 minute which is too short for recovery purposes\n    // extend the expiry to 1 day\n    txBuilder.extendValidTo(RECOVER_TRANSACTION_EXPIRY);\n    const tx = await txBuilder.build();\n\n    // this tx should be enough to drop into a node\n    if (isUnsignedSweep) {\n      return this.formatForOfflineVault(tx, SAFE_TRON_TRANSACTION_FEE, recoveryAmountMinusFees, addressInfo);\n    }\n\n    const userPrv = this.xprvToCompressedPrv(userXPrv);\n\n    txBuilder.sign({ key: userPrv });\n\n    // krs recoveries don't get signed\n    if (!isKrsRecovery && !isReceiveAddress) {\n      const backupXPrv = keys[1].toBase58();\n      const backupPrv = this.xprvToCompressedPrv(backupXPrv);\n\n      txBuilder.sign({ key: backupPrv });\n    }\n    const txSigned = await txBuilder.build();\n    return this.formatForOfflineVault(txSigned, SAFE_TRON_TRANSACTION_FEE, recoveryAmountMinusFees, addressInfo);\n  }\n\n  /**\n   * Builds native TRX recoveries of receive addresses in batch without BitGo.\n   * Funds will be recovered to base address first. You need to initiate another sweep txn after that.\n   * Note: there will be another recoverTokenConsolidations function to support token recover from receive addresses.\n   *\n   * @param {ConsolidationRecoveryOptions} params - options for consolidation recovery.\n   * @param {string} [params.startingScanIndex] - receive address index to start scanning from. default to 1 (inclusive).\n   * @param {string} [params.endingScanIndex] - receive address index to end scanning at. default to startingScanIndex + 20 (exclusive).\n   */\n  async recoverConsolidations(params: ConsolidationRecoveryOptions): Promise<ConsolidationRecoveryBatch> {\n    const isUnsignedConsolidations = getIsUnsignedSweep(params);\n    const startIdx = params.startingScanIndex || 1;\n    const endIdx = params.endingScanIndex || startIdx + DEFAULT_SCAN_FACTOR;\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 keys = getBip32Keys(this.bitgo, params, { requireBitGoXpub: false });\n    const baseAddrHex = this.pubToHexAddress(this.xpubToUncompressedPub(params.bitgoKey));\n\n    const txnsBatch: RecoveryTransaction[] = [];\n    for (let i = startIdx; i < endIdx; i++) {\n      const derivationPath = `0/0/0/${i}`;\n      const userKey = keys[0].derivePath(derivationPath);\n      const userKeyXPub = userKey.neutered();\n      const receiveAddressHex = this.pubToHexAddress(this.xpubToUncompressedPub(userKeyXPub.toBase58()));\n      const receiveAddress = Utils.getBase58AddressFromHex(receiveAddressHex);\n      // call the node to get our account balance\n      const accountInfo = await this.getAccountBalancesFromNode(receiveAddress);\n\n      if (accountInfo.data[0] && accountInfo.data[0].balance > SAFE_TRON_TRANSACTION_FEE) {\n        let recoveryAmount = 0;\n        // Tokens must be consolidate before the native asset. First construct token txns\n        let rawTokenTxn: any | undefined;\n\n        // check for possible token recovery, recover the token provide by user\n        if (params.tokenContractAddress) {\n          if (accountInfo.data[0].balance > SAFE_TRON_TOKEN_TRANSACTION_FEE && accountInfo.data[0].trc20[0]) {\n            const tokenDataArray = accountInfo.data[0].trc20;\n            for (const tokenData of tokenDataArray) {\n              const contractAddress = Object.keys(tokenData) as Array<string>;\n              if (params.tokenContractAddress === contractAddress[0]) {\n                const amount = tokenData[contractAddress[0]];\n                const tokenContractAddrHex = Utils.getHexAddressFromBase58Address(contractAddress[0]);\n                rawTokenTxn = (\n                  await this.getTriggerSmartContractTransaction(\n                    baseAddrHex,\n                    receiveAddressHex,\n                    amount,\n                    tokenContractAddrHex\n                  )\n                ).transaction;\n                recoveryAmount = parseInt(amount, 10);\n                break;\n              }\n            }\n          }\n          // build and sign token txns\n          if (rawTokenTxn) {\n            const addressInfo = {\n              address: receiveAddress,\n              chain: 0,\n              index: i,\n            };\n            const txBuilder = getBuilder(this.getChain()).from(rawTokenTxn);\n            // Default expiry is 1 minute which is too short for recovery purposes\n            // extend the expiry to 1 day\n            txBuilder.extendValidTo(RECOVER_TRANSACTION_EXPIRY);\n            // this tx should be enough to drop into a node\n            if (!isUnsignedConsolidations) {\n              const userPrv = this.xprvToCompressedPrv(userKey.toBase58());\n              // receive address only needs to be signed by user key\n              txBuilder.sign({ key: userPrv });\n            }\n            const tx = await txBuilder.build();\n            txnsBatch.push(\n              this.formatForOfflineVault(tx, SAFE_TRON_TOKEN_TRANSACTION_FEE, recoveryAmount, addressInfo)\n            );\n          }\n        } else {\n          const addressBalance = accountInfo.data[0].balance;\n          const addressInfo = {\n            address: receiveAddress,\n            chain: 0,\n            index: i,\n          };\n          const recoveryAmount = addressBalance - SAFE_TRON_TRANSACTION_FEE;\n          const buildTx = await this.getBuildTransaction(baseAddrHex, receiveAddressHex, recoveryAmount);\n          // construct our tx\n          const txBuilder = (getBuilder(this.getChain()) as WrappedBuilder).from(buildTx);\n          // Default expiry is 1 minute which is too short for recovery purposes\n          // extend the expiry to 1 day\n          txBuilder.extendValidTo(RECOVER_TRANSACTION_EXPIRY);\n\n          if (!isUnsignedConsolidations) {\n            const userPrv = this.xprvToCompressedPrv(userKey.toBase58());\n            // receive address only needs to be signed by user key\n            txBuilder.sign({ key: userPrv });\n          }\n          const tx = await txBuilder.build();\n          txnsBatch.push(this.formatForOfflineVault(tx, SAFE_TRON_TRANSACTION_FEE, recoveryAmount, addressInfo));\n        }\n      }\n    }\n\n    return {\n      transactions: txnsBatch,\n    };\n  }\n\n  /**\n   * Explain a Tron transaction from txHex\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TronTransactionExplanation> {\n    const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);\n    if (!txHex || !params.feeInfo) {\n      throw new Error('missing explain tx parameters');\n    }\n    const txBuilder = getBuilder(this.getChain()).from(txHex);\n    const tx = await txBuilder.build();\n    const outputs = [\n      {\n        amount: tx.outputs[0].value.toString(),\n        address: tx.outputs[0].address, // Should turn it into a readable format, aka base58\n      },\n    ];\n\n    const displayOrder = [\n      'id',\n      'outputAmount',\n      'changeAmount',\n      'outputs',\n      'changeOutputs',\n      'fee',\n      'timestamp',\n      'expiration',\n    ];\n\n    return {\n      displayOrder,\n      id: tx.id,\n      outputs,\n      outputAmount: outputs[0].amount,\n      changeOutputs: [], // account based does not use change outputs\n      changeAmount: '0', // account base does not make change\n      fee: params.feeInfo,\n      timestamp: tx.validFrom,\n      expiration: tx.validTo,\n    };\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ multiSigType, publicKey, prv }: AuditDecryptedKeyParams) {\n    if (multiSigType === 'tss') {\n      auditEcdsaPrivateKey(prv as string, publicKey as string);\n    } else {\n      throw new MethodNotImplementedError();\n    }\n  }\n}\n"]}