@bitgo/sdk-coin-iota 1.8.2 → 1.9.0

package/dist/src/iota.js

@@ -45,6 +45,7 @@ const sdk_lib_mpc_1 = require("@bitgo/sdk-lib-mpc");
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const _ = __importStar(require("lodash"));
 const transferTransaction_1 = require("./lib/transferTransaction");
+const constants_1 = require("./lib/constants");
 /**
  * IOTA coin implementation.
  * Supports TSS (Threshold Signature Scheme) with EDDSA algorithm.
@@ -225,6 +226,501 @@ class Iota extends sdk_core_1.BaseCoin {
     setCoinSpecificFieldsInIntent(intent, params) {
         intent.unspents = params.unspents;
     }
+    /**
+     * Builds funds recovery transaction(s) without BitGo
+     *
+     * @param {IotaRecoveryOptions} params parameters needed to construct and
+     * (maybe) sign the transaction
+     *
+     * @returns {MPCTx | MPCSweepTxs} array of the serialized transaction hex strings and indices
+     * of the addresses being swept
+     */
+    async recover(params) {
+        if (!params.bitgoKey) {
+            throw new Error('Missing bitgoKey');
+        }
+        if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('Invalid recoveryDestination address');
+        }
+        const startIdx = utils_1.default.getSafeNumber(0, 'Invalid starting index to scan for addresses', params.startingScanIndex);
+        const numIterations = utils_1.default.getSafeNumber(constants_1.DEFAULT_SCAN_FACTOR, 'Invalid scanning factor', params.scan);
+        const endIdx = startIdx + numIterations;
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        for (let idx = startIdx; idx < endIdx; idx++) {
+            const derivationPath = (params.seed ? (0, sdk_lib_mpc_1.getDerivationPath)(params.seed) : 'm') + `/${idx}`;
+            const derivedPublicKey = MPC.deriveUnhardened(bitgoKey, derivationPath).slice(0, 64);
+            const senderAddress = utils_1.default.getAddressFromPublicKey(derivedPublicKey);
+            // Token recovery path: recover the token provided by user
+            if (params.tokenContractAddress) {
+                if (!(await this.hasTokenBalance(senderAddress, params))) {
+                    continue;
+                }
+                let tokenObjects;
+                try {
+                    tokenObjects = await this.fetchOwnedObjects(senderAddress, params.fullnodeRpcUrl, params.tokenContractAddress);
+                }
+                catch (e) {
+                    continue;
+                }
+                if (tokenObjects.length === 0) {
+                    continue;
+                }
+                try {
+                    return await this.recoverIotaToken(params, tokenObjects, senderAddress, derivationPath, derivedPublicKey, idx, bitgoKey);
+                }
+                catch (e) {
+                    continue;
+                }
+            }
+            let ownedObjects;
+            try {
+                ownedObjects = await this.fetchOwnedObjects(senderAddress, params.fullnodeRpcUrl);
+            }
+            catch (e) {
+                continue;
+            }
+            if (ownedObjects.length === 0) {
+                continue;
+            }
+            // Cap objects to prevent oversized transactions (IOTA max tx size = 128 KiB)
+            if (ownedObjects.length > constants_1.MAX_GAS_OBJECTS) {
+                ownedObjects = ownedObjects
+                    .sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : -1))
+                    .slice(0, constants_1.MAX_GAS_OBJECTS);
+            }
+            const { gasBudget, gasPrice, gasObjects, totalBalance } = await this.prepareGasAndObjects(ownedObjects, senderAddress, params);
+            const netBalance = totalBalance - BigInt(gasBudget);
+            if (netBalance <= 0n) {
+                continue;
+            }
+            const recoveryAmount = netBalance.toString();
+            const factory = this.getTxBuilderFactory();
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder
+                .sender(senderAddress)
+                .recipients([{ address: params.recoveryDestination, amount: recoveryAmount }])
+                .gasData({ gasBudget, gasPrice, gasPaymentObjects: gasObjects });
+            // Return unsigned transaction for cold/custody wallets
+            const isUnsignedSweep = !params.walletPassphrase;
+            if (isUnsignedSweep) {
+                return this.buildUnsignedSweepTransaction(txBuilder, senderAddress, bitgoKey, idx, derivationPath);
+            }
+            // Build transaction for signing
+            const unsignedTx = (await txBuilder.build());
+            // Sign the transaction with decrypted keys
+            const fullSignatureBase64 = await this.signRecoveryTransaction(txBuilder, params, derivationPath, derivedPublicKey, unsignedTx);
+            // Build and return signed transaction
+            const finalTx = (await txBuilder.build());
+            const serializedTx = await finalTx.toBroadcastFormat();
+            return {
+                transactions: [
+                    {
+                        scanIndex: idx,
+                        recoveryAmount,
+                        serializedTx,
+                        signature: fullSignatureBase64,
+                        coin: this.getChain(),
+                    },
+                ],
+                lastScanIndex: idx,
+            };
+        }
+        throw new Error(`Did not find an address with sufficient funds to recover. ` +
+            `Scanned addresses from index ${startIdx} to ${endIdx - 1}. ` +
+            `Please start the next scan at address index ${endIdx}.`);
+    }
+    /**
+     * Checks whether the address holds a positive balance of the specified token.
+     */
+    async hasTokenBalance(senderAddress, params) {
+        try {
+            const balance = await this.getBalance(senderAddress, params.fullnodeRpcUrl, params.tokenContractAddress);
+            return balance > 0n;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Consolidates funds from multiple receive addresses to the base address (index 0).
+     * If walletPassphrase is not provided, returns unsigned transactions for offline signing
+     * (cold/custody wallet recovery). Otherwise, returns signed transactions.
+     *
+     * @param params - Consolidation recovery parameters
+     * @param params.bitgoKey - The commonKeychain (combined TSS public key)
+     * @param params.startingScanIndex - Starting address index to scan (default: 1)
+     * @param params.endingScanIndex - Ending address index to scan (default: startingScanIndex + 20)
+     * @param params.walletPassphrase - Optional passphrase for signing (omit for unsigned transactions)
+     * @returns MPCTxs (signed) or MPCSweepTxs (unsigned) containing all consolidation transactions
+     * @throws Error if no addresses with funds are found in the scan range
+     */
+    async recoverConsolidations(params) {
+        const isUnsignedSweep = !params.walletPassphrase;
+        const startIdx = utils_1.default.getSafeNumber(1, 'Invalid starting index to scan for addresses', params.startingScanIndex);
+        const endIdx = utils_1.default.getSafeNumber(startIdx + constants_1.DEFAULT_SCAN_FACTOR, 'Invalid ending index to scan for addresses', params.endingScanIndex);
+        if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * constants_1.DEFAULT_SCAN_FACTOR) {
+            throw new Error(`Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`);
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        const basePath = (params.seed ? (0, sdk_lib_mpc_1.getDerivationPath)(params.seed) : 'm') + '/0';
+        const derivedBasePublicKey = MPC.deriveUnhardened(bitgoKey, basePath).slice(0, 64);
+        const baseAddress = utils_1.default.getAddressFromPublicKey(derivedBasePublicKey);
+        const consolidationTransactions = [];
+        let lastScanIndex = startIdx;
+        for (let idx = startIdx; idx < endIdx; idx++) {
+            const recoverParams = {
+                userKey: params.userKey,
+                backupKey: params.backupKey,
+                bitgoKey: params.bitgoKey,
+                walletPassphrase: params.walletPassphrase,
+                seed: params.seed,
+                tokenContractAddress: params.tokenContractAddress,
+                recoveryDestination: baseAddress, // Consolidate to base address
+                startingScanIndex: idx,
+                scan: 1,
+            };
+            let recoveryTransaction;
+            try {
+                recoveryTransaction = await this.recover(recoverParams);
+            }
+            catch (e) {
+                if (e.message.startsWith('Did not find an address with sufficient funds to recover.')) {
+                    lastScanIndex = idx;
+                    continue;
+                }
+                throw e;
+            }
+            if (isUnsignedSweep) {
+                consolidationTransactions.push(recoveryTransaction.txRequests[0]);
+            }
+            else {
+                consolidationTransactions.push(recoveryTransaction.transactions[0]);
+            }
+            lastScanIndex = idx;
+        }
+        if (consolidationTransactions.length === 0) {
+            throw new Error(`Did not find an address with sufficient funds to recover. Please start the next scan at address index ${lastScanIndex + 1}.`);
+        }
+        if (isUnsignedSweep) {
+            consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific.lastScanIndex = lastScanIndex;
+            return { txRequests: consolidationTransactions };
+        }
+        return { transactions: consolidationTransactions, lastScanIndex };
+    }
+    /**
+     * Gets the total coin balance for an address.
+     *
+     * @param address - IOTA address to query
+     * @param rpcUrl - Optional RPC URL override
+     * @param coinType - Optional coin type (defaults to native IOTA)
+     * @returns Total balance as a bigint
+     */
+    async getBalance(address, rpcUrl, coinType) {
+        const url = rpcUrl || this.getPublicNodeUrl();
+        const normalizedCoinType = coinType || this.getNativeCoinType();
+        const response = await this.makeRpcCall(url, 'iotax_getBalance', [address, normalizedCoinType]);
+        return BigInt(response.totalBalance);
+    }
+    /**
+     * Fetches owned objects for an address via fullnode RPC.
+     * Handles pagination to retrieve all objects.
+     *
+     * @param address - IOTA address to query
+     * @param rpcUrl - Optional RPC URL override
+     * @param coinType - Optional coin type to filter objects (defaults to native IOTA)
+     * @returns Array of owned objects with balance information
+     */
+    async fetchOwnedObjects(address, rpcUrl, coinType) {
+        const url = rpcUrl || this.getPublicNodeUrl();
+        const allObjects = [];
+        const innerCoinType = coinType || this.getNativeCoinType();
+        const structType = `0x2::coin::Coin<${innerCoinType}>`;
+        let cursor = null;
+        let hasNextPage = true;
+        const MAX_PAGES = 500;
+        let pageCount = 0;
+        while (hasNextPage && pageCount < MAX_PAGES) {
+            pageCount++;
+            const query = {
+                filter: { StructType: structType },
+                options: { showContent: true, showType: true },
+            };
+            const response = await this.makeRpcCall(url, 'iotax_getOwnedObjects', [address, query, cursor, 50]);
+            const { data, nextCursor, hasNextPage: more } = response;
+            for (const item of data || []) {
+                const { objectId, version, digest } = item.data;
+                const balance = item.data.content?.fields?.balance || '0';
+                if (BigInt(balance) > 0n) {
+                    allObjects.push({ objectId, version: version.toString(), digest, balance });
+                }
+            }
+            if (nextCursor === cursor) {
+                break;
+            }
+            hasNextPage = more;
+            cursor = nextCursor;
+        }
+        if (pageCount >= MAX_PAGES) {
+            console.warn(`fetchOwnedObjects: Hit max page limit (${MAX_PAGES}) for ${address}`);
+        }
+        return allObjects;
+    }
+    /**
+     * Makes JSON-RPC call to IOTA fullnode.
+     *
+     * @param url - Fullnode RPC URL
+     * @param method - RPC method name
+     * @param params - RPC parameters
+     * @returns RPC result
+     * @throws Error if RPC call fails
+     */
+    async makeRpcCall(url, method, params) {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method,
+                params,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`RPC call failed with status ${response.status}`);
+        }
+        const json = await response.json();
+        if (json.error) {
+            throw new Error(`RPC error: ${json.error.message || JSON.stringify(json.error)}`);
+        }
+        return json.result;
+    }
+    /**
+     * Gets the public node RPC URL from the centralized environment configuration.
+     *
+     * @returns RPC URL for the current BitGo environment
+     */
+    getPublicNodeUrl() {
+        return sdk_core_1.Environments[this.bitgo.getEnv()].iotaNodeUrl;
+    }
+    /**
+     * Gets the native coin type identifier for filtering owned objects.
+     *
+     * @returns Native coin type string
+     */
+    getNativeCoinType() {
+        return '0x2::iota::IOTA';
+    }
+    /**
+     * Prepares gas configuration for a recovery transaction.
+     *
+     * Gas estimation is done via a dry-run of a temporary transaction, then
+     * multiplied by DEFAULT_GAS_OVERHEAD (1.1x) as a safety buffer.
+     *
+     * @param ownedObjects - Native IOTA coin objects to use as gas payment
+     * @param senderAddress - Sender address for the transaction
+     * @param params - Recovery parameters (includes recoveryDestination, rpcUrl)
+     * @param paymentObjects - Optional token objects for token recovery
+     * @returns Gas budget, gas price, gas objects array, and total native balance
+     */
+    async prepareGasAndObjects(ownedObjects, senderAddress, params, paymentObjects) {
+        const gasObjects = ownedObjects.map((obj) => ({
+            objectId: obj.objectId,
+            version: obj.version,
+            digest: obj.digest,
+        }));
+        const totalBalance = ownedObjects.reduce((sum, obj) => sum + BigInt(obj.balance), 0n);
+        const gasPrice = await this.fetchGasPrice(params.fullnodeRpcUrl);
+        // Build temp transaction for estimation
+        const factory = this.getTxBuilderFactory();
+        const tempBuilder = factory.getTransferBuilder();
+        const estimationAmount = totalBalance > 0n ? '1' : '0';
+        tempBuilder.sender(senderAddress).recipients([{ address: params.recoveryDestination, amount: estimationAmount }]);
+        if (paymentObjects && paymentObjects.length > 0) {
+            tempBuilder.paymentObjects(paymentObjects);
+        }
+        else {
+            tempBuilder.paymentObjects(gasObjects);
+        }
+        const tempTx = await tempBuilder.build();
+        const estimatedGas = await this.estimateGas(await tempTx.toBroadcastFormat(), params.fullnodeRpcUrl);
+        const gasBudget = Math.min(constants_1.MAX_GAS_BUDGET, Math.trunc(estimatedGas * constants_1.DEFAULT_GAS_OVERHEAD));
+        return { gasBudget, gasPrice, gasObjects, totalBalance };
+    }
+    async recoverIotaToken(params, tokenObjectsWithBalance, senderAddress, derivationPath, derivedPublicKey, idx, bitgoKey) {
+        tokenObjectsWithBalance = tokenObjectsWithBalance.sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : -1));
+        if (tokenObjectsWithBalance.length > constants_1.MAX_OBJECT_LIMIT) {
+            tokenObjectsWithBalance = tokenObjectsWithBalance.slice(0, constants_1.MAX_OBJECT_LIMIT);
+        }
+        const tokenObjects = tokenObjectsWithBalance.map((obj) => ({
+            objectId: obj.objectId,
+            version: obj.version,
+            digest: obj.digest,
+        }));
+        const tokenBalance = tokenObjectsWithBalance.reduce((sum, obj) => sum + BigInt(obj.balance), 0n);
+        if (tokenBalance <= 0n) {
+            throw new Error('Token balance is zero');
+        }
+        let gasObjectsWithBalance;
+        try {
+            gasObjectsWithBalance = await this.fetchOwnedObjects(senderAddress, params.fullnodeRpcUrl);
+        }
+        catch (e) {
+            throw new Error('Failed to fetch gas objects for token recovery');
+        }
+        if (gasObjectsWithBalance.length === 0) {
+            throw new Error('No gas objects found for token recovery');
+        }
+        gasObjectsWithBalance = gasObjectsWithBalance.sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : -1));
+        if (gasObjectsWithBalance.length >= constants_1.MAX_GAS_OBJECTS) {
+            gasObjectsWithBalance = gasObjectsWithBalance.slice(0, constants_1.MAX_GAS_OBJECTS - 1);
+        }
+        const { gasBudget, gasPrice, gasObjects, totalBalance } = await this.prepareGasAndObjects(gasObjectsWithBalance, senderAddress, params, tokenObjects);
+        const netGasBalance = totalBalance - BigInt(gasBudget);
+        if (netGasBalance <= 0n) {
+            throw new Error('Insufficient gas balance for token recovery');
+        }
+        const recoveryAmount = tokenBalance.toString();
+        const factory = this.getTxBuilderFactory();
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder
+            .sender(senderAddress)
+            .recipients([{ address: params.recoveryDestination, amount: recoveryAmount }])
+            .paymentObjects(tokenObjects)
+            .gasData({ gasBudget, gasPrice, gasPaymentObjects: gasObjects });
+        const isUnsignedSweep = !params.walletPassphrase;
+        const tokenCoin = params.tokenContractAddress || this.getChain();
+        if (isUnsignedSweep) {
+            return this.buildUnsignedSweepTransaction(txBuilder, senderAddress, bitgoKey, idx, derivationPath, params.tokenContractAddress);
+        }
+        const unsignedTx = (await txBuilder.build());
+        const fullSignatureBase64 = await this.signRecoveryTransaction(txBuilder, params, derivationPath, derivedPublicKey, unsignedTx);
+        const finalTx = (await txBuilder.build());
+        const serializedTx = await finalTx.toBroadcastFormat();
+        return {
+            transactions: [
+                {
+                    scanIndex: idx,
+                    recoveryAmount,
+                    serializedTx,
+                    signature: fullSignatureBase64,
+                    coin: tokenCoin,
+                },
+            ],
+            lastScanIndex: idx,
+        };
+    }
+    async signRecoveryTransaction(txBuilder, params, derivationPath, derivedPublicKey, unsignedTx) {
+        if (!params.userKey) {
+            throw new Error('missing userKey');
+        }
+        if (!params.backupKey) {
+            throw new Error('missing backupKey');
+        }
+        if (!params.walletPassphrase) {
+            throw new Error('missing wallet passphrase');
+        }
+        const userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        // Decrypt private keys from KeyCard values
+        let userPrv;
+        try {
+            userPrv = this.bitgo.decrypt({ input: userKey, password: params.walletPassphrase });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting user keychain: ${e.message}`);
+        }
+        const userSigningMaterial = JSON.parse(userPrv);
+        let backupPrv;
+        try {
+            backupPrv = this.bitgo.decrypt({ input: backupKey, password: params.walletPassphrase });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting backup keychain: ${e.message}`);
+        }
+        const backupSigningMaterial = JSON.parse(backupPrv);
+        // Generate TSS signature
+        const signatureBuffer = await sdk_core_1.EDDSAMethods.getTSSSignature(userSigningMaterial, backupSigningMaterial, derivationPath, unsignedTx);
+        // Build full signature: scheme_flag (1 byte) + signature (64 bytes) + public_key (32 bytes)
+        const schemeFlag = Buffer.alloc(1, 0x00); // Ed25519 scheme
+        const publicKeyBytes = Buffer.from(derivedPublicKey, 'hex');
+        const fullSignature = Buffer.concat([schemeFlag, signatureBuffer, publicKeyBytes]);
+        txBuilder.addSignature({ pub: derivedPublicKey }, signatureBuffer);
+        return fullSignature.toString('base64');
+    }
+    /**
+     * Fetches current reference gas price from fullnode.
+     *
+     * @param rpcUrl - Optional RPC URL override
+     * @returns Current gas price
+     */
+    async fetchGasPrice(rpcUrl) {
+        const url = rpcUrl || this.getPublicNodeUrl();
+        const result = await this.makeRpcCall(url, 'iotax_getReferenceGasPrice', []);
+        return parseInt(result, 10);
+    }
+    /**
+     * Estimates gas for a transaction via dry run.
+     *
+     * @param txBase64 - Transaction in base64 format
+     * @param rpcUrl - Optional RPC URL override
+     * @returns Estimated gas cost
+     */
+    async estimateGas(txBase64, rpcUrl) {
+        const url = rpcUrl || this.getPublicNodeUrl();
+        const result = await this.makeRpcCall(url, 'iota_dryRunTransactionBlock', [txBase64]);
+        const computationCost = parseInt(result.effects.gasUsed.computationCost, 10);
+        const storageCost = parseInt(result.effects.gasUsed.storageCost, 10);
+        const storageRebate = parseInt(result.effects.gasUsed.storageRebate, 10);
+        return Math.max(computationCost + storageCost - storageRebate, computationCost);
+    }
+    async buildUnsignedSweepTransaction(txBuilder, senderAddress, bitgoKey, scanIndex, derivationPath, tokenContractAddress) {
+        const unsignedTransaction = (await txBuilder.build());
+        const serializedTx = await unsignedTransaction.toBroadcastFormat();
+        const serializedTxHex = Buffer.from(serializedTx, 'base64').toString('hex');
+        const parsedTx = await this.parseTransaction({ txHex: serializedTxHex });
+        const walletCoin = tokenContractAddress || this.getChain();
+        const parsedOutputs = parsedTx.outputs;
+        const output = parsedOutputs[0];
+        // Build parsed transaction structure from parsed data
+        const inputs = [
+            {
+                address: senderAddress,
+                valueString: output.amount,
+                value: new bignumber_js_1.default(output.amount),
+            },
+        ];
+        const outputs = [
+            {
+                address: output.address,
+                valueString: output.amount,
+                coinName: walletCoin,
+            },
+        ];
+        const completedParsedTx = {
+            inputs: inputs,
+            outputs: outputs,
+            spendAmount: output.amount,
+            type: sdk_core_1.TransactionType.Send,
+        };
+        const fee = parsedTx.fee;
+        const feeInfo = { fee: fee.toNumber(), feeString: fee.toString() };
+        const coinSpecific = { commonKeychain: bitgoKey };
+        const transaction = {
+            serializedTx: serializedTxHex,
+            scanIndex,
+            coin: walletCoin,
+            signableHex: unsignedTransaction.signablePayload.toString('hex'),
+            derivationPath,
+            parsedTx: completedParsedTx,
+            feeInfo: feeInfo,
+            coinSpecific: coinSpecific,
+        };
+        const unsignedTxWrapper = { unsignedTx: transaction, signatureShares: [] };
+        const txRequest = { transactions: [unsignedTxWrapper], walletCoin };
+        return { txRequests: [txRequest] };
+    }
     // ========================================
     // Private Helper Methods
     // ========================================
@@ -372,4 +868,4 @@ class Iota extends sdk_core_1.BaseCoin {
     }
 }
 exports.Iota = Iota;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iota.js","sourceRoot":"","sources":["../../src/iota.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  ParsedTransaction,\n  SignTransactionOptions,\n  SignedTransaction,\n  VerifyTransactionOptions,\n  MultisigType,\n  multisigTypes,\n  MPCAlgorithm,\n  TssVerifyAddressOptions,\n  MPCType,\n  PopulatedIntent,\n  PrebuildTransactionWithIntentOptions,\n  TransactionRecipient,\n  verifyEddsaTssWalletAddress,\n} from '@bitgo/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';\nimport utils from './lib/utils';\nimport { KeyPair as IotaKeyPair, Transaction, TransactionBuilderFactory } from './lib';\nimport { auditEddsaPrivateKey } from '@bitgo/sdk-lib-mpc';\nimport BigNumber from 'bignumber.js';\nimport * as _ from 'lodash';\nimport {\n  ExplainTransactionOptions,\n  IotaParseTransactionOptions,\n  TransactionExplanation,\n  TransferTxData,\n} from './lib/iface';\nimport { TransferTransaction } from './lib/transferTransaction';\n\n/**\n * IOTA coin implementation.\n * Supports TSS (Threshold Signature Scheme) with EDDSA algorithm.\n */\nexport class Iota extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  /**\n   * Factory method to create an IOTA coin instance.\n   */\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Iota(bitgo, staticsCoin);\n  }\n\n  // ========================================\n  // Coin Configuration Methods\n  // ========================================\n\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n\n  // ========================================\n  // Multi-Signature and TSS Support\n  // ========================================\n\n  supportsTss(): boolean {\n    return true;\n  }\n\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return MPCType.EDDSA;\n  }\n\n  // ========================================\n  // Address and Public Key Validation\n  // ========================================\n\n  /**\n   * Validates an IOTA address.\n   * @param address - The address to validate (64-character hex string)\n   * @returns true if the address is valid\n   */\n  isValidAddress(address: string): boolean {\n    return utils.isValidAddress(address);\n  }\n\n  /**\n   * Validates a public key.\n   * @param pub - The public key to validate\n   * @returns true if the public key is valid\n   */\n  isValidPub(pub: string): boolean {\n    return utils.isValidPublicKey(pub);\n  }\n\n  /**\n   * Verifies if an address belongs to a TSS wallet.\n   * @param params - Verification parameters including wallet address and user/backup public keys\n   * @returns true if the address belongs to the wallet\n   */\n  async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {\n    return verifyEddsaTssWalletAddress(\n      params,\n      (address) => this.isValidAddress(address),\n      (publicKey) => utils.getAddressFromPublicKey(publicKey)\n    );\n  }\n\n  // ========================================\n  // Transaction Explanation and Verification\n  // ========================================\n\n  /**\n   * Explains a transaction by parsing its hex representation.\n   * @param params - Parameters containing the transaction hex\n   * @returns Detailed explanation of the transaction\n   * @throws Error if txHex is missing or transaction cannot be explained\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const rawTx = this.validateAndExtractTxHex(params.txHex, 'explain');\n    const transaction = await this.rebuildTransaction(rawTx);\n    return transaction.explainTransaction();\n  }\n\n  /**\n   * Verifies that a transaction prebuild matches the original transaction parameters.\n   * Ensures recipients and amounts align with the intended transaction.\n   *\n   * @param params - Verification parameters containing prebuild and original params\n   * @returns true if verification succeeds\n   * @throws Error if verification fails\n   */\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txPrebuild, txParams } = params;\n    const rawTx = this.validateAndExtractTxHex(txPrebuild.txHex, 'verify');\n\n    const transaction = await this.rebuildTransaction(rawTx);\n    this.validateTransactionType(transaction);\n\n    if (txParams.recipients !== undefined) {\n      this.verifyTransactionRecipients(transaction as TransferTransaction, txParams.recipients);\n    }\n\n    return true;\n  }\n\n  /**\n   * Parses a transaction and extracts inputs, outputs, and fees.\n   * @param params - Parameters containing the transaction hex\n   * @returns Parsed transaction with inputs, outputs, and fee information\n   */\n  async parseTransaction(params: IotaParseTransactionOptions): Promise<ParsedTransaction> {\n    const transactionExplanation = await this.explainTransaction({ txHex: params.txHex });\n\n    if (!transactionExplanation || transactionExplanation.outputs.length === 0) {\n      return this.createEmptyParsedTransaction();\n    }\n\n    const fee = this.calculateTransactionFee(transactionExplanation);\n    const inputs = this.buildTransactionInputs(transactionExplanation, fee);\n    const outputs = this.buildTransactionOutputs(transactionExplanation);\n\n    return { inputs, outputs, fee };\n  }\n\n  // ========================================\n  // Key Generation and Signing\n  // ========================================\n\n  /**\n   * Generates a key pair for IOTA transactions.\n   * @param seed - Optional seed to generate deterministic key pair\n   * @returns Key pair with public and private keys\n   * @throws Error if private key generation fails\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new IotaKeyPair({ seed }) : new IotaKeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Signs a transaction (not implemented for IOTA).\n   * IOTA transactions are signed externally using TSS.\n   */\n  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Audits a decrypted private key to ensure it's valid for the given public key.\n   * @param params - Parameters containing multiSigType, private key, and public key\n   * @throws Error if multiSigType is not TSS or if key validation fails\n   */\n  auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void {\n    if (multiSigType !== multisigTypes.tss) {\n      throw new Error('Unsupported multiSigType');\n    }\n    auditEddsaPrivateKey(prv, publicKey ?? '');\n  }\n\n  /**\n   * Extracts the signable payload from a serialized transaction.\n   * @param serializedTx - The serialized transaction hex\n   * @returns Buffer containing the signable payload\n   */\n  async getSignablePayload(serializedTx: string): Promise<Buffer> {\n    const rebuiltTransaction = await this.rebuildTransaction(serializedTx);\n    return rebuiltTransaction.signablePayload;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  /**\n   * Sets coin-specific fields in the transaction intent.\n   * @param intent - The populated intent object to modify\n   * @param params - Parameters containing unspents data\n   */\n  setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void {\n    intent.unspents = params.unspents;\n  }\n\n  // ========================================\n  // Private Helper Methods\n  // ========================================\n\n  /**\n   * Validates and extracts transaction hex from parameters.\n   * @param txHex - The transaction hex to validate\n   * @param operation - The operation being performed (for error messages)\n   * @returns The validated transaction hex\n   * @throws Error if txHex is missing\n   */\n  private validateAndExtractTxHex(txHex: string | undefined, operation: string): string {\n    if (!txHex) {\n      throw new Error(`missing required tx prebuild property txHex for ${operation} operation`);\n    }\n    return txHex;\n  }\n\n  /**\n   * Validates that the transaction is a TransferTransaction.\n   * @param transaction - The transaction to validate\n   * @throws Error if transaction is not a TransferTransaction\n   */\n  private validateTransactionType(transaction: Transaction): void {\n    if (!(transaction instanceof TransferTransaction)) {\n      throw new Error('Tx not a transfer transaction');\n    }\n  }\n\n  /**\n   * Verifies that transaction recipients match the expected recipients.\n   * @param transaction - The transfer transaction to verify\n   * @param expectedRecipients - The expected recipients from transaction params\n   * @throws Error if recipients don't match\n   */\n  private verifyTransactionRecipients(\n    transaction: TransferTransaction,\n    expectedRecipients: TransactionRecipient[]\n  ): void {\n    const txData = transaction.toJson() as TransferTxData;\n\n    if (!txData.recipients) {\n      throw new Error('Tx recipients does not match with expected txParams recipients');\n    }\n\n    const actualRecipients = this.normalizeRecipients(txData.recipients);\n    const expected = this.normalizeRecipients(expectedRecipients);\n\n    if (!this.recipientsMatch(expected, actualRecipients)) {\n      throw new Error('Tx recipients does not match with expected txParams recipients');\n    }\n  }\n\n  /**\n   * Normalizes recipients by extracting only relevant fields.\n   * @param recipients - Recipients to normalize\n   * @returns Normalized recipients with address, amount, and tokenName only\n   */\n  private normalizeRecipients(recipients: TransactionRecipient[]): TransactionRecipient[] {\n    return recipients.map((recipient) => _.pick(recipient, ['address', 'amount', 'tokenName']));\n  }\n\n  /**\n   * Checks if expected recipients match actual recipients.\n   * @param expected - Expected recipients\n   * @param actual - Actual recipients from transaction\n   * @returns true if all expected recipients are found in actual recipients\n   */\n  private recipientsMatch(expected: TransactionRecipient[], actual: TransactionRecipient[]): boolean {\n    return expected.every((expectedRecipient) =>\n      actual.some((actualRecipient) => _.isEqual(expectedRecipient, actualRecipient))\n    );\n  }\n\n  /**\n   * Creates an empty parsed transaction result.\n   * Used when transaction has no outputs.\n   */\n  private createEmptyParsedTransaction(): ParsedTransaction {\n    return {\n      inputs: [],\n      outputs: [],\n      fee: new BigNumber(0),\n    };\n  }\n\n  /**\n   * Calculates the transaction fee from the explanation.\n   * @param explanation - The transaction explanation\n   * @returns The fee as a BigNumber\n   */\n  private calculateTransactionFee(explanation: TransactionExplanation): BigNumber {\n    if (explanation.fee.fee === '') {\n      return new BigNumber(0);\n    }\n    return new BigNumber(explanation.fee.fee);\n  }\n\n  /**\n   * Builds the inputs array for a parsed transaction.\n   * Includes sender input and optionally sponsor input if present.\n   *\n   * @param explanation - The transaction explanation\n   * @param fee - The calculated transaction fee\n   * @returns Array of transaction inputs\n   */\n  private buildTransactionInputs(\n    explanation: TransactionExplanation,\n    fee: BigNumber\n  ): Array<{\n    address: string;\n    amount: string;\n  }> {\n    const senderAddress = explanation.outputs[0].address;\n    const outputAmount = new BigNumber(explanation.outputAmount);\n\n    // If there's a sponsor, sender only pays for outputs\n    // Otherwise, sender pays for outputs + fee\n    const senderAmount = explanation.sponsor ? outputAmount.toFixed() : outputAmount.plus(fee).toFixed();\n\n    const inputs = [\n      {\n        address: senderAddress,\n        amount: senderAmount,\n      },\n    ];\n\n    // Add sponsor input if present\n    if (explanation.sponsor) {\n      inputs.push({\n        address: explanation.sponsor,\n        amount: fee.toFixed(),\n      });\n    }\n\n    return inputs;\n  }\n\n  /**\n   * Builds the outputs array for a parsed transaction.\n   * @param explanation - The transaction explanation\n   * @returns Array of transaction outputs\n   */\n  private buildTransactionOutputs(explanation: TransactionExplanation): Array<{\n    address: string;\n    amount: string;\n  }> {\n    return explanation.outputs.map((output) => ({\n      address: output.address,\n      amount: new BigNumber(output.amount).toFixed(),\n    }));\n  }\n\n  /**\n   * Creates a transaction builder factory instance.\n   * @returns TransactionBuilderFactory for this coin\n   */\n  private getTxBuilderFactory(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /**\n   * Rebuilds a transaction from its hex representation.\n   * @param txHex - The transaction hex to rebuild\n   * @returns The rebuilt transaction\n   * @throws Error if transaction cannot be rebuilt\n   */\n  private async rebuildTransaction(txHex: string): Promise<Transaction> {\n    const txBuilderFactory = this.getTxBuilderFactory();\n    try {\n      const txBuilder = txBuilderFactory.from(txHex);\n      return (await txBuilder.build()) as Transaction;\n    } catch (err) {\n      throw new Error(`Failed to rebuild transaction: ${err.toString()}`);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iota.js","sourceRoot":"","sources":["../../src/iota.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BitGoBase,\n  EDDSAMethods,\n  EDDSAMethodTypes,\n  Environments,\n  KeyPair,\n  MPCAlgorithm,\n  MPCConsolidationRecoveryOptions,\n  MPCRecoveryOptions,\n  MPCSweepTxs,\n  MPCTx,\n  MPCTxs,\n  MPCType,\n  MPCUnsignedTx,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  PopulatedIntent,\n  PrebuildTransactionWithIntentOptions,\n  RecoveryTxRequest,\n  SignedTransaction,\n  SignTransactionOptions,\n  TransactionRecipient,\n  TransactionType,\n  TssVerifyAddressOptions,\n  verifyEddsaTssWalletAddress,\n  VerifyTransactionOptions,\n} from '@bitgo/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';\nimport utils from './lib/utils';\nimport { KeyPair as IotaKeyPair, Transaction, TransactionBuilder, TransactionBuilderFactory } from './lib';\nimport { auditEddsaPrivateKey, getDerivationPath } from '@bitgo/sdk-lib-mpc';\nimport BigNumber from 'bignumber.js';\nimport * as _ from 'lodash';\nimport {\n  ExplainTransactionOptions,\n  IotaParseTransactionOptions,\n  TransactionExplanation,\n  TransferTxData,\n  TransactionObjectInput,\n} from './lib/iface';\nimport { TransferTransaction } from './lib/transferTransaction';\nimport {\n  DEFAULT_GAS_OVERHEAD,\n  DEFAULT_SCAN_FACTOR,\n  MAX_GAS_BUDGET,\n  MAX_GAS_OBJECTS,\n  MAX_OBJECT_LIMIT,\n} from './lib/constants';\n\nexport interface IotaRecoveryOptions extends MPCRecoveryOptions {\n  fullnodeRpcUrl?: string; // Override default RPC URL\n}\n\ninterface IotaObjectWithBalance extends TransactionObjectInput {\n  balance: string;\n}\n\n/**\n * IOTA coin implementation.\n * Supports TSS (Threshold Signature Scheme) with EDDSA algorithm.\n */\nexport class Iota extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  /**\n   * Factory method to create an IOTA coin instance.\n   */\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Iota(bitgo, staticsCoin);\n  }\n\n  // ========================================\n  // Coin Configuration Methods\n  // ========================================\n\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n\n  // ========================================\n  // Multi-Signature and TSS Support\n  // ========================================\n\n  supportsTss(): boolean {\n    return true;\n  }\n\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return MPCType.EDDSA;\n  }\n\n  // ========================================\n  // Address and Public Key Validation\n  // ========================================\n\n  /**\n   * Validates an IOTA address.\n   * @param address - The address to validate (64-character hex string)\n   * @returns true if the address is valid\n   */\n  isValidAddress(address: string): boolean {\n    return utils.isValidAddress(address);\n  }\n\n  /**\n   * Validates a public key.\n   * @param pub - The public key to validate\n   * @returns true if the public key is valid\n   */\n  isValidPub(pub: string): boolean {\n    return utils.isValidPublicKey(pub);\n  }\n\n  /**\n   * Verifies if an address belongs to a TSS wallet.\n   * @param params - Verification parameters including wallet address and user/backup public keys\n   * @returns true if the address belongs to the wallet\n   */\n  async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {\n    return verifyEddsaTssWalletAddress(\n      params,\n      (address) => this.isValidAddress(address),\n      (publicKey) => utils.getAddressFromPublicKey(publicKey)\n    );\n  }\n\n  // ========================================\n  // Transaction Explanation and Verification\n  // ========================================\n\n  /**\n   * Explains a transaction by parsing its hex representation.\n   * @param params - Parameters containing the transaction hex\n   * @returns Detailed explanation of the transaction\n   * @throws Error if txHex is missing or transaction cannot be explained\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const rawTx = this.validateAndExtractTxHex(params.txHex, 'explain');\n    const transaction = await this.rebuildTransaction(rawTx);\n    return transaction.explainTransaction();\n  }\n\n  /**\n   * Verifies that a transaction prebuild matches the original transaction parameters.\n   * Ensures recipients and amounts align with the intended transaction.\n   *\n   * @param params - Verification parameters containing prebuild and original params\n   * @returns true if verification succeeds\n   * @throws Error if verification fails\n   */\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txPrebuild, txParams } = params;\n    const rawTx = this.validateAndExtractTxHex(txPrebuild.txHex, 'verify');\n\n    const transaction = await this.rebuildTransaction(rawTx);\n    this.validateTransactionType(transaction);\n\n    if (txParams.recipients !== undefined) {\n      this.verifyTransactionRecipients(transaction as TransferTransaction, txParams.recipients);\n    }\n\n    return true;\n  }\n\n  /**\n   * Parses a transaction and extracts inputs, outputs, and fees.\n   * @param params - Parameters containing the transaction hex\n   * @returns Parsed transaction with inputs, outputs, and fee information\n   */\n  async parseTransaction(params: IotaParseTransactionOptions): Promise<ParsedTransaction> {\n    const transactionExplanation = await this.explainTransaction({ txHex: params.txHex });\n\n    if (!transactionExplanation || transactionExplanation.outputs.length === 0) {\n      return this.createEmptyParsedTransaction();\n    }\n\n    const fee = this.calculateTransactionFee(transactionExplanation);\n    const inputs = this.buildTransactionInputs(transactionExplanation, fee);\n    const outputs = this.buildTransactionOutputs(transactionExplanation);\n\n    return { inputs, outputs, fee };\n  }\n\n  // ========================================\n  // Key Generation and Signing\n  // ========================================\n\n  /**\n   * Generates a key pair for IOTA transactions.\n   * @param seed - Optional seed to generate deterministic key pair\n   * @returns Key pair with public and private keys\n   * @throws Error if private key generation fails\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new IotaKeyPair({ seed }) : new IotaKeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Signs a transaction (not implemented for IOTA).\n   * IOTA transactions are signed externally using TSS.\n   */\n  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Audits a decrypted private key to ensure it's valid for the given public key.\n   * @param params - Parameters containing multiSigType, private key, and public key\n   * @throws Error if multiSigType is not TSS or if key validation fails\n   */\n  auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void {\n    if (multiSigType !== multisigTypes.tss) {\n      throw new Error('Unsupported multiSigType');\n    }\n    auditEddsaPrivateKey(prv, publicKey ?? '');\n  }\n\n  /**\n   * Extracts the signable payload from a serialized transaction.\n   * @param serializedTx - The serialized transaction hex\n   * @returns Buffer containing the signable payload\n   */\n  async getSignablePayload(serializedTx: string): Promise<Buffer> {\n    const rebuiltTransaction = await this.rebuildTransaction(serializedTx);\n    return rebuiltTransaction.signablePayload;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  /**\n   * Sets coin-specific fields in the transaction intent.\n   * @param intent - The populated intent object to modify\n   * @param params - Parameters containing unspents data\n   */\n  setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void {\n    intent.unspents = params.unspents;\n  }\n\n  /**\n   * Builds funds recovery transaction(s) without BitGo\n   *\n   * @param {IotaRecoveryOptions} params parameters needed to construct and\n   * (maybe) sign the transaction\n   *\n   * @returns {MPCTx | MPCSweepTxs} array of the serialized transaction hex strings and indices\n   * of the addresses being swept\n   */\n  async recover(params: IotaRecoveryOptions): Promise<MPCTxs | MPCSweepTxs> {\n    if (!params.bitgoKey) {\n      throw new Error('Missing bitgoKey');\n    }\n    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('Invalid recoveryDestination address');\n    }\n\n    const startIdx = utils.getSafeNumber(0, 'Invalid starting index to scan for addresses', params.startingScanIndex);\n    const numIterations = utils.getSafeNumber(DEFAULT_SCAN_FACTOR, 'Invalid scanning factor', params.scan);\n    const endIdx = startIdx + numIterations;\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n\n    for (let idx = startIdx; idx < endIdx; idx++) {\n      const derivationPath = (params.seed ? getDerivationPath(params.seed) : 'm') + `/${idx}`;\n      const derivedPublicKey = MPC.deriveUnhardened(bitgoKey, derivationPath).slice(0, 64);\n      const senderAddress = utils.getAddressFromPublicKey(derivedPublicKey);\n\n      // Token recovery path: recover the token provided by user\n      if (params.tokenContractAddress) {\n        if (!(await this.hasTokenBalance(senderAddress, params))) {\n          continue;\n        }\n\n        let tokenObjects: IotaObjectWithBalance[];\n        try {\n          tokenObjects = await this.fetchOwnedObjects(\n            senderAddress,\n            params.fullnodeRpcUrl,\n            params.tokenContractAddress\n          );\n        } catch (e) {\n          continue;\n        }\n\n        if (tokenObjects.length === 0) {\n          continue;\n        }\n\n        try {\n          return await this.recoverIotaToken(\n            params,\n            tokenObjects,\n            senderAddress,\n            derivationPath,\n            derivedPublicKey,\n            idx,\n            bitgoKey\n          );\n        } catch (e) {\n          continue;\n        }\n      }\n\n      let ownedObjects: IotaObjectWithBalance[];\n      try {\n        ownedObjects = await this.fetchOwnedObjects(senderAddress, params.fullnodeRpcUrl);\n      } catch (e) {\n        continue;\n      }\n\n      if (ownedObjects.length === 0) {\n        continue;\n      }\n\n      // Cap objects to prevent oversized transactions (IOTA max tx size = 128 KiB)\n      if (ownedObjects.length > MAX_GAS_OBJECTS) {\n        ownedObjects = ownedObjects\n          .sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : -1))\n          .slice(0, MAX_GAS_OBJECTS);\n      }\n\n      const { gasBudget, gasPrice, gasObjects, totalBalance } = await this.prepareGasAndObjects(\n        ownedObjects,\n        senderAddress,\n        params\n      );\n\n      const netBalance = totalBalance - BigInt(gasBudget);\n\n      if (netBalance <= 0n) {\n        continue;\n      }\n      const recoveryAmount = netBalance.toString();\n\n      const factory = this.getTxBuilderFactory();\n      const txBuilder = factory.getTransferBuilder();\n\n      txBuilder\n        .sender(senderAddress)\n        .recipients([{ address: params.recoveryDestination, amount: recoveryAmount }])\n        .gasData({ gasBudget, gasPrice, gasPaymentObjects: gasObjects });\n\n      // Return unsigned transaction for cold/custody wallets\n      const isUnsignedSweep = !params.walletPassphrase;\n      if (isUnsignedSweep) {\n        return this.buildUnsignedSweepTransaction(txBuilder, senderAddress, bitgoKey, idx, derivationPath);\n      }\n\n      // Build transaction for signing\n      const unsignedTx = (await txBuilder.build()) as TransferTransaction;\n\n      // Sign the transaction with decrypted keys\n      const fullSignatureBase64 = await this.signRecoveryTransaction(\n        txBuilder,\n        params,\n        derivationPath,\n        derivedPublicKey,\n        unsignedTx\n      );\n\n      // Build and return signed transaction\n      const finalTx = (await txBuilder.build()) as TransferTransaction;\n      const serializedTx = await finalTx.toBroadcastFormat();\n\n      return {\n        transactions: [\n          {\n            scanIndex: idx,\n            recoveryAmount,\n            serializedTx,\n            signature: fullSignatureBase64,\n            coin: this.getChain(),\n          },\n        ],\n        lastScanIndex: idx,\n      };\n    }\n\n    throw new Error(\n      `Did not find an address with sufficient funds to recover. ` +\n        `Scanned addresses from index ${startIdx} to ${endIdx - 1}. ` +\n        `Please start the next scan at address index ${endIdx}.`\n    );\n  }\n\n  /**\n   * Checks whether the address holds a positive balance of the specified token.\n   */\n  private async hasTokenBalance(senderAddress: string, params: IotaRecoveryOptions): Promise<boolean> {\n    try {\n      const balance = await this.getBalance(senderAddress, params.fullnodeRpcUrl, params.tokenContractAddress);\n      return balance > 0n;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Consolidates funds from multiple receive addresses to the base address (index 0).\n   * If walletPassphrase is not provided, returns unsigned transactions for offline signing\n   * (cold/custody wallet recovery). Otherwise, returns signed transactions.\n   *\n   * @param params - Consolidation recovery parameters\n   * @param params.bitgoKey - The commonKeychain (combined TSS public key)\n   * @param params.startingScanIndex - Starting address index to scan (default: 1)\n   * @param params.endingScanIndex - Ending address index to scan (default: startingScanIndex + 20)\n   * @param params.walletPassphrase - Optional passphrase for signing (omit for unsigned transactions)\n   * @returns MPCTxs (signed) or MPCSweepTxs (unsigned) containing all consolidation transactions\n   * @throws Error if no addresses with funds are found in the scan range\n   */\n  async recoverConsolidations(params: MPCConsolidationRecoveryOptions): Promise<MPCTxs | MPCSweepTxs> {\n    const isUnsignedSweep = !params.walletPassphrase;\n\n    const startIdx = utils.getSafeNumber(1, 'Invalid starting index to scan for addresses', params.startingScanIndex);\n    const endIdx = utils.getSafeNumber(\n      startIdx + DEFAULT_SCAN_FACTOR,\n      'Invalid ending index to scan for addresses',\n      params.endingScanIndex\n    );\n\n    if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * DEFAULT_SCAN_FACTOR) {\n      throw new Error(\n        `Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`\n      );\n    }\n\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n\n    const basePath = (params.seed ? getDerivationPath(params.seed) : 'm') + '/0';\n    const derivedBasePublicKey = MPC.deriveUnhardened(bitgoKey, basePath).slice(0, 64);\n    const baseAddress = utils.getAddressFromPublicKey(derivedBasePublicKey);\n\n    const consolidationTransactions: any[] = [];\n    let lastScanIndex = startIdx;\n\n    for (let idx = startIdx; idx < endIdx; idx++) {\n      const recoverParams: IotaRecoveryOptions = {\n        userKey: params.userKey,\n        backupKey: params.backupKey,\n        bitgoKey: params.bitgoKey,\n        walletPassphrase: params.walletPassphrase,\n        seed: params.seed,\n        tokenContractAddress: params.tokenContractAddress,\n        recoveryDestination: baseAddress, // Consolidate to base address\n        startingScanIndex: idx,\n        scan: 1,\n      };\n\n      let recoveryTransaction: MPCTxs | MPCSweepTxs;\n      try {\n        recoveryTransaction = await this.recover(recoverParams);\n      } catch (e) {\n        if ((e as Error).message.startsWith('Did not find an address with sufficient funds to recover.')) {\n          lastScanIndex = idx;\n          continue;\n        }\n        throw e;\n      }\n\n      if (isUnsignedSweep) {\n        consolidationTransactions.push((recoveryTransaction as MPCSweepTxs).txRequests[0]);\n      } else {\n        consolidationTransactions.push((recoveryTransaction as MPCTxs).transactions[0]);\n      }\n      lastScanIndex = idx;\n    }\n\n    if (consolidationTransactions.length === 0) {\n      throw new Error(\n        `Did not find an address with sufficient funds to recover. Please start the next scan at address index ${\n          lastScanIndex + 1\n        }.`\n      );\n    }\n\n    if (isUnsignedSweep) {\n      consolidationTransactions[\n        consolidationTransactions.length - 1\n      ].transactions[0].unsignedTx.coinSpecific.lastScanIndex = lastScanIndex;\n      return { txRequests: consolidationTransactions };\n    }\n\n    return { transactions: consolidationTransactions, lastScanIndex };\n  }\n\n  /**\n   * Gets the total coin balance for an address.\n   *\n   * @param address - IOTA address to query\n   * @param rpcUrl - Optional RPC URL override\n   * @param coinType - Optional coin type (defaults to native IOTA)\n   * @returns Total balance as a bigint\n   */\n  private async getBalance(address: string, rpcUrl?: string, coinType?: string): Promise<bigint> {\n    const url = rpcUrl || this.getPublicNodeUrl();\n    const normalizedCoinType = coinType || this.getNativeCoinType();\n    const response = await this.makeRpcCall(url, 'iotax_getBalance', [address, normalizedCoinType]);\n    return BigInt(response.totalBalance);\n  }\n\n  /**\n   * Fetches owned objects for an address via fullnode RPC.\n   * Handles pagination to retrieve all objects.\n   *\n   * @param address - IOTA address to query\n   * @param rpcUrl - Optional RPC URL override\n   * @param coinType - Optional coin type to filter objects (defaults to native IOTA)\n   * @returns Array of owned objects with balance information\n   */\n  private async fetchOwnedObjects(\n    address: string,\n    rpcUrl?: string,\n    coinType?: string\n  ): Promise<IotaObjectWithBalance[]> {\n    const url = rpcUrl || this.getPublicNodeUrl();\n    const allObjects: IotaObjectWithBalance[] = [];\n    const innerCoinType = coinType || this.getNativeCoinType();\n    const structType = `0x2::coin::Coin<${innerCoinType}>`;\n    let cursor: string | null = null;\n    let hasNextPage = true;\n    const MAX_PAGES = 500;\n    let pageCount = 0;\n    while (hasNextPage && pageCount < MAX_PAGES) {\n      pageCount++;\n      const query = {\n        filter: { StructType: structType },\n        options: { showContent: true, showType: true },\n      };\n\n      const response = await this.makeRpcCall(url, 'iotax_getOwnedObjects', [address, query, cursor, 50]);\n      const { data, nextCursor, hasNextPage: more } = response;\n\n      for (const item of data || []) {\n        const { objectId, version, digest } = item.data;\n        const balance = item.data.content?.fields?.balance || '0';\n        if (BigInt(balance) > 0n) {\n          allObjects.push({ objectId, version: version.toString(), digest, balance });\n        }\n      }\n\n      if (nextCursor === cursor) {\n        break;\n      }\n      hasNextPage = more;\n      cursor = nextCursor;\n    }\n\n    if (pageCount >= MAX_PAGES) {\n      console.warn(`fetchOwnedObjects: Hit max page limit (${MAX_PAGES}) for ${address}`);\n    }\n    return allObjects;\n  }\n\n  /**\n   * Makes JSON-RPC call to IOTA fullnode.\n   *\n   * @param url - Fullnode RPC URL\n   * @param method - RPC method name\n   * @param params - RPC parameters\n   * @returns RPC result\n   * @throws Error if RPC call fails\n   */\n  private async makeRpcCall(url: string, method: string, params: any[]): Promise<any> {\n    const response = await fetch(url, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({\n        jsonrpc: '2.0',\n        id: 1,\n        method,\n        params,\n      }),\n    });\n\n    if (!response.ok) {\n      throw new Error(`RPC call failed with status ${response.status}`);\n    }\n\n    const json = await response.json();\n\n    if (json.error) {\n      throw new Error(`RPC error: ${json.error.message || JSON.stringify(json.error)}`);\n    }\n\n    return json.result;\n  }\n\n  /**\n   * Gets the public node RPC URL from the centralized environment configuration.\n   *\n   * @returns RPC URL for the current BitGo environment\n   */\n  protected getPublicNodeUrl(): string {\n    return Environments[this.bitgo.getEnv()].iotaNodeUrl;\n  }\n\n  /**\n   * Gets the native coin type identifier for filtering owned objects.\n   *\n   * @returns Native coin type string\n   */\n  private getNativeCoinType(): string {\n    return '0x2::iota::IOTA';\n  }\n\n  /**\n   * Prepares gas configuration for a recovery transaction.\n   *\n   * Gas estimation is done via a dry-run of a temporary transaction, then\n   * multiplied by DEFAULT_GAS_OVERHEAD (1.1x) as a safety buffer.\n   *\n   * @param ownedObjects - Native IOTA coin objects to use as gas payment\n   * @param senderAddress - Sender address for the transaction\n   * @param params - Recovery parameters (includes recoveryDestination, rpcUrl)\n   * @param paymentObjects - Optional token objects for token recovery\n   * @returns Gas budget, gas price, gas objects array, and total native balance\n   */\n  private async prepareGasAndObjects(\n    ownedObjects: IotaObjectWithBalance[],\n    senderAddress: string,\n    params: IotaRecoveryOptions,\n    paymentObjects?: TransactionObjectInput[]\n  ): Promise<{\n    gasBudget: number;\n    gasPrice: number;\n    gasObjects: TransactionObjectInput[];\n    totalBalance: bigint;\n  }> {\n    const gasObjects: TransactionObjectInput[] = ownedObjects.map((obj) => ({\n      objectId: obj.objectId,\n      version: obj.version,\n      digest: obj.digest,\n    }));\n    const totalBalance = ownedObjects.reduce((sum, obj) => sum + BigInt(obj.balance), 0n);\n\n    const gasPrice = await this.fetchGasPrice(params.fullnodeRpcUrl);\n\n    // Build temp transaction for estimation\n    const factory = this.getTxBuilderFactory();\n    const tempBuilder = factory.getTransferBuilder();\n    const estimationAmount = totalBalance > 0n ? '1' : '0';\n\n    tempBuilder.sender(senderAddress).recipients([{ address: params.recoveryDestination, amount: estimationAmount }]);\n\n    if (paymentObjects && paymentObjects.length > 0) {\n      tempBuilder.paymentObjects(paymentObjects);\n    } else {\n      tempBuilder.paymentObjects(gasObjects);\n    }\n\n    const tempTx = await tempBuilder.build();\n    const estimatedGas = await this.estimateGas(await tempTx.toBroadcastFormat(), params.fullnodeRpcUrl);\n    const gasBudget = Math.min(MAX_GAS_BUDGET, Math.trunc(estimatedGas * DEFAULT_GAS_OVERHEAD));\n\n    return { gasBudget, gasPrice, gasObjects, totalBalance };\n  }\n\n  private async recoverIotaToken(\n    params: IotaRecoveryOptions,\n    tokenObjectsWithBalance: IotaObjectWithBalance[],\n    senderAddress: string,\n    derivationPath: string,\n    derivedPublicKey: string,\n    idx: number,\n    bitgoKey: string\n  ): Promise<MPCTxs | MPCSweepTxs> {\n    tokenObjectsWithBalance = tokenObjectsWithBalance.sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : -1));\n    if (tokenObjectsWithBalance.length > MAX_OBJECT_LIMIT) {\n      tokenObjectsWithBalance = tokenObjectsWithBalance.slice(0, MAX_OBJECT_LIMIT);\n    }\n\n    const tokenObjects: TransactionObjectInput[] = tokenObjectsWithBalance.map((obj) => ({\n      objectId: obj.objectId,\n      version: obj.version,\n      digest: obj.digest,\n    }));\n    const tokenBalance = tokenObjectsWithBalance.reduce((sum, obj) => sum + BigInt(obj.balance), 0n);\n    if (tokenBalance <= 0n) {\n      throw new Error('Token balance is zero');\n    }\n\n    let gasObjectsWithBalance: IotaObjectWithBalance[];\n    try {\n      gasObjectsWithBalance = await this.fetchOwnedObjects(senderAddress, params.fullnodeRpcUrl);\n    } catch (e) {\n      throw new Error('Failed to fetch gas objects for token recovery');\n    }\n    if (gasObjectsWithBalance.length === 0) {\n      throw new Error('No gas objects found for token recovery');\n    }\n\n    gasObjectsWithBalance = gasObjectsWithBalance.sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : -1));\n    if (gasObjectsWithBalance.length >= MAX_GAS_OBJECTS) {\n      gasObjectsWithBalance = gasObjectsWithBalance.slice(0, MAX_GAS_OBJECTS - 1);\n    }\n\n    const { gasBudget, gasPrice, gasObjects, totalBalance } = await this.prepareGasAndObjects(\n      gasObjectsWithBalance,\n      senderAddress,\n      params,\n      tokenObjects\n    );\n    const netGasBalance = totalBalance - BigInt(gasBudget);\n    if (netGasBalance <= 0n) {\n      throw new Error('Insufficient gas balance for token recovery');\n    }\n\n    const recoveryAmount = tokenBalance.toString();\n    const factory = this.getTxBuilderFactory();\n    const txBuilder = factory.getTransferBuilder();\n\n    txBuilder\n      .sender(senderAddress)\n      .recipients([{ address: params.recoveryDestination, amount: recoveryAmount }])\n      .paymentObjects(tokenObjects)\n      .gasData({ gasBudget, gasPrice, gasPaymentObjects: gasObjects });\n\n    const isUnsignedSweep = !params.walletPassphrase;\n    const tokenCoin = params.tokenContractAddress || this.getChain();\n\n    if (isUnsignedSweep) {\n      return this.buildUnsignedSweepTransaction(\n        txBuilder,\n        senderAddress,\n        bitgoKey,\n        idx,\n        derivationPath,\n        params.tokenContractAddress\n      );\n    }\n\n    const unsignedTx = (await txBuilder.build()) as TransferTransaction;\n\n    const fullSignatureBase64 = await this.signRecoveryTransaction(\n      txBuilder,\n      params,\n      derivationPath,\n      derivedPublicKey,\n      unsignedTx\n    );\n\n    const finalTx = (await txBuilder.build()) as TransferTransaction;\n    const serializedTx = await finalTx.toBroadcastFormat();\n\n    return {\n      transactions: [\n        {\n          scanIndex: idx,\n          recoveryAmount,\n          serializedTx,\n          signature: fullSignatureBase64,\n          coin: tokenCoin,\n        },\n      ],\n      lastScanIndex: idx,\n    };\n  }\n\n  private async signRecoveryTransaction(\n    txBuilder: TransactionBuilder,\n    params: IotaRecoveryOptions,\n    derivationPath: string,\n    derivedPublicKey: string,\n    unsignedTx: TransferTransaction\n  ): Promise<string> {\n    if (!params.userKey) {\n      throw new Error('missing userKey');\n    }\n    if (!params.backupKey) {\n      throw new Error('missing backupKey');\n    }\n    if (!params.walletPassphrase) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    const userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n\n    // Decrypt private keys from KeyCard values\n    let userPrv: string;\n    try {\n      userPrv = this.bitgo.decrypt({ input: userKey, password: params.walletPassphrase });\n    } catch (e) {\n      throw new Error(`Error decrypting user keychain: ${(e as Error).message}`);\n    }\n    const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;\n\n    let backupPrv: string;\n    try {\n      backupPrv = this.bitgo.decrypt({ input: backupKey, password: params.walletPassphrase });\n    } catch (e) {\n      throw new Error(`Error decrypting backup keychain: ${(e as Error).message}`);\n    }\n    const backupSigningMaterial = JSON.parse(backupPrv) as EDDSAMethodTypes.BackupSigningMaterial;\n\n    // Generate TSS signature\n    const signatureBuffer = await EDDSAMethods.getTSSSignature(\n      userSigningMaterial,\n      backupSigningMaterial,\n      derivationPath,\n      unsignedTx\n    );\n\n    // Build full signature: scheme_flag (1 byte) + signature (64 bytes) + public_key (32 bytes)\n    const schemeFlag = Buffer.alloc(1, 0x00); // Ed25519 scheme\n    const publicKeyBytes = Buffer.from(derivedPublicKey, 'hex');\n    const fullSignature = Buffer.concat([schemeFlag, signatureBuffer, publicKeyBytes]);\n\n    txBuilder.addSignature({ pub: derivedPublicKey }, signatureBuffer);\n\n    return fullSignature.toString('base64');\n  }\n\n  /**\n   * Fetches current reference gas price from fullnode.\n   *\n   * @param rpcUrl - Optional RPC URL override\n   * @returns Current gas price\n   */\n  private async fetchGasPrice(rpcUrl?: string): Promise<number> {\n    const url = rpcUrl || this.getPublicNodeUrl();\n    const result = await this.makeRpcCall(url, 'iotax_getReferenceGasPrice', []);\n    return parseInt(result, 10);\n  }\n\n  /**\n   * Estimates gas for a transaction via dry run.\n   *\n   * @param txBase64 - Transaction in base64 format\n   * @param rpcUrl - Optional RPC URL override\n   * @returns Estimated gas cost\n   */\n  private async estimateGas(txBase64: string, rpcUrl?: string): Promise<number> {\n    const url = rpcUrl || this.getPublicNodeUrl();\n    const result = await this.makeRpcCall(url, 'iota_dryRunTransactionBlock', [txBase64]);\n\n    const computationCost = parseInt(result.effects.gasUsed.computationCost, 10);\n    const storageCost = parseInt(result.effects.gasUsed.storageCost, 10);\n    const storageRebate = parseInt(result.effects.gasUsed.storageRebate, 10);\n\n    return Math.max(computationCost + storageCost - storageRebate, computationCost);\n  }\n\n  private async buildUnsignedSweepTransaction(\n    txBuilder: TransactionBuilder,\n    senderAddress: string,\n    bitgoKey: string,\n    scanIndex: number,\n    derivationPath: string,\n    tokenContractAddress?: string\n  ): Promise<MPCSweepTxs> {\n    const unsignedTransaction = (await txBuilder.build()) as TransferTransaction;\n    const serializedTx = await unsignedTransaction.toBroadcastFormat();\n    const serializedTxHex = Buffer.from(serializedTx, 'base64').toString('hex');\n    const parsedTx = await this.parseTransaction({ txHex: serializedTxHex });\n    const walletCoin = tokenContractAddress || this.getChain();\n    const parsedOutputs = parsedTx.outputs as Array<{ address: string; amount: string }>;\n    const output = parsedOutputs[0];\n\n    // Build parsed transaction structure from parsed data\n    const inputs = [\n      {\n        address: senderAddress,\n        valueString: output.amount,\n        value: new BigNumber(output.amount),\n      },\n    ];\n    const outputs = [\n      {\n        address: output.address,\n        valueString: output.amount,\n        coinName: walletCoin,\n      },\n    ];\n\n    const completedParsedTx = {\n      inputs: inputs,\n      outputs: outputs,\n      spendAmount: output.amount,\n      type: TransactionType.Send,\n    };\n\n    const fee = parsedTx.fee as BigNumber;\n    const feeInfo = { fee: fee.toNumber(), feeString: fee.toString() };\n    const coinSpecific = { commonKeychain: bitgoKey };\n\n    const transaction: MPCTx = {\n      serializedTx: serializedTxHex,\n      scanIndex,\n      coin: walletCoin,\n      signableHex: unsignedTransaction.signablePayload.toString('hex'),\n      derivationPath,\n      parsedTx: completedParsedTx,\n      feeInfo: feeInfo,\n      coinSpecific: coinSpecific,\n    };\n\n    const unsignedTxWrapper: MPCUnsignedTx = { unsignedTx: transaction, signatureShares: [] };\n    const txRequest: RecoveryTxRequest = { transactions: [unsignedTxWrapper], walletCoin };\n    return { txRequests: [txRequest] };\n  }\n\n  // ========================================\n  // Private Helper Methods\n  // ========================================\n\n  /**\n   * Validates and extracts transaction hex from parameters.\n   * @param txHex - The transaction hex to validate\n   * @param operation - The operation being performed (for error messages)\n   * @returns The validated transaction hex\n   * @throws Error if txHex is missing\n   */\n  private validateAndExtractTxHex(txHex: string | undefined, operation: string): string {\n    if (!txHex) {\n      throw new Error(`missing required tx prebuild property txHex for ${operation} operation`);\n    }\n    return txHex;\n  }\n\n  /**\n   * Validates that the transaction is a TransferTransaction.\n   * @param transaction - The transaction to validate\n   * @throws Error if transaction is not a TransferTransaction\n   */\n  private validateTransactionType(transaction: Transaction): void {\n    if (!(transaction instanceof TransferTransaction)) {\n      throw new Error('Tx not a transfer transaction');\n    }\n  }\n\n  /**\n   * Verifies that transaction recipients match the expected recipients.\n   * @param transaction - The transfer transaction to verify\n   * @param expectedRecipients - The expected recipients from transaction params\n   * @throws Error if recipients don't match\n   */\n  private verifyTransactionRecipients(\n    transaction: TransferTransaction,\n    expectedRecipients: TransactionRecipient[]\n  ): void {\n    const txData = transaction.toJson() as TransferTxData;\n\n    if (!txData.recipients) {\n      throw new Error('Tx recipients does not match with expected txParams recipients');\n    }\n\n    const actualRecipients = this.normalizeRecipients(txData.recipients);\n    const expected = this.normalizeRecipients(expectedRecipients);\n\n    if (!this.recipientsMatch(expected, actualRecipients)) {\n      throw new Error('Tx recipients does not match with expected txParams recipients');\n    }\n  }\n\n  /**\n   * Normalizes recipients by extracting only relevant fields.\n   * @param recipients - Recipients to normalize\n   * @returns Normalized recipients with address, amount, and tokenName only\n   */\n  private normalizeRecipients(recipients: TransactionRecipient[]): TransactionRecipient[] {\n    return recipients.map((recipient) => _.pick(recipient, ['address', 'amount', 'tokenName']));\n  }\n\n  /**\n   * Checks if expected recipients match actual recipients.\n   * @param expected - Expected recipients\n   * @param actual - Actual recipients from transaction\n   * @returns true if all expected recipients are found in actual recipients\n   */\n  private recipientsMatch(expected: TransactionRecipient[], actual: TransactionRecipient[]): boolean {\n    return expected.every((expectedRecipient) =>\n      actual.some((actualRecipient) => _.isEqual(expectedRecipient, actualRecipient))\n    );\n  }\n\n  /**\n   * Creates an empty parsed transaction result.\n   * Used when transaction has no outputs.\n   */\n  private createEmptyParsedTransaction(): ParsedTransaction {\n    return {\n      inputs: [],\n      outputs: [],\n      fee: new BigNumber(0),\n    };\n  }\n\n  /**\n   * Calculates the transaction fee from the explanation.\n   * @param explanation - The transaction explanation\n   * @returns The fee as a BigNumber\n   */\n  private calculateTransactionFee(explanation: TransactionExplanation): BigNumber {\n    if (explanation.fee.fee === '') {\n      return new BigNumber(0);\n    }\n    return new BigNumber(explanation.fee.fee);\n  }\n\n  /**\n   * Builds the inputs array for a parsed transaction.\n   * Includes sender input and optionally sponsor input if present.\n   *\n   * @param explanation - The transaction explanation\n   * @param fee - The calculated transaction fee\n   * @returns Array of transaction inputs\n   */\n  private buildTransactionInputs(\n    explanation: TransactionExplanation,\n    fee: BigNumber\n  ): Array<{\n    address: string;\n    amount: string;\n  }> {\n    const senderAddress = explanation.outputs[0].address;\n    const outputAmount = new BigNumber(explanation.outputAmount);\n\n    // If there's a sponsor, sender only pays for outputs\n    // Otherwise, sender pays for outputs + fee\n    const senderAmount = explanation.sponsor ? outputAmount.toFixed() : outputAmount.plus(fee).toFixed();\n\n    const inputs = [\n      {\n        address: senderAddress,\n        amount: senderAmount,\n      },\n    ];\n\n    // Add sponsor input if present\n    if (explanation.sponsor) {\n      inputs.push({\n        address: explanation.sponsor,\n        amount: fee.toFixed(),\n      });\n    }\n\n    return inputs;\n  }\n\n  /**\n   * Builds the outputs array for a parsed transaction.\n   * @param explanation - The transaction explanation\n   * @returns Array of transaction outputs\n   */\n  private buildTransactionOutputs(explanation: TransactionExplanation): Array<{\n    address: string;\n    amount: string;\n  }> {\n    return explanation.outputs.map((output) => ({\n      address: output.address,\n      amount: new BigNumber(output.amount).toFixed(),\n    }));\n  }\n\n  /**\n   * Creates a transaction builder factory instance.\n   * @returns TransactionBuilderFactory for this coin\n   */\n  private getTxBuilderFactory(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /**\n   * Rebuilds a transaction from its hex representation.\n   * @param txHex - The transaction hex to rebuild\n   * @returns The rebuilt transaction\n   * @throws Error if transaction cannot be rebuilt\n   */\n  private async rebuildTransaction(txHex: string): Promise<Transaction> {\n    const txBuilderFactory = this.getTxBuilderFactory();\n    try {\n      const txBuilder = txBuilderFactory.from(txHex);\n      return (await txBuilder.build()) as Transaction;\n    } catch (err) {\n      throw new Error(`Failed to rebuild transaction: ${err.toString()}`);\n    }\n  }\n}\n"]}