@hashgraphonline/standards-sdk 0.0.174 → 0.0.176

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

@@ -86,91 +86,100 @@ class TransactionParser {
     return fallbackResult;
   }
   /**
-   * Parse a Transaction object directly
-   * This method extracts data from Transaction objects created by the Hedera SDK
+   * 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, options = {}) {
+  static parseTransactionObject(transaction, originalBytes, options = {}) {
     try {
       const metadata = this.extractTransactionMetadata(transaction);
-      const specificData = this.parseTransactionSpecificData(transaction);
-      const scheduleData = ScheduleParser.parseScheduleTransaction(transaction);
-      let type = "UNKNOWN";
-      let humanReadableType = "Unknown Transaction";
-      try {
-        const transactionBytes = transaction.toBytes();
-        const decoded = proto.TransactionList.decode(transactionBytes);
-        if (decoded.transactionList && decoded.transactionList.length > 0) {
-          const tx = decoded.transactionList[0];
-          if (tx.signedTransactionBytes) {
-            const signedTx = proto.SignedTransaction.decode(
-              tx.signedTransactionBytes
-            );
-            if (signedTx.bodyBytes) {
-              const txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
-              if (txBody.tokenCreation) {
-                type = "TOKENCREATE";
-                humanReadableType = "Token Creation";
-              } else if (txBody.tokenAirdrop) {
-                type = "TOKENAIRDROP";
-                humanReadableType = "Token Airdrop";
-              } else if (txBody.cryptoTransfer) {
-                type = "CRYPTOTRANSFER";
-                humanReadableType = "Crypto Transfer";
-              } else if (txBody.consensusSubmitMessage) {
-                type = "CONSENSUSSUBMITMESSAGE";
-                humanReadableType = "Submit Message";
-              } else if (txBody.contractCall) {
-                type = "CONTRACTCALL";
-                humanReadableType = "Contract Call";
-              } else if (txBody.cryptoCreateAccount) {
-                type = "ACCOUNTCREATE";
-                humanReadableType = "Account Creation";
-              } else if (txBody.tokenMint) {
-                type = "TOKENMINT";
-                humanReadableType = "Token Mint";
-              } else if (txBody.tokenBurn) {
-                type = "TOKENBURN";
-                humanReadableType = "Token Burn";
-              } else if (txBody.tokenAssociate) {
-                type = "TOKENASSOCIATE";
-                humanReadableType = "Token Association";
-              } else if (txBody.fileCreate) {
-                type = "FILECREATE";
-                humanReadableType = "File Creation";
-              } else if (txBody.consensusCreateTopic) {
-                type = "TOPICCREATE";
-                humanReadableType = "Topic Creation";
+      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) {
         }
-      } catch (protoError) {
-        console.warn("Failed to parse transaction protobuf:", protoError);
       }
-      if (type === "UNKNOWN" && specificData.type) {
-        type = specificData.type;
-        humanReadableType = specificData.humanReadableType || humanReadableType;
+      if (finalType === "UNKNOWN" && primaryResult.type) {
+        finalType = primaryResult.type;
+        finalHumanReadableType = primaryResult.humanReadableType || finalHumanReadableType;
       }
       const result = {
-        type,
-        humanReadableType,
+        type: finalType,
+        humanReadableType: finalHumanReadableType,
+        transfers: [],
+        tokenTransfers: [],
         ...metadata,
-        ...specificData,
-        ...scheduleData,
+        ...primaryResult,
         raw: options.includeRaw ? transaction._transactionBody || {} : void 0
       };
-      if (type === "TOKENCREATE") {
-        const tokenCreation = this.extractTokenCreation(transaction);
-        if (tokenCreation) {
-          result.tokenCreation = tokenCreation;
-        }
-      }
-      result.transfers = result.transfers || [];
-      result.tokenTransfers = result.tokenTransfers || [];
+      this.mergeProtoParsingResults(
+        result,
+        protoParsingResult,
+        htsResult,
+        transaction,
+        originalBytes
+      );
+      result.transfers = cryptoResult.transfers || result.transfers || [];
+      result.tokenTransfers = cryptoResult.tokenTransfers || result.tokenTransfers || [];
       return result;
     } catch (error) {
       return {
@@ -370,6 +379,109 @@ class TransactionParser {
       };
     }
   }
+  /**
+   * Detect transaction type and human-readable type from transaction body protobuf
+   * Centralized method to eliminate duplication across parsing methods
+   */
+  static detectTransactionTypeFromBody(txBody) {
+    if (txBody.tokenCreation) {
+      return { type: "TOKENCREATE", humanReadableType: "Token Creation" };
+    } else if (txBody.tokenAirdrop) {
+      return { type: "TOKENAIRDROP", humanReadableType: "Token Airdrop" };
+    } else if (txBody.cryptoTransfer) {
+      return { type: "CRYPTOTRANSFER", humanReadableType: "Crypto Transfer" };
+    } else if (txBody.consensusSubmitMessage) {
+      return {
+        type: "CONSENSUSSUBMITMESSAGE",
+        humanReadableType: "Submit Message"
+      };
+    } else if (txBody.contractCall) {
+      return { type: "CONTRACTCALL", humanReadableType: "Contract Call" };
+    } else if (txBody.cryptoCreateAccount) {
+      return { type: "ACCOUNTCREATE", humanReadableType: "Account Creation" };
+    } else if (txBody.cryptoUpdateAccount) {
+      return { type: "ACCOUNTUPDATE", humanReadableType: "Account Update" };
+    } else if (txBody.cryptoDelete) {
+      return { type: "ACCOUNTDELETE", humanReadableType: "Account Deletion" };
+    } else if (txBody.cryptoApproveAllowance) {
+      return {
+        type: "APPROVEALLOWANCE",
+        humanReadableType: "Approve Allowance"
+      };
+    } else if (txBody.cryptoDeleteAllowance) {
+      return { type: "DELETEALLOWANCE", humanReadableType: "Delete Allowance" };
+    } else if (txBody.tokenMint) {
+      return { type: "TOKENMINT", humanReadableType: "Token Mint" };
+    } else if (txBody.tokenBurn) {
+      return { type: "TOKENBURN", humanReadableType: "Token Burn" };
+    } else if (txBody.tokenUpdate) {
+      return { type: "TOKENUPDATE", humanReadableType: "Token Update" };
+    } else if (txBody.tokenDeletion) {
+      return { type: "TOKENDELETE", humanReadableType: "Token Deletion" };
+    } else if (txBody.tokenAssociate) {
+      return { type: "TOKENASSOCIATE", humanReadableType: "Token Association" };
+    } else if (txBody.tokenDissociate) {
+      return {
+        type: "TOKENDISSOCIATE",
+        humanReadableType: "Token Dissociation"
+      };
+    } else if (txBody.tokenFreeze) {
+      return { type: "TOKENFREEZE", humanReadableType: "Token Freeze" };
+    } else if (txBody.tokenUnfreeze) {
+      return { type: "TOKENUNFREEZE", humanReadableType: "Token Unfreeze" };
+    } else if (txBody.tokenGrantKyc) {
+      return { type: "TOKENGRANTKYC", humanReadableType: "Token Grant KYC" };
+    } else if (txBody.tokenRevokeKyc) {
+      return { type: "TOKENREVOKEKYC", humanReadableType: "Token Revoke KYC" };
+    } else if (txBody.tokenWipe) {
+      return { type: "TOKENWIPE", humanReadableType: "Token Wipe" };
+    } else if (txBody.tokenPause) {
+      return { type: "TOKENPAUSE", humanReadableType: "Token Pause" };
+    } else if (txBody.tokenUnpause) {
+      return { type: "TOKENUNPAUSE", humanReadableType: "Token Unpause" };
+    } else if (txBody.tokenFeeScheduleUpdate) {
+      return {
+        type: "TOKENFEESCHEDULEUPDATE",
+        humanReadableType: "Token Fee Schedule Update"
+      };
+    } else if (txBody.fileCreate) {
+      return { type: "FILECREATE", humanReadableType: "File Creation" };
+    } else if (txBody.fileUpdate) {
+      return { type: "FILEUPDATE", humanReadableType: "File Update" };
+    } else if (txBody.fileDelete) {
+      return { type: "FILEDELETE", humanReadableType: "File Deletion" };
+    } else if (txBody.fileAppend) {
+      return { type: "FILEAPPEND", humanReadableType: "File Append" };
+    } else if (txBody.consensusCreateTopic) {
+      return { type: "TOPICCREATE", humanReadableType: "Topic Creation" };
+    } else if (txBody.consensusUpdateTopic) {
+      return { type: "TOPICUPDATE", humanReadableType: "Topic Update" };
+    } else if (txBody.consensusDeleteTopic) {
+      return { type: "TOPICDELETE", humanReadableType: "Topic Deletion" };
+    } else if (txBody.contractCreateInstance) {
+      return { type: "CONTRACTCREATE", humanReadableType: "Contract Creation" };
+    } else if (txBody.contractUpdateInstance) {
+      return { type: "CONTRACTUPDATE", humanReadableType: "Contract Update" };
+    } else if (txBody.contractDeleteInstance) {
+      return { type: "CONTRACTDELETE", humanReadableType: "Contract Deletion" };
+    } else if (txBody.scheduleCreate) {
+      return { type: "SCHEDULECREATE", humanReadableType: "Schedule Creation" };
+    } else if (txBody.scheduleSign) {
+      return { type: "SCHEDULESIGN", humanReadableType: "Schedule Sign" };
+    } else if (txBody.scheduleDelete) {
+      return { type: "SCHEDULEDELETE", humanReadableType: "Schedule Deletion" };
+    } else if (txBody.utilPrng) {
+      return { type: "PRNG", humanReadableType: "Pseudo Random Number" };
+    } else if (txBody.freeze) {
+      return { type: "FREEZE", humanReadableType: "Network Freeze" };
+    } else if (txBody.systemDelete) {
+      return { type: "SYSTEMDELETE", humanReadableType: "System Delete" };
+    } else if (txBody.systemUndelete) {
+      return { type: "SYSTEMUNDELETE", humanReadableType: "System Undelete" };
+    } else {
+      return { type: "UNKNOWN", humanReadableType: "Unknown Transaction" };
+    }
+  }
   /**
    * Parse details from a complete schedule response
    * @param scheduleResponse - The schedule response to parse
@@ -400,79 +512,42 @@ class TransactionParser {
    * @returns The type of the transaction
    */
   static getTransactionType(txBody) {
-    let transactionType = "unknown";
-    if (txBody.cryptoTransfer) {
-      transactionType = "cryptoTransfer";
-    } else if (txBody.cryptoCreateAccount) {
-      transactionType = "cryptoCreateAccount";
-    } else if (txBody.cryptoUpdateAccount) {
-      transactionType = "cryptoUpdateAccount";
-    } else if (txBody.cryptoApproveAllowance) {
-      transactionType = "cryptoApproveAllowance";
-    } else if (txBody.cryptoDeleteAllowance) {
-      transactionType = "cryptoDeleteAllowance";
-    } else if (txBody.cryptoDelete) {
-      transactionType = "cryptoDelete";
-    } else if (txBody.consensusCreateTopic) {
-      transactionType = "consensusCreateTopic";
-    } else if (txBody.consensusUpdateTopic) {
-      transactionType = "consensusUpdateTopic";
-    } else if (txBody.consensusSubmitMessage) {
-      transactionType = "consensusSubmitMessage";
-    } else if (txBody.consensusDeleteTopic) {
-      transactionType = "consensusDeleteTopic";
-    } else if (txBody.fileCreate) {
-      transactionType = "fileCreate";
-    } else if (txBody.fileAppend) {
-      transactionType = "fileAppend";
-    } else if (txBody.fileUpdate) {
-      transactionType = "fileUpdate";
-    } else if (txBody.fileDelete) {
-      transactionType = "fileDelete";
-    } else if (txBody.contractCall) {
-      transactionType = "contractCall";
-    } else if (txBody.contractCreateInstance) {
-      transactionType = "contractCreate";
-    } else if (txBody.contractUpdateInstance) {
-      transactionType = "contractUpdate";
-    } else if (txBody.contractDeleteInstance) {
-      transactionType = "contractDelete";
-    } else if (txBody.tokenCreation) {
-      transactionType = "tokenCreate";
-    } else if (txBody.tokenUpdate) {
-      transactionType = "tokenUpdate";
-    } else if (txBody.tokenDeletion) {
-      transactionType = "tokenDelete";
-    } else if (txBody.tokenAssociate) {
-      transactionType = "tokenAssociate";
-    } else if (txBody.tokenDissociate) {
-      transactionType = "tokenDissociate";
-    } else if (txBody.tokenMint) {
-      transactionType = "tokenMint";
-    } else if (txBody.tokenBurn) {
-      transactionType = "tokenBurn";
-    } else if (txBody.tokenFeeScheduleUpdate) {
-      transactionType = "tokenFeeScheduleUpdate";
-    } else if (txBody.tokenFreeze) {
-      transactionType = "tokenFreeze";
-    } else if (txBody.tokenUnfreeze) {
-      transactionType = "tokenUnfreeze";
-    } else if (txBody.tokenGrantKyc) {
-      transactionType = "tokenGrantKyc";
-    } else if (txBody.tokenRevokeKyc) {
-      transactionType = "tokenRevokeKyc";
-    } else if (txBody.tokenPause) {
-      transactionType = "tokenPause";
-    } else if (txBody.tokenUnpause) {
-      transactionType = "tokenUnpause";
-    } else if (txBody.tokenWipe) {
-      transactionType = "tokenWipe";
-    } else if (txBody.tokenAirdrop) {
-      transactionType = "tokenAirdrop";
-    } else if (txBody.utilPrng) {
-      transactionType = "utilPrng";
-    }
-    return transactionType;
+    if (txBody.tokenCreation) return "tokenCreate";
+    if (txBody.tokenAirdrop) return "tokenAirdrop";
+    if (txBody.cryptoTransfer) return "cryptoTransfer";
+    if (txBody.consensusSubmitMessage) return "consensusSubmitMessage";
+    if (txBody.contractCall) return "contractCall";
+    if (txBody.cryptoCreateAccount) return "cryptoCreateAccount";
+    if (txBody.cryptoUpdateAccount) return "cryptoUpdateAccount";
+    if (txBody.cryptoApproveAllowance) return "cryptoApproveAllowance";
+    if (txBody.cryptoDeleteAllowance) return "cryptoDeleteAllowance";
+    if (txBody.cryptoDelete) return "cryptoDelete";
+    if (txBody.consensusCreateTopic) return "consensusCreateTopic";
+    if (txBody.consensusUpdateTopic) return "consensusUpdateTopic";
+    if (txBody.consensusDeleteTopic) return "consensusDeleteTopic";
+    if (txBody.fileCreate) return "fileCreate";
+    if (txBody.fileAppend) return "fileAppend";
+    if (txBody.fileUpdate) return "fileUpdate";
+    if (txBody.fileDelete) return "fileDelete";
+    if (txBody.contractCreateInstance) return "contractCreate";
+    if (txBody.contractUpdateInstance) return "contractUpdate";
+    if (txBody.contractDeleteInstance) return "contractDelete";
+    if (txBody.tokenUpdate) return "tokenUpdate";
+    if (txBody.tokenDeletion) return "tokenDelete";
+    if (txBody.tokenAssociate) return "tokenAssociate";
+    if (txBody.tokenDissociate) return "tokenDissociate";
+    if (txBody.tokenMint) return "tokenMint";
+    if (txBody.tokenBurn) return "tokenBurn";
+    if (txBody.tokenFeeScheduleUpdate) return "tokenFeeScheduleUpdate";
+    if (txBody.tokenFreeze) return "tokenFreeze";
+    if (txBody.tokenUnfreeze) return "tokenUnfreeze";
+    if (txBody.tokenGrantKyc) return "tokenGrantKyc";
+    if (txBody.tokenRevokeKyc) return "tokenRevokeKyc";
+    if (txBody.tokenPause) return "tokenPause";
+    if (txBody.tokenUnpause) return "tokenUnpause";
+    if (txBody.tokenWipe) return "tokenWipe";
+    if (txBody.utilPrng) return "utilPrng";
+    return "unknown";
   }
   /**
    * Convert technical transaction type to human-readable format
@@ -868,148 +943,129 @@ class TransactionParser {
     return this.decodeTransactionBytes(transactionBytes);
   }
   /**
-   * Parse transaction bytes into structured data
+   * 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 hbarTransfers = this.extractHbarTransfersFromTransaction(transaction);
-      const tokenTransfers = this.extractTokenTransfersFromTransaction(transaction);
-      const tokenCreation = this.extractTokenCreation(transaction);
-      const tokenAirdrop = this.extractTokenAirdrop(transaction);
-      const htsResult = HTSParser.parseHTSTransaction(transaction);
-      const scheduleResult = ScheduleParser.parseScheduleTransaction(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 transactionType = "UNKNOWN";
       let humanReadableType = "Unknown Transaction";
+      let parsedTokenCreation;
       try {
-        const transactionBytes2 = transaction.toBytes();
-        const decoded = proto.TransactionList.decode(transactionBytes2);
+        const decoded = proto.TransactionList.decode(bytes);
         if (decoded.transactionList && decoded.transactionList.length > 0) {
           const tx = decoded.transactionList[0];
-          if (tx.signedTransactionBytes) {
+          if (tx.bodyBytes && tx.bodyBytes.length > 0) {
+            const txBody = proto.TransactionBody.decode(tx.bodyBytes);
+            const typeResult = this.detectTransactionTypeFromBody(txBody);
+            transactionType = typeResult.type;
+            humanReadableType = typeResult.humanReadableType;
+            const protoParsingResult = this.parseTransactionBodyDetails(
+              txBody,
+              transactionType
+            );
+            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);
-              if (txBody.cryptoTransfer) {
-                transactionType = "CRYPTOTRANSFER";
-                humanReadableType = "Crypto Transfer";
-              } else if (txBody.tokenCreation) {
-                transactionType = "TOKENCREATE";
-                humanReadableType = "Token Creation";
-              } else if (txBody.tokenAirdrop) {
-                transactionType = "TOKENAIRDROP";
-                humanReadableType = "Token Airdrop";
-              } else if (txBody.consensusSubmitMessage) {
-                transactionType = "CONSENSUSSUBMITMESSAGE";
-                humanReadableType = "Submit Message";
-              } else if (txBody.contractCall) {
-                transactionType = "CONTRACTCALL";
-                humanReadableType = "Contract Call";
-              } else if (txBody.cryptoCreateAccount) {
-                transactionType = "ACCOUNTCREATE";
-                humanReadableType = "Account Creation";
-              } else if (txBody.tokenMint) {
-                transactionType = "TOKENMINT";
-                humanReadableType = "Token Mint";
-              } else if (txBody.tokenBurn) {
-                transactionType = "TOKENBURN";
-                humanReadableType = "Token Burn";
-              } else if (txBody.tokenAssociate) {
-                transactionType = "TOKENASSOCIATE";
-                humanReadableType = "Token Association";
-              } else if (txBody.fileCreate) {
-                transactionType = "FILECREATE";
-                humanReadableType = "File Creation";
-              } else if (txBody.consensusCreateTopic) {
-                transactionType = "TOPICCREATE";
-                humanReadableType = "Topic Creation";
+              const typeResult = this.detectTransactionTypeFromBody(txBody);
+              transactionType = typeResult.type;
+              humanReadableType = typeResult.humanReadableType;
+              const protoParsingResult = this.parseTransactionBodyDetails(
+                txBody,
+                transactionType
+              );
+              if (protoParsingResult.tokenCreation) {
+                parsedTokenCreation = protoParsingResult.tokenCreation;
               }
             }
           }
         }
       } catch (protoError) {
-        console.warn("Failed to parse transaction protobuf:", protoError);
-      }
-      if (transactionType === "UNKNOWN") {
-        transactionType = htsResult.type || scheduleResult.type || "UNKNOWN";
-        humanReadableType = htsResult.humanReadableType || scheduleResult.humanReadableType || "Unknown Transaction";
-        if (!transactionType || transactionType === "UNKNOWN") {
-          if (tokenCreation) {
-            transactionType = "TOKENCREATE";
-            humanReadableType = "Token Creation";
-          } else if (tokenAirdrop) {
-            transactionType = "TOKENAIRDROP";
-            humanReadableType = "Token Airdrop";
-          } else if (hbarTransfers.length > 0) {
-            transactionType = "CRYPTOTRANSFER";
-            humanReadableType = "HBAR Transfer";
-          } else if (tokenTransfers.length > 0) {
-            transactionType = "TOKENTRANSFER";
-            humanReadableType = "Token Transfer";
-          }
-        }
       }
-      const convertedTransfers = hbarTransfers.map((transfer) => ({
-        accountId: transfer.accountId,
-        amount: transfer.amount.toString() + " ℏ",
-        isDecimal: true
-      }));
-      const convertedTokenTransfers = tokenTransfers.flatMap(
-        (tokenGroup) => tokenGroup.transfers.map((transfer) => ({
-          tokenId: tokenGroup.tokenId,
-          accountId: transfer.accountId,
-          amount: transfer.amount
-        }))
-      );
+      if (transactionType === "UNKNOWN" && primaryResult.type) {
+        transactionType = primaryResult.type;
+        humanReadableType = primaryResult.humanReadableType || "Unknown Transaction";
+      }
       const result = {
         type: transactionType,
         humanReadableType,
-        transfers: convertedTransfers,
-        tokenTransfers: convertedTokenTransfers,
+        transfers: cryptoResult.transfers || [],
+        tokenTransfers: cryptoResult.tokenTransfers || [],
         details: {
-          ...metadata,
-          transferCount: hbarTransfers.length + tokenTransfers.length
+          ...metadata
         },
-        memo: metadata.memo,
-        transactionId: metadata.transactionId,
-        nodeAccountIds: metadata.nodeAccountIds,
-        maxTransactionFee: metadata.maxTransactionFee,
-        validStart: metadata.validStart,
-        validDuration: metadata.validDuration,
+        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,
+        ...primaryResult,
         raw: options.includeRaw ? {} : void 0
       };
-      if (htsResult.type && transactionType === "UNKNOWN") {
-        Object.assign(result, htsResult);
-      } else if (htsResult.type && transactionType !== "UNKNOWN") {
-        const {
-          type: htsType,
-          humanReadableType: htsHumanType,
-          ...htsData
-        } = htsResult;
-        Object.assign(result, htsData);
-      }
-      if (scheduleResult.type && transactionType === "UNKNOWN") {
-        Object.assign(result, scheduleResult);
-      } else if (scheduleResult.type && transactionType !== "UNKNOWN") {
-        const {
-          type: scheduleType,
-          humanReadableType: scheduleHumanType,
-          ...scheduleData
-        } = scheduleResult;
-        Object.assign(result, scheduleData);
-      }
-      if (transactionType === "TOKENCREATE" || tokenCreation) {
-        const tokenCreationData = tokenCreation || this.extractTokenCreation(transaction);
+      if (transactionType === "TOKENCREATE") {
+        const tokenCreationData = parsedTokenCreation || htsResult.tokenCreation || HTSParser.extractTokenCreationFromTransaction(transaction);
         if (tokenCreationData) {
           result.tokenCreation = tokenCreationData;
         }
       }
-      if (tokenAirdrop && !result.tokenAirdrop) {
-        result.tokenAirdrop = tokenAirdrop;
+      if (htsResult.tokenAirdrop && !result.tokenAirdrop) {
+        result.tokenAirdrop = htsResult.tokenAirdrop;
+      }
+      if (transactionType === "TOKENAIRDROP" && !result.tokenAirdrop) {
+        try {
+          const buffer = Buffer.from(transactionBytes, "base64");
+          const decoded = proto.TransactionList.decode(buffer);
+          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 && txBody.tokenAirdrop) {
+              const parsedAirdrop = HTSParser.parseTokenAirdropFromProto(
+                txBody.tokenAirdrop
+              );
+              if (parsedAirdrop) {
+                result.tokenAirdrop = parsedAirdrop;
+              }
+            }
+          }
+        } catch (error) {
+        }
       }
       return result;
     } catch (error) {
@@ -1079,154 +1135,99 @@ class TransactionParser {
     };
   }
   /**
-   * Parse transaction-specific data using specialized parsers
+   * Parse transaction body details for all supported transaction types
+   * This is the DRY, unified approach that delegates to appropriate parsers
    */
-  static parseTransactionSpecificData(transaction) {
+  static parseTransactionBodyDetails(txBody, transactionType) {
     const result = {};
-    const htsData = HTSParser.parseHTSTransaction(transaction);
-    Object.assign(result, htsData);
-    const transfers = this.extractHbarTransfersFromTransaction(transaction);
-    const tokenTransfers = this.extractTokenTransfersFromTransaction(transaction);
-    if (transfers.length > 0) {
-      result.transfers = transfers.map((t) => ({
-        accountId: t.accountId,
-        amount: t.amount.toString(),
-        isDecimal: true
-      }));
-    }
-    if (tokenTransfers.length > 0) {
-      result.tokenTransfers = tokenTransfers.flatMap(
-        (tt) => tt.transfers.map((t) => ({
-          tokenId: tt.tokenId,
-          accountId: t.accountId,
-          amount: t.amount
-        }))
+    if (txBody.tokenCreation && transactionType === "TOKENCREATE") {
+      result.tokenCreation = HTSParser.parseTokenCreate(txBody.tokenCreation);
+    } else if (txBody.tokenMint && transactionType === "TOKENMINT") {
+      result.tokenMint = HTSParser.parseTokenMint(txBody.tokenMint);
+    } else if (txBody.tokenBurn && transactionType === "TOKENBURN") {
+      result.tokenBurn = HTSParser.parseTokenBurn(txBody.tokenBurn);
+    } else if (txBody.tokenUpdate && transactionType === "TOKENUPDATE") {
+      result.tokenUpdate = HTSParser.parseTokenUpdate(txBody.tokenUpdate);
+    } else if (txBody.tokenDeletion && transactionType === "TOKENDELETE") {
+      result.tokenDelete = HTSParser.parseTokenDelete(txBody.tokenDeletion);
+    } else if (txBody.tokenAssociate && transactionType === "TOKENASSOCIATE") {
+      result.tokenAssociate = HTSParser.parseTokenAssociate(
+        txBody.tokenAssociate
+      );
+    } else if (txBody.tokenDissociate && transactionType === "TOKENDISSOCIATE") {
+      result.tokenDissociate = HTSParser.parseTokenDissociate(
+        txBody.tokenDissociate
+      );
+    } else if (txBody.tokenFreeze && transactionType === "TOKENFREEZE") {
+      result.tokenFreeze = HTSParser.parseTokenFreeze(txBody.tokenFreeze);
+    } else if (txBody.tokenUnfreeze && transactionType === "TOKENUNFREEZE") {
+      result.tokenUnfreeze = HTSParser.parseTokenUnfreeze(txBody.tokenUnfreeze);
+    } else if (txBody.tokenGrantKyc && transactionType === "TOKENGRANTKYC") {
+      result.tokenGrantKyc = HTSParser.parseTokenGrantKyc(txBody.tokenGrantKyc);
+    } else if (txBody.tokenRevokeKyc && transactionType === "TOKENREVOKEKYC") {
+      result.tokenRevokeKyc = HTSParser.parseTokenRevokeKyc(
+        txBody.tokenRevokeKyc
+      );
+    } else if (txBody.tokenPause && transactionType === "TOKENPAUSE") {
+      result.tokenPause = HTSParser.parseTokenPause(txBody.tokenPause);
+    } else if (txBody.tokenUnpause && transactionType === "TOKENUNPAUSE") {
+      result.tokenUnpause = HTSParser.parseTokenUnpause(txBody.tokenUnpause);
+    } else if (txBody.tokenWipe && transactionType === "TOKENWIPEACCOUNT") {
+      result.tokenWipeAccount = HTSParser.parseTokenWipeAccount(
+        txBody.tokenWipe
+      );
+    } else if (txBody.tokenFeeScheduleUpdate && transactionType === "TOKENFEESCHEDULEUPDATE") {
+      result.tokenFeeScheduleUpdate = HTSParser.parseTokenFeeScheduleUpdate(
+        txBody.tokenFeeScheduleUpdate
+      );
+    } else if (txBody.tokenAirdrop && transactionType === "TOKENAIRDROP") {
+      result.tokenAirdrop = HTSParser.parseTokenAirdropFromProto(
+        txBody.tokenAirdrop
       );
     }
     return result;
   }
   /**
-   * Extract HBAR transfers from Transaction object
-   */
-  static extractHbarTransfersFromTransaction(transaction) {
-    const transfers = [];
-    try {
-      const hbarTransfers = transaction._hbarTransfers;
-      if (Array.isArray(hbarTransfers)) {
-        hbarTransfers.forEach((transfer) => {
-          if (transfer.accountId && transfer.amount) {
-            const amountInTinybars = transfer.amount.toTinybars();
-            const amountInHbar = Number(amountInTinybars) / 1e8;
-            transfers.push({
-              accountId: transfer.accountId.toString(),
-              amount: amountInHbar
-            });
-          }
-        });
-      }
-    } catch (error) {
-    }
-    return transfers;
-  }
-  /**
-   * Extract token transfers from Transaction object
+   * Merge protobuf parsing results with parser results using unified prioritization
    */
-  static extractTokenTransfersFromTransaction(transaction) {
-    const tokenTransfers = [];
-    try {
-      const tokenTransfersList = transaction._tokenTransfers;
-      if (Array.isArray(tokenTransfersList)) {
-        tokenTransfersList.forEach((tokenTransfer) => {
-          if (tokenTransfer.tokenId && Array.isArray(tokenTransfer.transfers)) {
-            const transfers = tokenTransfer.transfers.map((transfer) => ({
-              accountId: transfer.accountId?.toString() || "Unknown",
-              amount: Number(transfer.amount || 0)
-            }));
-            tokenTransfers.push({
-              tokenId: tokenTransfer.tokenId.toString(),
-              transfers
-            });
-          }
-        });
-      }
-    } catch (error) {
-      console.warn("Failed to extract token transfers:", error);
-    }
-    return tokenTransfers;
-  }
-  static extractTokenCreation(transaction) {
-    try {
-      const transactionBytes = transaction.toBytes();
-      const decoded = proto.TransactionList.decode(transactionBytes);
-      if (decoded.transactionList && decoded.transactionList.length > 0) {
-        const tx = decoded.transactionList[0];
-        if (tx.signedTransactionBytes) {
-          const signedTx = proto.SignedTransaction.decode(
-            tx.signedTransactionBytes
-          );
-          if (signedTx.bodyBytes) {
-            const txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
-            if (txBody.tokenCreation) {
-              const tokenCreation = txBody.tokenCreation;
-              return {
-                tokenName: tokenCreation.name || "Unknown Token",
-                tokenSymbol: tokenCreation.symbol || "UNKNOWN",
-                initialSupply: tokenCreation.initialSupply?.toString() || "0",
-                decimals: Number(tokenCreation.decimals || 0),
-                maxSupply: tokenCreation.maxSupply?.toString(),
-                tokenType: tokenCreation.tokenType || "FUNGIBLE_COMMON",
-                supplyType: tokenCreation.supplyType || "INFINITE",
-                tokenMemo: tokenCreation.memo || "",
-                treasuryAccountId: tokenCreation.treasury?.toString() || "Unknown"
-              };
-            }
-          }
+  static mergeProtoParsingResults(result, protoResult, htsResult, transaction, originalBytes) {
+    const transactionFields = [
+      "tokenCreation",
+      "tokenMint",
+      "tokenBurn",
+      "tokenUpdate",
+      "tokenDelete",
+      "tokenAssociate",
+      "tokenDissociate",
+      "tokenFreeze",
+      "tokenUnfreeze",
+      "tokenGrantKyc",
+      "tokenRevokeKyc",
+      "tokenPause",
+      "tokenUnpause",
+      "tokenWipeAccount",
+      "tokenFeeScheduleUpdate",
+      "tokenAirdrop"
+    ];
+    transactionFields.forEach((field) => {
+      const protoValue = protoResult[field];
+      const htsValue = htsResult[field];
+      if (protoValue !== void 0) {
+        result[field] = protoValue;
+      } else if (htsValue !== void 0) {
+        result[field] = htsValue;
+      } else if (field === "tokenCreation" && result.type === "TOKENCREATE") {
+        const extracted = HTSParser.extractTokenCreationFromTransaction(transaction);
+        if (extracted) {
+          result[field] = extracted;
         }
-      }
-      return null;
-    } catch (error) {
-      if (process.env.NODE_ENV === "development") {
-        console.warn("Failed to extract token creation data:", error);
-      }
-      return null;
-    }
-  }
-  static extractTokenAirdrop(transaction) {
-    try {
-      const transactionBytes = transaction.toBytes();
-      const decoded = proto.TransactionList.decode(transactionBytes);
-      if (decoded.transactionList && decoded.transactionList.length > 0) {
-        const tx = decoded.transactionList[0];
-        if (tx.signedTransactionBytes) {
-          const signedTx = proto.SignedTransaction.decode(
-            tx.signedTransactionBytes
-          );
-          if (signedTx.bodyBytes) {
-            const txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
-            if (txBody.tokenAirdrop) {
-              const airdrop = txBody.tokenAirdrop;
-              const tokenTransfers = airdrop.tokenTransfers || [];
-              return {
-                tokenTransfers: tokenTransfers.map(
-                  (transfer) => ({
-                    tokenId: transfer.token?.toString() || "Unknown",
-                    transfers: (transfer.transfers || []).map(
-                      (t) => ({
-                        accountId: t.accountID?.toString() || "Unknown",
-                        amount: t.amount?.toString() || "0"
-                      })
-                    )
-                  })
-                )
-              };
-            }
-          }
+      } else if (field === "tokenAirdrop" && result.type === "TOKENAIRDROP") {
+        const extracted = HTSParser.extractTokenAirdropFromTransaction(transaction);
+        if (extracted) {
+          result[field] = extracted;
         }
       }
-      return null;
-    } catch (error) {
-      return null;
-    }
+    });
   }
   /**
    * Create fallback result when all parsing methods fail