@hashgraphonline/standards-sdk 0.1.183 → 0.1.185

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

@@ -1,1160 +1,1125 @@
-import { Buffer } from "buffer";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { ZodError } from "zod";
-import { agentFeedbackResponseSchema, agentFeedbackIndexResponseSchema, agentFeedbackEntriesIndexResponseSchema, agentFeedbackEligibilityResponseSchema, agentFeedbackSubmissionResponseSchema, registerAgentResponseSchema } from "./standards-sdk.es161.js";
-import { fetchHistorySnapshot, attachDecryptedHistory, registerConversationContextForEncryption, resolveDecryptionContext, decryptHistoryEntryFromContext } from "./standards-sdk.es176.js";
-import { createChatApi, createSession, resumeSession, checkChatReadiness, startChat, startConversation, acceptConversation, compactHistory, fetchEncryptionStatus, postEncryptionHandshake, sendMessage, retryMessage, cancelSession, endSession, createPlaintextConversationHandle } from "./standards-sdk.es177.js";
-import { EncryptedChatManager } from "./standards-sdk.es178.js";
-import { generateEncryptionKeyPair, bootstrapEncryptionOptions, createEncryptionApi } from "./standards-sdk.es179.js";
-import { adapters, adaptersDetailed, adapterRegistryCategories, adapterRegistryAdapters, createAdapterRegistryCategory, submitAdapterRegistryAdapter, adapterRegistrySubmissionStatus } from "./standards-sdk.es180.js";
-import { resolveUaid, getRegistrationQuote, updateAgent, getRegistrationProgress, waitForRegistrationCompletion, validateUaid, getUaidConnectionStatus, closeUaidConnection, dashboardStats } from "./standards-sdk.es147.js";
-import { getRegisterStatus, registerOwnedMoltbookAgent, getVerificationStatus, createVerificationChallenge, getVerificationChallenge, verifyVerificationChallenge, getVerificationOwnership, verifySenderOwnership, verifyUaidDnsTxt, getVerificationDnsStatus } from "./standards-sdk.es181.js";
-import { getCreditsBalance, getCreditProviders, createHbarPurchaseIntent, purchaseCreditsWithHbar, getX402Minimums, purchaseCreditsWithX402, buyCreditsWithX402 } from "./standards-sdk.es182.js";
-import { getGuardSession, getGuardEntitlements, getGuardBillingBalance, getGuardFeed, getGuardOverview, getGuardTrustByHash, resolveGuardTrust, getGuardRevocations, fetchGuardAdvisories, fetchGuardPolicy, getGuardInventory, getGuardReceiptHistory, getGuardArtifactTimeline, getGuardInventoryDiff, exportGuardAbom, exportGuardArtifactAbom, exportGuardReceipts, getGuardDevices, getGuardAlertPreferences, updateGuardAlertPreferences, getGuardExceptions, getGuardWatchlist, lookupGuardWatchlist, getGuardPainSignals, getGuardAggregatedPainSignals, getGuardPreInstallVerdict, getGuardPreExecutionVerdict, addGuardWatchlistItem, removeGuardWatchlistItem, addGuardException, requestGuardException, removeGuardException, ingestGuardPainSignals, syncGuardReceipts, syncGuardInventory, submitGuardReceipts, getGuardTeamPolicyPack, updateGuardTeamPolicyPack } from "./standards-sdk.es183.js";
-import { createLedgerChallenge, verifyLedgerChallenge, authenticateWithLedger, authenticateWithLedgerCredentials } from "./standards-sdk.es184.js";
-import { search, delegate, stats, registries, getAdditionalRegistries, popularSearches, listProtocols, detectProtocol, registrySearchByNamespace, vectorSearch, searchStatus, websocketStats, metricsSummary, facets } from "./standards-sdk.es185.js";
-import { skillsConfig, listSkills, getSkillsCatalog, listSkillVersions, listMySkills, getMySkillsList, quoteSkillPublish, quoteSkillPublishPreview, publishSkill, getSkillPublishJob, getSkillOwnership, getRecommendedSkillVersion, setRecommendedSkillVersion, getSkillDeprecations, setSkillDeprecation, getSkillBadge, getSkillStatus, getSkillSecurityBreakdown, getSkillStatusByRepo, getSkillConversionSignalsByRepo, uploadSkillPreviewFromGithubOidc, getSkillPreview, getSkillPreviewByRepo, getSkillPreviewById, getSkillInstall, recordSkillInstallCopy, listSkillTags, listSkillCategories, resolveSkillMarkdown, resolveSkillManifest, getSkillVoteStatus, setSkillVote, requestSkillVerification, getSkillVerificationStatus, createSkillDomainProofChallenge, verifySkillDomainProof } from "./standards-sdk.es169.js";
-import { DEFAULT_BASE_URL, normaliseBaseUrl, normaliseHeaderName, isBrowserRuntime, DEFAULT_USER_AGENT, JSON_CONTENT_TYPE, serialiseAgentRegistrationRequest, MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS, createAbortError, isJsonObject, DEFAULT_HISTORY_TOP_UP_HBAR } from "./standards-sdk.es186.js";
-import { RegistryBrokerError, RegistryBrokerParseError } from "./standards-sdk.es146.js";
-import { optionalImportSync } from "./standards-sdk.es164.js";
-class RegistryBrokerClient {
-  constructor(options = {}) {
-    this.encryptionBootstrapPromise = null;
-    this.chatApi = null;
-    this.encryptedChatManager = null;
-    this.encryptionApi = null;
-    this.conversationContexts = /* @__PURE__ */ new Map();
-    const {
-      baseUrl = DEFAULT_BASE_URL,
-      fetchImplementation,
-      defaultHeaders,
-      apiKey,
-      accountId,
-      ledgerApiKey,
-      registrationAutoTopUp,
-      historyAutoTopUp,
-      encryption
-    } = options;
-    this.baseUrl = normaliseBaseUrl(baseUrl);
-    const resolvedFetch = fetchImplementation ?? (typeof globalThis.fetch === "function" ? globalThis.fetch : null);
-    if (!resolvedFetch) {
-      throw new Error(
-        "A fetch implementation is required for RegistryBrokerClient"
-      );
-    }
-    this.fetchImpl = resolvedFetch;
-    this.defaultHeaders = {
-      ...defaultHeaders ?? {}
-    };
-    Object.entries(this.defaultHeaders).forEach(([key, value]) => {
-      const headerName = normaliseHeaderName(key);
-      if (headerName !== key) {
-        delete this.defaultHeaders[key];
-        this.defaultHeaders[headerName] = value;
-      }
-    });
-    const existingLedgerHeader = this.defaultHeaders["x-ledger-api-key"]?.trim();
-    if (!this.defaultHeaders["x-api-key"] && existingLedgerHeader) {
-      this.defaultHeaders["x-api-key"] = existingLedgerHeader;
-    }
-    if (apiKey) {
-      this.defaultHeaders["x-api-key"] = apiKey;
-    }
-    if (typeof accountId === "string" && accountId.trim().length > 0) {
-      this.defaultHeaders["x-account-id"] = accountId.trim();
-    }
-    if (ledgerApiKey) {
-      if (!this.defaultHeaders["x-api-key"]) {
-        this.defaultHeaders["x-api-key"] = ledgerApiKey;
+import { InscriptionSDK } from "./standards-sdk.es163.js";
+import { Logger } from "./standards-sdk.es126.js";
+import { ProgressReporter } from "./standards-sdk.es129.js";
+import { TransactionParser } from "./standards-sdk.es131.js";
+import { isBrowser } from "./standards-sdk.es139.js";
+import { optionalImport } from "./standards-sdk.es168.js";
+import { validateQuoteParameters, getCachedQuote, getOrCreateSDK, cacheQuote } from "./standards-sdk.es146.js";
+import { HederaMirrorNode } from "./standards-sdk.es147.js";
+import { sleep } from "./standards-sdk.es136.js";
+import { computeInscriptionCostSummary } from "./standards-sdk.es172.js";
+let nodeModules = {};
+const normalizeTransactionId = (txId) => {
+  if (!txId.includes("@")) {
+    return txId;
+  }
+  const txParts = txId?.split("@");
+  return `${txParts[0]}-${txParts[1].replace(".", "-")}`;
+};
+async function loadNodeModules() {
+  if (isBrowser || nodeModules.readFileSync) {
+    return;
+  }
+  try {
+    const [fsModule, pathModule] = await Promise.all([
+      optionalImport("node:fs"),
+      optionalImport("node:path")
+    ]);
+    if (!fsModule || !pathModule) {
+      throw new Error("Node.js fs or path module not available");
+    }
+    nodeModules.readFileSync = fsModule.readFileSync;
+    nodeModules.basename = pathModule.basename;
+    nodeModules.extname = pathModule.extname;
+  } catch (error) {
+    Logger.getInstance({
+      module: "Inscriber",
+      level: "warn"
+    }).warn(
+      "Node.js modules not available, file path operations will be disabled",
+      {
+        error: error instanceof Error ? error.message : String(error)
       }
-    }
-    this.registrationAutoTopUp = registrationAutoTopUp;
-    this.historyAutoTopUp = historyAutoTopUp;
-    this.encryptionOptions = encryption;
-    if (this.encryptionOptions) {
-      this.encryptionBootstrapPromise = this.initializeEncryptionBootstrap(
-        this.encryptionOptions
-      );
-    }
+    );
   }
-  static async initializeAgent(options) {
-    const { uaid, ensureEncryptionKey = true, ...clientOptions } = options;
-    const client = new RegistryBrokerClient(clientOptions);
-    let encryption = null;
-    if (ensureEncryptionKey) {
-      const ensureOptions = typeof ensureEncryptionKey === "object" ? ensureEncryptionKey : { generateIfMissing: true };
-      encryption = await client.encryption.ensureAgentKey({
-        uaid,
-        ...ensureOptions
-      });
-    }
-    return { client, encryption };
+}
+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."
+    );
   }
-  get chat() {
-    if (this.chatApi) {
-      return this.chatApi;
-    }
-    const api = createChatApi(this, this.getEncryptedChatManager());
-    this.chatApi = api;
-    return api;
+  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."
+    );
   }
-  get encryption() {
-    if (this.encryptionApi) {
-      return this.encryptionApi;
+  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";
     }
-    const api = createEncryptionApi(this);
-    this.encryptionApi = api;
-    return api;
+    return { base64, fileName, mimeType };
+  } catch (error) {
+    throw new Error(
+      `Failed to read file ${filePath}: ${error.message}`
+    );
   }
-  setApiKey(apiKey) {
-    this.setDefaultHeader("x-api-key", apiKey);
+}
+function normalizeClientConfig(cfg) {
+  return {
+    accountId: cfg.accountId,
+    privateKey: typeof cfg.privateKey === "string" ? cfg.privateKey : cfg.privateKey.toString(),
+    network: cfg.network
+  };
+}
+function resolveConnectionMode(options) {
+  if (options.connectionMode) {
+    return options.connectionMode;
   }
-  setLedgerApiKey(apiKey) {
-    this.setDefaultHeader("x-api-key", apiKey);
-    delete this.defaultHeaders["x-ledger-api-key"];
+  if (typeof options.websocket === "boolean") {
+    return options.websocket ? "websocket" : "http";
   }
-  setDefaultHeader(name, value) {
-    if (!name || name.trim().length === 0) {
-      return;
-    }
-    const headerName = normaliseHeaderName(name);
-    if (!value || value.trim().length === 0) {
-      delete this.defaultHeaders[headerName];
-      return;
+  return "websocket";
+}
+async function inscribe(input, clientConfig, options, existingSDK) {
+  const logger = Logger.getInstance({
+    module: "Inscriber",
+    ...options.logging
+  });
+  const resolvedConnectionMode = resolveConnectionMode(options);
+  logger.info("Starting inscription process", {
+    type: input.type,
+    mode: options.mode || "file",
+    quoteOnly: options.quoteOnly || false,
+    ...input.type === "url" ? { url: input.url } : {},
+    ...input.type === "file" ? { path: input.path } : {},
+    ...input.type === "buffer" ? { fileName: input.fileName, bufferSize: input.buffer.byteLength } : {}
+  });
+  try {
+    if (options.quoteOnly) {
+      logger.debug("Quote-only mode requested, generating quote");
+      return await generateQuote(input, clientConfig, options, existingSDK);
+    }
+    if (options.mode === "hashinal" && options.metadata) {
+      validateHashinalMetadata(options.metadata, logger);
+    }
+    let sdk;
+    if (existingSDK) {
+      logger.debug("Using existing InscriptionSDK instance");
+      sdk = existingSDK;
+    } else if (options.apiKey) {
+      logger.debug("Initializing InscriptionSDK with API key");
+      sdk = new InscriptionSDK({
+        apiKey: options.apiKey,
+        network: clientConfig.network || "mainnet",
+        connectionMode: resolvedConnectionMode,
+        baseURL: options.baseURL
+      });
+    } else {
+      logger.debug("Initializing InscriptionSDK with server auth");
+      const normalized = normalizeClientConfig(clientConfig);
+      sdk = await InscriptionSDK.createWithAuth({
+        type: "server",
+        accountId: normalized.accountId,
+        privateKey: normalized.privateKey,
+        network: normalized.network || "mainnet",
+        connectionMode: resolvedConnectionMode,
+        baseUrl: options.baseURL
+      });
     }
-    this.defaultHeaders[headerName] = value.trim();
-  }
-  getDefaultHeaders() {
-    return { ...this.defaultHeaders };
-  }
-  async encryptionReady() {
-    if (!this.encryptionBootstrapPromise) {
-      return;
+    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;
+      }
     }
-    await this.encryptionBootstrapPromise;
-  }
-  buildUrl(path) {
-    const normalisedPath = path.startsWith("/") ? path : `/${path}`;
-    return `${this.baseUrl}${normalisedPath}`;
-  }
-  buildRequestInit(config) {
-    const headers = new Headers();
-    Object.entries(this.defaultHeaders).forEach(([key, value]) => {
-      headers.set(key, value);
+    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 (config.headers) {
-      Object.entries(config.headers).forEach(([key, value]) => {
-        headers.set(key, value);
+    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
+        )
+      };
     }
-    if (!headers.has("accept")) {
-      headers.set("accept", "application/json");
-    }
-    if (!headers.has("user-agent") && !isBrowserRuntime()) {
-      headers.set("user-agent", DEFAULT_USER_AGENT);
-    }
-    const init = {
-      method: config.method ?? "GET",
-      headers
+    return {
+      confirmed: false,
+      result: {
+        ...result,
+        jobId: waitId,
+        transactionId: normalizedTxId
+      },
+      sdk,
+      costSummary: await resolveInscriptionCost(
+        normalizedTxId,
+        clientConfig.network || "mainnet",
+        options.logging?.level
+      )
     };
-    if (config.body !== void 0) {
-      init.body = JSON.stringify(config.body);
-      if (!headers.has("content-type")) {
-        headers.set("content-type", "application/json");
+  } catch (error) {
+    logger.error("Error during inscription process", error);
+    throw error;
+  }
+}
+async function resolveInscriptionCost(transactionId, network, level) {
+  const logger = Logger.getInstance({
+    module: COST_LOGGER_MODULE,
+    level: level ?? "info"
+  });
+  const mirrorNode = new HederaMirrorNode(network, logger);
+  const normalizedId = normalizeTransactionId(transactionId);
+  const payerAccountId = normalizedId.split("-")[0];
+  for (let attempt = 0; attempt < COST_LOOKUP_ATTEMPTS; attempt++) {
+    try {
+      const txn = await mirrorNode.getTransaction(normalizedId);
+      if (!txn) {
+        if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
+          await sleep(COST_LOOKUP_DELAY_MS);
+        }
+        continue;
+      }
+      const computed = computeInscriptionCostSummary({
+        txn,
+        payerAccountId
+      });
+      if (!computed) {
+        if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
+          await sleep(COST_LOOKUP_DELAY_MS);
+        }
+        continue;
+      }
+      return computed.summary;
+    } catch (error) {
+      logger.warn("Unable to resolve inscription cost", {
+        transactionId: normalizedId,
+        attempt: attempt + 1,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (attempt < COST_LOOKUP_ATTEMPTS - 1) {
+        await sleep(COST_LOOKUP_DELAY_MS);
       }
     }
-    return init;
   }
-  async request(path, config) {
-    const init = this.buildRequestInit(config);
-    const response = await this.fetchImpl(this.buildUrl(path), init);
-    if (response.ok) {
-      return response;
+  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 errorBody = await this.extractErrorBody(response);
-    throw new RegistryBrokerError("Registry broker request failed", {
-      status: response.status,
-      statusText: response.statusText,
-      body: errorBody
-    });
-  }
-  async requestAbsolute(url, config) {
-    const init = this.buildRequestInit(config);
-    const response = await this.fetchImpl(url, init);
-    if (response.ok) {
-      return response;
+    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;
+      }
     }
-    const errorBody = await this.extractErrorBody(response);
-    throw new RegistryBrokerError("Registry broker request failed", {
-      status: response.status,
-      statusText: response.statusText,
-      body: errorBody
+    logger.debug("Starting inscription via startInscription (websocket)", {
+      type: input.type,
+      mode: options.mode || "file",
+      holderId: accountId,
+      usesStartInscription: true
     });
-  }
-  async requestJson(path, config) {
-    const response = await this.request(path, config);
-    const contentType = response.headers?.get("content-type") ?? "";
-    if (!JSON_CONTENT_TYPE.test(contentType)) {
-      const body = await response.text();
-      throw new RegistryBrokerParseError(
-        "Expected JSON response from registry broker",
-        body
+    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
       );
-    }
-    return await response.json();
-  }
-  async requestAbsoluteJson(url, config) {
-    const response = await this.requestAbsolute(url, config);
-    const contentType = response.headers?.get("content-type") ?? "";
-    if (!JSON_CONTENT_TYPE.test(contentType)) {
-      const body = await response.text();
-      throw new RegistryBrokerParseError(
-        "Expected JSON response from registry broker",
-        body
+    } 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
       );
     }
-    return await response.json();
-  }
-  async getAgentFeedback(uaid, options = {}) {
-    const normalized = uaid.trim();
-    if (!normalized) {
-      throw new Error("uaid is required");
+    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
+        )
+      };
     }
-    const query = options.includeRevoked === true ? "?includeRevoked=true" : "";
-    const raw = await this.requestJson(
-      `/agents/${encodeURIComponent(normalized)}/feedback${query}`,
-      { method: "GET" }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackResponseSchema,
-      "agent feedback response"
-    );
+    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 listAgentFeedbackIndex(options = {}) {
-    const params = new URLSearchParams();
-    if (typeof options.page === "number" && Number.isFinite(options.page)) {
-      params.set("page", String(Math.trunc(options.page)));
-    }
-    if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
-      params.set("limit", String(Math.trunc(options.limit)));
-    }
-    if (options.registries?.length) {
-      params.set("registry", options.registries.join(","));
+}
+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;
     }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(`/agents/feedback${suffix}`, {
-      method: "GET"
+    logger.debug("Initialized SDK for inscription retrieval", {
+      formattedTransactionId,
+      network: options.network || "mainnet"
     });
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackIndexResponseSchema,
-      "agent feedback index response"
-    );
+    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;
   }
-  async listAgentFeedbackEntriesIndex(options = {}) {
-    const params = new URLSearchParams();
-    if (typeof options.page === "number" && Number.isFinite(options.page)) {
-      params.set("page", String(Math.trunc(options.page)));
-    }
-    if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
-      params.set("limit", String(Math.trunc(options.limit)));
-    }
-    if (options.registries?.length) {
-      params.set("registry", options.registries.join(","));
-    }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(
-      `/agents/feedback/entries${suffix}`,
-      { method: "GET" }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackEntriesIndexResponseSchema,
-      "agent feedback entries index response"
+}
+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(", ")}`
     );
-  }
-  async checkAgentFeedbackEligibility(uaid, payload) {
-    const normalized = uaid.trim();
-    if (!normalized) {
-      throw new Error("uaid is required");
+    logger.error("Hashinal metadata validation failed", { missingFields });
+    throw error;
+  }
+  logger.debug("Hashinal metadata validation passed", {
+    name: metadata.name,
+    creator: metadata.creator,
+    description: metadata.description,
+    type: metadata.type,
+    hasAttributes: !!metadata.attributes,
+    hasProperties: !!metadata.properties
+  });
+}
+async function generateQuote(input, clientConfig, options, existingSDK) {
+  const logger = Logger.getInstance({
+    module: "Inscriber",
+    ...options.logging
+  });
+  logger.info("Generating inscription quote", {
+    type: input.type,
+    mode: options.mode || "file",
+    ...input.type === "url" ? { url: input.url } : {},
+    ...input.type === "file" ? { path: input.path } : {},
+    ...input.type === "buffer" ? { fileName: input.fileName, bufferSize: input.buffer.byteLength } : {}
+  });
+  try {
+    validateQuoteParameters(input, clientConfig, options);
+    const cachedQuote = getCachedQuote(input, clientConfig, options);
+    if (cachedQuote) {
+      logger.debug("Returning cached quote");
+      return {
+        confirmed: false,
+        quote: true,
+        result: cachedQuote
+      };
     }
-    const raw = await this.requestJson(
-      `/agents/${encodeURIComponent(normalized)}/feedback/eligibility`,
-      {
-        method: "POST",
-        body: payload,
-        headers: { "content-type": "application/json" }
+    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;
       }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackEligibilityResponseSchema,
-      "agent feedback eligibility response"
-    );
-  }
-  async submitAgentFeedback(uaid, payload) {
-    const normalized = uaid.trim();
-    if (!normalized) {
-      throw new Error("uaid is required");
-    }
-    const raw = await this.requestJson(
-      `/agents/${encodeURIComponent(normalized)}/feedback`,
-      {
-        method: "POST",
-        body: payload,
-        headers: { "content-type": "application/json" }
+      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;
       }
-    );
-    return this.parseWithSchema(
-      raw,
-      agentFeedbackSubmissionResponseSchema,
-      "agent feedback submission response"
-    );
-  }
-  async search(params = {}) {
-    return search(this, params);
-  }
-  async delegate(request) {
-    return delegate(this, request);
-  }
-  async searchErc8004ByAgentId(params) {
-    const chainId = Math.floor(params.chainId);
-    if (!Number.isFinite(chainId) || chainId <= 0) {
-      throw new Error("chainId must be a positive integer");
-    }
-    const rawAgentId = typeof params.agentId === "bigint" ? params.agentId.toString() : String(params.agentId);
-    const agentId = rawAgentId.trim();
-    if (!agentId) {
-      throw new Error("agentId is required");
     }
-    const nativeId = `${chainId}:${agentId}`;
-    return search(this, {
-      registries: ["erc-8004"],
-      limit: params.limit ?? 1,
-      ...typeof params.page === "number" ? { page: params.page } : {},
-      ...typeof params.sortBy === "string" ? { sortBy: params.sortBy } : {},
-      ...typeof params.sortOrder === "string" ? { sortOrder: params.sortOrder } : {},
-      metadata: {
-        nativeId: [nativeId],
-        networkKey: [`eip155:${chainId}`]
-      }
+    logger.debug("Calling inscription SDK startInscription for quote", {
+      type: input.type,
+      mode: options.mode || "file",
+      holderId: clientConfig.accountId
     });
-  }
-  async stats() {
-    return stats(this);
-  }
-  async registries() {
-    return registries(this);
-  }
-  async getAdditionalRegistries() {
-    return getAdditionalRegistries(this);
-  }
-  async popularSearches() {
-    return popularSearches(this);
-  }
-  async listProtocols() {
-    return listProtocols(this);
-  }
-  async detectProtocol(message) {
-    return detectProtocol(this, message);
-  }
-  async registrySearchByNamespace(registry, query) {
-    return registrySearchByNamespace(this, registry, query);
-  }
-  async vectorSearch(request) {
-    return vectorSearch(this, request);
-  }
-  async searchStatus() {
-    return searchStatus(this);
-  }
-  async websocketStats() {
-    return websocketStats(this);
-  }
-  async metricsSummary() {
-    return metricsSummary(this);
-  }
-  async facets(adapter) {
-    return facets(this, adapter);
-  }
-  async adapters() {
-    return adapters(this);
-  }
-  async skillsConfig() {
-    return skillsConfig(this);
-  }
-  async listSkills(options) {
-    return listSkills(this, options);
-  }
-  async getSkillsCatalog(options) {
-    return getSkillsCatalog(this, options);
-  }
-  async listSkillVersions(params) {
-    return listSkillVersions(this, params);
-  }
-  async listMySkills(params) {
-    return listMySkills(this, params);
-  }
-  async getMySkillsList(params) {
-    return getMySkillsList(this, params);
-  }
-  async quoteSkillPublish(payload) {
-    return quoteSkillPublish(this, payload);
-  }
-  async quoteSkillPublishPreview(payload) {
-    return quoteSkillPublishPreview(this, payload);
-  }
-  async publishSkill(payload) {
-    return publishSkill(this, payload);
-  }
-  async getSkillPublishJob(jobId, params) {
-    return getSkillPublishJob(this, jobId, params);
-  }
-  async getSkillOwnership(params) {
-    return getSkillOwnership(this, params);
-  }
-  async getRecommendedSkillVersion(params) {
-    return getRecommendedSkillVersion(this, params);
-  }
-  async setRecommendedSkillVersion(payload) {
-    return setRecommendedSkillVersion(this, payload);
-  }
-  async getSkillDeprecations(params) {
-    return getSkillDeprecations(this, params);
-  }
-  async setSkillDeprecation(payload) {
-    return setSkillDeprecation(this, payload);
-  }
-  async getSkillBadge(params) {
-    return getSkillBadge(this, params);
-  }
-  async getSkillStatus(params) {
-    return getSkillStatus(this, params);
-  }
-  async getSkillSecurityBreakdown(params) {
-    return getSkillSecurityBreakdown(this, params);
-  }
-  async getSkillStatusByRepo(params) {
-    return getSkillStatusByRepo(this, params);
-  }
-  async getSkillConversionSignalsByRepo(params) {
-    return getSkillConversionSignalsByRepo(this, params);
-  }
-  async uploadSkillPreviewFromGithubOidc(payload) {
-    return uploadSkillPreviewFromGithubOidc(this, payload);
-  }
-  async getSkillPreview(params) {
-    return getSkillPreview(this, params);
-  }
-  async getSkillPreviewByRepo(params) {
-    return getSkillPreviewByRepo(this, params);
-  }
-  async getSkillPreviewById(previewId) {
-    return getSkillPreviewById(this, previewId);
-  }
-  async getSkillInstall(skillRef) {
-    return getSkillInstall(this, skillRef);
-  }
-  async recordSkillInstallCopy(skillRef, payload) {
-    return recordSkillInstallCopy(this, skillRef, payload);
-  }
-  async listSkillTags() {
-    return listSkillTags(this);
-  }
-  async listSkillCategories() {
-    return listSkillCategories(this);
-  }
-  async resolveSkillMarkdown(skillRef) {
-    return resolveSkillMarkdown(this, skillRef);
-  }
-  async resolveSkillManifest(skillRef) {
-    return resolveSkillManifest(this, skillRef);
-  }
-  async getSkillVoteStatus(params) {
-    return getSkillVoteStatus(this, params);
-  }
-  async setSkillVote(payload) {
-    return setSkillVote(this, payload);
-  }
-  async requestSkillVerification(payload) {
-    return requestSkillVerification(this, payload);
-  }
-  async getSkillVerificationStatus(params) {
-    return getSkillVerificationStatus(this, params);
-  }
-  async createSkillDomainProofChallenge(payload) {
-    return createSkillDomainProofChallenge(this, payload);
-  }
-  async verifySkillDomainProof(payload) {
-    return verifySkillDomainProof(this, payload);
-  }
-  async adaptersDetailed() {
-    return adaptersDetailed(this);
-  }
-  async adapterRegistryCategories() {
-    return adapterRegistryCategories(this);
-  }
-  async adapterRegistryAdapters(filters) {
-    return adapterRegistryAdapters(this, filters);
-  }
-  async createAdapterRegistryCategory(payload) {
-    return createAdapterRegistryCategory(this, payload);
-  }
-  async submitAdapterRegistryAdapter(payload) {
-    return submitAdapterRegistryAdapter(this, payload);
-  }
-  async adapterRegistrySubmissionStatus(submissionId) {
-    return adapterRegistrySubmissionStatus(this, submissionId);
-  }
-  async resolveUaid(uaid) {
-    return resolveUaid(this, uaid);
-  }
-  async performRegisterAgent(payload) {
-    const raw = await this.requestJson("/register", {
-      method: "POST",
-      body: serialiseAgentRegistrationRequest(payload),
-      headers: { "content-type": "application/json" }
+    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
     });
-    return this.parseWithSchema(
-      raw,
-      registerAgentResponseSchema,
-      "register agent response"
-    );
-  }
-  calculateHbarAmount(creditsToPurchase, creditsPerHbar) {
-    if (creditsPerHbar <= 0) {
-      throw new Error("creditsPerHbar must be positive");
-    }
-    if (creditsToPurchase <= 0) {
-      throw new Error("creditsToPurchase must be positive");
-    }
-    const rawHbar = creditsToPurchase / creditsPerHbar;
-    const tinybars = Math.ceil(rawHbar * 1e8);
-    return tinybars / 1e8;
-  }
-  resolveCreditsToPurchase(shortfallCredits) {
-    if (!Number.isFinite(shortfallCredits) || shortfallCredits <= 0) {
-      return 0;
-    }
-    return Math.max(
-      Math.ceil(shortfallCredits),
-      MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS
+    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 ensureCreditsForRegistration(payload, autoTopUp) {
-    const details = autoTopUp ?? null;
-    if (!details) {
-      return;
-    }
-    if (!details.accountId || !details.accountId.trim()) {
-      throw new Error("autoTopUp.accountId is required");
-    }
-    if (!details.privateKey || !details.privateKey.trim()) {
-      throw new Error("autoTopUp.privateKey is required");
-    }
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-      const quote = await this.getRegistrationQuote(payload);
-      const shortfall = quote.shortfallCredits ?? 0;
-      if (shortfall <= 0) {
-        return;
-      }
-      const creditsToPurchase = this.resolveCreditsToPurchase(shortfall);
-      if (creditsToPurchase <= 0) {
-        return;
-      }
-      const creditsPerHbar = quote.creditsPerHbar ?? null;
-      if (!creditsPerHbar || creditsPerHbar <= 0) {
-        throw new Error("Unable to determine credits per HBAR for auto top-up");
-      }
-      const hbarAmount = this.calculateHbarAmount(
-        creditsToPurchase,
-        creditsPerHbar
-      );
-      await this.purchaseCreditsWithHbar({
-        accountId: details.accountId.trim(),
-        privateKey: details.privateKey.trim(),
-        hbarAmount,
-        memo: details.memo ?? "Registry Broker auto top-up",
-        metadata: {
-          shortfallCredits: shortfall,
-          requiredCredits: quote.requiredCredits,
-          purchasedCredits: creditsToPurchase
-        }
+}
+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
       });
-    }
-    const finalQuote = await this.getRegistrationQuote(payload);
-    if ((finalQuote.shortfallCredits ?? 0) > 0) {
-      throw new Error("Unable to purchase sufficient credits for registration");
-    }
-  }
-  async registerAgent(payload, options) {
-    const autoTopUp = options?.autoTopUp ?? this.registrationAutoTopUp;
-    if (!autoTopUp) {
-      return this.performRegisterAgent(payload);
-    }
-    await this.ensureCreditsForRegistration(payload, autoTopUp);
-    let retried = false;
-    while (true) {
+    } else if (inscriptionResponse.transactionBytes) {
+      logger.debug("Parsing transaction bytes for cost information");
       try {
-        return await this.performRegisterAgent(payload);
-      } catch (error) {
-        const shortfall = this.extractInsufficientCreditsDetails(error);
-        if (shortfall && !retried) {
-          await this.ensureCreditsForRegistration(payload, autoTopUp);
-          retried = true;
-          continue;
+        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
+              });
+            }
+          }
         }
-        throw error;
+        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)
+          }
+        );
       }
     }
-  }
-  async getRegistrationQuote(payload) {
-    return getRegistrationQuote(this, payload);
-  }
-  async updateAgent(uaid, payload) {
-    return updateAgent(this, uaid, payload);
-  }
-  async getRegisterStatus(uaid) {
-    return getRegisterStatus(this, uaid);
-  }
-  async registerOwnedMoltbookAgent(uaid, payload) {
-    return registerOwnedMoltbookAgent(this, uaid, payload);
-  }
-  async getRegistrationProgress(attemptId) {
-    return getRegistrationProgress(this, attemptId);
-  }
-  async waitForRegistrationCompletion(attemptId, options) {
-    return waitForRegistrationCompletion(this, attemptId, options);
-  }
-  async validateUaid(uaid) {
-    return validateUaid(this, uaid);
-  }
-  async getUaidConnectionStatus(uaid) {
-    return getUaidConnectionStatus(this, uaid);
-  }
-  async closeUaidConnection(uaid) {
-    return closeUaidConnection(this, uaid);
-  }
-  async dashboardStats() {
-    return dashboardStats(this);
-  }
-  async getCreditsBalance(params = {}) {
-    return getCreditsBalance(this, params);
-  }
-  async getCreditProviders() {
-    return getCreditProviders(this);
-  }
-  async getGuardSession() {
-    return getGuardSession(this);
-  }
-  async getGuardEntitlements() {
-    return getGuardEntitlements(this);
-  }
-  async getGuardBillingBalance() {
-    return getGuardBillingBalance(this);
-  }
-  async getGuardFeed(limit) {
-    return getGuardFeed(this, limit);
-  }
-  async getGuardOverview() {
-    return getGuardOverview(this);
-  }
-  async getGuardTrustByHash(sha256) {
-    return getGuardTrustByHash(this, sha256);
-  }
-  async resolveGuardTrust(query) {
-    return resolveGuardTrust(this, query);
-  }
-  async getGuardRevocations() {
-    return getGuardRevocations(this);
-  }
-  async fetchGuardAdvisories() {
-    return fetchGuardAdvisories(this);
-  }
-  async fetchGuardPolicy() {
-    return fetchGuardPolicy(this);
-  }
-  async getGuardInventory() {
-    return getGuardInventory(this);
-  }
-  async getGuardReceiptHistory() {
-    return getGuardReceiptHistory(this);
-  }
-  async getGuardArtifactTimeline(artifactId) {
-    return getGuardArtifactTimeline(this, artifactId);
-  }
-  async getGuardInventoryDiff() {
-    return getGuardInventoryDiff(this);
-  }
-  async exportGuardAbom() {
-    return exportGuardAbom(this);
-  }
-  async exportGuardArtifactAbom(artifactId) {
-    return exportGuardArtifactAbom(this, artifactId);
-  }
-  async exportGuardReceipts() {
-    return exportGuardReceipts(this);
-  }
-  async getGuardDevices() {
-    return getGuardDevices(this);
-  }
-  async getGuardAlertPreferences() {
-    return getGuardAlertPreferences(this);
-  }
-  async updateGuardAlertPreferences(payload) {
-    return updateGuardAlertPreferences(this, payload);
-  }
-  async getGuardExceptions() {
-    return getGuardExceptions(this);
-  }
-  async getGuardWatchlist() {
-    return getGuardWatchlist(this);
-  }
-  async lookupGuardWatchlist(payload) {
-    return lookupGuardWatchlist(this, payload);
-  }
-  async getGuardPainSignals() {
-    return getGuardPainSignals(this);
-  }
-  async getGuardAggregatedPainSignals() {
-    return getGuardAggregatedPainSignals(this);
-  }
-  async getGuardPreInstallVerdict(payload) {
-    return getGuardPreInstallVerdict(this, payload);
-  }
-  async getGuardPreExecutionVerdict(payload) {
-    return getGuardPreExecutionVerdict(this, payload);
-  }
-  async addGuardWatchlistItem(payload) {
-    return addGuardWatchlistItem(this, payload);
-  }
-  async removeGuardWatchlistItem(artifactId) {
-    return removeGuardWatchlistItem(this, artifactId);
-  }
-  async addGuardException(payload) {
-    return addGuardException(this, payload);
-  }
-  async requestGuardException(payload) {
-    return requestGuardException(this, payload);
-  }
-  async removeGuardException(exceptionId) {
-    return removeGuardException(this, exceptionId);
-  }
-  async ingestGuardPainSignals(items) {
-    return ingestGuardPainSignals(this, items);
-  }
-  async syncGuardReceipts(payload) {
-    return syncGuardReceipts(this, payload);
-  }
-  async syncGuardInventory(payload) {
-    return syncGuardInventory(this, payload);
-  }
-  async submitGuardReceipts(payload) {
-    return submitGuardReceipts(this, payload);
-  }
-  async getGuardTeamPolicyPack() {
-    return getGuardTeamPolicyPack(this);
-  }
-  async updateGuardTeamPolicyPack(payload) {
-    return updateGuardTeamPolicyPack(this, payload);
-  }
-  async createHbarPurchaseIntent(payload) {
-    return createHbarPurchaseIntent(this, payload);
-  }
-  async purchaseCreditsWithHbar(params) {
-    return purchaseCreditsWithHbar(this, params);
-  }
-  async getX402Minimums() {
-    return getX402Minimums(this);
-  }
-  async purchaseCreditsWithX402(params) {
-    return purchaseCreditsWithX402(this, params);
-  }
-  async buyCreditsWithX402(params) {
-    return buyCreditsWithX402(this, params);
-  }
-  async generateEncryptionKeyPair(options = {}) {
-    return generateEncryptionKeyPair(this, options);
-  }
-  async createLedgerChallenge(payload) {
-    return createLedgerChallenge(this, payload);
-  }
-  async verifyLedgerChallenge(payload) {
-    return verifyLedgerChallenge(this, payload);
-  }
-  async authenticateWithLedger(options) {
-    return authenticateWithLedger(this, options);
-  }
-  async authenticateWithLedgerCredentials(options) {
-    return authenticateWithLedgerCredentials(this, options);
-  }
-  async getVerificationStatus(uaid) {
-    return getVerificationStatus(this, uaid);
-  }
-  async createVerificationChallenge(uaid) {
-    return createVerificationChallenge(this, uaid);
-  }
-  async getVerificationChallenge(challengeId) {
-    return getVerificationChallenge(this, challengeId);
-  }
-  async verifyVerificationChallenge(params) {
-    return verifyVerificationChallenge(this, params);
-  }
-  async getVerificationOwnership(uaid) {
-    return getVerificationOwnership(this, uaid);
-  }
-  async verifySenderOwnership(uaid) {
-    return verifySenderOwnership(this, uaid);
-  }
-  async verifyUaidDnsTxt(payload) {
-    return verifyUaidDnsTxt(this, payload);
-  }
-  async getVerificationDnsStatus(uaid, query) {
-    return getVerificationDnsStatus(this, uaid, query);
-  }
-  async fetchHistorySnapshot(sessionId, options) {
-    return fetchHistorySnapshot(
-      this.conversationContexts,
-      this,
-      sessionId,
-      options
-    );
-  }
-  attachDecryptedHistory(sessionId, snapshot, options) {
-    return attachDecryptedHistory(
-      this.conversationContexts,
-      this,
-      sessionId,
-      snapshot,
-      options
-    );
-  }
-  registerConversationContextForEncryption(context) {
-    registerConversationContextForEncryption(
-      this.conversationContexts,
-      context
-    );
-  }
-  resolveDecryptionContext(sessionId, options) {
-    return resolveDecryptionContext(
-      this.conversationContexts,
-      this,
-      sessionId,
-      options
-    );
-  }
-  decryptHistoryEntryFromContext(_sessionId, entry, context) {
-    return decryptHistoryEntryFromContext(this, entry, context);
-  }
-  async createSession(payload, allowHistoryAutoTopUp = true) {
-    return createSession(this, payload, allowHistoryAutoTopUp);
-  }
-  async resumeSession(sessionId) {
-    return resumeSession(this, sessionId);
-  }
-  async checkChatReadiness(payload) {
-    return checkChatReadiness(this, payload);
-  }
-  async startChat(options) {
-    return startChat(this, this.getEncryptedChatManager(), options);
-  }
-  async startConversation(options) {
-    return startConversation(this, this.getEncryptedChatManager(), options);
-  }
-  async acceptConversation(options) {
-    return acceptConversation(
-      this,
-      this.getEncryptedChatManager(),
-      options
-    );
-  }
-  compactHistory(payload) {
-    return compactHistory(this, payload);
-  }
-  fetchEncryptionStatus(sessionId) {
-    return fetchEncryptionStatus(this, sessionId);
-  }
-  postEncryptionHandshake(sessionId, payload) {
-    return postEncryptionHandshake(this, sessionId, payload);
-  }
-  sendMessage(payload) {
-    return sendMessage(this, payload);
-  }
-  retryMessage(messageId, payload) {
-    return retryMessage(this, messageId, payload);
-  }
-  cancelSession(sessionId) {
-    return cancelSession(this, sessionId);
-  }
-  endSession(sessionId) {
-    return endSession(this, sessionId);
-  }
-  createPlaintextConversationHandle(sessionId, summary, defaultAuth, context) {
-    return createPlaintextConversationHandle(
-      this,
-      sessionId,
-      summary,
-      defaultAuth,
-      context
-    );
-  }
-  getEncryptedChatManager() {
-    if (this.encryptedChatManager) {
-      return this.encryptedChatManager;
-    }
-    const manager = new EncryptedChatManager(this);
-    this.encryptedChatManager = manager;
-    return manager;
-  }
-  async extractErrorBody(response) {
-    const contentType = response.headers?.get("content-type") ?? "";
-    if (JSON_CONTENT_TYPE.test(contentType)) {
-      try {
-        return await response.json();
-      } catch (error) {
-        return { parseError: String(error) };
+    const transfers = [
+      {
+        to: "Inscription Service",
+        amount: totalCostHbar,
+        description: `Inscription fee (${totalCostHbar} HBAR)`
       }
-    }
-    try {
-      return await response.text();
-    } catch (error) {
-      return { parseError: String(error) };
-    }
+    ];
+    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;
   }
-  parseWithSchema(value, schema, context) {
+}
+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 {
-      return schema.parse(value);
-    } catch (error) {
-      throw new RegistryBrokerParseError(
-        `Failed to parse ${context}`,
-        error instanceof ZodError || error instanceof Error ? error : String(error),
-        value
+      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
       );
     }
-  }
-  async delay(ms, signal) {
-    if (ms <= 0) {
-      if (signal?.aborted) {
-        throw createAbortError();
-      }
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (signal) {
-          signal.removeEventListener("abort", onAbort);
-        }
-        resolve();
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", onAbort);
-        reject(createAbortError());
-      };
-      if (signal) {
-        if (signal.aborted) {
-          clearTimeout(timer);
-          reject(createAbortError());
-          return;
-        }
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
+  } catch (error) {
+    logger.error("Error waiting for inscription confirmation", {
+      transactionId,
+      maxAttempts,
+      intervalMs,
+      error
     });
+    progressReporter.failed("Inscription confirmation failed", {
+      transactionId,
+      error
+    });
+    throw error;
   }
-  assertNodeRuntime(feature) {
-    if (typeof process === "undefined" || !process.versions?.node) {
-      throw new Error(`${feature} is only available in Node.js environments`);
-    }
-  }
-  getNodeCrypto(feature) {
-    this.assertNodeRuntime(feature);
-    const nodeCrypto = optionalImportSync("node:crypto") ?? optionalImportSync("crypto");
-    if (!nodeCrypto) {
-      throw new Error(`${feature} requires the Node.js crypto module`);
-    }
-    return nodeCrypto;
-  }
-  getSecureRandomBytes(size, feature) {
-    const webCrypto = globalThis.crypto;
-    if (webCrypto && typeof webCrypto.getRandomValues === "function") {
-      const bytes = new Uint8Array(size);
-      webCrypto.getRandomValues(bytes);
-      return bytes;
-    }
-    return this.getNodeCrypto(feature).randomBytes(size);
-  }
-  createEphemeralKeyPair() {
-    const privateKeyBytes = this.getSecureRandomBytes(
-      32,
-      "generateEphemeralKeyPair"
+}
+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 publicKey = secp256k1.getPublicKey(privateKeyBytes, true);
-    return {
-      privateKey: Buffer.from(privateKeyBytes).toString("hex"),
-      publicKey: Buffer.from(publicKey).toString("hex")
-    };
-  }
-  deriveSharedSecret(options) {
-    const { createHash } = this.getNodeCrypto("deriveSharedSecret");
-    const privateKey = this.hexToBuffer(options.privateKey);
-    const peerPublicKey = this.hexToBuffer(options.peerPublicKey);
-    const shared = secp256k1.getSharedSecret(privateKey, peerPublicKey, true);
-    return createHash("sha256").update(Buffer.from(shared)).digest();
   }
-  buildCipherEnvelope(options) {
-    const { createCipheriv, randomBytes } = this.getNodeCrypto(
-      "encryptCipherEnvelope"
-    );
-    const sharedSecret = this.normalizeSharedSecret(options.sharedSecret);
-    const iv = randomBytes(12);
-    const cipher = createCipheriv("aes-256-gcm", sharedSecret, iv);
-    const aadSource = options.associatedData ?? options.sessionId;
-    const associatedDataEncoded = aadSource ? Buffer.from(aadSource, "utf8").toString("base64") : void 0;
-    if (aadSource) {
-      cipher.setAAD(Buffer.from(aadSource, "utf8"));
+  logger.info("Starting inscription via Registry Broker", {
+    baseUrl,
+    inputType: input.type,
+    mode: options.mode ?? "file"
+  });
+  let base64Content;
+  let fileName;
+  let mimeType;
+  switch (input.type) {
+    case "url":
+      logger.debug("Creating job with URL input");
+      break;
+    case "file": {
+      const fileData = await convertFileToBase64(input.path);
+      base64Content = fileData.base64;
+      fileName = fileData.fileName;
+      mimeType = fileData.mimeType;
+      break;
+    }
+    case "buffer":
+      base64Content = Buffer.from(
+        input.buffer instanceof ArrayBuffer ? new Uint8Array(input.buffer) : input.buffer
+      ).toString("base64");
+      fileName = input.fileName;
+      mimeType = input.mimeType;
+      break;
+  }
+  const requestBody = {
+    inputType: input.type === "url" ? "url" : "base64",
+    mode: options.mode ?? "file"
+  };
+  if (input.type === "url") {
+    requestBody.url = input.url;
+  } else {
+    requestBody.base64 = base64Content;
+    requestBody.fileName = fileName;
+    if (mimeType) {
+      requestBody.mimeType = mimeType;
+    }
+  }
+  if (options.metadata) {
+    requestBody.metadata = options.metadata;
+  }
+  if (options.tags) {
+    requestBody.tags = options.tags;
+  }
+  if (options.fileStandard) {
+    requestBody.fileStandard = options.fileStandard;
+  }
+  if (options.chunkSize) {
+    requestBody.chunkSize = options.chunkSize;
+  }
+  logger.debug("Creating inscription job");
+  const job = await fetchRegistryBroker(
+    `${baseUrl}/inscribe/content`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody)
     }
-    const ciphertext = Buffer.concat([
-      cipher.update(Buffer.from(options.plaintext, "utf8")),
-      cipher.final()
-    ]);
-    const tag = cipher.getAuthTag();
-    const payload = Buffer.concat([ciphertext, tag]);
+  );
+  const jobId = job.jobId ?? job.id ?? "";
+  logger.info("Inscription job created", { jobId, status: job.status });
+  if (!waitForConfirmation) {
     return {
-      algorithm: "aes-256-gcm",
-      ciphertext: payload.toString("base64"),
-      nonce: iv.toString("base64"),
-      associatedData: associatedDataEncoded,
-      keyLocator: {
-        sessionId: options.sessionId,
-        revision: options.revision ?? 1
-      },
-      recipients: options.recipients.map((recipient) => ({
-        ...recipient,
-        encryptedShare: ""
-      }))
+      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
     };
   }
-  openCipherEnvelope(options) {
-    const { createDecipheriv } = this.getNodeCrypto("decryptCipherEnvelope");
-    const sharedSecret = this.normalizeSharedSecret(options.sharedSecret);
-    const payload = Buffer.from(options.envelope.ciphertext, "base64");
-    const nonce = Buffer.from(options.envelope.nonce, "base64");
-    const ciphertext = payload.slice(0, payload.length - 16);
-    const tag = payload.slice(payload.length - 16);
-    const decipher = createDecipheriv("aes-256-gcm", sharedSecret, nonce);
-    if (options.envelope.associatedData) {
-      decipher.setAAD(Buffer.from(options.envelope.associatedData, "base64"));
-    }
-    decipher.setAuthTag(tag);
-    const plaintext = Buffer.concat([
-      decipher.update(ciphertext),
-      decipher.final()
-    ]);
-    return plaintext.toString(options.encoding ?? "utf8");
-  }
-  normalizeSharedSecret(input) {
-    if (Buffer.isBuffer(input)) {
-      return Buffer.from(input);
-    }
-    if (input instanceof Uint8Array) {
-      return Buffer.from(input);
-    }
-    if (typeof input === "string") {
-      return this.bufferFromString(input);
-    }
-    throw new Error("Unsupported shared secret input");
-  }
-  bufferFromString(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      throw new Error("sharedSecret string cannot be empty");
-    }
-    const normalized = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
-    if (/^[0-9a-fA-F]+$/.test(normalized) && normalized.length % 2 === 0) {
-      return Buffer.from(normalized, "hex");
-    }
-    return Buffer.from(trimmed, "base64");
-  }
-  hexToBuffer(value) {
-    const normalized = value.startsWith("0x") ? value.slice(2) : value;
-    if (!/^[0-9a-fA-F]+$/.test(normalized) || normalized.length % 2 !== 0) {
-      throw new Error("Expected hex-encoded value");
-    }
-    return Buffer.from(normalized, "hex");
-  }
-  extractInsufficientCreditsDetails(error) {
-    if (!(error instanceof RegistryBrokerError) || error.status !== 402) {
-      return null;
-    }
-    const body = error.body;
-    if (!body || typeof body !== "object" || Array.isArray(body)) {
-      return null;
-    }
-    const maybeShortfall = body["shortfallCredits"];
-    if (typeof maybeShortfall !== "number" || maybeShortfall <= 0) {
-      return null;
-    }
-    return { shortfallCredits: maybeShortfall };
-  }
-  extractErrorMessage(body) {
-    if (typeof body === "string") {
-      return body;
-    }
-    if (isJsonObject(body) && typeof body.error === "string") {
-      return body.error;
+  logger.debug("Polling for job completion", { jobId, waitTimeoutMs });
+  const startTime = Date.now();
+  let lastStatus = "";
+  while (Date.now() - startTime < waitTimeoutMs) {
+    const currentJob = await fetchRegistryBroker(
+      `${baseUrl}/inscribe/content/${jobId}`,
+      { method: "GET", headers }
+    );
+    if (currentJob.status !== lastStatus) {
+      logger.debug("Job status update", { jobId, status: currentJob.status });
+      lastStatus = currentJob.status;
+    }
+    if (currentJob.status === "completed") {
+      logger.info("Inscription completed", {
+        jobId,
+        hrl: currentJob.hrl,
+        topicId: currentJob.topicId
+      });
+      return {
+        confirmed: true,
+        jobId,
+        status: currentJob.status,
+        hrl: currentJob.hrl,
+        topicId: currentJob.topicId,
+        network: currentJob.network,
+        credits: currentJob.credits ?? currentJob.quoteCredits,
+        usdCents: currentJob.usdCents ?? currentJob.quoteUsdCents,
+        sizeBytes: currentJob.sizeBytes,
+        createdAt: currentJob.createdAt,
+        updatedAt: currentJob.updatedAt
+      };
     }
-    if (isJsonObject(body) && typeof body.message === "string") {
-      return body.message;
+    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
+      };
     }
-    return void 0;
+    await sleep(pollIntervalMs);
   }
-  shouldAutoTopUpHistory(payload, error) {
-    if (!this.historyAutoTopUp || payload.historyTtlSeconds === void 0) {
-      return false;
-    }
-    if (!(error instanceof RegistryBrokerError)) {
-      return false;
-    }
-    if (error.status !== 402) {
-      return false;
-    }
-    const message = this.extractErrorMessage(error.body);
-    if (!message) {
-      return true;
-    }
-    const normalised = message.toLowerCase();
-    return normalised.includes("history") || normalised.includes("chat history");
+  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"
+    );
   }
-  async executeHistoryAutoTopUp(reason) {
-    if (!this.historyAutoTopUp) {
-      return;
+  let base64Content;
+  let fileName;
+  let mimeType;
+  switch (input.type) {
+    case "url":
+      break;
+    case "file": {
+      const fileData = await convertFileToBase64(input.path);
+      base64Content = fileData.base64;
+      fileName = fileData.fileName;
+      mimeType = fileData.mimeType;
+      break;
+    }
+    case "buffer":
+      base64Content = Buffer.from(
+        input.buffer instanceof ArrayBuffer ? new Uint8Array(input.buffer) : input.buffer
+      ).toString("base64");
+      fileName = input.fileName;
+      mimeType = input.mimeType;
+      break;
+  }
+  const requestBody = {
+    inputType: input.type === "url" ? "url" : "base64",
+    mode: options.mode ?? "file"
+  };
+  if (input.type === "url") {
+    requestBody.url = input.url;
+  } else {
+    requestBody.base64 = base64Content;
+    requestBody.fileName = fileName;
+    if (mimeType) {
+      requestBody.mimeType = mimeType;
+    }
+  }
+  if (options.metadata) {
+    requestBody.metadata = options.metadata;
+  }
+  if (options.tags) {
+    requestBody.tags = options.tags;
+  }
+  if (options.fileStandard) {
+    requestBody.fileStandard = options.fileStandard;
+  }
+  if (options.chunkSize) {
+    requestBody.chunkSize = options.chunkSize;
+  }
+  logger.debug("Getting inscription quote from Registry Broker");
+  return fetchRegistryBroker(
+    `${baseUrl}/inscribe/content/quote`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody)
     }
-    const hbarAmount = this.historyAutoTopUp.hbarAmount && this.historyAutoTopUp.hbarAmount > 0 ? this.historyAutoTopUp.hbarAmount : DEFAULT_HISTORY_TOP_UP_HBAR;
-    await this.purchaseCreditsWithHbar({
-      accountId: this.historyAutoTopUp.accountId,
-      privateKey: this.historyAutoTopUp.privateKey,
-      hbarAmount,
-      memo: this.historyAutoTopUp.memo ?? "registry-broker-client:chat-history-topup",
-      metadata: {
-        purpose: "chat-history",
-        reason
-      }
-    });
-  }
-  initializeEncryptionBootstrap(options) {
-    return this.bootstrapEncryptionOptions(options).then(() => void 0);
-  }
-  bootstrapEncryptionOptions(options) {
-    return bootstrapEncryptionOptions(this, options);
-  }
+  );
 }
-const isPendingRegisterAgentResponse = (response) => response.status === "pending";
-const isPartialRegisterAgentResponse = (response) => response.status === "partial" && response.success === false;
-const isSuccessRegisterAgentResponse = (response) => response.success === true && response.status !== "pending";
 export {
-  RegistryBrokerClient,
-  isPartialRegisterAgentResponse,
-  isPendingRegisterAgentResponse,
-  isSuccessRegisterAgentResponse
+  generateQuote,
+  getRegistryBrokerQuote,
+  inscribe,
+  inscribeViaRegistryBroker,
+  inscribeWithSigner,
+  normalizeTransactionId,
+  retrieveInscription,
+  waitForInscriptionConfirmation
 };
 //# sourceMappingURL=standards-sdk.es145.js.map