@hashgraphonline/standards-sdk 0.1.184 → 0.1.185

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

@@ -1,358 +1,1143 @@
-const protoFieldToTypeRegistry = {
-  tokenCreation: { type: "TOKENCREATE", humanReadableType: "Token Creation" },
-  tokenAirdrop: { type: "TOKENAIRDROP", humanReadableType: "Token Airdrop" },
-  tokenMint: { type: "TOKENMINT", humanReadableType: "Token Mint" },
-  tokenBurn: { type: "TOKENBURN", humanReadableType: "Token Burn" },
-  tokenUpdate: { type: "TOKENUPDATE", humanReadableType: "Token Update" },
-  tokenDeletion: { type: "TOKENDELETE", humanReadableType: "Token Deletion" },
-  tokenAssociate: {
-    type: "TOKENASSOCIATE",
-    humanReadableType: "Token Association"
-  },
-  tokenDissociate: {
-    type: "TOKENDISSOCIATE",
-    humanReadableType: "Token Dissociation"
-  },
-  tokenFreeze: { type: "TOKENFREEZE", humanReadableType: "Token Freeze" },
-  tokenUnfreeze: { type: "TOKENUNFREEZE", humanReadableType: "Token Unfreeze" },
-  tokenGrantKyc: {
-    type: "TOKENGRANTKYC",
-    humanReadableType: "Token Grant KYC"
-  },
-  tokenRevokeKyc: {
-    type: "TOKENREVOKEKYC",
-    humanReadableType: "Token Revoke KYC"
-  },
-  tokenPause: { type: "TOKENPAUSE", humanReadableType: "Token Pause" },
-  tokenUnpause: { type: "TOKENUNPAUSE", humanReadableType: "Token Unpause" },
-  tokenWipe: { type: "TOKENWIPE", humanReadableType: "Token Wipe" },
-  tokenFeeScheduleUpdate: {
-    type: "TOKENFEESCHEDULEUPDATE",
-    humanReadableType: "Token Fee Schedule Update"
-  },
-  tokenCancelAirdrop: {
-    type: "TOKENCANCELAIRDROP",
-    humanReadableType: "Cancel Token Airdrop"
-  },
-  tokenClaimAirdrop: {
-    type: "TOKENCLAIMAIRDROP",
-    humanReadableType: "Claim Token Airdrop"
-  },
-  tokenReject: { type: "TOKENREJECT", humanReadableType: "Token Reject" },
-  tokenUpdateNfts: {
-    type: "TOKENUPDATENFTS",
-    humanReadableType: "Update NFT Metadata"
-  },
-  cryptoTransfer: {
-    type: "CRYPTOTRANSFER",
-    humanReadableType: "Crypto Transfer"
-  },
-  cryptoCreateAccount: {
-    type: "ACCOUNTCREATE",
-    humanReadableType: "Account Creation"
-  },
-  cryptoUpdateAccount: {
-    type: "ACCOUNTUPDATE",
-    humanReadableType: "Account Update"
-  },
-  cryptoDelete: {
-    type: "ACCOUNTDELETE",
-    humanReadableType: "Account Deletion"
-  },
-  cryptoApproveAllowance: {
-    type: "APPROVEALLOWANCE",
-    humanReadableType: "Approve Allowance"
-  },
-  cryptoDeleteAllowance: {
-    type: "DELETEALLOWANCE",
-    humanReadableType: "Delete Allowance"
-  },
-  cryptoAddLiveHash: {
-    type: "CRYPTOADDLIVEHASH",
-    humanReadableType: "Add Live Hash"
-  },
-  cryptoDeleteLiveHash: {
-    type: "CRYPTODELETELIVEHASH",
-    humanReadableType: "Delete Live Hash"
-  },
-  consensusCreateTopic: {
-    type: "TOPICCREATE",
-    humanReadableType: "Topic Creation"
-  },
-  consensusSubmitMessage: {
-    type: "CONSENSUSSUBMITMESSAGE",
-    humanReadableType: "Submit Message"
-  },
-  consensusUpdateTopic: {
-    type: "TOPICUPDATE",
-    humanReadableType: "Topic Update"
-  },
-  consensusDeleteTopic: {
-    type: "TOPICDELETE",
-    humanReadableType: "Topic Deletion"
-  },
-  uncheckedSubmit: {
-    type: "UNCHECKEDSUBMIT",
-    humanReadableType: "Unchecked Submit"
-  },
-  contractCall: { type: "CONTRACTCALL", humanReadableType: "Contract Call" },
-  contractCreateInstance: {
-    type: "CONTRACTCREATE",
-    humanReadableType: "Contract Creation"
-  },
-  contractUpdateInstance: {
-    type: "CONTRACTUPDATE",
-    humanReadableType: "Contract Update"
-  },
-  contractDeleteInstance: {
-    type: "CONTRACTDELETE",
-    humanReadableType: "Contract Deletion"
-  },
-  ethereumTransaction: {
-    type: "ETHEREUMTRANSACTION",
-    humanReadableType: "Ethereum Transaction"
-  },
-  fileCreate: { type: "FILECREATE", humanReadableType: "File Creation" },
-  fileUpdate: { type: "FILEUPDATE", humanReadableType: "File Update" },
-  fileDelete: { type: "FILEDELETE", humanReadableType: "File Deletion" },
-  fileAppend: { type: "FILEAPPEND", humanReadableType: "File Append" },
-  scheduleCreate: {
-    type: "SCHEDULECREATE",
-    humanReadableType: "Schedule Creation"
-  },
-  scheduleSign: { type: "SCHEDULESIGN", humanReadableType: "Schedule Sign" },
-  scheduleDelete: {
-    type: "SCHEDULEDELETE",
-    humanReadableType: "Schedule Deletion"
-  },
-  freeze: { type: "FREEZE", humanReadableType: "Network Freeze" },
-  systemDelete: { type: "SYSTEMDELETE", humanReadableType: "System Delete" },
-  systemUndelete: {
-    type: "SYSTEMUNDELETE",
-    humanReadableType: "System Undelete"
-  },
-  nodeCreate: { type: "NODECREATE", humanReadableType: "Node Creation" },
-  nodeUpdate: { type: "NODEUPDATE", humanReadableType: "Node Update" },
-  nodeDelete: { type: "NODEDELETE", humanReadableType: "Node Deletion" },
-  nodeStakeUpdate: {
-    type: "NODESTAKEUPDATE",
-    humanReadableType: "Node Stake Update"
-  },
-  utilPrng: { type: "PRNG", humanReadableType: "Pseudo Random Number" },
-  atomicBatch: { type: "ATOMICBATCH", humanReadableType: "Atomic Batch" },
-  stateSignatureTransaction: {
-    type: "STATESIGNATURETRANSACTION",
-    humanReadableType: "State Signature"
-  },
-  historyProofSignature: {
-    type: "HISTORYPROOFSIGNATURE",
-    humanReadableType: "History Proof Signature"
-  },
-  historyProofKeyPublication: {
-    type: "HISTORYPROOFKEYPUBLICATION",
-    humanReadableType: "History Proof Key Publication"
-  },
-  historyProofVote: {
-    type: "HISTORYPROOFVOTE",
-    humanReadableType: "History Proof Vote"
-  },
-  hintsPreprocessingVote: {
-    type: "HINTSPREPROCESSINGVOTE",
-    humanReadableType: "Hints Preprocessing Vote"
-  },
-  hintsKeyPublication: {
-    type: "HINTSKEYPUBLICATION",
-    humanReadableType: "Hints Key Publication"
-  },
-  hintsPartialSignature: {
-    type: "HINTSPARTIALSIGNATURE",
-    humanReadableType: "Hints Partial Signature"
-  },
-  crsPublication: {
-    type: "CRSPUBLICATION",
-    humanReadableType: "CRS Publication"
-  },
-  transactionID: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  nodeAccountID: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  transactionFee: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  transactionValidDuration: {
-    type: "UNKNOWN",
-    humanReadableType: "Unknown Transaction"
-  },
-  generateRecord: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  memo: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  batchKey: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  maxCustomFees: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" }
-};
-const humanReadableTypeRegistry = {
-  cryptoTransfer: "HBAR Transfer",
-  CRYPTOTRANSFER: "HBAR Transfer",
-  cryptoCreateAccount: "Create Account",
-  ACCOUNTCREATE: "Create Account",
-  cryptoUpdateAccount: "Update Account",
-  ACCOUNTUPDATE: "Update Account",
-  cryptoDeleteAccount: "Delete Account",
-  cryptoDelete: "Delete Account",
-  ACCOUNTDELETE: "Delete Account",
-  cryptoApproveAllowance: "Approve Allowance",
-  APPROVEALLOWANCE: "Approve Allowance",
-  cryptoDeleteAllowance: "Delete Allowance",
-  DELETEALLOWANCE: "Delete Allowance",
-  CRYPTOADDLIVEHASH: "Add Live Hash",
-  CRYPTODELETELIVEHASH: "Delete Live Hash",
-  consensusCreateTopic: "Create Topic",
-  TOPICCREATE: "Create Topic",
-  consensusUpdateTopic: "Update Topic",
-  TOPICUPDATE: "Update Topic",
-  consensusSubmitMessage: "Submit Message",
-  CONSENSUSSUBMITMESSAGE: "Submit Message",
-  consensusDeleteTopic: "Delete Topic",
-  TOPICDELETE: "Delete Topic",
-  UNCHECKEDSUBMIT: "Unchecked Submit",
-  fileCreate: "Create File",
-  FILECREATE: "Create File",
-  fileAppend: "Append File",
-  FILEAPPEND: "Append File",
-  fileUpdate: "Update File",
-  FILEUPDATE: "Update File",
-  fileDelete: "Delete File",
-  FILEDELETE: "Delete File",
-  contractCall: "Contract Call",
-  CONTRACTCALL: "Contract Call",
-  contractCreate: "Create Contract",
-  CONTRACTCREATE: "Create Contract",
-  contractUpdate: "Update Contract",
-  CONTRACTUPDATE: "Update Contract",
-  contractDelete: "Delete Contract",
-  CONTRACTDELETE: "Delete Contract",
-  ethereumTransaction: "Ethereum Transaction",
-  ETHEREUMTRANSACTION: "Ethereum Transaction",
-  tokenCreate: "Create Token",
-  TOKENCREATE: "Create Token",
-  tokenUpdate: "Update Token",
-  TOKENUPDATE: "Update Token",
-  tokenDelete: "Delete Token",
-  TOKENDELETE: "Delete Token",
-  tokenAssociate: "Associate Token",
-  TOKENASSOCIATE: "Associate Token",
-  tokenDissociate: "Dissociate Token",
-  TOKENDISSOCIATE: "Dissociate Token",
-  tokenMint: "Mint Token",
-  TOKENMINT: "Mint Token",
-  tokenBurn: "Burn Token",
-  TOKENBURN: "Burn Token",
-  tokenFeeScheduleUpdate: "Update Token Fee Schedule",
-  TOKENFEESCHEDULEUPDATE: "Update Token Fee Schedule",
-  tokenFreeze: "Freeze Token",
-  TOKENFREEZE: "Freeze Token",
-  tokenUnfreeze: "Unfreeze Token",
-  TOKENUNFREEZE: "Unfreeze Token",
-  tokenGrantKyc: "Grant KYC",
-  TOKENGRANTKYC: "Grant KYC",
-  tokenRevokeKyc: "Revoke KYC",
-  TOKENREVOKEKYC: "Revoke KYC",
-  tokenPause: "Pause Token",
-  TOKENPAUSE: "Pause Token",
-  tokenUnpause: "Unpause Token",
-  TOKENUNPAUSE: "Unpause Token",
-  tokenWipe: "Wipe Token",
-  TOKENWIPE: "Wipe Token",
-  tokenAirdrop: "Token Airdrop",
-  TOKENAIRDROP: "Token Airdrop",
-  TOKENCANCELAIRDROP: "Cancel Token Airdrop",
-  TOKENCLAIMAIRDROP: "Claim Token Airdrop",
-  TOKENREJECT: "Token Reject",
-  TOKENUPDATENFTS: "Update NFT Metadata",
-  scheduleCreate: "Create Schedule",
-  SCHEDULECREATE: "Create Schedule",
-  scheduleSign: "Sign Schedule",
-  SCHEDULESIGN: "Sign Schedule",
-  SCHEDULEDELETE: "Delete Schedule",
-  FREEZE: "Network Freeze",
-  SYSTEMDELETE: "System Delete",
-  SYSTEMUNDELETE: "System Undelete",
-  NODECREATE: "Create Node",
-  NODEUPDATE: "Update Node",
-  NODEDELETE: "Delete Node",
-  NODESTAKEUPDATE: "Update Node Stake",
-  utilPrng: "Generate Random Number",
-  PRNG: "Generate Random Number",
-  ATOMICBATCH: "Atomic Batch",
-  STATESIGNATURETRANSACTION: "State Signature",
-  HISTORYPROOFSIGNATURE: "History Proof Signature",
-  HISTORYPROOFKEYPUBLICATION: "History Proof Key Publication",
-  HISTORYPROOFVOTE: "History Proof Vote",
-  HINTSPREPROCESSINGVOTE: "Hints Preprocessing Vote",
-  HINTSKEYPUBLICATION: "Hints Key Publication",
-  HINTSPARTIALSIGNATURE: "Hints Partial Signature",
-  CRSPUBLICATION: "CRS Publication",
-  unknown: "Unknown Transaction",
-  UNKNOWN: "Unknown Transaction"
-};
-const schedulableTransactionTypeRegistry = {
-  tokenCreation: "tokenCreate",
-  tokenAirdrop: "tokenAirdrop",
-  cryptoTransfer: "cryptoTransfer",
-  consensusSubmitMessage: "consensusSubmitMessage",
-  contractCall: "contractCall",
-  cryptoCreateAccount: "cryptoCreateAccount",
-  cryptoUpdateAccount: "cryptoUpdateAccount",
-  cryptoApproveAllowance: "cryptoApproveAllowance",
-  cryptoDeleteAllowance: "cryptoDeleteAllowance",
-  cryptoDelete: "cryptoDelete",
-  consensusCreateTopic: "consensusCreateTopic",
-  consensusUpdateTopic: "consensusUpdateTopic",
-  consensusDeleteTopic: "consensusDeleteTopic",
-  fileCreate: "fileCreate",
-  fileAppend: "fileAppend",
-  fileUpdate: "fileUpdate",
-  fileDelete: "fileDelete",
-  contractCreateInstance: "contractCreate",
-  contractUpdateInstance: "contractUpdate",
-  contractDeleteInstance: "contractDelete",
-  tokenUpdate: "tokenUpdate",
-  tokenDeletion: "tokenDelete",
-  tokenAssociate: "tokenAssociate",
-  tokenDissociate: "tokenDissociate",
-  tokenMint: "tokenMint",
-  tokenBurn: "tokenBurn",
-  tokenFeeScheduleUpdate: "tokenFeeScheduleUpdate",
-  tokenFreeze: "tokenFreeze",
-  tokenUnfreeze: "tokenUnfreeze",
-  tokenGrantKyc: "tokenGrantKyc",
-  tokenRevokeKyc: "tokenRevokeKyc",
-  tokenPause: "tokenPause",
-  tokenUnpause: "tokenUnpause",
-  tokenWipe: "tokenWipe",
-  utilPrng: "utilPrng"
-};
-function getTransactionTypeFromBody(txBody) {
-  for (const [field, typeInfo] of Object.entries(protoFieldToTypeRegistry)) {
-    if (txBody[field]) {
-      return typeInfo;
+import { proto } from "@hashgraph/proto";
+import { AccountId, Long, TokenId } from "@hashgraph/sdk";
+import { parseKey, hasTransactionType, extractTransactionBody } from "./standards-sdk.es178.js";
+import { Buffer } from "buffer";
+class HTSParser {
+  /**
+   * Main entry point for parsing HTS transactions from a Transaction object
+   * This method bridges between the Transaction object and the protobuf parsers
+   */
+  static parseHTSTransaction(transaction) {
+    try {
+      const transactionBody = transaction._transactionBody;
+      if (!transactionBody) {
+        return {};
+      }
+      if (transactionBody.tokenCreation) {
+        const tokenCreation = this.parseTokenCreate(
+          transactionBody.tokenCreation
+        );
+        if (tokenCreation) {
+          return {
+            type: "TOKENCREATE",
+            humanReadableType: "Token Creation",
+            tokenCreation
+          };
+        }
+      }
+      if (transactionBody.tokenMint) {
+        const tokenMint = this.parseTokenMint(transactionBody.tokenMint);
+        if (tokenMint) {
+          return {
+            type: "TOKENMINT",
+            humanReadableType: "Token Mint",
+            tokenMint
+          };
+        }
+      }
+      if (transactionBody.tokenBurn) {
+        const tokenBurn = this.parseTokenBurn(transactionBody.tokenBurn);
+        if (tokenBurn) {
+          return {
+            type: "TOKENBURN",
+            humanReadableType: "Token Burn",
+            tokenBurn
+          };
+        }
+      }
+      if (transactionBody.tokenUpdate) {
+        const tokenUpdate = this.parseTokenUpdate(transactionBody.tokenUpdate);
+        if (tokenUpdate) {
+          return {
+            type: "TOKENUPDATE",
+            humanReadableType: "Token Update",
+            tokenUpdate
+          };
+        }
+      }
+      if (transactionBody.tokenFreeze) {
+        const tokenFreeze = this.parseTokenFreeze(transactionBody.tokenFreeze);
+        if (tokenFreeze) {
+          return {
+            type: "TOKENFREEZE",
+            humanReadableType: "Token Freeze",
+            tokenFreeze
+          };
+        }
+      }
+      if (transactionBody.tokenUnfreeze) {
+        const tokenUnfreeze = this.parseTokenUnfreeze(
+          transactionBody.tokenUnfreeze
+        );
+        if (tokenUnfreeze) {
+          return {
+            type: "TOKENUNFREEZE",
+            humanReadableType: "Token Unfreeze",
+            tokenUnfreeze
+          };
+        }
+      }
+      if (transactionBody.tokenGrantKyc) {
+        const tokenGrantKyc = this.parseTokenGrantKyc(
+          transactionBody.tokenGrantKyc
+        );
+        if (tokenGrantKyc) {
+          return {
+            type: "TOKENGRANTKYC",
+            humanReadableType: "Token Grant KYC",
+            tokenGrantKyc
+          };
+        }
+      }
+      if (transactionBody.tokenRevokeKyc) {
+        const tokenRevokeKyc = this.parseTokenRevokeKyc(
+          transactionBody.tokenRevokeKyc
+        );
+        if (tokenRevokeKyc) {
+          return {
+            type: "TOKENREVOKEKYC",
+            humanReadableType: "Token Revoke KYC",
+            tokenRevokeKyc
+          };
+        }
+      }
+      if (transactionBody.tokenPause) {
+        const tokenPause = this.parseTokenPause(transactionBody.tokenPause);
+        if (tokenPause) {
+          return {
+            type: "TOKENPAUSE",
+            humanReadableType: "Token Pause",
+            tokenPause
+          };
+        }
+      }
+      if (transactionBody.tokenUnpause) {
+        const tokenUnpause = this.parseTokenUnpause(
+          transactionBody.tokenUnpause
+        );
+        if (tokenUnpause) {
+          return {
+            type: "TOKENUNPAUSE",
+            humanReadableType: "Token Unpause",
+            tokenUnpause
+          };
+        }
+      }
+      if (transactionBody.tokenWipe) {
+        const tokenWipeAccount = this.parseTokenWipeAccount(
+          transactionBody.tokenWipe
+        );
+        if (tokenWipeAccount) {
+          return {
+            type: "TOKENWIPEACCOUNT",
+            humanReadableType: "Token Wipe Account",
+            tokenWipeAccount
+          };
+        }
+      }
+      if (transactionBody.tokenDeletion) {
+        const tokenDelete = this.parseTokenDelete(
+          transactionBody.tokenDeletion
+        );
+        if (tokenDelete) {
+          return {
+            type: "TOKENDELETE",
+            humanReadableType: "Token Delete",
+            tokenDelete
+          };
+        }
+      }
+      if (transactionBody.tokenAssociate) {
+        const tokenAssociate = this.parseTokenAssociate(
+          transactionBody.tokenAssociate
+        );
+        if (tokenAssociate) {
+          return {
+            type: "TOKENASSOCIATE",
+            humanReadableType: "Token Associate",
+            tokenAssociate
+          };
+        }
+      }
+      if (transactionBody.tokenDissociate) {
+        const tokenDissociate = this.parseTokenDissociate(
+          transactionBody.tokenDissociate
+        );
+        if (tokenDissociate) {
+          return {
+            type: "TOKENDISSOCIATE",
+            humanReadableType: "Token Dissociate",
+            tokenDissociate
+          };
+        }
+      }
+      if (transactionBody.tokenFeeScheduleUpdate) {
+        const tokenFeeScheduleUpdate = this.parseTokenFeeScheduleUpdate(
+          transactionBody.tokenFeeScheduleUpdate
+        );
+        if (tokenFeeScheduleUpdate) {
+          return {
+            type: "TOKENFEESCHEDULEUPDATE",
+            humanReadableType: "Token Fee Schedule Update",
+            tokenFeeScheduleUpdate
+          };
+        }
+      }
+      const airdrop = this.parseTokenAirdrop(transaction);
+      if (airdrop) {
+        return {
+          type: "TOKENAIRDROP",
+          humanReadableType: "Token Airdrop",
+          tokenAirdrop: airdrop
+        };
+      }
+      return {};
+    } catch (error) {
+      console.warn("[HTSParser] Failed to parse HTS transaction:", error);
+      return {};
     }
   }
-  return { type: "UNKNOWN", humanReadableType: "Unknown Transaction" };
-}
-function getSchedulableTransactionType(txBody) {
-  for (const [field, type] of Object.entries(
-    schedulableTransactionTypeRegistry
-  )) {
-    if (txBody[field]) {
-      return type;
+  static parseTokenCreate(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.name) {
+      data.tokenName = body.name;
+    }
+    if (body.symbol) {
+      data.tokenSymbol = body.symbol;
+    }
+    if (body.treasury) {
+      data.treasuryAccountId = new AccountId(
+        body.treasury.shardNum ?? 0,
+        body.treasury.realmNum ?? 0,
+        body.treasury.accountNum ?? 0
+      ).toString();
+    }
+    if (body.initialSupply) {
+      data.initialSupply = Long.fromValue(body.initialSupply).toString();
+    }
+    if (body.decimals !== void 0 && body.decimals !== null) {
+      data.decimals = Long.fromValue(body.decimals).toNumber();
+    }
+    if (body.maxSupply) {
+      data.maxSupply = Long.fromValue(body.maxSupply).toString();
+    }
+    if (body.memo) {
+      data.memo = body.memo;
+    }
+    if (body.tokenType !== null && body.tokenType !== void 0) {
+      data.tokenType = proto.TokenType[body.tokenType];
+    }
+    if (body.supplyType !== null && body.supplyType !== void 0) {
+      data.supplyType = proto.TokenSupplyType[body.supplyType];
+    }
+    data.adminKey = parseKey(body.adminKey);
+    data.kycKey = parseKey(body.kycKey);
+    data.freezeKey = parseKey(body.freezeKey);
+    data.wipeKey = parseKey(body.wipeKey);
+    data.supplyKey = parseKey(body.supplyKey);
+    data.feeScheduleKey = parseKey(body.feeScheduleKey);
+    data.pauseKey = parseKey(body.pauseKey);
+    if (body.autoRenewAccount) {
+      data.autoRenewAccount = new AccountId(
+        body.autoRenewAccount.shardNum ?? 0,
+        body.autoRenewAccount.realmNum ?? 0,
+        body.autoRenewAccount.accountNum ?? 0
+      ).toString();
+    }
+    if (body.autoRenewPeriod?.seconds) {
+      data.autoRenewPeriod = Long.fromValue(
+        body.autoRenewPeriod.seconds
+      ).toString();
+    }
+    if (body.customFees && body.customFees.length > 0) {
+      data.customFees = body.customFees.map((fee) => {
+        const feeCollectorAccountId = fee.feeCollectorAccountId ? new AccountId(
+          fee.feeCollectorAccountId.shardNum ?? 0,
+          fee.feeCollectorAccountId.realmNum ?? 0,
+          fee.feeCollectorAccountId.accountNum ?? 0
+        ).toString() : "Not Set";
+        const commonFeeData = {
+          feeCollectorAccountId,
+          allCollectorsAreExempt: fee.allCollectorsAreExempt || false
+        };
+        if (fee.fixedFee) {
+          return {
+            ...commonFeeData,
+            feeType: "FIXED_FEE",
+            fixedFee: {
+              amount: Long.fromValue(fee.fixedFee.amount || 0).toString(),
+              denominatingTokenId: fee.fixedFee.denominatingTokenId ? new TokenId(
+                fee.fixedFee.denominatingTokenId.shardNum ?? 0,
+                fee.fixedFee.denominatingTokenId.realmNum ?? 0,
+                fee.fixedFee.denominatingTokenId.tokenNum ?? 0
+              ).toString() : void 0
+            }
+          };
+        } else if (fee.fractionalFee) {
+          return {
+            ...commonFeeData,
+            feeType: "FRACTIONAL_FEE",
+            fractionalFee: {
+              numerator: Long.fromValue(
+                fee.fractionalFee.fractionalAmount?.numerator || 0
+              ).toString(),
+              denominator: Long.fromValue(
+                fee.fractionalFee.fractionalAmount?.denominator || 1
+              ).toString(),
+              minimumAmount: Long.fromValue(
+                fee.fractionalFee.minimumAmount || 0
+              ).toString(),
+              maximumAmount: Long.fromValue(
+                fee.fractionalFee.maximumAmount || 0
+              ).toString(),
+              netOfTransfers: fee.fractionalFee.netOfTransfers || false
+            }
+          };
+        } else if (fee.royaltyFee) {
+          let fallbackFeeData = void 0;
+          if (fee.royaltyFee.fallbackFee) {
+            fallbackFeeData = {
+              amount: Long.fromValue(
+                fee.royaltyFee.fallbackFee.amount || 0
+              ).toString(),
+              denominatingTokenId: fee.royaltyFee.fallbackFee.denominatingTokenId ? new TokenId(
+                fee.royaltyFee.fallbackFee.denominatingTokenId.shardNum ?? 0,
+                fee.royaltyFee.fallbackFee.denominatingTokenId.realmNum ?? 0,
+                fee.royaltyFee.fallbackFee.denominatingTokenId.tokenNum ?? 0
+              ).toString() : void 0
+            };
+          }
+          return {
+            ...commonFeeData,
+            feeType: "ROYALTY_FEE",
+            royaltyFee: {
+              numerator: Long.fromValue(
+                fee.royaltyFee.exchangeValueFraction?.numerator || 0
+              ).toString(),
+              denominator: Long.fromValue(
+                fee.royaltyFee.exchangeValueFraction?.denominator || 1
+              ).toString(),
+              fallbackFee: fallbackFeeData
+            }
+          };
+        }
+        return {
+          ...commonFeeData,
+          feeType: "FIXED_FEE",
+          fixedFee: { amount: "0" }
+        };
+      });
+    }
+    return data;
+  }
+  static parseTokenMint(body) {
+    if (!body || !body.token || body.amount === null || body.amount === void 0) {
+      return void 0;
+    }
+    const data = {
+      tokenId: new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString(),
+      amount: Long.fromValue(body.amount).toNumber()
+    };
+    if (body.metadata && body.metadata.length > 0) {
+      data.metadata = body.metadata.map(
+        (meta) => Buffer.from(meta).toString("base64")
+      );
+    }
+    return data;
+  }
+  static parseTokenBurn(body) {
+    if (!body || !body.token || body.amount === null || body.amount === void 0) {
+      return void 0;
+    }
+    const data = {
+      tokenId: new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString(),
+      amount: Long.fromValue(body.amount).toNumber()
+    };
+    if (body.serialNumbers && body.serialNumbers.length > 0) {
+      data.serialNumbers = body.serialNumbers.map(
+        (sn) => Long.fromValue(sn).toNumber()
+      );
+    }
+    return data;
+  }
+  static parseTokenUpdate(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    if (body.name) {
+      data.name = body.name;
+    }
+    if (body.symbol) {
+      data.symbol = body.symbol;
+    }
+    if (body.treasury) {
+      data.treasuryAccountId = new AccountId(
+        body.treasury.shardNum ?? 0,
+        body.treasury.realmNum ?? 0,
+        body.treasury.accountNum ?? 0
+      ).toString();
+    }
+    data.adminKey = parseKey(body.adminKey);
+    data.kycKey = parseKey(body.kycKey);
+    data.freezeKey = parseKey(body.freezeKey);
+    data.wipeKey = parseKey(body.wipeKey);
+    data.supplyKey = parseKey(body.supplyKey);
+    data.feeScheduleKey = parseKey(body.feeScheduleKey);
+    data.pauseKey = parseKey(body.pauseKey);
+    if (body.autoRenewAccount) {
+      data.autoRenewAccountId = new AccountId(
+        body.autoRenewAccount.shardNum ?? 0,
+        body.autoRenewAccount.realmNum ?? 0,
+        body.autoRenewAccount.accountNum ?? 0
+      ).toString();
+    }
+    if (body.autoRenewPeriod?.seconds) {
+      data.autoRenewPeriod = Long.fromValue(
+        body.autoRenewPeriod.seconds
+      ).toString();
+    }
+    if (body.memo?.value !== void 0) {
+      data.memo = body.memo.value;
+    }
+    if (body.expiry?.seconds) {
+      data.expiry = `${Long.fromValue(body.expiry.seconds).toString()}.${body.expiry.nanos}`;
+    }
+    return data;
+  }
+  static parseTokenFeeScheduleUpdate(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.tokenId) {
+      data.tokenId = new TokenId(
+        body.tokenId.shardNum ?? 0,
+        body.tokenId.realmNum ?? 0,
+        body.tokenId.tokenNum ?? 0
+      ).toString();
+    }
+    if (body.customFees && body.customFees.length > 0) {
+      data.customFees = body.customFees.map((fee) => {
+        const feeCollectorAccountId = fee.feeCollectorAccountId ? new AccountId(
+          fee.feeCollectorAccountId.shardNum ?? 0,
+          fee.feeCollectorAccountId.realmNum ?? 0,
+          fee.feeCollectorAccountId.accountNum ?? 0
+        ).toString() : "Not Set";
+        const commonFeeData = {
+          feeCollectorAccountId,
+          allCollectorsAreExempt: fee.allCollectorsAreExempt || false
+        };
+        if (fee.fixedFee) {
+          return {
+            ...commonFeeData,
+            feeType: "FIXED_FEE",
+            fixedFee: {
+              amount: Long.fromValue(fee.fixedFee.amount || 0).toString(),
+              denominatingTokenId: fee.fixedFee.denominatingTokenId ? new TokenId(
+                fee.fixedFee.denominatingTokenId.shardNum ?? 0,
+                fee.fixedFee.denominatingTokenId.realmNum ?? 0,
+                fee.fixedFee.denominatingTokenId.tokenNum ?? 0
+              ).toString() : void 0
+            }
+          };
+        } else if (fee.fractionalFee) {
+          return {
+            ...commonFeeData,
+            feeType: "FRACTIONAL_FEE",
+            fractionalFee: {
+              numerator: Long.fromValue(
+                fee.fractionalFee.fractionalAmount?.numerator || 0
+              ).toString(),
+              denominator: Long.fromValue(
+                fee.fractionalFee.fractionalAmount?.denominator || 1
+              ).toString(),
+              minimumAmount: Long.fromValue(
+                fee.fractionalFee.minimumAmount || 0
+              ).toString(),
+              maximumAmount: Long.fromValue(
+                fee.fractionalFee.maximumAmount || 0
+              ).toString(),
+              netOfTransfers: fee.fractionalFee.netOfTransfers || false
+            }
+          };
+        } else if (fee.royaltyFee) {
+          let fallbackFeeData = void 0;
+          if (fee.royaltyFee.fallbackFee) {
+            fallbackFeeData = {
+              amount: Long.fromValue(
+                fee.royaltyFee.fallbackFee.amount || 0
+              ).toString(),
+              denominatingTokenId: fee.royaltyFee.fallbackFee.denominatingTokenId ? new TokenId(
+                fee.royaltyFee.fallbackFee.denominatingTokenId.shardNum ?? 0,
+                fee.royaltyFee.fallbackFee.denominatingTokenId.realmNum ?? 0,
+                fee.royaltyFee.fallbackFee.denominatingTokenId.tokenNum ?? 0
+              ).toString() : void 0
+            };
+          }
+          return {
+            ...commonFeeData,
+            feeType: "ROYALTY_FEE",
+            royaltyFee: {
+              numerator: Long.fromValue(
+                fee.royaltyFee.exchangeValueFraction?.numerator || 0
+              ).toString(),
+              denominator: Long.fromValue(
+                fee.royaltyFee.exchangeValueFraction?.denominator || 1
+              ).toString(),
+              fallbackFee: fallbackFeeData
+            }
+          };
+        }
+        return {
+          ...commonFeeData,
+          feeType: "FIXED_FEE",
+          fixedFee: { amount: "0" }
+        };
+      });
+    }
+    return data;
+  }
+  static parseTokenFreeze(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    if (body.account) {
+      data.accountId = new AccountId(
+        body.account.shardNum ?? 0,
+        body.account.realmNum ?? 0,
+        body.account.accountNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  static parseTokenUnfreeze(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    if (body.account) {
+      data.accountId = new AccountId(
+        body.account.shardNum ?? 0,
+        body.account.realmNum ?? 0,
+        body.account.accountNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  static parseTokenGrantKyc(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    if (body.account) {
+      data.accountId = new AccountId(
+        body.account.shardNum ?? 0,
+        body.account.realmNum ?? 0,
+        body.account.accountNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  static parseTokenRevokeKyc(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    if (body.account) {
+      data.accountId = new AccountId(
+        body.account.shardNum ?? 0,
+        body.account.realmNum ?? 0,
+        body.account.accountNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  static parseTokenPause(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  static parseTokenUnpause(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  static parseTokenWipeAccount(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    if (body.account) {
+      data.accountId = new AccountId(
+        body.account.shardNum ?? 0,
+        body.account.realmNum ?? 0,
+        body.account.accountNum ?? 0
+      ).toString();
+    }
+    if (body.serialNumbers && body.serialNumbers.length > 0) {
+      data.serialNumbers = body.serialNumbers.map(
+        (sn) => Long.fromValue(sn).toString()
+      );
+    }
+    if (body.amount) {
+      data.amount = Long.fromValue(body.amount).toString();
+    }
+    return data;
+  }
+  static parseTokenDelete(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.token) {
+      data.tokenId = new TokenId(
+        body.token.shardNum ?? 0,
+        body.token.realmNum ?? 0,
+        body.token.tokenNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  static parseTokenAssociate(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.account) {
+      data.accountId = new AccountId(
+        body.account.shardNum ?? 0,
+        body.account.realmNum ?? 0,
+        body.account.accountNum ?? 0
+      ).toString();
+    }
+    if (body.tokens && body.tokens.length > 0) {
+      data.tokenIds = body.tokens.map(
+        (t) => new TokenId(
+          t.shardNum ?? 0,
+          t.realmNum ?? 0,
+          t.tokenNum ?? 0
+        ).toString()
+      );
+    }
+    return data;
+  }
+  static parseTokenDissociate(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.account) {
+      data.accountId = new AccountId(
+        body.account.shardNum ?? 0,
+        body.account.realmNum ?? 0,
+        body.account.accountNum ?? 0
+      ).toString();
+    }
+    if (body.tokens && body.tokens.length > 0) {
+      data.tokenIds = body.tokens.map(
+        (t) => new TokenId(
+          t.shardNum ?? 0,
+          t.realmNum ?? 0,
+          t.tokenNum ?? 0
+        ).toString()
+      );
+    }
+    return data;
+  }
+  /**
+   * Parse token airdrop transaction for both fungible tokens and NFTs
+   * Extracts airdrop transfers from transaction protobuf data
+   */
+  static parseTokenAirdrop(transaction) {
+    try {
+      const transactionBody = transaction._transactionBody;
+      if (transactionBody?.tokenAirdrop) {
+        const airdrop = transactionBody.tokenAirdrop;
+        return {
+          tokenTransfers: (airdrop.tokenTransfers || []).map(
+            (transfer) => ({
+              tokenId: transfer.token?.toString() || "Unknown",
+              transfers: (transfer.transfers || []).map((t) => ({
+                accountId: t.accountID?.toString() || "Unknown",
+                amount: t.amount?.toString() || "0",
+                serialNumbers: t.serialNumbers?.map((sn) => sn.toString())
+              }))
+            })
+          )
+        };
+      }
+      if (hasTransactionType(transaction, "tokenAirdrop")) {
+        const txBody = extractTransactionBody(transaction);
+        if (txBody?.tokenAirdrop) {
+          return this.parseTokenAirdropFromProto(txBody.tokenAirdrop);
+        }
+      }
+      const tx = transaction;
+      const tokenTransfersList = tx._tokenTransfers || [];
+      if (tokenTransfersList.length > 0) {
+        return {
+          tokenTransfers: tokenTransfersList.map((transfer) => ({
+            tokenId: transfer.tokenId?.toString() || "Unknown",
+            transfers: (transfer.transfers || []).map((t) => ({
+              accountId: t.accountId?.toString() || "Unknown",
+              amount: t.amount?.toString() || "0",
+              serialNumbers: t.serialNumbers?.map((sn) => sn.toString())
+            }))
+          }))
+        };
+      }
+      return null;
+    } catch (error) {
+      console.warn("[HTSParser] Failed to parse token airdrop:", error);
+      return null;
+    }
+  }
+  /**
+   * Parse token airdrop from protobuf data for scheduled transactions
+   */
+  static parseTokenAirdropFromProto(airdrop) {
+    const tokenTransfers = [];
+    if (airdrop.tokenTransfers) {
+      for (const tokenTransfer of airdrop.tokenTransfers) {
+        const token = tokenTransfer.token ? new TokenId(
+          tokenTransfer.token.shardNum ?? 0,
+          tokenTransfer.token.realmNum ?? 0,
+          tokenTransfer.token.tokenNum ?? 0
+        ) : null;
+        const transfers = [];
+        if (tokenTransfer.transfers) {
+          for (const transfer of tokenTransfer.transfers) {
+            const accountId = transfer.accountID ? new AccountId(
+              transfer.accountID.shardNum ?? 0,
+              transfer.accountID.realmNum ?? 0,
+              transfer.accountID.accountNum ?? 0
+            ) : null;
+            transfers.push({
+              accountId: accountId?.toString() || "Unknown",
+              amount: transfer.amount ? Long.fromValue(transfer.amount).toString() : "0",
+              serialNumbers: transfer.serialNumbers?.map(
+                (sn) => Long.fromValue(sn).toString()
+              )
+            });
+          }
+        }
+        tokenTransfers.push({
+          tokenId: token?.toString() || "Unknown",
+          transfers
+        });
+      }
+    }
+    return { tokenTransfers };
+  }
+  /**
+   * Extract token creation data from Transaction object internal fields
+   * This handles the case where token creation data is stored in Transaction internals
+   */
+  static extractTokenCreationFromTransaction(transaction) {
+    try {
+      const tx = transaction;
+      if (tx._tokenName || tx._tokenSymbol) {
+        const result = {
+          tokenName: tx._tokenName || "Unknown Token",
+          tokenSymbol: tx._tokenSymbol || "UNKNOWN",
+          initialSupply: tx._initialSupply?.toString() || "0",
+          decimals: Number(tx._decimals || 0),
+          treasuryAccountId: tx._treasuryAccountId?.toString() || "Unknown"
+        };
+        if (tx._maxSupply) {
+          result.maxSupply = tx._maxSupply.toString();
+        }
+        if (tx._tokenType) {
+          result.tokenType = tx._tokenType.toString ? tx._tokenType.toString() : String(tx._tokenType);
+        }
+        if (tx._supplyType) {
+          result.supplyType = tx._supplyType.toString ? tx._supplyType.toString() : String(tx._supplyType);
+        }
+        if (tx._tokenMemo) {
+          result.memo = tx._tokenMemo;
+        }
+        if (tx._adminKey) {
+          result.adminKey = tx._adminKey.toString();
+        }
+        if (tx._kycKey) {
+          result.kycKey = tx._kycKey.toString();
+        }
+        if (tx._freezeKey) {
+          result.freezeKey = tx._freezeKey.toString();
+        }
+        if (tx._wipeKey) {
+          result.wipeKey = tx._wipeKey.toString();
+        }
+        if (tx._supplyKey) {
+          result.supplyKey = tx._supplyKey.toString();
+        }
+        if (tx._feeScheduleKey) {
+          result.feeScheduleKey = tx._feeScheduleKey.toString();
+        }
+        if (tx._pauseKey) {
+          result.pauseKey = tx._pauseKey.toString();
+        }
+        if (tx._metadataKey) {
+          result.metadataKey = tx._metadataKey.toString();
+        }
+        if (tx._autoRenewAccountId) {
+          result.autoRenewAccount = tx._autoRenewAccountId.toString();
+        }
+        if (tx._autoRenewPeriod) {
+          result.autoRenewPeriod = tx._autoRenewPeriod.seconds?.toString() || tx._autoRenewPeriod.toString();
+        }
+        if (tx._expirationTime) {
+          result.expiry = tx._expirationTime.seconds?.toString() || tx._expirationTime.toString();
+        }
+        if (tx._customFees && Array.isArray(tx._customFees) && tx._customFees.length > 0) {
+          result.customFees = tx._customFees.map((fee) => {
+            const customFee = {
+              feeCollectorAccountId: fee.feeCollectorAccountId?.toString() || "",
+              feeType: "FIXED_FEE"
+            };
+            if (fee.fixedFee) {
+              customFee.feeType = "FIXED_FEE";
+              customFee.fixedFee = {
+                amount: fee.fixedFee.amount?.toString() || "0",
+                denominatingTokenId: fee.fixedFee.denominatingTokenId?.toString()
+              };
+            } else if (fee.fractionalFee) {
+              customFee.feeType = "FRACTIONAL_FEE";
+              customFee.fractionalFee = {
+                numerator: fee.fractionalFee.numerator?.toString() || "0",
+                denominator: fee.fractionalFee.denominator?.toString() || "1",
+                minimumAmount: fee.fractionalFee.minimumAmount?.toString() || "0",
+                maximumAmount: fee.fractionalFee.maximumAmount?.toString() || "0",
+                netOfTransfers: fee.fractionalFee.netOfTransfers || false
+              };
+            } else if (fee.royaltyFee) {
+              customFee.feeType = "ROYALTY_FEE";
+              customFee.royaltyFee = {
+                numerator: fee.royaltyFee.numerator?.toString() || "0",
+                denominator: fee.royaltyFee.denominator?.toString() || "1",
+                fallbackFee: fee.royaltyFee.fallbackFee ? {
+                  amount: fee.royaltyFee.fallbackFee.amount?.toString() || "0",
+                  denominatingTokenId: fee.royaltyFee.fallbackFee.denominatingTokenId?.toString()
+                } : void 0
+              };
+            }
+            customFee.allCollectorsAreExempt = fee.allCollectorsAreExempt || false;
+            return customFee;
+          });
+        }
+        return result;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Extract token airdrop data from Transaction object internal fields
+   * This handles the case where airdrop data is stored in Transaction internals
+   */
+  static extractTokenAirdropFromTransaction(transaction) {
+    try {
+      const tx = transaction;
+      if (tx._tokenAirdrops && Array.isArray(tx._tokenAirdrops)) {
+        const tokenTransfers = tx._tokenAirdrops.map((airdrop) => ({
+          tokenId: airdrop.tokenId?.toString() || "Unknown",
+          transfers: (airdrop.transfers || []).map((transfer) => ({
+            accountId: transfer.accountId?.toString() || "Unknown",
+            amount: transfer.amount?.toString() || "0",
+            serialNumbers: transfer.serialNumbers?.map((s) => s.toString()) || []
+          }))
+        }));
+        return { tokenTransfers };
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Parse HTS transaction from Transaction object with comprehensive extraction
+   * This is the unified entry point that handles both protobuf and internal field extraction
+   */
+  static parseFromTransactionObject(transaction) {
+    try {
+      try {
+        const bytes = transaction.toBytes ? transaction.toBytes() : void 0;
+        if (bytes) {
+          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) {
+              if (txBody.tokenCreation) {
+                const tokenCreation2 = this.parseTokenCreate(
+                  txBody.tokenCreation
+                );
+                if (tokenCreation2) {
+                  return {
+                    type: "TOKENCREATE",
+                    humanReadableType: "Token Creation",
+                    tokenCreation: tokenCreation2
+                  };
+                }
+              }
+              if (txBody.tokenMint) {
+                const tokenMint = this.parseTokenMint(txBody.tokenMint);
+                if (tokenMint) {
+                  return {
+                    type: "TOKENMINT",
+                    humanReadableType: "Token Mint",
+                    tokenMint
+                  };
+                }
+              }
+              if (txBody.tokenBurn) {
+                const tokenBurn = this.parseTokenBurn(txBody.tokenBurn);
+                if (tokenBurn) {
+                  return {
+                    type: "TOKENBURN",
+                    humanReadableType: "Token Burn",
+                    tokenBurn
+                  };
+                }
+              }
+              if (txBody.tokenUpdate) {
+                const tokenUpdate = this.parseTokenUpdate(txBody.tokenUpdate);
+                if (tokenUpdate) {
+                  return {
+                    type: "TOKENUPDATE",
+                    humanReadableType: "Token Update",
+                    tokenUpdate
+                  };
+                }
+              }
+              if (txBody.tokenFreeze) {
+                const tokenFreeze = this.parseTokenFreeze(txBody.tokenFreeze);
+                if (tokenFreeze) {
+                  return {
+                    type: "TOKENFREEZE",
+                    humanReadableType: "Token Freeze",
+                    tokenFreeze
+                  };
+                }
+              }
+              if (txBody.tokenUnfreeze) {
+                const tokenUnfreeze = this.parseTokenUnfreeze(
+                  txBody.tokenUnfreeze
+                );
+                if (tokenUnfreeze) {
+                  return {
+                    type: "TOKENUNFREEZE",
+                    humanReadableType: "Token Unfreeze",
+                    tokenUnfreeze
+                  };
+                }
+              }
+              if (txBody.tokenGrantKyc) {
+                const tokenGrantKyc = this.parseTokenGrantKyc(
+                  txBody.tokenGrantKyc
+                );
+                if (tokenGrantKyc) {
+                  return {
+                    type: "TOKENGRANTKYC",
+                    humanReadableType: "Token Grant KYC",
+                    tokenGrantKyc
+                  };
+                }
+              }
+              if (txBody.tokenRevokeKyc) {
+                const tokenRevokeKyc = this.parseTokenRevokeKyc(
+                  txBody.tokenRevokeKyc
+                );
+                if (tokenRevokeKyc) {
+                  return {
+                    type: "TOKENREVOKEKYC",
+                    humanReadableType: "Token Revoke KYC",
+                    tokenRevokeKyc
+                  };
+                }
+              }
+              if (txBody.tokenPause) {
+                const tokenPause = this.parseTokenPause(txBody.tokenPause);
+                if (tokenPause) {
+                  return {
+                    type: "TOKENPAUSE",
+                    humanReadableType: "Token Pause",
+                    tokenPause
+                  };
+                }
+              }
+              if (txBody.tokenUnpause) {
+                const tokenUnpause = this.parseTokenUnpause(
+                  txBody.tokenUnpause
+                );
+                if (tokenUnpause) {
+                  return {
+                    type: "TOKENUNPAUSE",
+                    humanReadableType: "Token Unpause",
+                    tokenUnpause
+                  };
+                }
+              }
+              if (txBody.tokenWipe) {
+                const tokenWipeAccount = this.parseTokenWipeAccount(
+                  txBody.tokenWipe
+                );
+                if (tokenWipeAccount) {
+                  return {
+                    type: "TOKENWIPEACCOUNT",
+                    humanReadableType: "Token Wipe Account",
+                    tokenWipeAccount
+                  };
+                }
+              }
+              if (txBody.tokenDeletion) {
+                const tokenDelete = this.parseTokenDelete(txBody.tokenDeletion);
+                if (tokenDelete) {
+                  return {
+                    type: "TOKENDELETE",
+                    humanReadableType: "Token Delete",
+                    tokenDelete
+                  };
+                }
+              }
+              if (txBody.tokenAssociate) {
+                const tokenAssociate = this.parseTokenAssociate(
+                  txBody.tokenAssociate
+                );
+                if (tokenAssociate) {
+                  return {
+                    type: "TOKENASSOCIATE",
+                    humanReadableType: "Token Associate",
+                    tokenAssociate
+                  };
+                }
+              }
+              if (txBody.tokenDissociate) {
+                const tokenDissociate = this.parseTokenDissociate(
+                  txBody.tokenDissociate
+                );
+                if (tokenDissociate) {
+                  return {
+                    type: "TOKENDISSOCIATE",
+                    humanReadableType: "Token Dissociate",
+                    tokenDissociate
+                  };
+                }
+              }
+              if (txBody.tokenFeeScheduleUpdate) {
+                const tokenFeeScheduleUpdate = this.parseTokenFeeScheduleUpdate(
+                  txBody.tokenFeeScheduleUpdate
+                );
+                if (tokenFeeScheduleUpdate) {
+                  return {
+                    type: "TOKENFEESCHEDULEUPDATE",
+                    humanReadableType: "Token Fee Schedule Update",
+                    tokenFeeScheduleUpdate
+                  };
+                }
+              }
+              if (txBody.tokenAirdrop) {
+                const tokenAirdrop2 = this.parseTokenAirdropFromProto(
+                  txBody.tokenAirdrop
+                );
+                if (tokenAirdrop2) {
+                  return {
+                    type: "TOKENAIRDROP",
+                    humanReadableType: "Token Airdrop",
+                    tokenAirdrop: tokenAirdrop2
+                  };
+                }
+              }
+            }
+          }
+        }
+      } catch (e) {
+      }
+      const protoResult = this.parseHTSTransaction(transaction);
+      if (protoResult.type) {
+        return protoResult;
+      }
+      const tokenCreation = this.extractTokenCreationFromTransaction(transaction);
+      const tokenAirdrop = this.extractTokenAirdropFromTransaction(transaction);
+      if (tokenCreation) {
+        return {
+          type: "TOKENCREATE",
+          humanReadableType: "Token Creation",
+          tokenCreation
+        };
+      }
+      if (tokenAirdrop) {
+        return {
+          type: "TOKENAIRDROP",
+          humanReadableType: "Token Airdrop",
+          tokenAirdrop
+        };
+      }
+      return {};
+    } catch (error) {
+      return {};
     }
   }
-  return "unknown";
-}
-function getHumanReadableTransactionType(type) {
-  return humanReadableTypeRegistry[type] || "Unknown Transaction";
 }
 export {
-  getHumanReadableTransactionType,
-  getSchedulableTransactionType,
-  getTransactionTypeFromBody,
-  humanReadableTypeRegistry,
-  protoFieldToTypeRegistry,
-  schedulableTransactionTypeRegistry
+  HTSParser
 };
 //# sourceMappingURL=standards-sdk.es141.js.map