@hashgraphonline/standards-sdk 0.1.188 → 0.1.190

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

@@ -1,1125 +1,185 @@
-import { InscriptionSDK } from "./standards-sdk.es185.js";
-import { Logger } from "./standards-sdk.es128.js";
-import { ProgressReporter } from "./standards-sdk.es131.js";
-import { TransactionParser } from "./standards-sdk.es133.js";
-import { isBrowser } from "./standards-sdk.es141.js";
-import { optionalImport } from "./standards-sdk.es187.js";
-import { validateQuoteParameters, getCachedQuote, getOrCreateSDK, cacheQuote } from "./standards-sdk.es148.js";
-import { HederaMirrorNode } from "./standards-sdk.es149.js";
-import { sleep } from "./standards-sdk.es138.js";
-import { computeInscriptionCostSummary } from "./standards-sdk.es198.js";
-let nodeModules = {};
-const normalizeTransactionId = (txId) => {
-  if (!txId.includes("@")) {
-    return txId;
-  }
-  const txParts = txId?.split("@");
-  return `${txParts[0]}-${txParts[1].replace(".", "-")}`;
-};
-async function loadNodeModules() {
-  if (isBrowser || nodeModules.readFileSync) {
-    return;
-  }
-  try {
-    const [fsModule, pathModule] = await Promise.all([
-      optionalImport("node:fs"),
-      optionalImport("node:path")
-    ]);
-    if (!fsModule || !pathModule) {
-      throw new Error("Node.js fs or path module not available");
-    }
-    nodeModules.readFileSync = fsModule.readFileSync;
-    nodeModules.basename = pathModule.basename;
-    nodeModules.extname = pathModule.extname;
-  } catch (error) {
-    Logger.getInstance({
-      module: "Inscriber",
-      level: "warn"
-    }).warn(
-      "Node.js modules not available, file path operations will be disabled",
-      {
-        error: error instanceof Error ? error.message : String(error)
-      }
-    );
-  }
-}
-const COST_LOOKUP_ATTEMPTS = 3;
-const COST_LOOKUP_DELAY_MS = 1e3;
-const COST_LOGGER_MODULE = "InscriberCost";
-async function convertFileToBase64(filePath) {
-  if (isBrowser) {
-    throw new Error(
-      "File path operations are not supported in browser environment. Use buffer input type instead."
-    );
-  }
-  await loadNodeModules();
-  if (!nodeModules.readFileSync || !nodeModules.basename || !nodeModules.extname) {
-    throw new Error(
-      "Node.js file system modules are not available. Cannot read file from path."
-    );
-  }
-  try {
-    const buffer = nodeModules.readFileSync(filePath);
-    const base64 = buffer.toString("base64");
-    const fileName = nodeModules.basename(filePath);
-    let mimeType = "application/octet-stream";
-    try {
-      const fileTypeModule = await optionalImport("file-type");
-      const fileTypeResult = typeof fileTypeModule?.fileTypeFromBuffer === "function" ? await fileTypeModule.fileTypeFromBuffer(buffer) : void 0;
-      if (fileTypeResult) {
-        mimeType = fileTypeResult.mime;
-      }
-    } catch (_error) {
-      const ext = nodeModules.extname(filePath).toLowerCase();
-      const mimeMap = {
-        ".txt": "text/plain",
-        ".json": "application/json",
-        ".html": "text/html",
-        ".css": "text/css",
-        ".js": "application/javascript",
-        ".png": "image/png",
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-        ".gif": "image/gif",
-        ".svg": "image/svg+xml",
-        ".pdf": "application/pdf"
-      };
-      mimeType = mimeMap[ext] || "application/octet-stream";
-    }
-    return { base64, fileName, mimeType };
-  } catch (error) {
-    throw new Error(
-      `Failed to read file ${filePath}: ${error.message}`
-    );
-  }
-}
-function normalizeClientConfig(cfg) {
-  return {
-    accountId: cfg.accountId,
-    privateKey: typeof cfg.privateKey === "string" ? cfg.privateKey : cfg.privateKey.toString(),
-    network: cfg.network
+let loggerFactory = null;
+function normalizeErrorData(error) {
+  const normalizedData = {
+    name: error.name,
+    message: error.message
   };
-}
-function resolveConnectionMode(options) {
-  if (options.connectionMode) {
-    return options.connectionMode;
+  if (error.stack) {
+    normalizedData.stack = error.stack;
   }
-  if (typeof options.websocket === "boolean") {
-    return options.websocket ? "websocket" : "http";
+  for (const [key, value] of Object.entries(error)) {
+    normalizedData[key] = value;
   }
-  return "websocket";
+  return normalizedData;
 }
-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 } : {}
-  });
+function serializeLogData(data) {
   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);
+    return JSON.stringify(
+      data,
+      (_key, value) => {
+        if (value instanceof Error) {
+          return normalizeErrorData(value);
         }
-        continue;
-      }
-      const computed = computeInscriptionCostSummary({
-        txn,
-        payerAccountId
-      });
-      if (!computed) {
-        if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
-          await sleep(COST_LOOKUP_DELAY_MS);
+        if (typeof value === "bigint") {
+          return value.toString();
         }
-        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);
-      }
-    }
+        if (value instanceof Map) {
+          return Object.fromEntries(value);
+        }
+        if (value instanceof Set) {
+          return Array.from(value);
+        }
+        if (value instanceof Uint8Array) {
+          return Array.from(value);
+        }
+        return value;
+      },
+      2
+    );
+  } catch {
+    return String(data);
   }
-  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;
+function setLoggerFactory(factory) {
+  loggerFactory = factory;
+  Logger.clearInstances();
+}
+const _Logger = class _Logger {
+  constructor(options = {}) {
+    if (loggerFactory) {
+      return loggerFactory(options);
+    }
+    const globalDisable = typeof process !== "undefined" && process.env?.DISABLE_LOGS === "true";
+    this.silent = options.silent || globalDisable;
+    this.level = this.silent ? "silent" : options.level || "info";
+    this.moduleContext = options.module || "app";
+    this.prettyPrint = !this.silent && options.prettyPrint !== false;
+  }
+  static getInstance(options = {}) {
+    const moduleKey = options.module || "default";
+    const globalDisable = typeof process !== "undefined" && process.env?.DISABLE_LOGS === "true";
+    if (globalDisable && _Logger.instances.has(moduleKey)) {
+      const existingLogger = _Logger.instances.get(moduleKey);
+      if (existingLogger.getLevel() !== "silent") {
+        _Logger.instances.delete(moduleKey);
       }
-      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;
-      }
+    if (!_Logger.instances.has(moduleKey)) {
+      const logger = loggerFactory ? loggerFactory(options) : new _Logger(options);
+      _Logger.instances.set(moduleKey, logger);
     }
-    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;
+    return _Logger.instances.get(moduleKey);
   }
-}
-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;
+  setLogLevel(level) {
+    this.level = level;
   }
-}
-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;
+  getLevel() {
+    return this.level;
   }
-  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;
-      }
+  setSilent(silent) {
+    this.silent = silent;
+    if (silent) {
+      this.level = "silent";
     }
-    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
-              });
-            }
-          }
-        }
-        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)
-          }
-        );
-      }
+  setModule(module) {
+    this.moduleContext = module;
+  }
+  formatArgs(args) {
+    if (args.length === 0) {
+      return { msg: "" };
     }
-    const transfers = [
-      {
-        to: "Inscription Service",
-        amount: totalCostHbar,
-        description: `Inscription fee (${totalCostHbar} HBAR)`
+    if (args.length === 1) {
+      if (typeof args[0] === "string") {
+        return { msg: args[0] };
       }
-    ];
-    const validUntil = new Date(Date.now() + 15 * 60 * 1e3).toISOString();
-    const quote = {
-      totalCostHbar,
-      validUntil,
-      breakdown: {
-        transfers
+      return { msg: "", data: args[0] };
+    }
+    const stringArgs = [];
+    const objectArgs = [];
+    args.forEach((arg) => {
+      if (typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean") {
+        stringArgs.push(String(arg));
+      } else {
+        objectArgs.push(arg);
       }
-    };
-    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;
+    const msg = stringArgs.join(" ");
+    return objectArgs.length > 0 ? { msg, data: objectArgs } : { msg };
   }
-}
-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
-      );
+  shouldLog(level) {
+    if (this.silent || this.level === "silent") {
+      return false;
     }
-  } 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"
-    );
+    const levels = ["trace", "debug", "info", "warn", "error", "silent"];
+    const currentLevelIndex = levels.indexOf(this.level);
+    const targetLevelIndex = levels.indexOf(level);
+    return targetLevelIndex >= currentLevelIndex;
   }
-  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;
+  getConsoleMethod(level) {
+    if (level === "error") {
+      return console.error;
     }
-    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 (level === "warn") {
+      return console.warn;
     }
-  }
-  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)
+    if (level === "debug") {
+      return console.debug;
     }
-  );
-  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
-    };
+    return console.log;
   }
-  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
-      };
+  writeLog(level, ...args) {
+    if (!this.shouldLog(level)) {
+      return;
     }
-    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
+    const { msg, data } = this.formatArgs(args);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const consoleMethod = this.getConsoleMethod(level);
+    if (this.prettyPrint) {
+      const levelFormatted = level.toUpperCase().padEnd(5);
+      let output = `${timestamp} ${levelFormatted} [${this.moduleContext}] ${msg}`;
+      if (data) {
+        output += "\n" + serializeLogData(data);
+      }
+      consoleMethod(output);
+    } else {
+      const logObj = {
+        timestamp,
+        level,
+        module: this.moduleContext,
+        message: msg,
+        ...data && { data }
       };
+      consoleMethod(JSON.stringify(logObj));
     }
-    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"
-    );
+  debug(...args) {
+    this.writeLog("debug", ...args);
   }
-  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;
-    }
+  info(...args) {
+    this.writeLog("info", ...args);
   }
-  if (options.metadata) {
-    requestBody.metadata = options.metadata;
+  warn(...args) {
+    this.writeLog("warn", ...args);
   }
-  if (options.tags) {
-    requestBody.tags = options.tags;
+  error(...args) {
+    this.writeLog("error", ...args);
   }
-  if (options.fileStandard) {
-    requestBody.fileStandard = options.fileStandard;
+  trace(...args) {
+    this.writeLog("trace", ...args);
   }
-  if (options.chunkSize) {
-    requestBody.chunkSize = options.chunkSize;
+  /**
+   * Clear all logger instances
+   * Used when switching logger implementations
+   */
+  static clearInstances() {
+    _Logger.instances.clear();
   }
-  logger.debug("Getting inscription quote from Registry Broker");
-  return fetchRegistryBroker(
-    `${baseUrl}/inscribe/content/quote`,
-    {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody)
-    }
-  );
-}
+};
+_Logger.instances = /* @__PURE__ */ new Map();
+let Logger = _Logger;
 export {
-  generateQuote,
-  getRegistryBrokerQuote,
-  inscribe,
-  inscribeViaRegistryBroker,
-  inscribeWithSigner,
-  normalizeTransactionId,
-  retrieveInscription,
-  waitForInscriptionConfirmation
+  Logger,
+  setLoggerFactory
 };
 //# sourceMappingURL=standards-sdk.es147.js.map