@hashgraphonline/standards-sdk 0.1.185 → 0.1.187

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

@@ -1,1125 +1,425 @@
-import { InscriptionSDK } from "./standards-sdk.es163.js";
-import { Logger } from "./standards-sdk.es126.js";
-import { ProgressReporter } from "./standards-sdk.es129.js";
-import { TransactionParser } from "./standards-sdk.es131.js";
-import { isBrowser } from "./standards-sdk.es139.js";
-import { optionalImport } from "./standards-sdk.es168.js";
-import { validateQuoteParameters, getCachedQuote, getOrCreateSDK, cacheQuote } from "./standards-sdk.es146.js";
-import { HederaMirrorNode } from "./standards-sdk.es147.js";
-import { sleep } from "./standards-sdk.es136.js";
-import { computeInscriptionCostSummary } from "./standards-sdk.es172.js";
-let nodeModules = {};
-const normalizeTransactionId = (txId) => {
-  if (!txId.includes("@")) {
-    return txId;
-  }
-  const txParts = txId?.split("@");
-  return `${txParts[0]}-${txParts[1].replace(".", "-")}`;
-};
-async function loadNodeModules() {
-  if (isBrowser || nodeModules.readFileSync) {
-    return;
-  }
-  try {
-    const [fsModule, pathModule] = await Promise.all([
-      optionalImport("node:fs"),
-      optionalImport("node:path")
-    ]);
-    if (!fsModule || !pathModule) {
-      throw new Error("Node.js fs or path module not available");
-    }
-    nodeModules.readFileSync = fsModule.readFileSync;
-    nodeModules.basename = pathModule.basename;
-    nodeModules.extname = pathModule.extname;
-  } catch (error) {
-    Logger.getInstance({
-      module: "Inscriber",
-      level: "warn"
-    }).warn(
-      "Node.js modules not available, file path operations will be disabled",
-      {
-        error: error instanceof Error ? error.message : String(error)
-      }
-    );
-  }
-}
-const COST_LOOKUP_ATTEMPTS = 3;
-const COST_LOOKUP_DELAY_MS = 1e3;
-const COST_LOGGER_MODULE = "InscriberCost";
-async function convertFileToBase64(filePath) {
-  if (isBrowser) {
-    throw new Error(
-      "File path operations are not supported in browser environment. Use buffer input type instead."
-    );
-  }
-  await loadNodeModules();
-  if (!nodeModules.readFileSync || !nodeModules.basename || !nodeModules.extname) {
-    throw new Error(
-      "Node.js file system modules are not available. Cannot read file from path."
-    );
-  }
-  try {
-    const buffer = nodeModules.readFileSync(filePath);
-    const base64 = buffer.toString("base64");
-    const fileName = nodeModules.basename(filePath);
-    let mimeType = "application/octet-stream";
-    try {
-      const fileTypeModule = await optionalImport("file-type");
-      const fileTypeResult = typeof fileTypeModule?.fileTypeFromBuffer === "function" ? await fileTypeModule.fileTypeFromBuffer(buffer) : void 0;
-      if (fileTypeResult) {
-        mimeType = fileTypeResult.mime;
-      }
-    } catch (_error) {
-      const ext = nodeModules.extname(filePath).toLowerCase();
-      const mimeMap = {
-        ".txt": "text/plain",
-        ".json": "application/json",
-        ".html": "text/html",
-        ".css": "text/css",
-        ".js": "application/javascript",
-        ".png": "image/png",
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-        ".gif": "image/gif",
-        ".svg": "image/svg+xml",
-        ".pdf": "application/pdf"
-      };
-      mimeType = mimeMap[ext] || "application/octet-stream";
-    }
-    return { base64, fileName, mimeType };
-  } catch (error) {
-    throw new Error(
-      `Failed to read file ${filePath}: ${error.message}`
-    );
-  }
-}
-function normalizeClientConfig(cfg) {
-  return {
-    accountId: cfg.accountId,
-    privateKey: typeof cfg.privateKey === "string" ? cfg.privateKey : cfg.privateKey.toString(),
-    network: cfg.network
-  };
-}
-function resolveConnectionMode(options) {
-  if (options.connectionMode) {
-    return options.connectionMode;
-  }
-  if (typeof options.websocket === "boolean") {
-    return options.websocket ? "websocket" : "http";
-  }
-  return "websocket";
-}
-async function inscribe(input, clientConfig, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  const resolvedConnectionMode = resolveConnectionMode(options);
-  logger.info("Starting inscription process", {
-    type: input.type,
-    mode: options.mode || "file",
-    quoteOnly: options.quoteOnly || false,
-    ...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.quoteOnly) {
-      logger.debug("Quote-only mode requested, generating quote");
-      return await generateQuote(input, clientConfig, options, existingSDK);
-    }
-    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",
-        connectionMode: resolvedConnectionMode,
-        baseURL: options.baseURL
-      });
-    } else {
-      logger.debug("Initializing InscriptionSDK with server auth");
-      const normalized = normalizeClientConfig(clientConfig);
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "server",
-        accountId: normalized.accountId,
-        privateKey: normalized.privateKey,
-        network: normalized.network || "mainnet",
-        connectionMode: resolvedConnectionMode,
-        baseUrl: options.baseURL
-      });
-    }
-    const baseRequest = {
-      holderId: clientConfig.accountId,
-      metadata: options.metadata || {},
-      tags: options.tags || [],
-      mode: options.mode || "file",
-      fileStandard: options.fileStandard,
-      chunkSize: options.chunkSize
-    };
-    let request;
-    switch (input.type) {
-      case "url":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "url",
-            url: input.url
-          }
-        };
-        break;
-      case "file": {
-        const fileData = await convertFileToBase64(input.path);
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: fileData.base64,
-            fileName: fileData.fileName,
-            mimeType: fileData.mimeType
-          }
-        };
-        break;
-      }
-      case "buffer":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: Buffer.from(
-              input.buffer instanceof ArrayBuffer ? new Uint8Array(input.buffer) : 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;
-      }
-    }
-    logger.debug("Preparing to inscribe content", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: clientConfig.accountId
-    });
-    const normalizedCfg = normalizeClientConfig(clientConfig);
-    const result = await sdk.inscribeAndExecute(
-      request,
-      normalizedCfg,
-      options.progressCallback
-    );
-    const rawJobId = result.jobId || result.tx_id || result.transactionId || "";
-    const rawTxId = result.transactionId || rawJobId || "";
-    const normalizedJobId = normalizeTransactionId(rawJobId);
-    const normalizedTxId = normalizeTransactionId(rawTxId);
-    const waitId = normalizeTransactionId(
-      normalizedJobId || normalizedTxId || rawJobId || result.jobId || ""
-    );
-    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: waitId,
-        maxAttempts: options.waitMaxAttempts,
-        intervalMs: options.waitIntervalMs
-      });
-      const inscription = await waitForInscriptionConfirmation(
-        sdk,
-        waitId,
-        options.waitMaxAttempts,
-        options.waitIntervalMs,
-        options.progressCallback
-      );
-      logger.info("Inscription confirmation received", {
-        transactionId: result.jobId
-      });
-      return {
-        confirmed: true,
-        result: {
-          ...result,
-          jobId: waitId,
-          transactionId: normalizedTxId
-        },
-        inscription,
-        sdk,
-        costSummary: await resolveInscriptionCost(
-          normalizedTxId,
-          clientConfig.network || "mainnet",
-          options.logging?.level
-        )
-      };
-    }
-    return {
-      confirmed: false,
-      result: {
-        ...result,
-        jobId: waitId,
-        transactionId: normalizedTxId
-      },
-      sdk,
-      costSummary: await resolveInscriptionCost(
-        normalizedTxId,
-        clientConfig.network || "mainnet",
-        options.logging?.level
-      )
-    };
-  } catch (error) {
-    logger.error("Error during inscription process", error);
-    throw error;
-  }
-}
-async function resolveInscriptionCost(transactionId, network, level) {
-  const logger = Logger.getInstance({
-    module: COST_LOGGER_MODULE,
-    level: level ?? "info"
-  });
-  const mirrorNode = new HederaMirrorNode(network, logger);
-  const normalizedId = normalizeTransactionId(transactionId);
-  const payerAccountId = normalizedId.split("-")[0];
-  for (let attempt = 0; attempt < COST_LOOKUP_ATTEMPTS; attempt++) {
-    try {
-      const txn = await mirrorNode.getTransaction(normalizedId);
-      if (!txn) {
-        if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
-          await sleep(COST_LOOKUP_DELAY_MS);
-        }
-        continue;
-      }
-      const computed = computeInscriptionCostSummary({
-        txn,
-        payerAccountId
-      });
-      if (!computed) {
-        if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
-          await sleep(COST_LOOKUP_DELAY_MS);
-        }
-        continue;
-      }
-      return computed.summary;
-    } catch (error) {
-      logger.warn("Unable to resolve inscription cost", {
-        transactionId: normalizedId,
-        attempt: attempt + 1,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
-        await sleep(COST_LOOKUP_DELAY_MS);
-      }
-    }
-  }
-  return void 0;
-}
-async function inscribeWithSigner(input, signer, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  const resolvedConnectionMode = resolveConnectionMode(options);
-  logger.info("Starting inscription process with signer", {
-    type: input.type,
-    mode: options.mode || "file",
-    quoteOnly: options.quoteOnly || false,
-    ...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.quoteOnly) {
-      logger.debug("Quote-only mode requested with signer, generating quote");
-      const clientConfig = {
-        accountId: signer.getAccountId().toString(),
-        privateKey: "",
-        network: options.network || "mainnet"
-      };
-      return await generateQuote(input, clientConfig, options, existingSDK);
-    }
-    if (options.mode === "hashinal" && options.metadata) {
-      validateHashinalMetadata(options.metadata, logger);
-    }
-    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",
-        connectionMode: resolvedConnectionMode,
-        baseURL: options.baseURL
-      });
-    } else {
-      logger.debug("Initializing InscriptionSDK with client auth (websocket)");
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "client",
-        accountId,
-        signer,
-        network: options.network || "mainnet",
-        connectionMode: resolvedConnectionMode,
-        baseUrl: options.baseURL
-      });
-    }
-    const baseRequest = {
-      holderId: accountId,
-      metadata: options.metadata || {},
-      tags: options.tags || [],
-      mode: options.mode || "file",
-      fileStandard: options.fileStandard,
-      chunkSize: options.chunkSize
-    };
-    let request;
-    switch (input.type) {
-      case "url":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "url",
-            url: input.url
-          }
-        };
-        break;
-      case "file": {
-        const fileData = await convertFileToBase64(input.path);
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: fileData.base64,
-            fileName: fileData.fileName,
-            mimeType: fileData.mimeType
-          }
-        };
-        break;
-      }
-      case "buffer":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: Buffer.from(
-              input.buffer instanceof ArrayBuffer ? new Uint8Array(input.buffer) : 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;
-      }
-    }
-    logger.debug("Starting inscription via startInscription (websocket)", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: accountId,
-      usesStartInscription: true
-    });
-    const startResult = await sdk.startInscription({
-      ...request,
-      holderId: accountId,
-      network: options.network || "mainnet"
-    });
-    const startTransactionIdRaw = typeof startResult?.tx_id === "string" && startResult.tx_id.trim() || typeof startResult?.jobId === "string" && (startResult.jobId || "").trim() || typeof startResult?.id === "string" && (startResult.id || "").trim() || "";
-    const waitId = normalizeTransactionId(startTransactionIdRaw);
-    if (!waitId) {
-      throw new Error("startInscription did not return a transaction id");
-    }
-    logger.info("about to start inscription", {
-      type: input.type,
-      mode: options.mode || "file",
-      jobId: waitId,
-      ...startResult
-    });
-    if (typeof startResult?.transactionBytes === "string") {
-      logger.debug("Executing inscription transaction with signer from bytes");
-      await sdk.executeTransactionWithSigner(
-        startResult.transactionBytes,
-        signer
-      );
-    } else if (startResult?.transactionBytes?.type === "Buffer") {
-      logger.debug("Executing inscription transaction with signer from buffer");
-      await sdk.executeTransactionWithSigner(
-        Buffer.from(startResult.transactionBytes.data).toString("base64"),
-        signer
-      );
-    }
-    if (options.waitForConfirmation) {
-      logger.debug("Waiting for inscription confirmation (websocket)", {
-        jobId: waitId,
-        maxAttempts: options.waitMaxAttempts,
-        intervalMs: options.waitIntervalMs
-      });
-      const inscription = await waitForInscriptionConfirmation(
-        sdk,
-        waitId,
-        options.waitMaxAttempts,
-        options.waitIntervalMs,
-        options.progressCallback
-      );
-      logger.info("Inscription confirmation received", {
-        jobId: waitId
-      });
-      return {
-        confirmed: true,
-        result: {
-          jobId: waitId,
-          transactionId: waitId,
-          topic_id: startResult.topic_id,
-          status: startResult.status,
-          completed: startResult.completed
-        },
-        inscription,
-        sdk,
-        costSummary: await resolveInscriptionCost(
-          waitId,
-          options.network || "mainnet",
-          options.logging?.level
-        )
-      };
-    }
-    return {
-      confirmed: false,
-      result: {
-        jobId: waitId,
-        transactionId: waitId,
-        topic_id: startResult.topic_id,
-        status: startResult.status,
-        completed: startResult.completed
-      },
-      sdk,
-      costSummary: await resolveInscriptionCost(
-        waitId,
-        options.network || "mainnet",
-        options.logging?.level
-      )
-    };
-  } 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",
-        baseURL: options.baseURL
-      });
-    } 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",
-        baseUrl: options.baseURL
-      });
-    } 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;
-    }
-    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 generateQuote(input, clientConfig, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  logger.info("Generating inscription quote", {
-    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 {
-    validateQuoteParameters(input, clientConfig, options);
-    const cachedQuote = getCachedQuote(input, clientConfig, options);
-    if (cachedQuote) {
-      logger.debug("Returning cached quote");
-      return {
-        confirmed: false,
-        quote: true,
-        result: cachedQuote
+import { HTSParser } from "./standards-sdk.es143.js";
+import { HCSParser } from "./standards-sdk.es191.js";
+import { CryptoParser } from "./standards-sdk.es193.js";
+import { FileParser } from "./standards-sdk.es192.js";
+import { SCSParser } from "./standards-sdk.es194.js";
+import { ScheduleParser } from "./standards-sdk.es144.js";
+import { UtilParser } from "./standards-sdk.es195.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: []
       };
-    }
-    if (options.mode === "hashinal" && options.metadata) {
-      validateHashinalMetadata(options.metadata, logger);
-    }
-    const sdk = await getOrCreateSDK(clientConfig, options, existingSDK);
-    const baseRequest = {
-      holderId: clientConfig.accountId,
-      metadata: options.metadata || {},
-      tags: options.tags || [],
-      mode: options.mode || "file",
-      fileStandard: options.fileStandard,
-      chunkSize: options.chunkSize
-    };
-    let request;
-    switch (input.type) {
-      case "url":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "url",
-            url: input.url
-          }
-        };
-        break;
-      case "file": {
-        const fileData = await convertFileToBase64(input.path);
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: fileData.base64,
-            fileName: fileData.fileName,
-            mimeType: fileData.mimeType
-          }
-        };
-        break;
-      }
-      case "buffer":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: Buffer.from(
-              input.buffer instanceof ArrayBuffer ? new Uint8Array(input.buffer) : 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;
-      }
-    }
-    logger.debug("Calling inscription SDK startInscription for quote", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: clientConfig.accountId
-    });
-    const inscriptionResponse = await sdk.startInscription(request);
-    logger.debug("Received inscription response for quote parsing", {
-      hasTransactionBytes: !!inscriptionResponse.transactionBytes,
-      bytesLength: inscriptionResponse.transactionBytes?.length || 0,
-      transactionBytesType: typeof inscriptionResponse.transactionBytes,
-      totalCost: inscriptionResponse.totalCost
-    });
-    const quote = await parseTransactionForQuote(
-      inscriptionResponse,
-      logger
-    );
-    cacheQuote(input, clientConfig, options, quote);
-    logger.info("Successfully generated inscription quote", {
-      totalCostHbar: quote.totalCostHbar
-    });
-    return {
-      confirmed: false,
-      quote: true,
-      result: quote
-    };
-  } catch (error) {
-    logger.error("Error generating inscription quote", error);
-    throw error;
+      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"
   }
+};
+function getParserConfig(transactionType) {
+  return transactionParserRegistry[transactionType];
 }
-async function parseTransactionForQuote(inscriptionResponse, logger) {
-  try {
-    let totalCostHbar = "0.001";
-    if (inscriptionResponse.totalCost && typeof inscriptionResponse.totalCost === "number") {
-      const hbarAmount = inscriptionResponse.totalCost / 1e8;
-      totalCostHbar = hbarAmount.toString();
-      logger.debug("Using totalCost from inscription response", {
-        totalCostTinybars: inscriptionResponse.totalCost,
-        totalCostHbar
-      });
-    } else if (inscriptionResponse.transactionBytes) {
-      logger.debug("Parsing transaction bytes for cost information");
-      try {
-        let transactionBytesString;
-        if (typeof inscriptionResponse.transactionBytes === "string") {
-          transactionBytesString = inscriptionResponse.transactionBytes;
-        } else if (inscriptionResponse.transactionBytes && typeof inscriptionResponse.transactionBytes === "object" && "data" in inscriptionResponse.transactionBytes) {
-          const buffer = Buffer.from(inscriptionResponse.transactionBytes.data);
-          transactionBytesString = buffer.toString("base64");
-        } else {
-          throw new Error("Invalid transactionBytes format");
-        }
-        logger.debug("About to parse transaction bytes", {
-          bytesLength: transactionBytesString.length,
-          bytesPreview: transactionBytesString.slice(0, 100)
-        });
-        const parsedTransaction = await TransactionParser.parseTransactionBytes(
-          transactionBytesString,
-          { includeRaw: false }
-        );
-        logger.debug("Parsed transaction for quote", {
-          type: parsedTransaction.type,
-          hasTransfers: !!parsedTransaction.transfers,
-          transferCount: parsedTransaction.transfers?.length || 0,
-          transfers: parsedTransaction.transfers
-        });
-        let totalTransferAmount = 0;
-        if (parsedTransaction.transfers && parsedTransaction.transfers.length > 0) {
-          for (const transfer of parsedTransaction.transfers) {
-            const transferAmount = typeof transfer.amount === "string" ? parseFloat(transfer.amount) : transfer.amount;
-            if (transferAmount < 0) {
-              const amountHbar = Math.abs(transferAmount);
-              totalTransferAmount += amountHbar;
-              logger.debug("Found HBAR transfer", {
-                from: transfer.accountId,
-                to: "service",
-                amount: amountHbar
-              });
-            }
-          }
-        }
-        if (totalTransferAmount > 0) {
-          totalCostHbar = totalTransferAmount.toString();
-          logger.debug("Using parsed transaction transfer amount", {
-            totalTransferAmount,
-            totalCostHbar
-          });
-        }
-      } catch (parseError) {
-        logger.warn(
-          "Could not parse transaction bytes, using totalCost fallback",
-          {
-            error: parseError,
-            errorMessage: parseError instanceof Error ? parseError.message : String(parseError)
-          }
-        );
-      }
-    }
-    const transfers = [
-      {
-        to: "Inscription Service",
-        amount: totalCostHbar,
-        description: `Inscription fee (${totalCostHbar} HBAR)`
-      }
-    ];
-    const validUntil = new Date(Date.now() + 15 * 60 * 1e3).toISOString();
-    const quote = {
-      totalCostHbar,
-      validUntil,
-      breakdown: {
-        transfers
-      }
-    };
-    logger.debug("Successfully parsed transaction for quote", {
-      totalCostHbar: quote.totalCostHbar,
-      transferCount: transfers.length,
-      hasTransactionBytes: !!inscriptionResponse.transactionBytes,
-      hasTotalCost: !!inscriptionResponse.totalCost
-    });
-    return quote;
-  } catch (error) {
-    logger.error("Error parsing transaction for quote", error);
-    throw error;
-  }
-}
-async function waitForInscriptionConfirmation(sdk, transactionId, maxAttempts = 450, intervalMs = 4e3, progressCallback) {
-  const logger = Logger.getInstance({ module: "Inscriber" });
-  const normalizedId = normalizeTransactionId(transactionId);
-  const progressReporter = new ProgressReporter({
-    module: "Inscriber",
-    logger,
-    callback: progressCallback
-  });
-  try {
-    logger.debug("Waiting for inscription confirmation", {
-      transactionId: normalizedId,
-      maxAttempts,
-      intervalMs
-    });
-    progressReporter.preparing("Preparing for inscription confirmation", 5, {
-      transactionId: normalizedId,
-      maxAttempts,
-      intervalMs
-    });
-    try {
-      const waitMethod = sdk.waitForInscription.bind(sdk);
-      const wrappedCallback = (data) => {
-        const stageRaw = data.stage || "confirming";
-        const allowedStages = [
-          "preparing",
-          "submitting",
-          "confirming",
-          "verifying",
-          "completed",
-          "failed"
-        ];
-        const stage = allowedStages.includes(stageRaw) ? stageRaw : "confirming";
-        const message = data.message || "Processing inscription";
-        const percent = data.progressPercent || 50;
-        progressReporter.report({
-          stage,
-          message,
-          progressPercent: percent,
-          details: data.details
-        });
-      };
-      return await waitMethod(
-        normalizedId,
-        maxAttempts,
-        intervalMs,
-        true,
-        wrappedCallback
-      );
-    } catch (e) {
-      logger.debug("Falling back to standard waitForInscription method", {
-        error: e
-      });
-      progressReporter.verifying("Verifying inscription status", 50, {
-        error: e
-      });
-      return await sdk.waitForInscription(
-        normalizedId,
-        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;
-  }
-}
-const DEFAULT_REGISTRY_BROKER_URL = "https://hol.org/registry/api/v1";
-const DEFAULT_POLL_INTERVAL_MS = 2e3;
-const DEFAULT_WAIT_TIMEOUT_MS = 12e4;
-async function fetchRegistryBroker(url, options) {
-  const response = await fetch(url, options);
-  const body = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    const errorMessage = typeof body === "object" && body && "error" in body ? String(body.error) : `HTTP ${response.status}`;
-    throw new Error(errorMessage);
-  }
-  return body;
-}
-async function inscribeViaRegistryBroker(input, options = {}) {
-  const logger = Logger.getInstance({
-    module: "InscribeViaBroker",
-    ...options.logging
-  });
-  const baseUrl = options.baseUrl ?? DEFAULT_REGISTRY_BROKER_URL;
-  const waitForConfirmation = options.waitForConfirmation ?? true;
-  const waitTimeoutMs = options.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
-  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const headers = {
-    "Content-Type": "application/json",
-    Accept: "application/json"
-  };
-  if (options.ledgerApiKey) {
-    headers["x-api-key"] = options.ledgerApiKey;
-  } else if (options.apiKey) {
-    headers["x-api-key"] = options.apiKey;
-  } else {
-    throw new Error(
-      "Either ledgerApiKey or apiKey is required for Registry Broker inscription"
-    );
-  }
-  logger.info("Starting inscription via Registry Broker", {
-    baseUrl,
-    inputType: input.type,
-    mode: options.mode ?? "file"
-  });
-  let base64Content;
-  let fileName;
-  let mimeType;
-  switch (input.type) {
-    case "url":
-      logger.debug("Creating job with URL input");
-      break;
-    case "file": {
-      const fileData = await convertFileToBase64(input.path);
-      base64Content = fileData.base64;
-      fileName = fileData.fileName;
-      mimeType = fileData.mimeType;
-      break;
-    }
-    case "buffer":
-      base64Content = Buffer.from(
-        input.buffer instanceof ArrayBuffer ? new Uint8Array(input.buffer) : input.buffer
-      ).toString("base64");
-      fileName = input.fileName;
-      mimeType = input.mimeType;
-      break;
-  }
-  const requestBody = {
-    inputType: input.type === "url" ? "url" : "base64",
-    mode: options.mode ?? "file"
-  };
-  if (input.type === "url") {
-    requestBody.url = input.url;
-  } else {
-    requestBody.base64 = base64Content;
-    requestBody.fileName = fileName;
-    if (mimeType) {
-      requestBody.mimeType = mimeType;
-    }
-  }
-  if (options.metadata) {
-    requestBody.metadata = options.metadata;
-  }
-  if (options.tags) {
-    requestBody.tags = options.tags;
-  }
-  if (options.fileStandard) {
-    requestBody.fileStandard = options.fileStandard;
-  }
-  if (options.chunkSize) {
-    requestBody.chunkSize = options.chunkSize;
-  }
-  logger.debug("Creating inscription job");
-  const job = await fetchRegistryBroker(
-    `${baseUrl}/inscribe/content`,
-    {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody)
-    }
-  );
-  const jobId = job.jobId ?? job.id ?? "";
-  logger.info("Inscription job created", { jobId, status: job.status });
-  if (!waitForConfirmation) {
-    return {
-      confirmed: false,
-      jobId,
-      status: job.status,
-      credits: job.credits ?? job.quoteCredits,
-      usdCents: job.usdCents ?? job.quoteUsdCents,
-      sizeBytes: job.sizeBytes,
-      createdAt: job.createdAt,
-      updatedAt: job.updatedAt,
-      network: job.network
-    };
-  }
-  logger.debug("Polling for job completion", { jobId, waitTimeoutMs });
-  const startTime = Date.now();
-  let lastStatus = "";
-  while (Date.now() - startTime < waitTimeoutMs) {
-    const currentJob = await fetchRegistryBroker(
-      `${baseUrl}/inscribe/content/${jobId}`,
-      { method: "GET", headers }
-    );
-    if (currentJob.status !== lastStatus) {
-      logger.debug("Job status update", { jobId, status: currentJob.status });
-      lastStatus = currentJob.status;
-    }
-    if (currentJob.status === "completed") {
-      logger.info("Inscription completed", {
-        jobId,
-        hrl: currentJob.hrl,
-        topicId: currentJob.topicId
-      });
-      return {
-        confirmed: true,
-        jobId,
-        status: currentJob.status,
-        hrl: currentJob.hrl,
-        topicId: currentJob.topicId,
-        network: currentJob.network,
-        credits: currentJob.credits ?? currentJob.quoteCredits,
-        usdCents: currentJob.usdCents ?? currentJob.quoteUsdCents,
-        sizeBytes: currentJob.sizeBytes,
-        createdAt: currentJob.createdAt,
-        updatedAt: currentJob.updatedAt
-      };
-    }
-    if (currentJob.status === "failed") {
-      logger.error("Inscription failed", { jobId, error: currentJob.error });
-      return {
-        confirmed: false,
-        jobId,
-        status: currentJob.status,
-        error: currentJob.error ?? "Inscription failed",
-        credits: currentJob.credits ?? currentJob.quoteCredits,
-        createdAt: currentJob.createdAt,
-        updatedAt: currentJob.updatedAt
-      };
-    }
-    await sleep(pollIntervalMs);
-  }
-  throw new Error(
-    `Inscription job ${jobId} did not complete within ${waitTimeoutMs}ms`
-  );
+function isTransactionTypeSupported(transactionType) {
+  return transactionType in transactionParserRegistry;
 }
-async function getRegistryBrokerQuote(input, options = {}) {
-  const logger = Logger.getInstance({
-    module: "InscribeViaBroker",
-    ...options.logging
-  });
-  const baseUrl = options.baseUrl ?? DEFAULT_REGISTRY_BROKER_URL;
-  const headers = {
-    "Content-Type": "application/json",
-    Accept: "application/json"
-  };
-  if (options.ledgerApiKey) {
-    headers["x-api-key"] = options.ledgerApiKey;
-  } else if (options.apiKey) {
-    headers["x-api-key"] = options.apiKey;
-  } else {
-    throw new Error(
-      "Either ledgerApiKey or apiKey is required for Registry Broker quotes"
-    );
-  }
-  let base64Content;
-  let fileName;
-  let mimeType;
-  switch (input.type) {
-    case "url":
-      break;
-    case "file": {
-      const fileData = await convertFileToBase64(input.path);
-      base64Content = fileData.base64;
-      fileName = fileData.fileName;
-      mimeType = fileData.mimeType;
-      break;
-    }
-    case "buffer":
-      base64Content = Buffer.from(
-        input.buffer instanceof ArrayBuffer ? new Uint8Array(input.buffer) : input.buffer
-      ).toString("base64");
-      fileName = input.fileName;
-      mimeType = input.mimeType;
-      break;
-  }
-  const requestBody = {
-    inputType: input.type === "url" ? "url" : "base64",
-    mode: options.mode ?? "file"
-  };
-  if (input.type === "url") {
-    requestBody.url = input.url;
-  } else {
-    requestBody.base64 = base64Content;
-    requestBody.fileName = fileName;
-    if (mimeType) {
-      requestBody.mimeType = mimeType;
-    }
-  }
-  if (options.metadata) {
-    requestBody.metadata = options.metadata;
-  }
-  if (options.tags) {
-    requestBody.tags = options.tags;
-  }
-  if (options.fileStandard) {
-    requestBody.fileStandard = options.fileStandard;
-  }
-  if (options.chunkSize) {
-    requestBody.chunkSize = options.chunkSize;
-  }
-  logger.debug("Getting inscription quote from Registry Broker");
-  return fetchRegistryBroker(
-    `${baseUrl}/inscribe/content/quote`,
-    {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody)
-    }
-  );
+function getSupportedTransactionTypes() {
+  return Object.keys(transactionParserRegistry);
 }
 export {
-  generateQuote,
-  getRegistryBrokerQuote,
-  inscribe,
-  inscribeViaRegistryBroker,
-  inscribeWithSigner,
-  normalizeTransactionId,
-  retrieveInscription,
-  waitForInscriptionConfirmation
+  getParserConfig,
+  getSupportedTransactionTypes,
+  isTransactionTypeSupported,
+  transactionParserRegistry
 };
 //# sourceMappingURL=standards-sdk.es145.js.map