@hashgraphonline/standards-sdk 0.1.188 → 0.1.190

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

@@ -1,98 +1,1125 @@
-import { clampScore } from "./standards-sdk.es119.js";
-import { readSubjectAdditional, readNumber } from "./standards-sdk.es179.js";
-import "./standards-sdk.es163.js";
-import "./standards-sdk.es176.js";
-import "./standards-sdk.es177.js";
-import "./standards-sdk.es178.js";
-import { clampUnit } from "./standards-sdk.es164.js";
-const DEFAULT_INCLUDED_REGISTRIES = ["agentverse", "uagent"];
-const MISSING = { value: 0, status: "missing" };
-function normalizeInsights(subject) {
-  const additional = readSubjectAdditional(subject);
-  const rating = readNumber(additional, "agentverseInsightsRating");
-  if (rating !== null) {
-    return { value: clampScore(rating / 5 * 100), status: "ok" };
-  }
-  const proxies = [
-    readNumber(additional, "agentverseInsightsReadmeQualityScore"),
-    readNumber(additional, "agentverseInsightsReadmeUniquenessScore"),
-    readNumber(additional, "agentverseInsightsInteractionsScore")
-  ].filter((value) => value !== null);
-  if (proxies.length === 0) {
-    return MISSING;
-  }
-  const mean = proxies.reduce((sum, value) => sum + value, 0) / proxies.length;
-  return { value: clampScore(mean * 100), status: "ok" };
+import { InscriptionSDK } from "./standards-sdk.es204.js";
+import { Logger } from "./standards-sdk.es147.js";
+import { ProgressReporter } from "./standards-sdk.es150.js";
+import { TransactionParser } from "./standards-sdk.es152.js";
+import { isBrowser } from "./standards-sdk.es160.js";
+import { optionalImport } from "./standards-sdk.es207.js";
+import { validateQuoteParameters, getCachedQuote, getOrCreateSDK, cacheQuote } from "./standards-sdk.es167.js";
+import { HederaMirrorNode } from "./standards-sdk.es168.js";
+import { sleep } from "./standards-sdk.es157.js";
+import { computeInscriptionCostSummary } from "./standards-sdk.es211.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 createAgentverseInsightsAdapter(options = {}) {
+function normalizeClientConfig(cfg) {
   return {
-    id: "agentverse-insights",
-    weight: 1,
-    contributionMode: "scoped",
-    includeRegistries: options.includeRegistries ?? DEFAULT_INCLUDED_REGISTRIES,
-    defaultComponentKey: "agentverse-insights.score",
-    components: [
-      { name: "score", normalize: ({ subject }) => normalizeInsights(subject) }
-    ]
+    accountId: cfg.accountId,
+    privateKey: typeof cfg.privateKey === "string" ? cfg.privateKey : cfg.privateKey.toString(),
+    network: cfg.network
   };
 }
-function createAgentverseVerifierAdapter(options = {}) {
-  const interactionCap = options.interactionCap ?? 1e3;
-  const responseTimeCapSeconds = options.responseTimeCapSeconds ?? 30;
-  return {
-    id: "agentverse-verifier",
-    weight: 1,
-    contributionMode: "conditional",
-    includeRegistries: options.includeRegistries ?? DEFAULT_INCLUDED_REGISTRIES,
-    defaultComponentKey: "agentverse-verifier.score",
-    components: [
-      {
-        name: "score",
-        nonScorableWhenUnavailable: true,
-        normalize: ({ subject }) => {
-          const additional = readSubjectAdditional(subject);
-          const recentInteractions = readNumber(
-            additional,
-            "agentverseInsightsVerifierRecentInteractions"
-          ) ?? 0;
-          const recentSuccesses = readNumber(
-            additional,
-            "agentverseInsightsVerifierRecentSuccessInteractions"
-          ) ?? 0;
-          const totalInteractions = readNumber(
-            additional,
-            "agentverseInsightsVerifierTotalInteractions"
-          ) ?? 0;
-          const totalSuccesses = readNumber(
-            additional,
-            "agentverseInsightsVerifierTotalSuccessInteractions"
-          ) ?? 0;
-          const useRecent = recentInteractions > 0;
-          const interactions = useRecent ? recentInteractions : totalInteractions;
-          const successes = useRecent ? recentSuccesses : totalSuccesses;
-          if (interactions <= 0) {
-            return MISSING;
+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
+      };
+    }
+    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;
+  }
+}
+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
+              });
+            }
           }
-          const successRate = clampUnit(successes / interactions) * 100;
-          const avgResponseTime = readNumber(
-            additional,
-            "agentverseInsightsAvgResponseTime"
-          );
-          const responseFactor = avgResponseTime === null ? 1 : clampUnit(1 - avgResponseTime / responseTimeCapSeconds);
-          const volumeFactor = clampUnit(
-            Math.log1p(interactions) / Math.log1p(interactionCap)
-          );
-          return {
-            value: clampScore(successRate * responseFactor * volumeFactor),
-            status: "ok"
-          };
         }
+        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`
+  );
+}
+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)
+    }
+  );
 }
 export {
-  createAgentverseInsightsAdapter,
-  createAgentverseVerifierAdapter
+  generateQuote,
+  getRegistryBrokerQuote,
+  inscribe,
+  inscribeViaRegistryBroker,
+  inscribeWithSigner,
+  normalizeTransactionId,
+  retrieveInscription,
+  waitForInscriptionConfirmation
 };
 //# sourceMappingURL=standards-sdk.es166.js.map