@hashgraphonline/standards-sdk 0.0.96 → 0.0.98

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

@@ -1,417 +1,410 @@
-import { proto } from "@hashgraph/proto";
-import { Buffer as Buffer$1 } from "./standards-sdk.es24.js";
-import { Hbar, Long, HbarUnit, AccountId, TokenId, ContractId } from "@hashgraph/sdk";
-import { decodeBase64 } from "./standards-sdk.es33.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 = parseFloat(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}`);
+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);
     }
-  }
-  /**
-   * 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");
-    }
-    const parsed = this.parseTransactionBody(scheduleResponse.transaction_body);
-    if (scheduleResponse.memo) {
-      parsed.memo = scheduleResponse.memo;
-    }
-    return parsed;
-  }
-  /**
-   * 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";
-    }
-    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];
+    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 {
-      result = "Unknown Transaction";
+      logger.debug("Initializing InscriptionSDK with server auth");
+      sdk = await InscriptionSDK.createWithAuth({
+        type: "server",
+        accountId: clientConfig.accountId,
+        privateKey: clientConfig.privateKey,
+        network: clientConfig.network || "mainnet"
+      });
     }
-    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: parseFloat(hbarAmount.toString(HbarUnit.Hbar)),
-              isDecimal: true
-            };
+    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
           }
-        );
-      }
-    }
-    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
-            });
+        };
+        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;
       }
     }
-  }
-  /**
-   * 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.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
       );
-      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
+      logger.info("Inscription confirmation received", {
+        transactionId: result.jobId
+      });
+      return {
+        confirmed: true,
+        result,
+        inscription,
+        sdk
       };
     }
+    return {
+      confirmed: false,
+      result,
+      sdk
+    };
+  } catch (error) {
+    logger.error("Error during inscription process", error);
+    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
-      };
+}
+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);
     }
-  }
-  /**
-   * 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());
+    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"
+      });
+    } else {
+      logger.debug("Initializing InscriptionSDK with client auth");
+      sdk = await InscriptionSDK.createWithAuth({
+        type: "client",
+        accountId,
+        signer,
+        network: options.network || "mainnet"
+      });
+    }
+    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
+          }
+        };
+        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;
       }
-      result.tokenBurn = {
-        tokenId: tokenId.toString(),
-        amount,
-        serialNumbers: serialNumbers.length > 0 ? serialNumbers : void 0
+    }
+    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
+      );
+      logger.info("Inscription confirmation received", {
+        transactionId: result.jobId
+      });
+      return {
+        confirmed: true,
+        result,
+        inscription,
+        sdk
       };
     }
+    return {
+      confirmed: false,
+      result,
+      sdk
+    };
+  } catch (error) {
+    logger.error("Error during inscription process", 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) {
-        if (transfer.amount < 0) {
-          senders.push(
-            `${transfer.accountId} (${Math.abs(transfer.amount)} ℏ)`
-          );
-        } else if (transfer.amount > 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) {
-          if (transfer.amount < 0) {
-            senders.push(
-              `${transfer.accountId} (${Math.abs(transfer.amount)})`
-            );
-          } else if (transfer.amount > 0) {
-            receivers.push(`${transfer.accountId} (${transfer.amount})`);
-          }
-        }
-        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;
-      }
+}
+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 {
-      summary = parsedTx.humanReadableType;
+      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;
+    }
+    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: {}
+        });
+      };
+      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
+      );
     }
-    return summary;
+  } catch (error) {
+    logger.error("Error waiting for inscription confirmation", {
+      transactionId,
+      maxAttempts,
+      intervalMs,
+      error
+    });
+    progressReporter.failed("Inscription confirmation failed", {
+      transactionId,
+      error
+    });
+    throw error;
   }
 }
 export {
-  TransactionParser
+  inscribe,
+  inscribeWithSigner,
+  retrieveInscription
 };
 //# sourceMappingURL=standards-sdk.es19.js.map