@hashgraphonline/standards-sdk 0.0.98 → 0.0.100

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

@@ -1,410 +1,421 @@
-import Buffer from "./standards-sdk.es24.js";
-import { I as InscriptionSDK } from "./standards-sdk.es27.js";
-import { Logger } from "./standards-sdk.es15.js";
-import { ProgressReporter } from "./standards-sdk.es17.js";
-async function inscribe(input, clientConfig, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  logger.info("Starting inscription process", {
-    type: input.type,
-    mode: options.mode || "file",
-    ...input.type === "url" ? { url: input.url } : {},
-    ...input.type === "file" ? { path: input.path } : {},
-    ...input.type === "buffer" ? { fileName: input.fileName, bufferSize: input.buffer.byteLength } : {}
-  });
-  try {
-    if (options.mode === "hashinal" && options.metadata) {
-      validateHashinalMetadata(options.metadata, logger);
-    }
-    let sdk;
-    if (existingSDK) {
-      logger.debug("Using existing InscriptionSDK instance");
-      sdk = existingSDK;
-    } else if (options.apiKey) {
-      logger.debug("Initializing InscriptionSDK with API key");
-      sdk = new InscriptionSDK({
-        apiKey: options.apiKey,
-        network: clientConfig.network || "mainnet"
-      });
-    } else {
-      logger.debug("Initializing InscriptionSDK with server auth");
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "server",
-        accountId: clientConfig.accountId,
-        privateKey: clientConfig.privateKey,
-        network: clientConfig.network || "mainnet"
-      });
-    }
-    const baseRequest = {
-      holderId: clientConfig.accountId,
-      metadata: options.metadata || {},
-      tags: options.tags || [],
-      mode: options.mode || "file",
-      chunkSize: options.chunkSize
-    };
-    let request;
-    switch (input.type) {
-      case "url":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "url",
-            url: input.url
-          }
-        };
-        break;
-      case "file":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "path",
-            path: input.path
-          }
-        };
-        break;
-      case "buffer":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: Buffer.from(input.buffer).toString("base64"),
-            fileName: input.fileName,
-            mimeType: input.mimeType
-          }
-        };
-        break;
-    }
-    if (options.mode === "hashinal") {
-      request.metadataObject = options.metadata;
-      request.creator = options.metadata?.creator || clientConfig.accountId;
-      request.description = options.metadata?.description;
-      if (options.jsonFileURL) {
-        request.jsonFileURL = options.jsonFileURL;
+import { proto } from "@hashgraph/proto";
+import { Buffer as Buffer$1 } from "./standards-sdk.es28.js";
+import { Hbar, Long, HbarUnit, AccountId, TokenId, ContractId } from "@hashgraph/sdk";
+import { decodeBase64 } from "./standards-sdk.es29.js";
+class TransactionParser {
+  /**
+   * Parse a base64 encoded transaction body and return structured data
+   * @param transactionBodyBase64 - The base64 encoded transaction body
+   * @returns The parsed transaction
+   */
+  static parseTransactionBody(transactionBodyBase64) {
+    try {
+      const buffer = decodeBase64(transactionBodyBase64);
+      const txBody = proto.SchedulableTransactionBody.decode(buffer);
+      const transactionType = this.getTransactionType(txBody);
+      const result = {
+        type: transactionType,
+        humanReadableType: this.getHumanReadableType(transactionType),
+        transfers: [],
+        tokenTransfers: [],
+        raw: txBody
+      };
+      if (txBody.memo) {
+        result.memo = txBody.memo;
+      }
+      if (txBody.transactionFee) {
+        const hbarAmount = Hbar.fromTinybars(
+          Long.fromValue(txBody.transactionFee)
+        );
+        result.transactionFee = hbarAmount.toString(HbarUnit.Hbar);
+      }
+      if (txBody.cryptoTransfer) {
+        this.parseCryptoTransfers(txBody.cryptoTransfer, result);
+      }
+      if (txBody.contractCall) {
+        this.parseContractCall(txBody.contractCall, result);
+      }
+      if (txBody.tokenMint) {
+        this.parseTokenMint(txBody.tokenMint, result);
+      }
+      if (txBody.tokenBurn) {
+        this.parseTokenBurn(txBody.tokenBurn, result);
       }
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to parse transaction body: ${error}`);
     }
-    logger.debug("Preparing to inscribe content", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: clientConfig.accountId
-    });
-    const result = await sdk.inscribeAndExecute(request, clientConfig);
-    logger.info("Starting to inscribe.", {
-      type: input.type,
-      mode: options.mode || "file",
-      transactionId: result.jobId
-    });
-    if (options.waitForConfirmation) {
-      logger.debug("Waiting for inscription confirmation", {
-        transactionId: result.jobId,
-        maxAttempts: options.waitMaxAttempts,
-        intervalMs: options.waitIntervalMs
-      });
-      const inscription = await waitForInscriptionConfirmation(
-        sdk,
-        result.jobId,
-        options.waitMaxAttempts,
-        options.waitIntervalMs,
-        options.progressCallback
-      );
-      logger.info("Inscription confirmation received", {
-        transactionId: result.jobId
-      });
-      return {
-        confirmed: true,
-        result,
-        inscription,
-        sdk
-      };
+  }
+  /**
+   * Parse details from a complete schedule response
+   * @param scheduleResponse - The schedule response to parse
+   * @returns The parsed transaction
+   */
+  static parseScheduleResponse(scheduleResponse) {
+    if (!scheduleResponse.transaction_body) {
+      throw new Error("Schedule response missing transaction_body");
     }
-    return {
-      confirmed: false,
-      result,
-      sdk
-    };
-  } catch (error) {
-    logger.error("Error during inscription process", error);
-    throw error;
+    const parsed = this.parseTransactionBody(scheduleResponse.transaction_body);
+    if (scheduleResponse.memo) {
+      parsed.memo = scheduleResponse.memo;
+    }
+    return parsed;
   }
-}
-async function inscribeWithSigner(input, signer, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  logger.info("Starting inscription process with signer", {
-    type: input.type,
-    mode: options.mode || "file",
-    ...input.type === "url" ? { url: input.url } : {},
-    ...input.type === "file" ? { path: input.path } : {},
-    ...input.type === "buffer" ? { fileName: input.fileName, bufferSize: input.buffer.byteLength } : {}
-  });
-  try {
-    if (options.mode === "hashinal" && options.metadata) {
-      validateHashinalMetadata(options.metadata, logger);
+  /**
+   * Determine the transaction type
+   * @param txBody - The transaction body to determine the type of
+   * @returns The type of the transaction
+   */
+  static getTransactionType(txBody) {
+    let transactionType = "unknown";
+    if (txBody.cryptoTransfer) {
+      transactionType = "cryptoTransfer";
+    } else if (txBody.cryptoCreateAccount) {
+      transactionType = "cryptoCreateAccount";
+    } else if (txBody.cryptoUpdateAccount) {
+      transactionType = "cryptoUpdateAccount";
+    } else if (txBody.cryptoApproveAllowance) {
+      transactionType = "cryptoApproveAllowance";
+    } else if (txBody.cryptoDeleteAllowance) {
+      transactionType = "cryptoDeleteAllowance";
+    } else if (txBody.consensusCreateTopic) {
+      transactionType = "consensusCreateTopic";
+    } else if (txBody.consensusUpdateTopic) {
+      transactionType = "consensusUpdateTopic";
+    } else if (txBody.consensusSubmitMessage) {
+      transactionType = "consensusSubmitMessage";
+    } else if (txBody.consensusDeleteTopic) {
+      transactionType = "consensusDeleteTopic";
+    } else if (txBody.fileCreate) {
+      transactionType = "fileCreate";
+    } else if (txBody.fileAppend) {
+      transactionType = "fileAppend";
+    } else if (txBody.fileUpdate) {
+      transactionType = "fileUpdate";
+    } else if (txBody.fileDelete) {
+      transactionType = "fileDelete";
+    } else if (txBody.contractCall) {
+      transactionType = "contractCall";
+    } else if (txBody.contractCreateInstance) {
+      transactionType = "contractCreate";
+    } else if (txBody.contractUpdateInstance) {
+      transactionType = "contractUpdate";
+    } else if (txBody.contractDeleteInstance) {
+      transactionType = "contractDelete";
+    } else if (txBody.tokenCreation) {
+      transactionType = "tokenCreate";
+    } else if (txBody.tokenUpdate) {
+      transactionType = "tokenUpdate";
+    } else if (txBody.tokenDeletion) {
+      transactionType = "tokenDelete";
+    } else if (txBody.tokenAssociate) {
+      transactionType = "tokenAssociate";
+    } else if (txBody.tokenDissociate) {
+      transactionType = "tokenDissociate";
+    } else if (txBody.tokenMint) {
+      transactionType = "tokenMint";
+    } else if (txBody.tokenBurn) {
+      transactionType = "tokenBurn";
+    } else if (txBody.tokenFeeScheduleUpdate) {
+      transactionType = "tokenFeeScheduleUpdate";
+    } else if (txBody.tokenFreeze) {
+      transactionType = "tokenFreeze";
+    } else if (txBody.tokenUnfreeze) {
+      transactionType = "tokenUnfreeze";
+    } else if (txBody.tokenGrantKyc) {
+      transactionType = "tokenGrantKyc";
+    } else if (txBody.tokenRevokeKyc) {
+      transactionType = "tokenRevokeKyc";
+    } else if (txBody.tokenPause) {
+      transactionType = "tokenPause";
+    } else if (txBody.tokenUnpause) {
+      transactionType = "tokenUnpause";
+    } else if (txBody.tokenWipe) {
+      transactionType = "tokenWipe";
+    } else if (txBody.scheduleDelete) {
+      transactionType = "scheduleDelete";
     }
-    const accountId = signer.getAccountId().toString();
-    logger.debug("Using account ID from signer", { accountId });
-    let sdk;
-    if (existingSDK) {
-      logger.debug("Using existing InscriptionSDK instance");
-      sdk = existingSDK;
-    } else if (options.apiKey) {
-      logger.debug("Initializing InscriptionSDK with API key");
-      sdk = new InscriptionSDK({
-        apiKey: options.apiKey,
-        network: options.network || "mainnet"
-      });
+    return transactionType;
+  }
+  /**
+   * Convert technical transaction type to human-readable format
+   * @param type - The technical transaction type
+   * @returns The human-readable transaction type
+   */
+  static getHumanReadableType(type) {
+    const typeMap = {
+      cryptoTransfer: "HBAR Transfer",
+      cryptoCreateAccount: "Create Account",
+      cryptoUpdateAccount: "Update Account",
+      cryptoDeleteAccount: "Delete Account",
+      cryptoApproveAllowance: "Approve Allowance",
+      cryptoDeleteAllowance: "Delete Allowance",
+      consensusCreateTopic: "Create Topic",
+      consensusUpdateTopic: "Update Topic",
+      consensusSubmitMessage: "Submit Message",
+      consensusDeleteTopic: "Delete Topic",
+      fileCreate: "Create File",
+      fileAppend: "Append File",
+      fileUpdate: "Update File",
+      fileDelete: "Delete File",
+      contractCall: "Contract Call",
+      contractCreate: "Create Contract",
+      contractUpdate: "Update Contract",
+      contractDelete: "Delete Contract",
+      ethereumTransaction: "Ethereum Transaction",
+      tokenCreate: "Create Token",
+      tokenUpdate: "Update Token",
+      tokenDelete: "Delete Token",
+      tokenAssociate: "Associate Token",
+      tokenDissociate: "Dissociate Token",
+      tokenMint: "Mint Token",
+      tokenBurn: "Burn Token",
+      tokenFeeScheduleUpdate: "Update Token Fee Schedule",
+      tokenFreeze: "Freeze Token",
+      tokenUnfreeze: "Unfreeze Token",
+      tokenGrantKyc: "Grant KYC",
+      tokenRevokeKyc: "Revoke KYC",
+      tokenPause: "Pause Token",
+      tokenUnpause: "Unpause Token",
+      tokenWipe: "Wipe Token",
+      scheduleCreate: "Create Schedule",
+      scheduleDelete: "Delete Schedule",
+      scheduleSign: "Sign Schedule",
+      systemDelete: "System Delete",
+      systemUndelete: "System Undelete",
+      unknown: "Unknown Transaction"
+    };
+    let result;
+    if (typeMap[type]) {
+      result = typeMap[type];
     } else {
-      logger.debug("Initializing InscriptionSDK with client auth");
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "client",
-        accountId,
-        signer,
-        network: options.network || "mainnet"
-      });
+      result = "Unknown Transaction";
     }
-    const baseRequest = {
-      holderId: accountId,
-      metadata: options.metadata || {},
-      tags: options.tags || [],
-      mode: options.mode || "file",
-      chunkSize: options.chunkSize
-    };
-    let request;
-    switch (input.type) {
-      case "url":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "url",
-            url: input.url
-          }
-        };
-        break;
-      case "file":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "path",
-            path: input.path
-          }
-        };
-        break;
-      case "buffer":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: Buffer.from(input.buffer).toString("base64"),
-            fileName: input.fileName,
-            mimeType: input.mimeType
+    return result;
+  }
+  /**
+   * Parse crypto transfers from the transaction
+   * @param cryptoTransfer - The crypto transfer transaction body
+   * @param result - The parsed transaction
+   */
+  static parseCryptoTransfers(cryptoTransfer, result) {
+    if (cryptoTransfer.transfers) {
+      if (cryptoTransfer.transfers.accountAmounts) {
+        result.transfers = cryptoTransfer.transfers.accountAmounts.map(
+          (amount) => {
+            const shard = amount.accountID?.shardNum ? Long.fromValue(amount.accountID.shardNum).toNumber() : 0;
+            const realm = amount.accountID?.realmNum ? Long.fromValue(amount.accountID.realmNum).toNumber() : 0;
+            const accountNum = amount.accountID?.accountNum ? Long.fromValue(amount.accountID.accountNum).toNumber() : 0;
+            const accountId = AccountId.fromString(
+              `${shard}.${realm}.${accountNum}`
+            );
+            const hbarValue = amount.amount ? Long.fromValue(amount.amount) : Long.ZERO;
+            const hbarAmount = Hbar.fromTinybars(hbarValue);
+            return {
+              accountId: accountId.toString(),
+              amount: hbarAmount.toString(HbarUnit.Hbar),
+              isDecimal: true
+            };
           }
-        };
-        break;
+        );
+      }
     }
-    if (options.mode === "hashinal") {
-      request.metadataObject = options.metadata;
-      request.creator = options.metadata?.creator || accountId;
-      request.description = options.metadata?.description;
-      if (options.jsonFileURL) {
-        request.jsonFileURL = options.jsonFileURL;
+    if (cryptoTransfer.tokenTransfers) {
+      for (const tokenTransfer of cryptoTransfer.tokenTransfers) {
+        const shard = tokenTransfer.token?.shardNum ? Long.fromValue(tokenTransfer.token.shardNum).toNumber() : 0;
+        const realm = tokenTransfer.token?.realmNum ? Long.fromValue(tokenTransfer.token.realmNum).toNumber() : 0;
+        const tokenNum = tokenTransfer.token?.tokenNum ? Long.fromValue(tokenTransfer.token.tokenNum).toNumber() : 0;
+        const tokenId = TokenId.fromString(`${shard}.${realm}.${tokenNum}`);
+        if (tokenTransfer.transfers) {
+          for (const transfer of tokenTransfer.transfers) {
+            const accShard = transfer.accountID?.shardNum ? Long.fromValue(transfer.accountID.shardNum).toNumber() : 0;
+            const accRealm = transfer.accountID?.realmNum ? Long.fromValue(transfer.accountID.realmNum).toNumber() : 0;
+            const accNum = transfer.accountID?.accountNum ? Long.fromValue(transfer.accountID.accountNum).toNumber() : 0;
+            const accountId = AccountId.fromString(
+              `${accShard}.${accRealm}.${accNum}`
+            );
+            const tokenAmount = transfer.amount ? Long.fromValue(transfer.amount).toNumber() : 0;
+            result.tokenTransfers.push({
+              tokenId: tokenId.toString(),
+              accountId: accountId.toString(),
+              amount: tokenAmount
+            });
+          }
+        }
       }
     }
-    logger.debug("Preparing to inscribe content with signer", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: accountId
-    });
-    const result = await sdk.inscribe(
-      {
-        ...request,
-        holderId: accountId
-      },
-      signer
-    );
-    logger.info("Inscription started", {
-      type: input.type,
-      mode: options.mode || "file",
-      transactionId: result.jobId
-    });
-    if (options.waitForConfirmation) {
-      logger.debug("Waiting for inscription confirmation", {
-        transactionId: result.jobId,
-        maxAttempts: options.waitMaxAttempts,
-        intervalMs: options.waitIntervalMs
-      });
-      const inscription = await waitForInscriptionConfirmation(
-        sdk,
-        result.jobId,
-        options.waitMaxAttempts,
-        options.waitIntervalMs,
-        options.progressCallback
+  }
+  /**
+   * Parse contract call transaction data
+   * @param contractCall - The contract call transaction body
+   * @param result - The parsed transaction
+   */
+  static parseContractCall(contractCall, result) {
+    if (contractCall) {
+      const shard = contractCall.contractID?.shardNum ? Long.fromValue(contractCall.contractID.shardNum).toNumber() : 0;
+      const realm = contractCall.contractID?.realmNum ? Long.fromValue(contractCall.contractID.realmNum).toNumber() : 0;
+      const contractNum = contractCall.contractID?.contractNum ? Long.fromValue(contractCall.contractID.contractNum).toNumber() : 0;
+      const contractId = ContractId.fromString(
+        `${shard}.${realm}.${contractNum}`
       );
-      logger.info("Inscription confirmation received", {
-        transactionId: result.jobId
-      });
-      return {
-        confirmed: true,
-        result,
-        inscription,
-        sdk
+      const gasLimit = contractCall.gas ? Long.fromValue(contractCall.gas).toNumber() : 0;
+      let amount = 0;
+      if (contractCall.amount) {
+        const hbar = Hbar.fromTinybars(Long.fromValue(contractCall.amount));
+        amount = parseFloat(hbar.toString(HbarUnit.Hbar));
+      }
+      const functionParameters = contractCall.functionParameters ? Buffer$1.from(contractCall.functionParameters).toString("hex") : void 0;
+      let functionName;
+      if (functionParameters && functionParameters.length >= 8) {
+        functionName = functionParameters.substring(0, 8);
+      }
+      result.contractCall = {
+        contractId: contractId.toString(),
+        gas: gasLimit,
+        amount,
+        functionParameters,
+        functionName
       };
     }
-    return {
-      confirmed: false,
-      result,
-      sdk
-    };
-  } catch (error) {
-    logger.error("Error during inscription process", error);
-    throw error;
   }
-}
-async function retrieveInscription(transactionId, options) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options?.logging || {}
-  });
-  const formattedTransactionId = transactionId.includes("@") ? `${transactionId.split("@")[0]}-${transactionId.split("@")[1].replace(/\./g, "-")}` : transactionId;
-  logger.info("Retrieving inscription", {
-    originalTransactionId: transactionId,
-    formattedTransactionId
-  });
-  try {
-    let sdk;
-    if (options?.apiKey) {
-      logger.debug("Initializing InscriptionSDK with API key");
-      sdk = new InscriptionSDK({
-        apiKey: options.apiKey,
-        network: options.network || "mainnet"
-      });
-    } else if (options?.accountId && options?.privateKey) {
-      logger.debug("Initializing InscriptionSDK with server auth");
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "server",
-        accountId: options.accountId,
-        privateKey: options.privateKey,
-        network: options.network || "mainnet"
-      });
-    } else {
-      const error = new Error(
-        "Either API key or account ID and private key are required for retrieving inscriptions"
-      );
-      logger.error("Missing authentication credentials", {
-        hasApiKey: Boolean(options?.apiKey),
-        hasAccountId: Boolean(options?.accountId),
-        hasPrivateKey: Boolean(options?.privateKey)
-      });
-      throw error;
+  /**
+   * Parse token mint transaction data
+   * @param tokenMint - The token mint transaction body
+   * @param result - The parsed transaction
+   */
+  static parseTokenMint(tokenMint, result) {
+    if (tokenMint) {
+      const shard = tokenMint.token?.shardNum ? Long.fromValue(tokenMint.token.shardNum).toNumber() : 0;
+      const realm = tokenMint.token?.realmNum ? Long.fromValue(tokenMint.token.realmNum).toNumber() : 0;
+      const tokenNum = tokenMint.token?.tokenNum ? Long.fromValue(tokenMint.token.tokenNum).toNumber() : 0;
+      const tokenId = TokenId.fromString(`${shard}.${realm}.${tokenNum}`);
+      const amount = tokenMint.amount ? Long.fromValue(tokenMint.amount).toNumber() : 0;
+      const metadata = [];
+      if (tokenMint.metadata) {
+        for (const meta of tokenMint.metadata) {
+          if (meta) {
+            metadata.push(Buffer$1.from(meta).toString("base64"));
+          }
+        }
+      }
+      result.tokenMint = {
+        tokenId: tokenId.toString(),
+        amount,
+        metadata: metadata.length > 0 ? metadata : void 0
+      };
     }
-    logger.debug("Initialized SDK for inscription retrieval", {
-      formattedTransactionId,
-      network: options.network || "mainnet"
-    });
-    const result = await sdk.retrieveInscription(formattedTransactionId);
-    logger.info("Successfully retrieved inscription", {
-      formattedTransactionId
-    });
-    return result;
-  } catch (error) {
-    logger.error("Error retrieving inscription", {
-      formattedTransactionId,
-      error
-    });
-    throw error;
   }
-}
-function validateHashinalMetadata(metadata, logger) {
-  const requiredFields = ["name", "creator", "description", "type"];
-  const missingFields = requiredFields.filter((field) => !metadata[field]);
-  if (missingFields.length > 0) {
-    const error = new Error(
-      `Missing required Hashinal metadata fields: ${missingFields.join(", ")}`
-    );
-    logger.error("Hashinal metadata validation failed", { missingFields });
-    throw error;
-  }
-  logger.debug("Hashinal metadata validation passed", {
-    name: metadata.name,
-    creator: metadata.creator,
-    description: metadata.description,
-    type: metadata.type,
-    hasAttributes: !!metadata.attributes,
-    hasProperties: !!metadata.properties
-  });
-}
-async function waitForInscriptionConfirmation(sdk, transactionId, maxAttempts = 30, intervalMs = 4e3, progressCallback) {
-  const logger = Logger.getInstance({ module: "Inscriber" });
-  const progressReporter = new ProgressReporter({
-    module: "Inscriber",
-    logger,
-    callback: progressCallback
-  });
-  try {
-    logger.debug("Waiting for inscription confirmation", {
-      transactionId,
-      maxAttempts,
-      intervalMs
-    });
-    progressReporter.preparing("Preparing for inscription confirmation", 5, {
-      transactionId,
-      maxAttempts,
-      intervalMs
-    });
-    try {
-      const waitMethod = sdk.waitForInscription.bind(sdk);
-      const wrappedCallback = (data) => {
-        const stage = data.stage || "confirming";
-        const message = data.message || "Processing inscription";
-        const percent = data.progressPercent || 50;
-        progressReporter.report({
-          stage,
-          message,
-          progressPercent: percent,
-          details: {}
-        });
+  /**
+   * Parse token burn transaction data
+   * @param tokenBurn - The token burn transaction body
+   * @param result - The parsed transaction
+   */
+  static parseTokenBurn(tokenBurn, result) {
+    if (tokenBurn) {
+      const shard = tokenBurn.token?.shardNum ? Long.fromValue(tokenBurn.token.shardNum).toNumber() : 0;
+      const realm = tokenBurn.token?.realmNum ? Long.fromValue(tokenBurn.token.realmNum).toNumber() : 0;
+      const tokenNum = tokenBurn.token?.tokenNum ? Long.fromValue(tokenBurn.token.tokenNum).toNumber() : 0;
+      const tokenId = TokenId.fromString(`${shard}.${realm}.${tokenNum}`);
+      const amount = tokenBurn.amount ? Long.fromValue(tokenBurn.amount).toNumber() : 0;
+      const serialNumbers = [];
+      if (tokenBurn.serialNumbers) {
+        for (const serial of tokenBurn.serialNumbers) {
+          if (serial) {
+            serialNumbers.push(Long.fromValue(serial).toNumber());
+          }
+        }
+      }
+      result.tokenBurn = {
+        tokenId: tokenId.toString(),
+        amount,
+        serialNumbers: serialNumbers.length > 0 ? serialNumbers : void 0
       };
-      return await waitMethod(
-        transactionId,
-        maxAttempts,
-        intervalMs,
-        true,
-        wrappedCallback
-      );
-    } catch (e) {
-      console.log(e);
-      logger.debug("Falling back to standard waitForInscription method", {
-        error: e
-      });
-      progressReporter.verifying("Verifying inscription status", 50, {
-        error: e
-      });
-      return await sdk.waitForInscription(
-        transactionId,
-        maxAttempts,
-        intervalMs,
-        true
-      );
     }
-  } catch (error) {
-    logger.error("Error waiting for inscription confirmation", {
-      transactionId,
-      maxAttempts,
-      intervalMs,
-      error
-    });
-    progressReporter.failed("Inscription confirmation failed", {
-      transactionId,
-      error
-    });
-    throw error;
+  }
+  /**
+   * Get a human-readable summary of the transaction
+   * @param parsedTx - The parsed transaction
+   * @returns The human-readable summary of the transaction
+   */
+  static getTransactionSummary(parsedTx) {
+    let summary;
+    if (parsedTx.type === "cryptoTransfer") {
+      const senders = [];
+      const receivers = [];
+      for (const transfer of parsedTx.transfers) {
+        const transferAmount = parseFloat(transfer.amount);
+        if (transferAmount < 0) {
+          senders.push(
+            `${transfer.accountId} (${transfer.amount.startsWith("-") ? transfer.amount.substring(1) : transfer.amount} ℏ)`
+          );
+        } else if (transferAmount > 0) {
+          receivers.push(
+            `${transfer.accountId} (${transfer.amount} ℏ)`
+          );
+        }
+      }
+      if (senders.length > 0 && receivers.length > 0) {
+        summary = `Transfer of HBAR from ${senders.join(
+          ", "
+        )} to ${receivers.join(", ")}`;
+      } else {
+        summary = parsedTx.humanReadableType;
+      }
+    } else if (parsedTx.contractCall) {
+      let contractCallSummary = `Contract call to ${parsedTx.contractCall.contractId} with ${parsedTx.contractCall.gas} gas`;
+      if (parsedTx.contractCall.amount > 0) {
+        contractCallSummary += ` and ${parsedTx.contractCall.amount} HBAR`;
+      }
+      if (parsedTx.contractCall.functionName) {
+        contractCallSummary += ` calling function ${parsedTx.contractCall.functionName}`;
+      }
+      summary = contractCallSummary;
+    } else if (parsedTx.tokenMint) {
+      summary = `Mint ${parsedTx.tokenMint.amount} tokens for token ${parsedTx.tokenMint.tokenId}`;
+    } else if (parsedTx.tokenBurn) {
+      summary = `Burn ${parsedTx.tokenBurn.amount} tokens for token ${parsedTx.tokenBurn.tokenId}`;
+    } else if (parsedTx.tokenTransfers.length > 0) {
+      const tokenGroups = {};
+      for (const transfer of parsedTx.tokenTransfers) {
+        if (!tokenGroups[transfer.tokenId]) {
+          tokenGroups[transfer.tokenId] = [];
+        }
+        tokenGroups[transfer.tokenId].push(transfer);
+      }
+      const tokenSummaries = [];
+      for (const [tokenId, transfers] of Object.entries(tokenGroups)) {
+        const senders = [];
+        const receivers = [];
+        for (const transfer of transfers) {
+          const transferAmount = parseFloat(transfer.amount.toString());
+          if (transferAmount < 0) {
+            senders.push(
+              `${transfer.accountId} (${Math.abs(transferAmount)})`
+            );
+          } else if (transferAmount > 0) {
+            receivers.push(`${transfer.accountId} (${transferAmount})`);
+          }
+        }
+        if (senders.length > 0 && receivers.length > 0) {
+          tokenSummaries.push(
+            `Transfer of token ${tokenId} from ${senders.join(
+              ", "
+            )} to ${receivers.join(", ")}`
+          );
+        }
+      }
+      if (tokenSummaries.length > 0) {
+        summary = tokenSummaries.join("; ");
+      } else {
+        summary = parsedTx.humanReadableType;
+      }
+    } else {
+      summary = parsedTx.humanReadableType;
+    }
+    return summary;
   }
 }
 export {
-  inscribe,
-  inscribeWithSigner,
-  retrieveInscription
+  TransactionParser
 };
 //# sourceMappingURL=standards-sdk.es19.js.map