@hashgraphonline/standards-sdk 0.1.160 → 0.1.162

package/dist/es/standards-sdk.es123.js

@@ -1,570 +1,793 @@
-const getNested = (tx, path) => {
-  const parts = path.split(".");
-  let current = tx;
-  for (const p of parts) {
-    if (current == null) {
-      return void 0;
-    }
-    current = current[p];
-  }
-  return current;
-};
-const renderTemplate = (template, tx) => {
-  return template.replace(/\{([^}]+)\}/g, (_m, path) => {
-    const value = getNested(tx, String(path).trim());
-    if (value === null || value === void 0) {
-      return "(Unknown)";
-    }
-    return String(value);
-  });
-};
-const summarizeCryptoTransfer = (tx) => {
-  const senders = [];
-  const receivers = [];
-  if (Array.isArray(tx.transfers)) {
-    for (const transfer of tx.transfers) {
-      const originalAmountFloat = parseFloat(transfer.amount);
-      let displayStr = transfer.amount;
-      if (displayStr.startsWith("-")) {
-        displayStr = displayStr.substring(1);
+import { proto } from "@hashgraph/proto";
+import { Buffer } from "buffer";
+import { Hbar, Long, HbarUnit, Transaction } from "@hashgraph/sdk";
+import { ethers } from "ethers";
+import { TransactionParsingError } from "./standards-sdk.es124.js";
+import { resolveTransactionSummary } from "./standards-sdk.es125.js";
+import { HTSParser } from "./standards-sdk.es133.js";
+import { HCSParser } from "./standards-sdk.es163.js";
+import { FileParser } from "./standards-sdk.es164.js";
+import { CryptoParser } from "./standards-sdk.es165.js";
+import { SCSParser } from "./standards-sdk.es166.js";
+import { UtilParser } from "./standards-sdk.es167.js";
+import { ScheduleParser } from "./standards-sdk.es134.js";
+import { transactionParserRegistry } from "./standards-sdk.es135.js";
+import { getTransactionTypeFromBody, getHumanReadableTransactionType } from "./standards-sdk.es136.js";
+class TransactionParser {
+  /**
+   * Parse transaction bytes in any supported format (base64 or hex, regular or scheduled)
+   * This is the main entry point for transaction parsing with enhanced retry logic
+   *
+   * @param transactionBytes - Transaction bytes in base64 or hex format
+   * @param options - Parsing options and configuration
+   * @returns Promise resolving to ParsedTransaction
+   */
+  static async parseTransactionBytes(transactionBytes, options = {}) {
+    const {
+      enableFallback = true,
+      strictMode = false,
+      includeRaw = true,
+      maxRetries = 2
+    } = options;
+    const validation = this.validateTransactionBytes(transactionBytes);
+    if (!validation.isValid && strictMode) {
+      throw new TransactionParsingError(
+        `Invalid transaction bytes format: ${validation.error}`,
+        "INVALID_FORMAT",
+        void 0,
+        transactionBytes
+      );
+    }
+    let lastError;
+    let retryCount = 0;
+    while (retryCount <= maxRetries) {
+      try {
+        const result = await this.parseTransaction(transactionBytes, options);
+        result.formatDetection = {
+          originalFormat: validation.format || "base64",
+          wasConverted: validation.format === "hex",
+          length: transactionBytes.length
+        };
+        return result;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        retryCount++;
+        if (!enableFallback || retryCount > maxRetries) {
+          if (strictMode) {
+            throw new TransactionParsingError(
+              "Failed to parse transaction after all attempts",
+              "PARSING_FAILED",
+              lastError,
+              transactionBytes
+            );
+          }
+          break;
+        }
+        try {
+          const result = this.parseScheduledTransaction(
+            transactionBytes,
+            options
+          );
+          result.formatDetection = {
+            originalFormat: validation.format || "base64",
+            wasConverted: false,
+            length: transactionBytes.length
+          };
+          return result;
+        } catch (scheduledError) {
+        }
+      }
+    }
+    const fallbackResult = this.createFallbackResult(
+      transactionBytes,
+      lastError,
+      void 0
+    );
+    if (fallbackResult.details) {
+      fallbackResult.details.parseAttempts = Math.max(retryCount, 1);
+    }
+    return fallbackResult;
+  }
+  /**
+   * Parse a Transaction object directly using unified delegation approach
+   * This method delegates to specialized parsers for clean separation of concerns
+   *
+   * @param transaction - The Transaction object to parse
+   * @param originalBytes - The original transaction bytes (optional, for protobuf parsing)
+   * @param options - Parsing options
+   * @returns Parsed transaction data
+   */
+  static parseTransactionObject(transaction, originalBytesOrOptions, options = {}) {
+    let originalBytes;
+    let actualOptions;
+    if (originalBytesOrOptions && !Buffer.isBuffer(originalBytesOrOptions) && !(originalBytesOrOptions instanceof Uint8Array)) {
+      actualOptions = originalBytesOrOptions;
+      originalBytes = void 0;
+    } else {
+      originalBytes = originalBytesOrOptions;
+      actualOptions = options;
+    }
+    try {
+      const metadata = this.extractTransactionMetadata(transaction);
+      const htsResult = HTSParser.parseFromTransactionObject(transaction);
+      const cryptoResult = CryptoParser.parseFromTransactionObject(transaction);
+      const hcsResult = HCSParser.parseFromTransactionObject(transaction);
+      const fileResult = FileParser.parseFromTransactionObject(transaction);
+      const scsResult = SCSParser.parseFromTransactionObject(transaction);
+      const scheduleResult = ScheduleParser.parseFromTransactionObject(transaction);
+      const utilResult = UtilParser.parseFromTransactionObject(transaction);
+      const results = [
+        htsResult,
+        cryptoResult,
+        hcsResult,
+        fileResult,
+        scsResult,
+        scheduleResult,
+        utilResult
+      ];
+      const primaryResult = results.find((result2) => result2.type && result2.type !== "UNKNOWN") || {};
+      let finalType = "UNKNOWN";
+      let finalHumanReadableType = "Unknown Transaction";
+      let parsedTokenCreation;
+      let protoParsingResult = {};
+      if (originalBytes || transaction.toBytes) {
+        try {
+          const bytesToParse = originalBytes || transaction.toBytes();
+          const decoded = proto.TransactionList.decode(bytesToParse);
+          if (decoded.transactionList && decoded.transactionList.length > 0) {
+            const tx = decoded.transactionList[0];
+            if (tx.bodyBytes && tx.bodyBytes.length > 0) {
+              const txBody = proto.TransactionBody.decode(tx.bodyBytes);
+              const typeResult = this.detectTransactionTypeFromBody(txBody);
+              finalType = typeResult.type;
+              finalHumanReadableType = typeResult.humanReadableType;
+              protoParsingResult = this.parseTransactionBodyDetails(
+                txBody,
+                finalType
+              );
+              if (protoParsingResult.tokenCreation) {
+                parsedTokenCreation = protoParsingResult.tokenCreation;
+              }
+            } else if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {
+              const signedTx = proto.SignedTransaction.decode(
+                tx.signedTransactionBytes
+              );
+              if (signedTx.bodyBytes) {
+                const txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
+                const typeResult = this.detectTransactionTypeFromBody(txBody);
+                finalType = typeResult.type;
+                finalHumanReadableType = typeResult.humanReadableType;
+                protoParsingResult = this.parseTransactionBodyDetails(
+                  txBody,
+                  finalType
+                );
+                if (protoParsingResult.tokenCreation) {
+                  parsedTokenCreation = protoParsingResult.tokenCreation;
+                }
+              }
+            }
+          }
+        } catch (protoError) {
+        }
       }
-      displayStr = displayStr.replace(/\s*ℏ$/, "");
-      if (originalAmountFloat < 0) {
-        senders.push(`${transfer.accountId} (${displayStr} ℏ)`);
-      } else if (originalAmountFloat > 0) {
-        receivers.push(`${transfer.accountId} (${displayStr} ℏ)`);
+      if (finalType === "UNKNOWN" && primaryResult.type) {
+        finalType = primaryResult.type;
+        finalHumanReadableType = primaryResult.humanReadableType || finalHumanReadableType;
       }
+      const result = {
+        type: finalType,
+        humanReadableType: finalHumanReadableType,
+        transfers: [],
+        tokenTransfers: [],
+        ...metadata,
+        ...primaryResult,
+        raw: actualOptions.includeRaw ? transaction._transactionBody || {} : void 0
+      };
+      this.mergeProtoParsingResults(
+        result,
+        protoParsingResult,
+        htsResult,
+        transaction,
+        originalBytes
+      );
+      result.transfers = cryptoResult.transfers || result.transfers || [];
+      result.tokenTransfers = cryptoResult.tokenTransfers || result.tokenTransfers || [];
+      return result;
+    } catch (error) {
+      return {
+        type: "UNKNOWN",
+        humanReadableType: "Unknown Transaction",
+        transfers: [],
+        tokenTransfers: [],
+        raw: actualOptions.includeRaw ? {} : void 0,
+        details: {
+          error: `Failed to parse Transaction object: ${error instanceof Error ? error.message : String(error)}`
+        }
+      };
     }
   }
-  if (senders.length > 0 && receivers.length > 0) {
-    return `Transfer of HBAR from ${senders.join(", ")} to ${receivers.join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const groupTokenTransfers = (tokenTransfers) => {
-  const groups = {};
-  for (const t of tokenTransfers) {
-    if (!groups[t.tokenId]) {
-      groups[t.tokenId] = [];
+  /**
+   * Parse a base64 encoded transaction body using registry pattern
+   * @param transactionBodyBase64 - The base64 encoded transaction body
+   * @returns The parsed transaction
+   */
+  static parseTransactionBody(transactionBodyBase64) {
+    try {
+      const buffer = ethers.decodeBase64(transactionBodyBase64);
+      const txBody = proto.SchedulableTransactionBody.decode(buffer);
+      const transactionType = this.getTransactionType(txBody);
+      const result = {
+        type: transactionType,
+        humanReadableType: this.getHumanReadableType(transactionType),
+        transfers: [],
+        tokenTransfers: [],
+        raw: txBody
+      };
+      if (txBody.memo) {
+        result.memo = txBody.memo;
+      }
+      if (txBody.transactionFee) {
+        const hbarAmount = Hbar.fromTinybars(
+          Long.fromValue(txBody.transactionFee)
+        );
+        result.transactionFee = hbarAmount.toString(HbarUnit.Hbar);
+      }
+      this.applySchedulableTransactionParsing(txBody, result);
+      return result;
+    } catch (error) {
+      return {
+        type: "UNKNOWN",
+        humanReadableType: "Unknown Transaction",
+        transfers: [],
+        tokenTransfers: [],
+        raw: void 0,
+        details: {
+          error: `Failed to parse transaction body: ${error instanceof Error ? error.message : String(error)}`
+        }
+      };
     }
-    groups[t.tokenId].push(t);
   }
-  return groups;
-};
-const summarizeTokenTransfers = (tx) => {
-  const tokenSummaries = [];
-  const groups = groupTokenTransfers(tx.tokenTransfers || []);
-  for (const [tokenId, transfers] of Object.entries(groups)) {
-    const tokenSenders = [];
-    const tokenReceivers = [];
-    for (const t of transfers) {
-      const amt = parseFloat(String(t.amount));
-      if (amt < 0) {
-        tokenSenders.push(`${t.accountId} (${Math.abs(amt)})`);
-      } else if (amt > 0) {
-        tokenReceivers.push(`${t.accountId} (${amt})`);
+  /**
+   * Detect transaction type and human-readable type from transaction body protobuf
+   * Uses registry pattern to eliminate massive if-else chain
+   */
+  static detectTransactionTypeFromBody(txBody) {
+    return getTransactionTypeFromBody(txBody);
+  }
+  /**
+   * Parse details from a complete schedule response
+   * @param scheduleResponse - The schedule response to parse
+   * @returns The parsed transaction
+   */
+  static parseScheduleResponse(scheduleResponse) {
+    if (!scheduleResponse.transaction_body) {
+      return {
+        type: "UNKNOWN",
+        humanReadableType: "Unknown Transaction",
+        transfers: [],
+        tokenTransfers: [],
+        raw: void 0,
+        details: {
+          error: "Schedule response missing transaction_body"
+        }
+      };
+    }
+    const parsed = this.parseTransactionBody(scheduleResponse.transaction_body);
+    if (scheduleResponse.memo) {
+      parsed.memo = scheduleResponse.memo;
+    }
+    return parsed;
+  }
+  /**
+   * Determine the transaction type using registry pattern
+   * @param txBody - The transaction body to determine the type of
+   * @returns The type of the transaction
+   */
+  static getTransactionType(txBody) {
+    return getTransactionTypeFromBody(txBody).type;
+  }
+  /**
+   * Convert technical transaction type to human-readable format using registry pattern
+   * @param type - The technical transaction type
+   * @returns The human-readable transaction type
+   */
+  static getHumanReadableType(type) {
+    return getHumanReadableTransactionType(type);
+  }
+  /**
+   * Get a human-readable summary of the transaction
+   * @param parsedTx - The parsed transaction
+   * @returns The human-readable summary of the transaction
+   */
+  static getTransactionSummary(parsedTx) {
+    return resolveTransactionSummary(parsedTx);
+  }
+  /**
+   * Validate transaction bytes format and encoding
+   * Enhanced validation with better format detection
+   */
+  static validateTransactionBytes(transactionBytes) {
+    if (!transactionBytes || typeof transactionBytes !== "string") {
+      return {
+        isValid: false,
+        error: "Transaction bytes must be a non-empty string"
+      };
+    }
+    const format = this.detectTransactionFormat(transactionBytes);
+    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+    const hexRegex = /^0x[0-9a-fA-F]+$/;
+    let isValid = false;
+    let error;
+    if (format === "hex") {
+      isValid = hexRegex.test(transactionBytes) && transactionBytes.length > 2;
+      if (!isValid) {
+        error = "Invalid hex format";
+      }
+    } else {
+      isValid = base64Regex.test(transactionBytes) && transactionBytes.length > 0;
+      if (!isValid) {
+        error = "Invalid base64 format";
       }
     }
-    if (tokenSenders.length > 0 && tokenReceivers.length > 0) {
-      tokenSummaries.push(
-        `Transfer of token ${tokenId} from ${tokenSenders.join(", ")} to ${tokenReceivers.join(", ")}`
+    return {
+      isValid,
+      format,
+      error,
+      length: transactionBytes.length
+    };
+  }
+  /**
+   * Detects the format of transaction bytes
+   * @param transactionBytes - The transaction bytes to analyze
+   * @returns The detected format ('base64' or 'hex')
+   */
+  static detectTransactionFormat(transactionBytes) {
+    return transactionBytes.startsWith("0x") ? "hex" : "base64";
+  }
+  /**
+   * Decodes transaction bytes from string to Uint8Array
+   * @param transactionBytes - The transaction bytes string (base64 or hex)
+   * @returns Decoded Uint8Array
+   * @throws TransactionParsingError if decoding fails
+   */
+  static decodeTransactionBytes(transactionBytes) {
+    try {
+      const format = this.detectTransactionFormat(transactionBytes);
+      if (format === "hex") {
+        const hexString = transactionBytes.slice(2);
+        return new Uint8Array(Buffer.from(hexString, "hex"));
+      } else {
+        return new Uint8Array(Buffer.from(transactionBytes, "base64"));
+      }
+    } catch (error) {
+      throw new TransactionParsingError(
+        "Failed to decode transaction bytes",
+        "DECODE_ERROR",
+        error instanceof Error ? error : void 0,
+        transactionBytes
       );
     }
   }
-  if (tokenSummaries.length > 0) {
-    return tokenSummaries.join("; ");
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractCall = (tx) => {
-  if (!tx.contractCall) {
-    return tx.humanReadableType;
-  }
-  let summary = `Contract call to ${tx.contractCall.contractId} with ${tx.contractCall.gas} gas`;
-  if (tx.contractCall.amount > 0) {
-    summary += ` and ${tx.contractCall.amount} HBAR`;
-  }
-  if (tx.contractCall.functionName) {
-    summary += ` calling function ${tx.contractCall.functionName}`;
-  }
-  return summary;
-};
-const summarizeTokenMint = (tx) => {
-  if (tx.tokenMint) {
-    return `Mint ${tx.tokenMint.amount} tokens for token ${tx.tokenMint.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenBurn = (tx) => {
-  if (tx.tokenBurn) {
-    return `Burn ${tx.tokenBurn.amount} tokens for token ${tx.tokenBurn.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenCreate = (tx) => {
-  if (!tx.tokenCreation) {
-    return tx.humanReadableType;
-  }
-  let summary = `Create token ${tx.tokenCreation.tokenName || "(No Name)"} (${tx.tokenCreation.tokenSymbol || "(No Symbol)"})`;
-  if (tx.tokenCreation.initialSupply) {
-    summary += ` with initial supply ${tx.tokenCreation.initialSupply}`;
-  }
-  if (tx.tokenCreation.customFees && tx.tokenCreation.customFees.length > 0) {
-    summary += ` including ${tx.tokenCreation.customFees.length} custom fee(s)`;
-  }
-  return summary;
-};
-const summarizeConsensusCreateTopic = (tx) => {
-  if (!tx.consensusCreateTopic) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create new topic";
-  if (tx.consensusCreateTopic.memo) {
-    summary += ` with memo "${tx.consensusCreateTopic.memo}"`;
-  }
-  if (tx.consensusCreateTopic.autoRenewAccountId) {
-    summary += `, auto-renew by ${tx.consensusCreateTopic.autoRenewAccountId}`;
-  }
-  return summary;
-};
-const summarizeConsensusSubmitMessage = (tx) => {
-  if (!tx.consensusSubmitMessage) {
-    return tx.humanReadableType;
-  }
-  let summary = "Submit message";
-  if (tx.consensusSubmitMessage.topicId) {
-    summary += ` to topic ${tx.consensusSubmitMessage.topicId}`;
-  }
-  if (tx.consensusSubmitMessage.message) {
-    if (tx.consensusSubmitMessage.messageEncoding === "utf8") {
-      const preview = tx.consensusSubmitMessage.message.substring(0, 70);
-      const needsEllipsis = tx.consensusSubmitMessage.message.length > 70;
-      summary += `: "${preview}${needsEllipsis ? "..." : ""}"`;
-    } else {
-      const byteLength = Buffer.from(
-        tx.consensusSubmitMessage.message,
-        "base64"
-      ).length;
-      summary += ` (binary message data, length: ${byteLength} bytes)`;
+  /**
+   * Check if transaction bytes represent a valid Hedera transaction
+   */
+  static async isValidHederaTransaction(transactionBytes) {
+    try {
+      if (!this.validateTransactionBytes(transactionBytes).isValid) {
+        return false;
+      }
+      const bytes = this.decodeTransactionBytes(transactionBytes);
+      Transaction.fromBytes(bytes);
+      return true;
+    } catch {
+      return false;
     }
   }
-  if (tx.consensusSubmitMessage.chunkInfoNumber && tx.consensusSubmitMessage.chunkInfoTotal) {
-    summary += ` (chunk ${tx.consensusSubmitMessage.chunkInfoNumber}/${tx.consensusSubmitMessage.chunkInfoTotal})`;
-  }
-  return summary;
-};
-const summarizeFileCreate = (tx) => {
-  if (!tx.fileCreate) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create File";
-  if (tx.fileCreate.memo) {
-    summary += ` with memo "${tx.fileCreate.memo}"`;
-  }
-  if (tx.fileCreate.contents) {
-    summary += " (includes content)";
-  }
-  return summary;
-};
-const summarizeFileAppend = (tx) => {
-  if (tx.fileAppend) {
-    return `Append to File ${tx.fileAppend.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeFileUpdate = (tx) => {
-  if (tx.fileUpdate) {
-    return `Update File ${tx.fileUpdate.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeFileDelete = (tx) => {
-  if (tx.fileDelete) {
-    return `Delete File ${tx.fileDelete.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeConsensusUpdateTopic = (tx) => {
-  if (tx.consensusUpdateTopic) {
-    return `Update Topic ${tx.consensusUpdateTopic.topicId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeConsensusDeleteTopic = (tx) => {
-  if (tx.consensusDeleteTopic) {
-    return `Delete Topic ${tx.consensusDeleteTopic.topicId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenFreeze = (tx) => {
-  if (tx.tokenFreeze) {
-    return `Freeze Token ${tx.tokenFreeze.tokenId} for Account ${tx.tokenFreeze.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUnfreeze = (tx) => {
-  if (tx.tokenUnfreeze) {
-    return `Unfreeze Token ${tx.tokenUnfreeze.tokenId} for Account ${tx.tokenUnfreeze.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenGrantKyc = (tx) => {
-  if (tx.tokenGrantKyc) {
-    return `Grant KYC for Token ${tx.tokenGrantKyc.tokenId} to Account ${tx.tokenGrantKyc.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenRevokeKyc = (tx) => {
-  if (tx.tokenRevokeKyc) {
-    return `Revoke KYC for Token ${tx.tokenRevokeKyc.tokenId} from Account ${tx.tokenRevokeKyc.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenPause = (tx) => {
-  if (tx.tokenPause) {
-    return `Pause Token ${tx.tokenPause.tokenId}`;
+  /**
+   * Legacy alias for decodeTransactionBytes - keeping for backward compatibility
+   */
+  static decodeBytesLegacy(transactionBytes) {
+    return this.decodeTransactionBytes(transactionBytes);
+  }
+  /**
+   * Parse transaction bytes into structured data using thin orchestration
+   * Delegates to specialized parsers for clean separation of concerns
+   */
+  static async parseTransaction(transactionBytes, options = {}) {
+    try {
+      const bytes = this.decodeTransactionBytes(transactionBytes);
+      const transaction = Transaction.fromBytes(bytes);
+      const metadata = this.extractTransactionMetadataEnhanced(transaction);
+      const parserResults = this.runAllParsers(transaction);
+      const primaryResult = parserResults.find(
+        (result2) => result2.type && result2.type !== "UNKNOWN"
+      ) || {};
+      const protoParsingResult = this.parseFromProtobuf(bytes);
+      const finalType = protoParsingResult.type || primaryResult.type || "UNKNOWN";
+      const finalHumanReadableType = protoParsingResult.humanReadableType || primaryResult.humanReadableType || "Unknown Transaction";
+      const result = {
+        type: finalType,
+        humanReadableType: finalHumanReadableType,
+        transfers: [],
+        tokenTransfers: [],
+        details: { ...metadata },
+        memo: typeof metadata.memo === "string" ? metadata.memo : void 0,
+        transactionId: typeof metadata.transactionId === "string" ? metadata.transactionId : void 0,
+        nodeAccountIds: Array.isArray(metadata.nodeAccountIds) ? metadata.nodeAccountIds : [],
+        maxTransactionFee: typeof metadata.maxTransactionFee === "string" ? metadata.maxTransactionFee : void 0,
+        validStart: typeof metadata.validStart === "string" ? metadata.validStart : void 0,
+        validDuration: typeof metadata.validDuration === "string" ? metadata.validDuration : void 0,
+        raw: options.includeRaw ? {} : void 0
+      };
+      this.mergeAllResults(
+        result,
+        protoParsingResult,
+        primaryResult,
+        parserResults
+      );
+      return result;
+    } catch (error) {
+      throw new TransactionParsingError(
+        "Failed to parse as regular transaction",
+        "REGULAR_PARSING_FAILED",
+        error instanceof Error ? error : void 0,
+        transactionBytes
+      );
+    }
   }
-  return tx.humanReadableType;
-};
-const summarizeTokenUnpause = (tx) => {
-  if (tx.tokenUnpause) {
-    return `Unpause Token ${tx.tokenUnpause.tokenId}`;
+  /**
+   * Parse scheduled transaction body
+   */
+  static parseScheduledTransaction(transactionBytes, options = {}) {
+    try {
+      const parsedTx = this.parseTransactionBody(transactionBytes);
+      const validation = this.validateTransactionBytes(transactionBytes);
+      const enhancedResult = {
+        ...parsedTx,
+        details: {
+          ...parsedTx.details || {},
+          parseMethod: "scheduled",
+          validation,
+          parseAttempts: parsedTx.details?.parseAttempts || 1
+        },
+        formatDetection: {
+          originalFormat: validation.format || "base64",
+          wasConverted: false,
+          length: transactionBytes.length
+        }
+      };
+      return enhancedResult;
+    } catch (error) {
+      throw new TransactionParsingError(
+        "Failed to parse as scheduled transaction",
+        "SCHEDULED_PARSING_FAILED",
+        error instanceof Error ? error : void 0,
+        transactionBytes
+      );
+    }
   }
-  return tx.humanReadableType;
-};
-const summarizeTokenWipe = (tx) => {
-  if (tx.tokenWipeAccount) {
-    let summary = `Wipe Token ${tx.tokenWipeAccount.tokenId} from Account ${tx.tokenWipeAccount.accountId}`;
-    if (tx.tokenWipeAccount.serialNumbers && tx.tokenWipeAccount.serialNumbers.length > 0) {
-      summary += ` (Serials: ${tx.tokenWipeAccount.serialNumbers.join(", ")})`;
+  /**
+   * Extract metadata from Transaction object (legacy method - keeping for backward compatibility)
+   */
+  static extractTransactionMetadata(transaction) {
+    return {
+      transactionId: transaction.transactionId?.toString(),
+      nodeAccountIds: transaction.nodeAccountIds?.map((id) => id.toString()) || [],
+      maxTransactionFee: transaction.maxTransactionFee?.toTinybars().toString() || "0",
+      memo: transaction._transactionMemo || void 0,
+      transfers: [],
+      tokenTransfers: []
+    };
+  }
+  /**
+   * Extract enhanced metadata from Transaction object
+   */
+  static extractTransactionMetadataEnhanced(transaction) {
+    return {
+      transactionId: transaction.transactionId?.toString(),
+      nodeAccountIds: transaction.nodeAccountIds?.map((id) => id.toString()) || [],
+      maxTransactionFee: transaction.maxTransactionFee?.toTinybars().toString() || "0",
+      memo: transaction._transactionMemo || void 0,
+      validStart: transaction._transactionValidStart?.toString(),
+      validDuration: transaction._transactionValidDuration?.toString()
+    };
+  }
+  /**
+   * Run all available parsers on a transaction
+   */
+  static runAllParsers(transaction) {
+    return [
+      HTSParser.parseFromTransactionObject(transaction),
+      CryptoParser.parseFromTransactionObject(transaction),
+      HCSParser.parseFromTransactionObject(transaction),
+      FileParser.parseFromTransactionObject(transaction),
+      SCSParser.parseFromTransactionObject(transaction),
+      ScheduleParser.parseFromTransactionObject(transaction),
+      UtilParser.parseFromTransactionObject(transaction)
+    ];
+  }
+  /**
+   * Parse transaction from protobuf bytes
+   */
+  static parseFromProtobuf(bytes) {
+    const result = {};
+    try {
+      const decoded = proto.TransactionList.decode(bytes);
+      if (decoded.transactionList && decoded.transactionList.length > 0) {
+        const tx = decoded.transactionList[0];
+        let txBody = null;
+        if (tx.bodyBytes && tx.bodyBytes.length > 0) {
+          txBody = proto.TransactionBody.decode(tx.bodyBytes);
+        } else if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {
+          const signedTx = proto.SignedTransaction.decode(
+            tx.signedTransactionBytes
+          );
+          if (signedTx.bodyBytes) {
+            txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
+          }
+        }
+        if (txBody) {
+          const typeResult = this.detectTransactionTypeFromBody(txBody);
+          result.type = typeResult.type;
+          result.humanReadableType = typeResult.humanReadableType;
+          const details = this.parseTransactionBodyDetails(
+            txBody,
+            typeResult.type
+          );
+          Object.assign(result, details);
+        }
+      }
+    } catch (error) {
     }
-    if (tx.tokenWipeAccount.amount) {
-      summary += ` (Amount: ${tx.tokenWipeAccount.amount})`;
+    return result;
+  }
+  /**
+   * Intelligently merge all parsing results
+   */
+  static mergeAllResults(result, protoResult, primaryResult, parserResults) {
+    const cryptoResult = parserResults.find((r) => r.transfers || r.tokenTransfers) || {};
+    result.transfers = cryptoResult.transfers || result.transfers || [];
+    result.tokenTransfers = cryptoResult.tokenTransfers || result.tokenTransfers || [];
+    Object.keys(protoResult).forEach((key) => {
+      if (protoResult[key] !== void 0 && key !== "type" && key !== "humanReadableType") {
+        result[key] = protoResult[key];
+      }
+    });
+    Object.keys(primaryResult).forEach((key) => {
+      if (primaryResult[key] !== void 0 && !(key in result) && key !== "type" && key !== "humanReadableType") {
+        result[key] = primaryResult[key];
+      }
+    });
+  }
+  /**
+   * Apply schedulable transaction parsing using registry pattern
+   * Eliminates conditional logic in parseTransactionBody
+   */
+  static applySchedulableTransactionParsing(txBody, result) {
+    if (txBody.cryptoTransfer) {
+      CryptoParser.parseCryptoTransfers(txBody.cryptoTransfer, result);
     }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenDelete = (tx) => {
-  if (tx.tokenDelete) {
-    return `Delete Token ${tx.tokenDelete.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenAssociate = (tx) => {
-  if (tx.tokenAssociate) {
-    return `Associate Account ${tx.tokenAssociate.accountId} with Tokens: ${(tx.tokenAssociate.tokenIds || []).join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenDissociate = (tx) => {
-  if (tx.tokenDissociate) {
-    return `Dissociate Account ${tx.tokenDissociate.accountId} from Tokens: ${(tx.tokenDissociate.tokenIds || []).join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeAccountDelete = (tx) => {
-  if (tx.cryptoDelete) {
-    return `Delete Account ${tx.cryptoDelete.deleteAccountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeAccountCreate = (tx) => {
-  if (!tx.cryptoCreateAccount) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create Account";
-  if (tx.cryptoCreateAccount.initialBalance && tx.cryptoCreateAccount.initialBalance !== "0") {
-    summary += ` with balance ${tx.cryptoCreateAccount.initialBalance}`;
-  }
-  if (tx.cryptoCreateAccount.alias) {
-    summary += ` (Alias: ${tx.cryptoCreateAccount.alias})`;
-  }
-  return summary;
-};
-const summarizeAccountUpdate = (tx) => {
-  if (tx.cryptoUpdateAccount) {
-    return `Update Account ${tx.cryptoUpdateAccount.accountIdToUpdate || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeApproveAllowance = (tx) => {
-  if (tx.cryptoApproveAllowance) {
-    let count = 0;
-    if (tx.cryptoApproveAllowance.hbarAllowances) {
-      count += tx.cryptoApproveAllowance.hbarAllowances.length;
+    if (txBody.cryptoDelete) {
+      result.cryptoDelete = CryptoParser.parseCryptoDelete(txBody.cryptoDelete);
     }
-    if (tx.cryptoApproveAllowance.tokenAllowances) {
-      count += tx.cryptoApproveAllowance.tokenAllowances.length;
+    if (txBody.cryptoCreateAccount) {
+      result.cryptoCreateAccount = CryptoParser.parseCryptoCreateAccount(
+        txBody.cryptoCreateAccount
+      );
     }
-    if (tx.cryptoApproveAllowance.nftAllowances) {
-      count += tx.cryptoApproveAllowance.nftAllowances.length;
+    if (txBody.cryptoUpdateAccount) {
+      result.cryptoUpdateAccount = CryptoParser.parseCryptoUpdateAccount(
+        txBody.cryptoUpdateAccount
+      );
     }
-    return `Approve ${count} Crypto Allowance(s)`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeDeleteAllowance = (tx) => {
-  if (tx.cryptoDeleteAllowance) {
-    const count = (tx.cryptoDeleteAllowance.nftAllowancesToRemove || []).length;
-    return `Delete ${count} NFT Crypto Allowance(s)`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractCreate = (tx) => {
-  if (tx.contractCreate) {
-    let summary = "Create Contract";
-    if (tx.contractCreate.memo) {
-      summary += ` (Memo: ${tx.contractCreate.memo})`;
+    if (txBody.cryptoApproveAllowance) {
+      result.cryptoApproveAllowance = CryptoParser.parseCryptoApproveAllowance(
+        txBody.cryptoApproveAllowance
+      );
     }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractUpdate = (tx) => {
-  if (tx.contractUpdate) {
-    return `Update Contract ${tx.contractUpdate.contractIdToUpdate || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractDelete = (tx) => {
-  if (tx.contractDelete) {
-    let summary = `Delete Contract ${tx.contractDelete.contractIdToDelete || "(Unknown ID)"}`;
-    if (tx.contractDelete.transferAccountId) {
-      summary += ` (Transfer to Account: ${tx.contractDelete.transferAccountId})`;
-    } else if (tx.contractDelete.transferContractId) {
-      summary += ` (Transfer to Contract: ${tx.contractDelete.transferContractId})`;
-    }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUpdate = (tx) => {
-  if (tx.tokenUpdate) {
-    return `Update Token ${tx.tokenUpdate.tokenId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenFeeScheduleUpdate = (tx) => {
-  if (tx.tokenFeeScheduleUpdate) {
-    return `Update Fee Schedule for Token ${tx.tokenFeeScheduleUpdate.tokenId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenAirdrop = (tx) => {
-  if (!tx.tokenAirdrop || !tx.tokenAirdrop.tokenTransfers) {
-    return tx.humanReadableType;
-  }
-  let tokenTypes = 0;
-  let totalTransfers = 0;
-  for (const t of tx.tokenAirdrop.tokenTransfers) {
-    tokenTypes += 1;
-    totalTransfers += Array.isArray(t.transfers) ? t.transfers.length : 0;
-  }
-  return `Token Airdrop across ${tokenTypes} token(s), ${totalTransfers} transfer(s)`;
-};
-const summarizeScheduleCreate = (tx) => {
-  if (!tx.scheduleCreate) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create Schedule";
-  if (tx.scheduleCreate.memo) {
-    summary += ` (Memo: ${tx.scheduleCreate.memo})`;
-  }
-  return summary;
-};
-const summarizeScheduleSign = (tx) => {
-  if (tx.scheduleSign) {
-    return "Sign Schedule";
-  }
-  return tx.humanReadableType;
-};
-const summarizeScheduleDelete = (tx) => {
-  if (tx.scheduleDelete) {
-    return "Delete Schedule";
-  }
-  return tx.humanReadableType;
-};
-const summarizeSystemDelete = (tx) => {
-  if (!tx.systemDelete) {
-    return tx.humanReadableType;
-  }
-  if (tx.systemDelete.fileId) {
-    return `System Delete File ${tx.systemDelete.fileId}`;
-  }
-  if (tx.systemDelete.contractId) {
-    return `System Delete Contract ${tx.systemDelete.contractId}`;
-  }
-  return "System Delete";
-};
-const summarizeSystemUndelete = (tx) => {
-  if (!tx.systemUndelete) {
-    return tx.humanReadableType;
-  }
-  if (tx.systemUndelete.fileId) {
-    return `System Undelete File ${tx.systemUndelete.fileId}`;
-  }
-  if (tx.systemUndelete.contractId) {
-    return `System Undelete Contract ${tx.systemUndelete.contractId}`;
-  }
-  return "System Undelete";
-};
-const summarizeFreeze = (tx) => {
-  return "Network Freeze";
-};
-const summarizeEthereumTransaction = (tx) => {
-  return "Ethereum Transaction";
-};
-const summarizeUncheckedSubmit = (tx) => {
-  if (tx.uncheckedSubmit && tx.uncheckedSubmit.topicId) {
-    return `Unchecked Submit to topic ${tx.uncheckedSubmit.topicId}`;
-  }
-  return "Unchecked Submit";
-};
-const summarizeNodeCreate = (tx) => {
-  return "Create Node";
-};
-const summarizeNodeUpdate = (tx) => {
-  return "Update Node";
-};
-const summarizeNodeDelete = (tx) => {
-  return "Delete Node";
-};
-const summarizeAtomicBatch = (tx) => {
-  const count = Array.isArray(tx.atomicBatch?.transactions) ? tx.atomicBatch.transactions.length : 0;
-  return `Atomic Batch (${count} transaction(s))`;
-};
-const transactionSummaryRegistry = {
-  CRYPTOTRANSFER: { fn: summarizeCryptoTransfer },
-  cryptoTransfer: { fn: summarizeCryptoTransfer },
-  CONTRACTCALL: { fn: summarizeContractCall },
-  contractCall: { fn: summarizeContractCall },
-  TOKENMINT: { fn: summarizeTokenMint },
-  tokenMint: { fn: summarizeTokenMint },
-  TOKENBURN: { fn: summarizeTokenBurn },
-  tokenBurn: { fn: summarizeTokenBurn },
-  TOKENCREATE: { fn: summarizeTokenCreate },
-  tokenCreation: { fn: summarizeTokenCreate },
-  TOPICCREATE: { fn: summarizeConsensusCreateTopic },
-  consensusCreateTopic: { fn: summarizeConsensusCreateTopic },
-  CONSENSUSSUBMITMESSAGE: { fn: summarizeConsensusSubmitMessage },
-  consensusSubmitMessage: { fn: summarizeConsensusSubmitMessage },
-  TOPICUPDATE: { fn: summarizeConsensusUpdateTopic },
-  consensusUpdateTopic: { fn: summarizeConsensusUpdateTopic },
-  TOPICDELETE: { fn: summarizeConsensusDeleteTopic },
-  consensusDeleteTopic: { fn: summarizeConsensusDeleteTopic },
-  FILECREATE: { fn: summarizeFileCreate },
-  fileCreate: { fn: summarizeFileCreate },
-  FILEAPPEND: { fn: summarizeFileAppend },
-  fileAppend: { fn: summarizeFileAppend },
-  FILEUPDATE: { fn: summarizeFileUpdate },
-  fileUpdate: { fn: summarizeFileUpdate },
-  FILEDELETE: { fn: summarizeFileDelete },
-  fileDelete: { fn: summarizeFileDelete },
-  TOKENUPDATE: { fn: summarizeTokenUpdate },
-  tokenUpdate: { fn: summarizeTokenUpdate },
-  TOKENFEESCHEDULEUPDATE: { fn: summarizeTokenFeeScheduleUpdate },
-  tokenFeeScheduleUpdate: { fn: summarizeTokenFeeScheduleUpdate },
-  TOKENFREEZE: { fn: summarizeTokenFreeze },
-  tokenFreeze: { fn: summarizeTokenFreeze },
-  TOKENUNFREEZE: { fn: summarizeTokenUnfreeze },
-  tokenUnfreeze: { fn: summarizeTokenUnfreeze },
-  TOKENGRANTKYC: { fn: summarizeTokenGrantKyc },
-  tokenGrantKyc: { fn: summarizeTokenGrantKyc },
-  TOKENREVOKEKYC: { fn: summarizeTokenRevokeKyc },
-  tokenRevokeKyc: { fn: summarizeTokenRevokeKyc },
-  TOKENPAUSE: { fn: summarizeTokenPause },
-  tokenPause: { fn: summarizeTokenPause },
-  TOKENUNPAUSE: { fn: summarizeTokenUnpause },
-  tokenUnpause: { fn: summarizeTokenUnpause },
-  TOKENWIPE: { fn: summarizeTokenWipe },
-  TOKENWIPEACCOUNT: { fn: summarizeTokenWipe },
-  tokenWipe: { fn: summarizeTokenWipe },
-  tokenWipeAccount: { fn: summarizeTokenWipe },
-  TOKENDELETE: { fn: summarizeTokenDelete },
-  tokenDelete: { fn: summarizeTokenDelete },
-  TOKENASSOCIATE: { fn: summarizeTokenAssociate },
-  tokenAssociate: { fn: summarizeTokenAssociate },
-  TOKENDISSOCIATE: { fn: summarizeTokenDissociate },
-  tokenDissociate: { fn: summarizeTokenDissociate },
-  ACCOUNTDELETE: { fn: summarizeAccountDelete },
-  cryptoDelete: { fn: summarizeAccountDelete },
-  ACCOUNTCREATE: { fn: summarizeAccountCreate },
-  cryptoCreateAccount: { fn: summarizeAccountCreate },
-  ACCOUNTUPDATE: { fn: summarizeAccountUpdate },
-  cryptoUpdateAccount: { fn: summarizeAccountUpdate },
-  APPROVEALLOWANCE: { fn: summarizeApproveAllowance },
-  cryptoApproveAllowance: { fn: summarizeApproveAllowance },
-  DELETEALLOWANCE: { fn: summarizeDeleteAllowance },
-  cryptoDeleteAllowance: { fn: summarizeDeleteAllowance },
-  CONTRACTCREATE: { fn: summarizeContractCreate },
-  contractCreate: { fn: summarizeContractCreate },
-  CONTRACTUPDATE: { fn: summarizeContractUpdate },
-  contractUpdate: { fn: summarizeContractUpdate },
-  CONTRACTDELETE: { fn: summarizeContractDelete },
-  contractDelete: { fn: summarizeContractDelete },
-  TOKENAIRDROP: { fn: summarizeTokenAirdrop },
-  tokenAirdrop: { fn: summarizeTokenAirdrop },
-  SCHEDULECREATE: { fn: summarizeScheduleCreate },
-  scheduleCreate: { fn: summarizeScheduleCreate },
-  SCHEDULESIGN: { fn: summarizeScheduleSign },
-  scheduleSign: { fn: summarizeScheduleSign },
-  SCHEDULEDELETE: { fn: summarizeScheduleDelete },
-  scheduleDelete: { fn: summarizeScheduleDelete },
-  SYSTEMDELETE: { fn: summarizeSystemDelete },
-  systemDelete: { fn: summarizeSystemDelete },
-  SYSTEMUNDELETE: { fn: summarizeSystemUndelete },
-  systemUndelete: { fn: summarizeSystemUndelete },
-  FREEZE: { fn: summarizeFreeze },
-  freeze: { fn: summarizeFreeze },
-  ETHEREUMTRANSACTION: { fn: summarizeEthereumTransaction },
-  ethereumTransaction: { fn: summarizeEthereumTransaction },
-  UNCHECKEDSUBMIT: { fn: summarizeUncheckedSubmit },
-  uncheckedSubmit: { fn: summarizeUncheckedSubmit },
-  NODECREATE: { fn: summarizeNodeCreate },
-  nodeCreate: { fn: summarizeNodeCreate },
-  NODEUPDATE: { fn: summarizeNodeUpdate },
-  nodeUpdate: { fn: summarizeNodeUpdate },
-  NODEDELETE: { fn: summarizeNodeDelete },
-  nodeDelete: { fn: summarizeNodeDelete },
-  ATOMICBATCH: { fn: summarizeAtomicBatch },
-  atomicBatch: { fn: summarizeAtomicBatch }
-};
-const resolveTransactionSummary = (tx) => {
-  const spec = transactionSummaryRegistry[tx.type];
-  if (spec) {
-    if (spec.fn) {
-      return spec.fn(tx);
+    if (txBody.cryptoDeleteAllowance) {
+      result.cryptoDeleteAllowance = CryptoParser.parseCryptoDeleteAllowance(
+        txBody.cryptoDeleteAllowance
+      );
     }
-    if (spec.template) {
-      return renderTemplate(spec.template, tx);
+    if (txBody.contractCall) {
+      result.contractCall = SCSParser.parseContractCall(txBody.contractCall);
     }
-  }
-  const hrSpec = transactionSummaryRegistry[tx.humanReadableType];
-  if (hrSpec) {
-    if (hrSpec.fn) {
-      return hrSpec.fn(tx);
+    if (txBody.contractCreateInstance) {
+      result.contractCreate = SCSParser.parseContractCreate(
+        txBody.contractCreateInstance
+      );
+    }
+    if (txBody.contractUpdateInstance) {
+      result.contractUpdate = SCSParser.parseContractUpdate(
+        txBody.contractUpdateInstance
+      );
     }
-    if (hrSpec.template) {
-      return renderTemplate(hrSpec.template, tx);
+    if (txBody.contractDeleteInstance) {
+      result.contractDelete = SCSParser.parseContractDelete(
+        txBody.contractDeleteInstance
+      );
+    }
+    if (txBody.tokenCreation) {
+      result.tokenCreation = HTSParser.parseTokenCreate(txBody.tokenCreation);
+    }
+    if (txBody.tokenMint) {
+      result.tokenMint = HTSParser.parseTokenMint(txBody.tokenMint);
+    }
+    if (txBody.tokenBurn) {
+      result.tokenBurn = HTSParser.parseTokenBurn(txBody.tokenBurn);
+    }
+    if (txBody.tokenUpdate) {
+      result.tokenUpdate = HTSParser.parseTokenUpdate(txBody.tokenUpdate);
+    }
+    if (txBody.tokenFeeScheduleUpdate) {
+      result.tokenFeeScheduleUpdate = HTSParser.parseTokenFeeScheduleUpdate(
+        txBody.tokenFeeScheduleUpdate
+      );
+    }
+    if (txBody.tokenFreeze) {
+      result.tokenFreeze = HTSParser.parseTokenFreeze(txBody.tokenFreeze);
+    }
+    if (txBody.tokenUnfreeze) {
+      result.tokenUnfreeze = HTSParser.parseTokenUnfreeze(txBody.tokenUnfreeze);
+    }
+    if (txBody.tokenGrantKyc) {
+      result.tokenGrantKyc = HTSParser.parseTokenGrantKyc(txBody.tokenGrantKyc);
+    }
+    if (txBody.tokenRevokeKyc) {
+      result.tokenRevokeKyc = HTSParser.parseTokenRevokeKyc(
+        txBody.tokenRevokeKyc
+      );
+    }
+    if (txBody.tokenPause) {
+      result.tokenPause = HTSParser.parseTokenPause(txBody.tokenPause);
+    }
+    if (txBody.tokenUnpause) {
+      result.tokenUnpause = HTSParser.parseTokenUnpause(txBody.tokenUnpause);
+    }
+    if (txBody.tokenWipe) {
+      result.tokenWipeAccount = HTSParser.parseTokenWipeAccount(
+        txBody.tokenWipe
+      );
+    }
+    if (txBody.tokenDeletion) {
+      result.tokenDelete = HTSParser.parseTokenDelete(txBody.tokenDeletion);
+    }
+    if (txBody.tokenAssociate) {
+      result.tokenAssociate = HTSParser.parseTokenAssociate(
+        txBody.tokenAssociate
+      );
+    }
+    if (txBody.tokenDissociate) {
+      result.tokenDissociate = HTSParser.parseTokenDissociate(
+        txBody.tokenDissociate
+      );
+    }
+    if (txBody.tokenAirdrop) {
+      result.tokenAirdrop = HTSParser.parseTokenAirdropFromProto(
+        txBody.tokenAirdrop
+      );
+    }
+    if (txBody.consensusCreateTopic) {
+      result.consensusCreateTopic = HCSParser.parseConsensusCreateTopic(
+        txBody.consensusCreateTopic
+      );
+    }
+    if (txBody.consensusSubmitMessage) {
+      result.consensusSubmitMessage = HCSParser.parseConsensusSubmitMessage(
+        txBody.consensusSubmitMessage
+      );
+    }
+    if (txBody.consensusUpdateTopic) {
+      result.consensusUpdateTopic = HCSParser.parseConsensusUpdateTopic(
+        txBody.consensusUpdateTopic
+      );
+    }
+    if (txBody.consensusDeleteTopic) {
+      result.consensusDeleteTopic = HCSParser.parseConsensusDeleteTopic(
+        txBody.consensusDeleteTopic
+      );
+    }
+    if (txBody.fileCreate) {
+      result.fileCreate = FileParser.parseFileCreate(txBody.fileCreate);
+    }
+    if (txBody.fileAppend) {
+      result.fileAppend = FileParser.parseFileAppend(txBody.fileAppend);
+    }
+    if (txBody.fileUpdate) {
+      result.fileUpdate = FileParser.parseFileUpdate(txBody.fileUpdate);
+    }
+    if (txBody.fileDelete) {
+      result.fileDelete = FileParser.parseFileDelete(txBody.fileDelete);
+    }
+    if (txBody.utilPrng) {
+      result.utilPrng = UtilParser.parseUtilPrng(txBody.utilPrng);
     }
   }
-  if (tx.type === "cryptoTransfer" || tx.type === "CRYPTOTRANSFER") {
-    return summarizeCryptoTransfer(tx);
-  }
-  if (tx.contractCall) {
-    return summarizeContractCall(tx);
-  }
-  if (Array.isArray(tx.tokenTransfers) && tx.tokenTransfers.length > 0) {
-    return summarizeTokenTransfers(tx);
+  /**
+   * Parse transaction body details for all supported transaction types
+   * Uses a scalable registry pattern instead of if-else chains
+   */
+  static parseTransactionBodyDetails(txBody, transactionType) {
+    const result = {};
+    const parserConfig = transactionParserRegistry[transactionType];
+    if (parserConfig) {
+      const bodyData = txBody[parserConfig.bodyField];
+      if (bodyData) {
+        const parserResult = parserConfig.parser(bodyData);
+        if (parserConfig.spreadResult) {
+          Object.assign(result, parserResult);
+        } else {
+          result[parserConfig.resultField] = parserResult;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Merge protobuf parsing results with parser results using registry pattern
+   * Eliminates transactionFields array and forEach logic
+   */
+  static mergeProtoParsingResults(result, protoResult, htsResult, transaction, originalBytes) {
+    const fieldsToMerge = Object.values(transactionParserRegistry).map(
+      (config) => config.resultField
+    );
+    for (const field of fieldsToMerge) {
+      const protoValue = protoResult[field];
+      const htsValue = htsResult[field];
+      if (protoValue !== void 0) {
+        result[field] = protoValue;
+      } else if (htsValue !== void 0) {
+        result[field] = htsValue;
+      } else {
+        this.handleSpecialFieldExtraction(result, field, transaction);
+      }
+    }
   }
-  if (tx.humanReadableType && tx.humanReadableType !== "Unknown Transaction") {
-    return tx.humanReadableType;
+  /**
+   * Handle special field extraction cases using registry pattern
+   */
+  static handleSpecialFieldExtraction(result, field, transaction) {
+    if (field === "tokenCreation" && result.type === "TOKENCREATE") {
+      const extracted = HTSParser.extractTokenCreationFromTransaction(transaction);
+      if (extracted) {
+        result[field] = extracted;
+      }
+    } else if (field === "tokenAirdrop" && result.type === "TOKENAIRDROP") {
+      const extracted = HTSParser.extractTokenAirdropFromTransaction(transaction);
+      if (extracted) {
+        result[field] = extracted;
+      }
+    }
   }
-  return "Unknown Transaction";
-};
+  /**
+   * Create fallback result when all parsing methods fail
+   */
+  static createFallbackResult(transactionBytes, primaryError, secondaryError) {
+    const validation = this.validateTransactionBytes(transactionBytes);
+    return {
+      type: "UNKNOWN",
+      humanReadableType: "Unknown Transaction",
+      transfers: [],
+      tokenTransfers: [],
+      details: {
+        rawBytes: transactionBytes.length > 100 ? transactionBytes.substring(0, 100) + "..." : transactionBytes,
+        primaryError: primaryError?.message,
+        secondaryError: secondaryError?.message,
+        parseAttempts: secondaryError ? 2 : 1,
+        validation
+      },
+      formatDetection: {
+        originalFormat: validation.format || "base64",
+        wasConverted: false,
+        length: transactionBytes.length
+      },
+      raw: {}
+    };
+  }
+}
 export {
-  resolveTransactionSummary,
-  transactionSummaryRegistry
+  TransactionParser,
+  TransactionParsingError
 };
 //# sourceMappingURL=standards-sdk.es123.js.map