@hashgraphonline/standards-sdk 0.1.144 → 0.1.146-chore-jsr-improvements.canary.74bacb9.89

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

@@ -1,883 +1,211 @@
-import { InscriptionSDK } from "./standards-sdk.es147.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";
-import { HederaMirrorNode } from "./standards-sdk.es127.js";
-import BigNumber from "bignumber.js";
-import { sleep } from "./standards-sdk.es116.js";
-let nodeModules = {};
-const normalizeTransactionId = (txId) => {
-  if (!txId.includes("@")) {
-    return txId;
+import { InscriptionSDK } from "./standards-sdk.es150.js";
+class QuoteCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = 100;
+    this.defaultTtlMs = 5 * 60 * 1e3;
   }
-  const txParts = txId?.split("@");
-  return `${txParts[0]}-${txParts[1].replace(".", "-")}`;
-};
-async function loadNodeModules() {
-  if (isBrowser || nodeModules.readFileSync) {
-    return;
+  // 5 minutes
+  /**
+   * Generate cache key from input parameters
+   */
+  generateKey(key) {
+    return `${key.inputHash}-${key.clientConfigHash}-${key.optionsHash}`;
   }
-  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"
-    );
+  /**
+   * Hash object to string for cache key
+   */
+  hashObject(obj) {
+    return Buffer.from(JSON.stringify(obj)).toString("base64").slice(0, 16);
   }
-}
-const COST_LOOKUP_ATTEMPTS = 3;
-const COST_LOOKUP_DELAY_MS = 1e3;
-const TINYBAR_DIVISOR = 1e8;
-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 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";
-    }
-    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
-  };
-}
-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;
-      }
-    }
-    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);
-    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
-        )
-      };
-    }
+  /**
+   * Create cache key from parameters
+   */
+  createCacheKey(input, clientConfig, options) {
     return {
-      confirmed: false,
-      result: {
-        ...result,
-        jobId: waitId,
-        transactionId: normalizedTxId
-      },
-      sdk,
-      costSummary: await resolveInscriptionCost(
-        normalizedTxId,
-        clientConfig.network || "mainnet",
-        options.logging?.level
-      )
+      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
+      })
     };
-  } 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 payerTransfer = txn.transfers?.find(
-        (transfer) => transfer.account === payerAccountId && typeof transfer.amount === "number" && transfer.amount < 0
-      );
-      let payerTinybars = null;
-      if (payerTransfer) {
-        payerTinybars = Math.abs(payerTransfer.amount);
-      } else if (txn.transfers && txn.transfers.length > 0) {
-        const negativeSum = txn.transfers.filter((t) => typeof t.amount === "number" && t.amount < 0).reduce((sum, t) => sum + Math.abs(t.amount), 0);
-        payerTinybars = negativeSum > 0 ? negativeSum : null;
-      } else if (typeof txn.charged_tx_fee === "number") {
-        payerTinybars = txn.charged_tx_fee;
-      }
-      if (!payerTinybars || payerTinybars <= 0) {
-        if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
-          await sleep(COST_LOOKUP_DELAY_MS);
-        }
-        continue;
-      }
-      const totalCostHbar = new BigNumber(payerTinybars).dividedBy(TINYBAR_DIVISOR).toFixed();
-      return {
-        totalCostHbar,
-        breakdown: {
-          transfers: [
-            {
-              to: "Hedera network (payer)",
-              amount: totalCostHbar,
-              description: `Transaction fee debited from ${payerAccountId}`
-            }
-          ]
-        }
-      };
-    } 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);
-      }
-    }
+  /**
+   * 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;
   }
-  return void 0;
-}
-async function inscribeWithSigner(input, signer, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  logger.info("Starting inscription process with signer", {
-    type: input.type,
-    mode: options.mode || "file",
-    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;
+  /**
+   * 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);
       }
     }
-    logger.debug("Starting inscription via startInscription (websocket)", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: accountId,
-      usesStartInscription: true
+    this.cache.set(cacheKey, {
+      quote,
+      timestamp: Date.now(),
+      ttlMs
     });
-    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,
-        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"
-      });
-    } 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;
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
   }
 }
-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;
+class SDKCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = 10;
+    this.defaultTtlMs = 30 * 60 * 1e3;
   }
-  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;
+  // 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);
       }
     }
-    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
+    this.cache.set(configKey, {
+      sdk,
+      timestamp: Date.now(),
+      config: configKey
     });
-    return {
-      confirmed: false,
-      quote: true,
-      result: quote
-    };
-  } catch (error) {
-    logger.error("Error generating inscription quote", error);
-    throw error;
+  }
+  /**
+   * Clear all cached SDK instances
+   */
+  clear() {
+    this.cache.clear();
   }
 }
-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
+const quoteCache = new QuoteCache();
+const sdkCache = new SDKCache();
+async function getOrCreateSDK(clientConfig, options, existingSDK) {
+  if (existingSDK) {
+    return existingSDK;
+  }
+  const connectionMode = options.connectionMode ?? "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
     });
-    return quote;
-  } catch (error) {
-    logger.error("Error parsing transaction for quote", error);
-    throw error;
   }
+  sdkCache.set(cacheConfig, sdk);
+  return sdk;
 }
-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
+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");
+  }
+  if (!options) {
+    throw new Error("Options are required");
+  }
+  if (options.mode === "hashinal") {
+    if (!options.metadata) {
+      throw new Error("Hashinal mode requires metadata");
+    }
+    const requiredFields = ["name", "creator", "description", "type"];
+    const missingFields = requiredFields.filter(
+      (field) => !options.metadata || !options.metadata[field]
+    );
+    if (missingFields.length > 0) {
+      throw new Error(
+        `Missing required Hashinal metadata fields: ${missingFields.join(", ")}`
       );
     }
-  } catch (error) {
-    logger.error("Error waiting for inscription confirmation", {
-      transactionId,
-      maxAttempts,
-      intervalMs,
-      error
-    });
-    progressReporter.failed("Inscription confirmation failed", {
-      transactionId,
-      error
-    });
-    throw error;
   }
 }
 export {
-  generateQuote,
-  inscribe,
-  inscribeWithSigner,
-  normalizeTransactionId,
-  retrieveInscription,
-  waitForInscriptionConfirmation
+  cacheQuote,
+  getCachedQuote,
+  getOrCreateSDK,
+  validateQuoteParameters
 };
 //# sourceMappingURL=standards-sdk.es125.js.map