@hashgraphonline/standards-sdk 0.1.141-canary.11 → 0.1.141-canary.13

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

@@ -1,425 +1,309 @@
-import { HTSParser } from "./standards-sdk.es120.js";
-import { HCSParser } from "./standards-sdk.es142.js";
-import { CryptoParser } from "./standards-sdk.es144.js";
-import { FileParser } from "./standards-sdk.es143.js";
-import { SCSParser } from "./standards-sdk.es145.js";
-import { ScheduleParser } from "./standards-sdk.es121.js";
-import { UtilParser } from "./standards-sdk.es146.js";
-const transactionParserRegistry = {
-  TOKENCREATE: {
-    bodyField: "tokenCreation",
-    parser: HTSParser.parseTokenCreate,
-    resultField: "tokenCreation"
-  },
-  TOKENMINT: {
-    bodyField: "tokenMint",
-    parser: HTSParser.parseTokenMint,
-    resultField: "tokenMint"
-  },
-  TOKENBURN: {
-    bodyField: "tokenBurn",
-    parser: HTSParser.parseTokenBurn,
-    resultField: "tokenBurn"
-  },
-  TOKENUPDATE: {
-    bodyField: "tokenUpdate",
-    parser: HTSParser.parseTokenUpdate,
-    resultField: "tokenUpdate"
-  },
-  TOKENDELETE: {
-    bodyField: "tokenDeletion",
-    parser: HTSParser.parseTokenDelete,
-    resultField: "tokenDelete"
-  },
-  TOKENASSOCIATE: {
-    bodyField: "tokenAssociate",
-    parser: HTSParser.parseTokenAssociate,
-    resultField: "tokenAssociate"
-  },
-  TOKENDISSOCIATE: {
-    bodyField: "tokenDissociate",
-    parser: HTSParser.parseTokenDissociate,
-    resultField: "tokenDissociate"
-  },
-  TOKENFREEZE: {
-    bodyField: "tokenFreeze",
-    parser: HTSParser.parseTokenFreeze,
-    resultField: "tokenFreeze"
-  },
-  TOKENUNFREEZE: {
-    bodyField: "tokenUnfreeze",
-    parser: HTSParser.parseTokenUnfreeze,
-    resultField: "tokenUnfreeze"
-  },
-  TOKENGRANTKYC: {
-    bodyField: "tokenGrantKyc",
-    parser: HTSParser.parseTokenGrantKyc,
-    resultField: "tokenGrantKyc"
-  },
-  TOKENREVOKEKYC: {
-    bodyField: "tokenRevokeKyc",
-    parser: HTSParser.parseTokenRevokeKyc,
-    resultField: "tokenRevokeKyc"
-  },
-  TOKENPAUSE: {
-    bodyField: "tokenPause",
-    parser: HTSParser.parseTokenPause,
-    resultField: "tokenPause"
-  },
-  TOKENUNPAUSE: {
-    bodyField: "tokenUnpause",
-    parser: HTSParser.parseTokenUnpause,
-    resultField: "tokenUnpause"
-  },
-  TOKENWIPEACCOUNT: {
-    bodyField: "tokenWipe",
-    parser: HTSParser.parseTokenWipeAccount,
-    resultField: "tokenWipeAccount"
-  },
-  TOKENFEESCHEDULEUPDATE: {
-    bodyField: "tokenFeeScheduleUpdate",
-    parser: HTSParser.parseTokenFeeScheduleUpdate,
-    resultField: "tokenFeeScheduleUpdate"
-  },
-  TOKENAIRDROP: {
-    bodyField: "tokenAirdrop",
-    parser: HTSParser.parseTokenAirdropFromProto,
-    resultField: "tokenAirdrop"
-  },
-  TOPICCREATE: {
-    bodyField: "consensusCreateTopic",
-    parser: HCSParser.parseConsensusCreateTopic,
-    resultField: "consensusCreateTopic"
-  },
-  CONSENSUSSUBMITMESSAGE: {
-    bodyField: "consensusSubmitMessage",
-    parser: HCSParser.parseConsensusSubmitMessage,
-    resultField: "consensusSubmitMessage"
-  },
-  TOPICUPDATE: {
-    bodyField: "consensusUpdateTopic",
-    parser: HCSParser.parseConsensusUpdateTopic,
-    resultField: "consensusUpdateTopic"
-  },
-  TOPICDELETE: {
-    bodyField: "consensusDeleteTopic",
-    parser: HCSParser.parseConsensusDeleteTopic,
-    resultField: "consensusDeleteTopic"
-  },
-  ACCOUNTCREATE: {
-    bodyField: "cryptoCreateAccount",
-    parser: CryptoParser.parseCryptoCreateAccount,
-    resultField: "cryptoCreateAccount"
-  },
-  ACCOUNTUPDATE: {
-    bodyField: "cryptoUpdateAccount",
-    parser: CryptoParser.parseCryptoUpdateAccount,
-    resultField: "cryptoUpdateAccount"
-  },
-  ACCOUNTDELETE: {
-    bodyField: "cryptoDelete",
-    parser: CryptoParser.parseCryptoDelete,
-    resultField: "cryptoDelete"
-  },
-  CRYPTOTRANSFER: {
-    bodyField: "cryptoTransfer",
-    parser: (body) => {
-      const result = {
-        transfers: [],
-        tokenTransfers: []
+import { proto } from "@hashgraph/proto";
+import { hasTransactionType, parseKey } from "./standards-sdk.es147.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"
       };
-      CryptoParser.parseCryptoTransfers(body, result);
-      return result;
-    },
-    resultField: "transfers",
-    spreadResult: true
-  },
-  APPROVEALLOWANCE: {
-    bodyField: "cryptoApproveAllowance",
-    parser: CryptoParser.parseCryptoApproveAllowance,
-    resultField: "cryptoApproveAllowance"
-  },
-  DELETEALLOWANCE: {
-    bodyField: "cryptoDeleteAllowance",
-    parser: CryptoParser.parseCryptoDeleteAllowance,
-    resultField: "cryptoDeleteAllowance"
-  },
-  FILECREATE: {
-    bodyField: "fileCreate",
-    parser: FileParser.parseFileCreate,
-    resultField: "fileCreate"
-  },
-  FILEUPDATE: {
-    bodyField: "fileUpdate",
-    parser: FileParser.parseFileUpdate,
-    resultField: "fileUpdate"
-  },
-  FILEDELETE: {
-    bodyField: "fileDelete",
-    parser: FileParser.parseFileDelete,
-    resultField: "fileDelete"
-  },
-  FILEAPPEND: {
-    bodyField: "fileAppend",
-    parser: FileParser.parseFileAppend,
-    resultField: "fileAppend"
-  },
-  CONTRACTCREATE: {
-    bodyField: "contractCreateInstance",
-    parser: SCSParser.parseContractCreate,
-    resultField: "contractCreate"
-  },
-  CONTRACTUPDATE: {
-    bodyField: "contractUpdateInstance",
-    parser: SCSParser.parseContractUpdate,
-    resultField: "contractUpdate"
-  },
-  CONTRACTDELETE: {
-    bodyField: "contractDeleteInstance",
-    parser: SCSParser.parseContractDelete,
-    resultField: "contractDelete"
-  },
-  CONTRACTCALL: {
-    bodyField: "contractCall",
-    parser: SCSParser.parseContractCall,
-    resultField: "contractCall"
-  },
-  ETHEREUMTRANSACTION: {
-    bodyField: "ethereumTransaction",
-    parser: SCSParser.parseEthereumTransaction,
-    resultField: "ethereumTransaction"
-  },
-  SCHEDULECREATE: {
-    bodyField: "scheduleCreate",
-    parser: ScheduleParser.parseScheduleCreateFromProto,
-    resultField: "scheduleCreate"
-  },
-  SCHEDULESIGN: {
-    bodyField: "scheduleSign",
-    parser: ScheduleParser.parseScheduleSignFromProto,
-    resultField: "scheduleSign"
-  },
-  SCHEDULEDELETE: {
-    bodyField: "scheduleDelete",
-    parser: ScheduleParser.parseScheduleDeleteFromProto,
-    resultField: "scheduleDelete"
-  },
-  PRNG: {
-    bodyField: "utilPrng",
-    parser: UtilParser.parseUtilPrng,
-    resultField: "utilPrng"
-  },
-  FREEZE: {
-    bodyField: "freeze",
-    parser: UtilParser.parseFreeze,
-    resultField: "freeze"
-  },
-  SYSTEMDELETE: {
-    bodyField: "systemDelete",
-    parser: (body) => ({
-      fileId: body.fileID ? `${body.fileID.shardNum}.${body.fileID.realmNum}.${body.fileID.fileNum}` : void 0,
-      contractId: body.contractID ? `${body.contractID.shardNum}.${body.contractID.realmNum}.${body.contractID.contractNum}` : void 0,
-      expirationTime: body.expirationTime?.seconds ? body.expirationTime.seconds.toString() : void 0
-    }),
-    resultField: "systemDelete"
-  },
-  SYSTEMUNDELETE: {
-    bodyField: "systemUndelete",
-    parser: (body) => ({
-      fileId: body.fileID ? `${body.fileID.shardNum}.${body.fileID.realmNum}.${body.fileID.fileNum}` : void 0,
-      contractId: body.contractID ? `${body.contractID.shardNum}.${body.contractID.realmNum}.${body.contractID.contractNum}` : void 0
-    }),
-    resultField: "systemUndelete"
-  },
-  TOKENCANCELAIRDROP: {
-    bodyField: "tokenCancelAirdrop",
-    parser: (body) => ({
-      pendingAirdrops: body.pendingAirdrops || []
-    }),
-    resultField: "tokenCancelAirdrop"
-  },
-  TOKENCLAIMAIRDROP: {
-    bodyField: "tokenClaimAirdrop",
-    parser: (body) => ({
-      pendingAirdrops: body.pendingAirdrops || []
-    }),
-    resultField: "tokenClaimAirdrop"
-  },
-  TOKENREJECT: {
-    bodyField: "tokenReject",
-    parser: (body) => ({
-      owner: body.owner ? `${body.owner.shardNum}.${body.owner.realmNum}.${body.owner.accountNum}` : void 0,
-      rejections: body.rejections || []
-    }),
-    resultField: "tokenReject"
-  },
-  TOKENUPDATENFTS: {
-    bodyField: "tokenUpdateNfts",
-    parser: (body) => ({
-      tokenId: body.token ? `${body.token.shardNum}.${body.token.realmNum}.${body.token.tokenNum}` : void 0,
-      serialNumbers: body.serialNumbers || [],
-      metadata: body.metadata
-    }),
-    resultField: "tokenUpdateNfts"
-  },
-  TOKENWIPE: {
-    bodyField: "tokenWipe",
-    parser: HTSParser.parseTokenWipeAccount,
-    resultField: "tokenWipeAccount"
-  },
-  CRYPTOADDLIVEHASH: {
-    bodyField: "cryptoAddLiveHash",
-    parser: (body) => ({
-      accountId: body.accountID ? `${body.accountID.shardNum}.${body.accountID.realmNum}.${body.accountID.accountNum}` : void 0,
-      liveHash: body.liveHash
-    }),
-    resultField: "cryptoAddLiveHash"
-  },
-  CRYPTODELETELIVEHASH: {
-    bodyField: "cryptoDeleteLiveHash",
-    parser: (body) => ({
-      accountId: body.accountOfLiveHash ? `${body.accountOfLiveHash.shardNum}.${body.accountOfLiveHash.realmNum}.${body.accountOfLiveHash.accountNum}` : void 0,
-      liveHashToDelete: body.liveHashToDelete
-    }),
-    resultField: "cryptoDeleteLiveHash"
-  },
-  UNCHECKEDSUBMIT: {
-    bodyField: "uncheckedSubmit",
-    parser: (body) => ({
-      topicId: body.topicID ? `${body.topicID.shardNum}.${body.topicID.realmNum}.${body.topicID.topicNum}` : void 0,
-      message: body.message
-    }),
-    resultField: "uncheckedSubmit"
-  },
-  NODECREATE: {
-    bodyField: "nodeCreate",
-    parser: (body) => ({
-      accountId: body.accountId ? `${body.accountId.shardNum}.${body.accountId.realmNum}.${body.accountId.accountNum}` : void 0,
-      description: body.description,
-      gossipEndpoint: body.gossipEndpoint,
-      serviceEndpoint: body.serviceEndpoint,
-      gossipCaCertificate: body.gossipCaCertificate,
-      grpcCertificateHash: body.grpcCertificateHash,
-      adminKey: body.adminKey
-    }),
-    resultField: "nodeCreate"
-  },
-  NODEUPDATE: {
-    bodyField: "nodeUpdate",
-    parser: (body) => ({
-      nodeId: body.nodeId?.toString(),
-      accountId: body.accountId ? `${body.accountId.shardNum}.${body.accountId.realmNum}.${body.accountId.accountNum}` : void 0,
-      description: body.description,
-      gossipEndpoint: body.gossipEndpoint,
-      serviceEndpoint: body.serviceEndpoint,
-      gossipCaCertificate: body.gossipCaCertificate,
-      grpcCertificateHash: body.grpcCertificateHash,
-      adminKey: body.adminKey
-    }),
-    resultField: "nodeUpdate"
-  },
-  NODEDELETE: {
-    bodyField: "nodeDelete",
-    parser: (body) => ({
-      nodeId: body.nodeId?.toString()
-    }),
-    resultField: "nodeDelete"
-  },
-  NODESTAKEUPDATE: {
-    bodyField: "nodeStakeUpdate",
-    parser: (body) => ({
-      nodeId: body.nodeId?.toString(),
-      maxStake: body.maxStake?.toString(),
-      minStake: body.minStake?.toString(),
-      rewardRate: body.rewardRate?.toString()
-    }),
-    resultField: "nodeStakeUpdate"
-  },
-  ATOMICBATCH: {
-    bodyField: "atomicBatch",
-    parser: (body) => ({
-      transactions: body.transactions || []
-    }),
-    resultField: "atomicBatch"
-  },
-  STATESIGNATURETRANSACTION: {
-    bodyField: "stateSignatureTransaction",
-    parser: (body) => ({
-      signature: body.signature,
-      round: body.round?.toString()
-    }),
-    resultField: "stateSignatureTransaction"
-  },
-  HISTORYPROOFSIGNATURE: {
-    bodyField: "historyProofSignature",
-    parser: (body) => ({
-      signature: body.signature,
-      round: body.round?.toString()
-    }),
-    resultField: "historyProofSignature"
-  },
-  HISTORYPROOFKEYPUBLICATION: {
-    bodyField: "historyProofKeyPublication",
-    parser: (body) => ({
-      publicKey: body.publicKey,
-      round: body.round?.toString()
-    }),
-    resultField: "historyProofKeyPublication"
-  },
-  HISTORYPROOFVOTE: {
-    bodyField: "historyProofVote",
-    parser: (body) => ({
-      vote: body.vote,
-      round: body.round?.toString()
-    }),
-    resultField: "historyProofVote"
-  },
-  HINTSPREPROCESSINGVOTE: {
-    bodyField: "hintsPreprocessingVote",
-    parser: (body) => ({
-      vote: body.vote,
-      round: body.round?.toString()
-    }),
-    resultField: "hintsPreprocessingVote"
-  },
-  HINTSKEYPUBLICATION: {
-    bodyField: "hintsKeyPublication",
-    parser: (body) => ({
-      publicKey: body.publicKey,
-      round: body.round?.toString()
-    }),
-    resultField: "hintsKeyPublication"
-  },
-  HINTSPARTIALSIGNATURE: {
-    bodyField: "hintsPartialSignature",
-    parser: (body) => ({
-      signature: body.signature,
-      round: body.round?.toString()
-    }),
-    resultField: "hintsPartialSignature"
-  },
-  CRSPUBLICATION: {
-    bodyField: "crsPublication",
-    parser: (body) => ({
-      crs: body.crs,
-      round: body.round?.toString()
-    }),
-    resultField: "crsPublication"
+    }
+  }
+  /**
+   * 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);
   }
-};
-function getParserConfig(transactionType) {
-  return transactionParserRegistry[transactionType];
-}
-function isTransactionTypeSupported(transactionType) {
-  return transactionType in transactionParserRegistry;
-}
-function getSupportedTransactionTypes() {
-  return Object.keys(transactionParserRegistry);
 }
 export {
-  getParserConfig,
-  getSupportedTransactionTypes,
-  isTransactionTypeSupported,
-  transactionParserRegistry
+  ScheduleParser
 };
 //# sourceMappingURL=standards-sdk.es122.js.map