@hashgraphonline/standards-sdk 0.1.160 → 0.1.162

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

@@ -1,358 +1,309 @@
-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 { hasTransactionType, parseKey } from "./standards-sdk.es168.js";
+import { AccountId, Long, ScheduleId } from "@hashgraph/sdk";
+class ScheduleParser {
+  /**
+   * Parse Schedule Service transaction using unified dual-branch approach
+   * This handles both regular transactions and signed transaction variants
+   */
+  static parseScheduleTransaction(transaction, originalBytes) {
+    try {
+      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];
+            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 protoResult = this.parseFromProtobufTxBody(txBody);
+              if (protoResult.type && protoResult.type !== "UNKNOWN") {
+                return protoResult;
+              }
+            }
+          }
+        } catch (protoError) {
+        }
+      }
+      return this.parseFromTransactionInternals(transaction);
+    } catch (error) {
+      return {
+        type: "UNKNOWN",
+        humanReadableType: "Unknown Schedule Transaction"
+      };
     }
   }
-  return { type: "UNKNOWN", humanReadableType: "Unknown Transaction" };
-}
-function getSchedulableTransactionType(txBody) {
-  for (const [field, type] of Object.entries(
-    schedulableTransactionTypeRegistry
-  )) {
-    if (txBody[field]) {
-      return type;
+  /**
+   * Parse schedule transaction from protobuf TransactionBody
+   * Handles all schedule operations from decoded protobuf data
+   */
+  static parseFromProtobufTxBody(txBody) {
+    if (txBody.scheduleCreate) {
+      const scheduleCreate = this.parseScheduleCreateFromProto(
+        txBody.scheduleCreate
+      );
+      if (scheduleCreate) {
+        return {
+          type: "SCHEDULECREATE",
+          humanReadableType: "Schedule Create",
+          scheduleCreate
+        };
+      }
     }
+    if (txBody.scheduleSign) {
+      const scheduleSign = this.parseScheduleSignFromProto(txBody.scheduleSign);
+      if (scheduleSign) {
+        return {
+          type: "SCHEDULESIGN",
+          humanReadableType: "Schedule Sign",
+          scheduleSign
+        };
+      }
+    }
+    if (txBody.scheduleDelete) {
+      const scheduleDelete = this.parseScheduleDeleteFromProto(
+        txBody.scheduleDelete
+      );
+      if (scheduleDelete) {
+        return {
+          type: "SCHEDULEDELETE",
+          humanReadableType: "Schedule Delete",
+          scheduleDelete
+        };
+      }
+    }
+    return {};
+  }
+  /**
+   * Extract schedule data from Transaction internal fields
+   * This handles cases where data is stored in Transaction object internals
+   */
+  static parseFromTransactionInternals(transaction) {
+    try {
+      const tx = transaction;
+      if (hasTransactionType(transaction, "scheduleCreate")) {
+        const scheduleCreate = {
+          scheduledTransactionBody: Buffer.from(
+            tx._scheduledTransaction
+          ).toString("base64"),
+          memo: tx._scheduleMemo,
+          adminKey: tx._adminKey ? parseKey(tx._adminKey) : void 0,
+          payerAccountId: tx._payerAccountId?.toString(),
+          expirationTime: tx._expirationTime?.toString(),
+          waitForExpiry: tx._waitForExpiry || false
+        };
+        return {
+          type: "SCHEDULECREATE",
+          humanReadableType: "Schedule Create",
+          scheduleCreate
+        };
+      }
+      if (hasTransactionType(transaction, "scheduleSign")) {
+        const scheduleSign = {
+          scheduleId: tx._scheduleId.toString()
+        };
+        return {
+          type: "SCHEDULESIGN",
+          humanReadableType: "Schedule Sign",
+          scheduleSign
+        };
+      }
+      if (hasTransactionType(transaction, "scheduleDelete")) {
+        const scheduleDelete = {
+          scheduleId: tx._scheduleId.toString()
+        };
+        return {
+          type: "SCHEDULEDELETE",
+          humanReadableType: "Schedule Delete",
+          scheduleDelete
+        };
+      }
+      return {};
+    } catch (error) {
+      return {};
+    }
+  }
+  /**
+   * Parse Schedule Create from protobuf data
+   */
+  static parseScheduleCreateFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.scheduledTransactionBody) {
+      const schedBytes = proto.SchedulableTransactionBody.encode(
+        proto.SchedulableTransactionBody.create(body.scheduledTransactionBody)
+      ).finish();
+      data.scheduledTransactionBody = Buffer.from(schedBytes).toString("base64");
+    }
+    if (body.memo) {
+      data.memo = body.memo;
+    }
+    if (body.adminKey) {
+      data.adminKey = parseKey(body.adminKey);
+    }
+    if (body.payerAccountID) {
+      data.payerAccountId = new AccountId(
+        body.payerAccountID.shardNum ?? 0,
+        body.payerAccountID.realmNum ?? 0,
+        body.payerAccountID.accountNum ?? 0
+      ).toString();
+    }
+    if (body.expirationTime?.seconds) {
+      data.expirationTime = `${Long.fromValue(
+        body.expirationTime.seconds
+      ).toString()}.${body.expirationTime.nanos ?? 0}`;
+    }
+    if (body.waitForExpiry !== void 0) {
+      data.waitForExpiry = body.waitForExpiry;
+    }
+    return data;
+  }
+  /**
+   * Parse Schedule Sign from protobuf data
+   */
+  static parseScheduleSignFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.scheduleID) {
+      data.scheduleId = new ScheduleId(
+        body.scheduleID.shardNum ?? 0,
+        body.scheduleID.realmNum ?? 0,
+        body.scheduleID.scheduleNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  /**
+   * Parse Schedule Delete from protobuf data
+   */
+  static parseScheduleDeleteFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.scheduleID) {
+      data.scheduleId = new ScheduleId(
+        body.scheduleID.shardNum ?? 0,
+        body.scheduleID.realmNum ?? 0,
+        body.scheduleID.scheduleNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  /**
+   * Legacy method: Parse schedule create transaction
+   * @deprecated Use parseScheduleTransaction instead
+   */
+  static parseScheduleCreate(transaction) {
+    try {
+      const result = this.parseScheduleTransaction(transaction);
+      return result.scheduleCreate || null;
+    } catch (error) {
+      console.warn("[ScheduleParser] Failed to parse schedule create:", error);
+      return null;
+    }
+  }
+  /**
+   * Legacy method: Parse schedule sign transaction
+   * @deprecated Use parseScheduleTransaction instead
+   */
+  static parseScheduleSign(transaction) {
+    try {
+      const result = this.parseScheduleTransaction(transaction);
+      return result.scheduleSign || null;
+    } catch (error) {
+      console.warn("[ScheduleParser] Failed to parse schedule sign:", error);
+      return null;
+    }
+  }
+  /**
+   * Legacy method: Parse schedule delete transaction
+   * @deprecated Use parseScheduleTransaction instead
+   */
+  static parseScheduleDelete(transaction) {
+    try {
+      const result = this.parseScheduleTransaction(transaction);
+      return result.scheduleDelete || null;
+    } catch (error) {
+      console.warn("[ScheduleParser] Failed to parse schedule delete:", error);
+      return null;
+    }
+  }
+  /**
+   * Parse schedule info from transaction body (for scheduled transactions)
+   */
+  static extractScheduleInfo(transaction) {
+    try {
+      const transactionBody = transaction._transactionBody;
+      if (transactionBody?.scheduleRef) {
+        return {
+          isScheduled: true,
+          scheduleRef: transactionBody.scheduleRef.toString()
+        };
+      }
+      const tx = transaction;
+      if (tx._scheduleId || tx.scheduleId) {
+        return {
+          isScheduled: true,
+          scheduleRef: (tx._scheduleId || tx.scheduleId)?.toString()
+        };
+      }
+      return { isScheduled: false };
+    } catch (error) {
+      return { isScheduled: false };
+    }
+  }
+  /**
+   * Parse a scheduled transaction body to extract the inner transaction
+   * This is used when a schedule contains another transaction to be executed
+   */
+  static parseScheduledTransactionBody(scheduledTxBytes) {
+    try {
+      let bytes;
+      if (scheduledTxBytes.startsWith("0x")) {
+        const hexString = scheduledTxBytes.slice(2);
+        bytes = new Uint8Array(Buffer.from(hexString, "hex"));
+      } else {
+        bytes = new Uint8Array(Buffer.from(scheduledTxBytes, "base64"));
+      }
+      const schedulableBody = proto.SchedulableTransactionBody.decode(bytes);
+      const txType = Object.keys(schedulableBody).find(
+        (key) => schedulableBody[key] !== null && key !== "transactionFee" && key !== "memo"
+      );
+      if (txType) {
+        return {
+          type: txType.toUpperCase(),
+          body: schedulableBody[txType],
+          memo: schedulableBody.memo,
+          transactionFee: schedulableBody.transactionFee?.toString()
+        };
+      }
+      return null;
+    } catch (error) {
+      console.warn(
+        "[ScheduleParser] Failed to parse scheduled transaction body:",
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Parse Schedule Service transaction from Transaction object
+   * This is the unified entry point that delegates to the comprehensive parsing logic
+   */
+  static parseFromTransactionObject(transaction) {
+    return this.parseScheduleTransaction(transaction);
   }
-  return "unknown";
-}
-function getHumanReadableTransactionType(type) {
-  return humanReadableTypeRegistry[type] || "Unknown Transaction";
 }
 export {
-  getHumanReadableTransactionType,
-  getSchedulableTransactionType,
-  getTransactionTypeFromBody,
-  humanReadableTypeRegistry,
-  protoFieldToTypeRegistry,
-  schedulableTransactionTypeRegistry
+  ScheduleParser
 };
 //# sourceMappingURL=standards-sdk.es134.js.map