@hashgraphonline/standards-sdk 0.1.141-canary.8 → 0.1.141-feat-hcs-21-flora-adapter.canary.cff94ea.45

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

@@ -1,211 +1,795 @@
-import { InscriptionSDK } from "./standards-sdk.es136.js";
-class QuoteCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = 100;
-    this.defaultTtlMs = 5 * 60 * 1e3;
+import { InscriptionSDK } from "./standards-sdk.es141.js";
+import { Logger } from "./standards-sdk.es106.js";
+import { ProgressReporter } from "./standards-sdk.es109.js";
+import { TransactionParser } from "./standards-sdk.es111.js";
+import { isBrowser } from "./standards-sdk.es119.js";
+import { fileTypeFromBuffer } from "file-type";
+import { validateQuoteParameters, getCachedQuote, getOrCreateSDK, cacheQuote } from "./standards-sdk.es126.js";
+let nodeModules = {};
+const normalizeTransactionId = (txId) => {
+  if (!txId.includes("@")) {
+    return txId;
   }
-  // 5 minutes
-  /**
-   * Generate cache key from input parameters
-   */
-  generateKey(key) {
-    return `${key.inputHash}-${key.clientConfigHash}-${key.optionsHash}`;
+  const txParts = txId?.split("@");
+  return `${txParts[0]}-${txParts[1].replace(".", "-")}`;
+};
+async function loadNodeModules() {
+  if (isBrowser || nodeModules.readFileSync) {
+    return;
   }
-  /**
-   * Hash object to string for cache key
-   */
-  hashObject(obj) {
-    return Buffer.from(JSON.stringify(obj)).toString("base64").slice(0, 16);
+  try {
+    const globalObj = typeof global !== "undefined" ? global : globalThis;
+    const req = globalObj.process?.mainModule?.require || globalObj.require;
+    if (typeof req === "function") {
+      const fs = req("fs");
+      const path = req("path");
+      nodeModules.readFileSync = fs.readFileSync;
+      nodeModules.basename = path.basename;
+      nodeModules.extname = path.extname;
+    } else {
+      throw new Error("require function not available");
+    }
+  } catch (error) {
+    console.warn(
+      "Node.js modules not available, file path operations will be disabled"
+    );
   }
-  /**
-   * Create cache key from parameters
-   */
-  createCacheKey(input, clientConfig, options) {
-    return {
-      inputHash: this.hashObject(input),
-      clientConfigHash: this.hashObject({
-        accountId: clientConfig.accountId,
-        network: clientConfig.network
-      }),
-      optionsHash: this.hashObject({
-        mode: options.mode,
-        apiKey: options.apiKey ? "present" : "absent",
-        network: options.network,
-        metadata: options.metadata
-      })
-    };
+}
+async function convertFileToBase64(filePath) {
+  if (isBrowser) {
+    throw new Error(
+      "File path operations are not supported in browser environment. Use buffer input type instead."
+    );
   }
-  /**
-   * Get cached quote if available and not expired
-   */
-  get(key) {
-    const cacheKey = this.generateKey(key);
-    const entry = this.cache.get(cacheKey);
-    if (!entry) {
-      return null;
-    }
-    const now = Date.now();
-    if (now - entry.timestamp > entry.ttlMs) {
-      this.cache.delete(cacheKey);
-      return null;
-    }
-    this.cache.delete(cacheKey);
-    this.cache.set(cacheKey, entry);
-    return entry.quote;
+  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."
+    );
   }
-  /**
-   * Store quote in cache
-   */
-  set(key, quote, ttlMs = this.defaultTtlMs) {
-    const cacheKey = this.generateKey(key);
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
+  try {
+    const buffer = nodeModules.readFileSync(filePath);
+    const base64 = buffer.toString("base64");
+    const fileName = nodeModules.basename(filePath);
+    let mimeType = "application/octet-stream";
+    try {
+      const fileTypeResult = await fileTypeFromBuffer(buffer);
+      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";
     }
-    this.cache.set(cacheKey, {
-      quote,
-      timestamp: Date.now(),
-      ttlMs
-    });
-  }
-  /**
-   * Clear all cached entries
-   */
-  clear() {
-    this.cache.clear();
+    return { base64, fileName, mimeType };
+  } catch (error) {
+    throw new Error(
+      `Failed to read file ${filePath}: ${error.message}`
+    );
   }
 }
-class SDKCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = 10;
-    this.defaultTtlMs = 30 * 60 * 1e3;
-  }
-  // 30 minutes
-  /**
-   * Generate config key for SDK instance
-   */
-  generateConfigKey(config) {
-    return Buffer.from(JSON.stringify(config)).toString("base64");
-  }
-  /**
-   * Get cached SDK instance
-   */
-  get(config) {
-    const configKey = this.generateConfigKey(config);
-    const entry = this.cache.get(configKey);
-    if (!entry) {
-      return null;
-    }
-    const now = Date.now();
-    if (now - entry.timestamp > this.defaultTtlMs) {
-      this.cache.delete(configKey);
-      return null;
-    }
-    return entry.sdk;
-  }
-  /**
-   * Store SDK instance in cache
-   */
-  set(config, sdk) {
-    const configKey = this.generateConfigKey(config);
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
+function normalizeClientConfig(cfg) {
+  return {
+    accountId: cfg.accountId,
+    privateKey: typeof cfg.privateKey === "string" ? cfg.privateKey : cfg.privateKey.toString(),
+    network: cfg.network
+  };
+}
+async function inscribe(input, clientConfig, options, existingSDK) {
+  const logger = Logger.getInstance({
+    module: "Inscriber",
+    ...options.logging
+  });
+  logger.info("Starting inscription process", {
+    type: input.type,
+    mode: options.mode || "file",
+    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: "auto"
+      });
+    } 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: "auto"
+      });
+    }
+    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;
       }
     }
-    this.cache.set(configKey, {
-      sdk,
-      timestamp: Date.now(),
-      config: configKey
+    logger.debug("Preparing to inscribe content", {
+      type: input.type,
+      mode: options.mode || "file",
+      holderId: clientConfig.accountId
     });
-  }
-  /**
-   * Clear all cached SDK instances
-   */
-  clear() {
-    this.cache.clear();
+    const normalizedCfg = normalizeClientConfig(clientConfig);
+    const result = await sdk.inscribeAndExecute(request, normalizedCfg);
+    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
+      };
+    }
+    return {
+      confirmed: false,
+      result: {
+        ...result,
+        jobId: waitId,
+        transactionId: normalizedTxId
+      },
+      sdk
+    };
+  } catch (error) {
+    logger.error("Error during inscription process", error);
+    throw error;
   }
 }
-const quoteCache = new QuoteCache();
-const sdkCache = new SDKCache();
-async function getOrCreateSDK(clientConfig, options, existingSDK) {
-  if (existingSDK) {
-    return existingSDK;
-  }
-  const connectionMode = options.connectionMode || (options.websocket === false ? "http" : "auto");
-  const cacheConfig = {
-    apiKey: options.apiKey,
-    accountId: clientConfig.accountId,
-    network: clientConfig.network || "mainnet",
-    authType: options.apiKey ? "api" : "server",
-    connectionMode
-  };
-  const cachedSDK = sdkCache.get(cacheConfig);
-  if (cachedSDK) {
-    return cachedSDK;
-  }
-  let sdk;
-  if (options.apiKey) {
-    sdk = new InscriptionSDK({
-      apiKey: options.apiKey,
-      network: clientConfig.network || "mainnet",
-      connectionMode
-    });
-  } else {
-    sdk = await InscriptionSDK.createWithAuth({
-      type: "server",
-      accountId: clientConfig.accountId,
-      privateKey: typeof clientConfig.privateKey === "string" ? clientConfig.privateKey : clientConfig.privateKey.toString(),
-      network: clientConfig.network || "mainnet",
-      connectionMode
+async function inscribeWithSigner(input, signer, options, existingSDK) {
+  const logger = Logger.getInstance({
+    module: "Inscriber",
+    ...options.logging
+  });
+  logger.info("Starting inscription process with signer", {
+    type: input.type,
+    mode: options.mode || "file",
+    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: "websocket"
+      });
+    } else {
+      logger.debug("Initializing InscriptionSDK with client auth (websocket)");
+      sdk = await InscriptionSDK.createWithAuth({
+        type: "client",
+        accountId,
+        signer,
+        network: options.network || "mainnet",
+        connectionMode: "websocket"
+      });
+    }
+    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"
+    });
+    logger.info("about to start inscription", {
+      type: input.type,
+      mode: options.mode || "file",
+      jobId: startResult.id || startResult.tx_id,
+      ...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
+      );
+    }
+    const trackingId = normalizeTransactionId(
+      startResult.tx_id || startResult.id || ""
+    );
+    const waitId = normalizeTransactionId(
+      trackingId || startResult.id || startResult.tx_id || ""
+    );
+    if (options.waitForConfirmation) {
+      logger.debug("Waiting for inscription confirmation (websocket)", {
+        jobId: startResult.id || startResult.tx_id,
+        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
+      };
+    }
+    return {
+      confirmed: false,
+      result: {
+        jobId: waitId,
+        transactionId: waitId,
+        topic_id: startResult.topic_id,
+        status: startResult.status,
+        completed: startResult.completed
+      },
+      sdk
+    };
+  } catch (error) {
+    logger.error("Error during inscription process", error);
+    throw error;
   }
-  sdkCache.set(cacheConfig, sdk);
-  return sdk;
-}
-function getCachedQuote(input, clientConfig, options) {
-  const cacheKey = quoteCache.createCacheKey(input, clientConfig, options);
-  return quoteCache.get(cacheKey);
-}
-function cacheQuote(input, clientConfig, options, quote) {
-  const cacheKey = quoteCache.createCacheKey(input, clientConfig, options);
-  const quoteTtlMs = 10 * 60 * 1e3;
-  quoteCache.set(cacheKey, quote, quoteTtlMs);
 }
-function validateQuoteParameters(input, clientConfig, options) {
-  if (!input || typeof input !== "object" || !("type" in input)) {
-    throw new Error("Invalid inscription input: type is required");
-  }
-  if (!clientConfig || !clientConfig.accountId) {
-    throw new Error("Invalid client config: accountId is required");
+async function retrieveInscription(transactionId, options) {
+  const logger = Logger.getInstance({
+    module: "Inscriber",
+    ...options?.logging || {}
+  });
+  const formattedTransactionId = transactionId.includes("@") ? `${transactionId.split("@")[0]}-${transactionId.split("@")[1].replace(/\./g, "-")}` : transactionId;
+  logger.info("Retrieving inscription", {
+    originalTransactionId: transactionId,
+    formattedTransactionId
+  });
+  try {
+    let sdk;
+    if (options?.apiKey) {
+      logger.debug("Initializing InscriptionSDK with API key");
+      sdk = new InscriptionSDK({
+        apiKey: options.apiKey,
+        network: options.network || "mainnet"
+      });
+    } else if (options?.accountId && options?.privateKey) {
+      logger.debug("Initializing InscriptionSDK with server auth");
+      sdk = await InscriptionSDK.createWithAuth({
+        type: "server",
+        accountId: options.accountId,
+        privateKey: options.privateKey,
+        network: options.network || "mainnet"
+      });
+    } else {
+      const error = new Error(
+        "Either API key or account ID and private key are required for retrieving inscriptions"
+      );
+      logger.error("Missing authentication credentials", {
+        hasApiKey: Boolean(options?.apiKey),
+        hasAccountId: Boolean(options?.accountId),
+        hasPrivateKey: Boolean(options?.privateKey)
+      });
+      throw error;
+    }
+    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;
   }
-  if (!options) {
-    throw new Error("Options are required");
+}
+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;
   }
-  if (options.mode === "hashinal") {
-    if (!options.metadata) {
-      throw new Error("Hashinal mode requires metadata");
+  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;
     }
-    const requiredFields = ["name", "creator", "description", "type"];
-    const missingFields = requiredFields.filter(
-      (field) => !options.metadata || !options.metadata[field]
+    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
     );
-    if (missingFields.length > 0) {
-      throw new Error(
-        `Missing required Hashinal metadata fields: ${missingFields.join(", ")}`
+    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
+              });
+            }
+          }
+        }
+        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 = 30, 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;
   }
 }
 export {
-  cacheQuote,
-  getCachedQuote,
-  getOrCreateSDK,
-  validateQuoteParameters
+  generateQuote,
+  inscribe,
+  inscribeWithSigner,
+  normalizeTransactionId,
+  retrieveInscription,
+  waitForInscriptionConfirmation
 };
 //# sourceMappingURL=standards-sdk.es125.js.map