@hashgraphonline/standards-sdk 0.1.141 → 0.1.143

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

@@ -1,2174 +1,1570 @@
-import * as path from "node:path";
-import { Buffer } from "node:buffer";
-import { randomBytes, createHash, createCipheriv, createDecipheriv } from "node:crypto";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { canonicalizeLedgerNetwork } from "./standards-sdk.es129.js";
+import { PublicKey, Timestamp, AccountId } from "@hashgraph/sdk";
 import axios from "axios";
-import { privateKeyToAccount } from "viem/accounts";
-import "viem/chains";
-import { withPaymentInterceptor, decodeXPaymentResponse } from "x402-axios";
-import { createSigner } from "x402/types";
-import { searchResponseSchema, statsResponseSchema, registriesResponseSchema, additionalRegistryCatalogResponseSchema, popularResponseSchema, resolveResponseSchema, registerAgentResponseSchema, registrationQuoteResponseSchema, registrationProgressResponseSchema, creditPurchaseResponseSchema, x402MinimumsResponseSchema, x402CreditPurchaseResponseSchema, ledgerChallengeResponseSchema, ledgerVerifyResponseSchema, protocolsResponseSchema, detectProtocolResponseSchema, registrySearchByNamespaceSchema, vectorSearchResponseSchema, searchStatusResponseSchema, adapterDetailsResponseSchema, websocketStatsResponseSchema, metricsSummaryResponseSchema, uaidValidationResponseSchema, uaidConnectionStatusSchema, dashboardStatsResponseSchema, adaptersResponseSchema, searchFacetsResponseSchema, createSessionResponseSchema, chatHistorySnapshotResponseSchema, chatHistoryCompactionResponseSchema, sessionEncryptionStatusResponseSchema, encryptionHandshakeResponseSchema, registerEncryptionKeyResponseSchema, sendMessageResponseSchema } from "./standards-sdk.es137.js";
-import { ZodError } from "zod";
-import { createPrivateKeySigner } from "./standards-sdk.es128.js";
-const getFs = () => {
-  if (typeof require !== "function") {
-    return null;
-  }
-  try {
-    const fsModule = require("node:fs");
-    if (fsModule && typeof fsModule.existsSync === "function" && typeof fsModule.readFileSync === "function" && typeof fsModule.writeFileSync === "function" && typeof fsModule.appendFileSync === "function") {
-      return fsModule;
-    }
-  } catch {
-  }
-  return null;
-};
-const DEFAULT_USER_AGENT = "@hashgraphonline/standards-sdk/registry-broker-client";
-const DEFAULT_PROGRESS_INTERVAL_MS = 1500;
-const DEFAULT_PROGRESS_TIMEOUT_MS = 5 * 60 * 1e3;
-const createAbortError = () => typeof DOMException === "function" ? new DOMException("Aborted", "AbortError") : new Error("The operation was aborted");
-const normaliseHeaderName = (name) => name.trim().toLowerCase();
-const isBrowserRuntime = () => typeof window !== "undefined" && typeof window.fetch === "function";
-const DEFAULT_BASE_URL = "https://hol.org/registry/api/v1";
-const JSON_CONTENT_TYPE = /application\/json/i;
-const DEFAULT_HISTORY_TOP_UP_HBAR = 0.25;
-const MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS = 1;
-const toJsonValue = (value) => {
-  if (value === null) {
-    return null;
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => item === void 0 ? null : toJsonValue(item));
-  }
-  if (typeof value === "object") {
-    const result = {};
-    Object.entries(value).forEach(
-      ([key, entryValue]) => {
-        if (entryValue !== void 0) {
-          result[key] = toJsonValue(entryValue);
-        }
-      }
+import { Logger } from "./standards-sdk.es106.js";
+import { proto } from "@hashgraph/proto";
+class HederaMirrorNode {
+  constructor(network, logger, config) {
+    this.maxRetries = 5;
+    this.initialDelayMs = 2e3;
+    this.maxDelayMs = 3e4;
+    this.backoffFactor = 2;
+    this.network = network;
+    this.apiKey = config?.apiKey;
+    this.customHeaders = config?.headers || {};
+    this.baseUrl = config?.customUrl || this.getMirrorNodeUrl();
+    this.logger = logger || new Logger({
+      level: "debug",
+      module: "MirrorNode"
+    });
+    this.isServerEnvironment = typeof window === "undefined";
+    if (config?.customUrl) {
+      this.logger.info(`Using custom mirror node URL: ${config.customUrl}`);
+    }
+    if (config?.apiKey) {
+      this.logger.info("Using API key for mirror node requests");
+    }
+  }
+  /**
+   * Configures the retry mechanism for API requests.
+   * @param config The retry configuration.
+   */
+  configureRetry(config) {
+    this.maxRetries = config.maxRetries ?? this.maxRetries;
+    this.initialDelayMs = config.initialDelayMs ?? this.initialDelayMs;
+    this.maxDelayMs = config.maxDelayMs ?? this.maxDelayMs;
+    this.backoffFactor = config.backoffFactor ?? this.backoffFactor;
+    this.logger.info(
+      `Retry configuration updated: maxRetries=${this.maxRetries}, initialDelayMs=${this.initialDelayMs}, maxDelayMs=${this.maxDelayMs}, backoffFactor=${this.backoffFactor}`
     );
-    return result;
-  }
-  throw new TypeError("Only JSON-compatible values are supported");
-};
-const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const toJsonObject = (value) => {
-  const normalised = toJsonValue(value);
-  if (isJsonObject(normalised)) {
-    return normalised;
-  }
-  throw new TypeError("Expected JSON object value");
-};
-const serialiseAuthConfig = (auth) => {
-  const authPayload = {};
-  if (auth.type) {
-    authPayload.type = auth.type;
-  }
-  if (auth.token) {
-    authPayload.token = auth.token;
-  }
-  if (auth.username) {
-    authPayload.username = auth.username;
-  }
-  if (auth.password) {
-    authPayload.password = auth.password;
-  }
-  if (auth.headerName) {
-    authPayload.headerName = auth.headerName;
-  }
-  if (auth.headerValue) {
-    authPayload.headerValue = auth.headerValue;
-  }
-  if (auth.headers) {
-    authPayload.headers = { ...auth.headers };
-  }
-  return authPayload;
-};
-const serialiseAgentRegistrationRequest = (payload) => {
-  const body = {
-    profile: toJsonObject(payload.profile)
-  };
-  if (payload.endpoint !== void 0) {
-    body.endpoint = payload.endpoint;
-  }
-  if (payload.protocol !== void 0) {
-    body.protocol = payload.protocol;
-  }
-  if (payload.communicationProtocol !== void 0) {
-    body.communicationProtocol = payload.communicationProtocol;
-  }
-  if (payload.registry !== void 0) {
-    body.registry = payload.registry;
-  }
-  if (payload.additionalRegistries !== void 0) {
-    body.additionalRegistries = payload.additionalRegistries;
-  }
-  if (payload.metadata !== void 0) {
-    body.metadata = toJsonObject(payload.metadata);
-  }
-  return body;
-};
-const normalizeHexPrivateKey = (value) => {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    throw new Error("evmPrivateKey is required");
-  }
-  return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
-};
-class RegistryBrokerError extends Error {
-  constructor(message, details) {
-    super(message);
-    this.status = details.status;
-    this.statusText = details.statusText;
-    this.body = details.body;
-  }
-}
-class RegistryBrokerParseError extends Error {
-  constructor(message, cause, rawValue) {
-    super(message);
-    this.cause = cause;
-    this.rawValue = rawValue;
   }
-}
-function normaliseBaseUrl(input) {
-  const trimmed = input?.trim();
-  let baseCandidate = trimmed && trimmed.length > 0 ? trimmed : DEFAULT_BASE_URL;
-  try {
-    const url = new URL(baseCandidate.replace(/\/+$/, ""));
-    const hostname = url.hostname.toLowerCase();
-    const ensureRegistryPrefix = () => {
-      if (!url.pathname.startsWith("/registry")) {
-        url.pathname = url.pathname === "/" ? "/registry" : `/registry${url.pathname}`;
+  /**
+   * Updates the mirror node configuration.
+   * @param config The new mirror node configuration.
+   */
+  configureMirrorNode(config) {
+    if (config.customUrl) {
+      this.baseUrl = config.customUrl;
+      this.logger.info(`Updated mirror node URL: ${config.customUrl}`);
+    }
+    if (config.apiKey) {
+      this.apiKey = config.apiKey;
+      this.logger.info("Updated API key for mirror node requests");
+    }
+    if (config.headers) {
+      this.customHeaders = { ...this.customHeaders, ...config.headers };
+      this.logger.info("Updated custom headers for mirror node requests");
+    }
+  }
+  /**
+   * Constructs a full URL for API requests, handling custom providers with API keys in the path.
+   * @param endpoint The API endpoint (e.g., '/api/v1/accounts/0.0.123')
+   * @returns The full URL for the request
+   */
+  constructUrl(endpoint) {
+    if (this.baseUrl.includes("<API-KEY>") && this.apiKey) {
+      const baseUrlWithKey = this.baseUrl.replace("<API-KEY>", this.apiKey);
+      return endpoint.startsWith("/") ? `${baseUrlWithKey}${endpoint}` : `${baseUrlWithKey}/${endpoint}`;
+    }
+    return endpoint.startsWith("/") ? `${this.baseUrl}${endpoint}` : `${this.baseUrl}/${endpoint}`;
+  }
+  /**
+   * Returns the base URL for the Hedera mirror node based on the network type
+   * @returns The mirror node base URL
+   * @private
+   */
+  getMirrorNodeUrl() {
+    return this.network === "mainnet" ? "https://mainnet-public.mirrornode.hedera.com" : "https://testnet.mirrornode.hedera.com";
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Retrieves the public key for a given account ID from the mirror node.
+   * @param accountId The ID of the account to retrieve the public key for.
+   * @returns A promise that resolves to the public key for the given account.
+   * @throws An error if the account ID is invalid or the public key cannot be retrieved.
+   */
+  async getPublicKey(accountId) {
+    this.logger.debug(`Getting public key for account ${accountId}`);
+    const accountInfo = await this.requestAccount(accountId);
+    try {
+      if (!accountInfo || !accountInfo.key) {
+        throw new Error(
+          `Failed to retrieve public key for account ID: ${accountId}`
+        );
       }
-    };
-    if (hostname === "hol.org") {
-      ensureRegistryPrefix();
-      baseCandidate = url.toString();
-    } else if (hostname === "registry.hashgraphonline.com" || hostname === "hashgraphonline.com") {
-      ensureRegistryPrefix();
-      url.hostname = "hol.org";
-      baseCandidate = url.toString();
-    }
-  } catch {
-  }
-  const withoutTrailing = baseCandidate.replace(/\/+$/, "");
-  if (/\/api\/v\d+$/i.test(withoutTrailing)) {
-    return withoutTrailing;
-  }
-  if (/\/api$/i.test(withoutTrailing)) {
-    return `${withoutTrailing}/v1`;
-  }
-  return `${withoutTrailing}/api/v1`;
-}
-function buildSearchQuery(params) {
-  const query = new URLSearchParams();
-  const appendList = (key, values) => {
-    if (!values) {
-      return;
-    }
-    values.forEach((value) => {
-      if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed.length > 0) {
-          query.append(key, trimmed);
-        }
+      return PublicKey.fromString(accountInfo.key.key);
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error fetching public key from Mirror Node: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
+  /**
+   * Retrieves the memo for a given account ID from the mirror node.
+   * @param accountId The ID of the account to retrieve the memo for.
+   * @returns A promise that resolves to the memo for the given account.
+   * @throws An error if the account ID is invalid or the memo cannot be retrieved.
+   */
+  async getAccountMemo(accountId) {
+    this.logger.debug(`Getting account memo for account ID: ${accountId}`);
+    try {
+      const accountInfo = await this._requestWithRetry(
+        `/api/v1/accounts/${accountId}`
+      );
+      if (accountInfo?.memo) {
+        return accountInfo.memo;
       }
-    });
-  };
-  if (params.q) {
-    const trimmed = params.q.trim();
-    if (trimmed.length > 0) {
-      query.set("q", trimmed);
-    }
-  }
-  if (typeof params.page === "number") {
-    query.set("page", params.page.toString());
-  }
-  if (typeof params.limit === "number") {
-    query.set("limit", params.limit.toString());
-  }
-  if (params.registry) {
-    const trimmed = params.registry.trim();
-    if (trimmed.length > 0) {
-      query.set("registry", trimmed);
+      this.logger.warn(`No memo found for account ${accountId}`);
+      return null;
+    } catch (e) {
+      const error = e;
+      this.logger.error(
+        `Failed to get account memo for ${accountId} after retries: ${error.message}`
+      );
+      return null;
     }
   }
-  appendList("registries", params.registries);
-  if (typeof params.minTrust === "number") {
-    query.set("minTrust", params.minTrust.toString());
-  }
-  appendList("capabilities", params.capabilities);
-  appendList("protocols", params.protocols);
-  appendList("adapters", params.adapters);
-  if (params.metadata) {
-    Object.entries(params.metadata).forEach(([key, values]) => {
-      if (!key || !Array.isArray(values) || values.length === 0) {
-        return;
-      }
-      const trimmedKey = key.trim();
-      if (trimmedKey.length === 0) {
-        return;
-      }
-      values.forEach((value) => {
-        if (value === void 0 || value === null) {
-          return;
-        }
-        query.append(`metadata.${trimmedKey}`, String(value));
-      });
-    });
-  }
-  if (params.type) {
-    const trimmedType = params.type.trim();
-    if (trimmedType.length > 0 && trimmedType.toLowerCase() !== "all") {
-      query.set("type", trimmedType);
+  /**
+   * Retrieves topic information for a given topic ID from the mirror node.
+   * @param topicId The ID of the topic to retrieve information for.
+   * @returns A promise that resolves to the topic information.
+   * @throws An error if the topic ID is invalid or the information cannot be retrieved.
+   */
+  async getTopicInfo(topicId) {
+    try {
+      this.logger.debug(`Fetching topic info for ${topicId}`);
+      const data = await this._requestWithRetry(
+        `/api/v1/topics/${topicId}`
+      );
+      return data;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error retrieving topic information for ${topicId} after retries: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
+  /**
+   * Retrieves custom fees for a given topic ID from the mirror node.
+   * @param topicId The ID of the topic to retrieve custom fees for.
+   * @returns A promise that resolves to the custom fees for the given topic.
+   * @throws An error if the topic ID is invalid or the custom fees cannot be retrieved.
+   */
+  async getTopicFees(topicId) {
+    try {
+      const topicInfo = await this.getTopicInfo(topicId);
+      return topicInfo.custom_fees;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error retrieving topic fees: ${error.message}`;
+      this.logger.error(logMessage);
+      return null;
     }
   }
-  if (params.verified === true) {
-    query.set("verified", "true");
-  }
-  if (params.online === true) {
-    query.set("online", "true");
-  }
-  if (params.sortBy) {
-    const trimmedSort = params.sortBy.trim();
-    if (trimmedSort.length > 0) {
-      query.set("sortBy", trimmedSort);
+  /**
+   * Retrieves the current HBAR price from the mirror node.
+   * @param date The date to retrieve the HBAR price for.
+   * @returns A promise that resolves to the HBAR price for the given date.
+   * @throws An error if the date is invalid or the price cannot be retrieved.
+   */
+  async getHBARPrice(date) {
+    try {
+      const timestamp = Timestamp.fromDate(date).toString();
+      this.logger.debug(`Fetching HBAR price for timestamp ${timestamp}`);
+      const response = await this._requestWithRetry(
+        `/api/v1/network/exchangerate?timestamp=${timestamp}`
+      );
+      const usdPrice = Number(response?.current_rate?.cent_equivalent) / Number(response?.current_rate?.hbar_equivalent) / 100;
+      return usdPrice;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error retrieving HBAR price: ${error.message}`;
+      this.logger.error(logMessage);
+      return null;
     }
   }
-  if (params.sortOrder) {
-    const lowered = params.sortOrder.toLowerCase();
-    if (lowered === "asc" || lowered === "desc") {
-      query.set("sortOrder", lowered);
+  /**
+   * Retrieves token information for a given token ID from the mirror node.
+   * @param tokenId The ID of the token to retrieve information for.
+   * @returns A promise that resolves to the token information.
+   * @throws An error if the token ID is invalid or the information cannot be retrieved.
+   */
+  async getTokenInfo(tokenId) {
+    this.logger.debug(`Fetching token info for ${tokenId}`);
+    try {
+      const data = await this._requestWithRetry(
+        `/api/v1/tokens/${tokenId}`
+      );
+      if (data) {
+        this.logger.trace(`Token info found for ${tokenId}:`, data);
+        return data;
+      }
+      this.logger.warn(`No token info found for ${tokenId}`);
+      return null;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error fetching token info for ${tokenId}: ${error.message}`;
+      this.logger.error(logMessage);
+      return null;
     }
   }
-  const queryString = query.toString();
-  return queryString.length > 0 ? `?${queryString}` : "";
-}
-class RegistryBrokerClient {
-  constructor(options = {}) {
-    this.conversationContexts = /* @__PURE__ */ new Map();
-    this.request = async (path2, config) => {
-      const headers = new Headers();
-      Object.entries(this.defaultHeaders).forEach(([key, value]) => {
-        headers.set(key, value);
-      });
-      if (config.headers) {
-        Object.entries(config.headers).forEach(([key, value]) => {
-          headers.set(key, value);
-        });
-      }
-      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
-      };
-      if (config.body !== void 0) {
-        init.body = JSON.stringify(config.body);
-        if (!headers.has("content-type")) {
-          headers.set("content-type", "application/json");
+  /**
+   * Retrieves messages for a given topic ID from the mirror node. Supports filtering by sequence number
+   * based on the OpenAPI specification.
+   * @param topicId The ID of the topic to retrieve messages for.
+   * @param options Optional filtering parameters.
+   * @returns A promise that resolves to the messages for the given topic.
+   */
+  async getTopicMessages(topicId, options) {
+    this.logger.trace(
+      `Querying messages for topic ${topicId}${options ? " with filters" : ""}`
+    );
+    let endpoint = `/api/v1/topics/${topicId}/messages`;
+    const params = new URLSearchParams();
+    if (options) {
+      if (options.sequenceNumber !== void 0) {
+        const seqNum = typeof options.sequenceNumber === "number" ? options.sequenceNumber.toString() : options.sequenceNumber;
+        if (!seqNum.match(/^(gt|gte|lt|lte|eq|ne):/)) {
+          params.append("sequencenumber", `gt:${seqNum}`);
+        } else {
+          params.append("sequencenumber", seqNum);
         }
       }
-      const response = await this.fetchImpl(this.buildUrl(path2), init);
-      if (response.ok) {
-        return response;
+      if (options.limit) {
+        params.append("limit", options.limit.toString());
+      }
+      if (options.order) {
+        params.append("order", options.order);
       }
-      const errorBody = await this.extractErrorBody(response);
-      throw new RegistryBrokerError("Registry broker request failed", {
-        status: response.status,
-        statusText: response.statusText,
-        body: errorBody
-      });
-    };
-    this.baseUrl = normaliseBaseUrl(options.baseUrl);
-    const fetchCandidate = options.fetchImplementation ?? globalThis.fetch;
-    if (!fetchCandidate) {
-      throw new Error(
-        "A fetch implementation is required for RegistryBrokerClient"
-      );
-    }
-    this.fetchImpl = fetchCandidate;
-    this.defaultHeaders = {};
-    if (options.defaultHeaders) {
-      Object.entries(options.defaultHeaders).forEach(([name, value]) => {
-        if (typeof value === "string") {
-          this.setDefaultHeader(name, value);
-        }
-      });
     }
-    if (options.apiKey && options.apiKey.trim().length > 0) {
-      this.setApiKey(options.apiKey);
+    const queryString = params.toString();
+    if (queryString) {
+      endpoint += `?${queryString}`;
     }
-    if (options.ledgerApiKey && options.ledgerApiKey.trim().length > 0) {
-      this.setLedgerApiKey(options.ledgerApiKey);
+    const messages = [];
+    let nextEndpoint = endpoint;
+    while (nextEndpoint) {
+      try {
+        const data = await this._requestWithRetry(nextEndpoint);
+        if (data.messages && data.messages.length > 0) {
+          for (const message of data.messages) {
+            try {
+              if (!message.message) {
+                continue;
+              }
+              let messageContent;
+              try {
+                if (this.isServerEnvironment) {
+                  messageContent = Buffer.from(
+                    message.message,
+                    "base64"
+                  ).toString("utf-8");
+                } else {
+                  messageContent = new TextDecoder().decode(
+                    Uint8Array.from(
+                      atob(message.message),
+                      (c) => c.charCodeAt(0)
+                    )
+                  );
+                }
+              } catch (error) {
+                const logMessage = `Error decoding message: ${error}`;
+                this.logger.error(logMessage);
+                continue;
+              }
+              let messageJson;
+              try {
+                messageJson = JSON.parse(messageContent);
+              } catch (error) {
+                const logMessage = `Invalid JSON message content: ${messageContent}`;
+                this.logger.error(logMessage);
+                continue;
+              }
+              messageJson.sequence_number = message.sequence_number;
+              messages.push({
+                ...messageJson,
+                consensus_timestamp: message.consensus_timestamp,
+                sequence_number: message.sequence_number,
+                running_hash: message.running_hash,
+                running_hash_version: message.running_hash_version,
+                topic_id: message.topic_id,
+                payer: message.payer_account_id,
+                created: new Date(Number(message.consensus_timestamp) * 1e3)
+              });
+            } catch (error) {
+              const logMessage = `Error processing message: ${error.message}`;
+              this.logger.error(logMessage);
+            }
+          }
+        }
+        nextEndpoint = data.links?.next || "";
+      } catch (e) {
+        const error = e;
+        const logMessage = `Error querying topic messages for topic ${topicId} (endpoint: ${nextEndpoint}) after retries: ${error.message}`;
+        this.logger.error(logMessage);
+        throw new Error(logMessage);
+      }
     }
-    this.registrationAutoTopUp = options.registrationAutoTopUp;
-    this.historyAutoTopUp = options.historyAutoTopUp;
-    this.encryptedChatManager = new EncryptedChatManager(this);
-    this.encryptionOptions = options.encryption;
-    this.encryptionBootstrapPromise = this.bootstrapEncryptionOptions(
-      options.encryption
-    );
-    this.chat = {
-      start: (options2) => this.startChat(options2),
-      createSession: (payload) => this.createSession(payload),
-      sendMessage: (payload) => this.sendMessage(payload),
-      endSession: (sessionId) => this.endSession(sessionId),
-      getHistory: (sessionId, options2) => this.fetchHistorySnapshot(sessionId, options2),
-      compactHistory: (payload) => this.compactHistory(payload),
-      getEncryptionStatus: (sessionId) => this.fetchEncryptionStatus(sessionId),
-      submitEncryptionHandshake: (sessionId, payload) => this.postEncryptionHandshake(sessionId, payload),
-      startConversation: (opts) => this.startConversation(opts),
-      acceptConversation: (opts) => this.acceptConversation(opts)
-    };
-    this.encryption = {
-      registerKey: (payload) => this.registerEncryptionKey(payload),
-      generateEphemeralKeyPair: () => this.createEphemeralKeyPair(),
-      deriveSharedSecret: (options2) => this.deriveSharedSecret(options2),
-      encryptCipherEnvelope: (options2) => this.buildCipherEnvelope(options2),
-      decryptCipherEnvelope: (options2) => this.openCipherEnvelope(options2),
-      ensureAgentKey: (options2) => this.ensureAgentEncryptionKey(options2)
-    };
-    this.chat.createEncryptedSession = (options2) => this.encryptedChatManager.startSession(options2);
-    this.chat.acceptEncryptedSession = (options2) => this.encryptedChatManager.acceptSession(options2);
+    return messages;
   }
-  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 };
-  }
-  setApiKey(apiKey) {
-    this.setDefaultHeader("x-api-key", apiKey);
-  }
-  setLedgerApiKey(apiKey) {
-    this.setDefaultHeader("x-ledger-api-key", apiKey);
-  }
-  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;
+  /**
+   * Requests account information for a given account ID from the mirror node.
+   * @param accountId The ID of the account to retrieve information for.
+   * @returns A promise that resolves to the account information.
+   * @throws An error if the account ID is invalid or the information cannot be retrieved.
+   */
+  async requestAccount(accountId) {
+    try {
+      this.logger.debug(`Requesting account info for ${accountId}`);
+      const data = await this._requestWithRetry(
+        `/api/v1/accounts/${accountId}`
+      );
+      if (!data) {
+        throw new Error(
+          `No data received from mirror node for account: ${accountId}`
+        );
+      }
+      return data;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Failed to fetch account ${accountId} after retries: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
+  /**
+   * Checks if a user has access to a given key list.
+   * @param keyBytes The key list to check access for.
+   * @param userPublicKey The public key of the user to check access for.
+   * @returns A promise that resolves to true if the user has access, false otherwise.
+   */
+  async checkKeyListAccess(keyBytes, userPublicKey) {
+    try {
+      const key = proto.Key.decode(keyBytes);
+      return this.evaluateKeyAccess(key, userPublicKey);
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error decoding protobuf key: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
+  /**
+   * Evaluates the access of a given key to a user's public key.
+   * @param key The key to evaluate access for.
+   * @param userPublicKey The public key of the user to evaluate access for.
+   * @returns A promise that resolves to true if the key has access, false otherwise.
+   */
+  async evaluateKeyAccess(key, userPublicKey) {
+    if (key.ed25519) {
+      return this.compareEd25519Key(key.ed25519, userPublicKey);
+    }
+    if (key.keyList) {
+      return this.evaluateKeyList(key.keyList, userPublicKey);
+    }
+    if (key.thresholdKey && key.thresholdKey.keys) {
+      return this.evaluateKeyList(key.thresholdKey.keys, userPublicKey);
     }
-    this.defaultHeaders[headerName] = value.trim();
-  }
-  getDefaultHeaders() {
-    return { ...this.defaultHeaders };
+    return false;
   }
-  async encryptionReady() {
-    if (!this.encryptionBootstrapPromise) {
-      return;
+  /**
+   * Evaluates the access of a given key list to a user's public key.
+   * @param keyList The key list to evaluate access for.
+   * @param userPublicKey The public key of the user to evaluate access for.
+   * @returns A promise that resolves to true if the key list has access, false otherwise.
+   */
+  async evaluateKeyList(keyList, userPublicKey) {
+    const keys = keyList.keys || [];
+    for (const listKey of keys) {
+      if (!listKey) continue;
+      if (listKey.ed25519) {
+        if (this.compareEd25519Key(listKey.ed25519, userPublicKey)) {
+          return true;
+        }
+      } else if (listKey.keyList || listKey.thresholdKey) {
+        try {
+          const nestedKeyBytes = proto.Key.encode({
+            ...listKey.keyList ? { keyList: listKey.keyList } : {},
+            ...listKey.thresholdKey ? { thresholdKey: listKey.thresholdKey } : {}
+          }).finish();
+          const hasNestedAccess = await this.checkKeyListAccess(
+            Buffer.from(nestedKeyBytes),
+            userPublicKey
+          );
+          if (hasNestedAccess) {
+            return true;
+          }
+        } catch (e) {
+          const error = e;
+          const logMessage = `Error in nested key: ${error.message}`;
+          this.logger.debug(logMessage);
+        }
+      }
     }
-    await this.encryptionBootstrapPromise;
-  }
-  async search(params = {}) {
-    const query = buildSearchQuery(params);
-    const raw = await this.requestJson(`/search${query}`, {
-      method: "GET"
-    });
-    return this.parseWithSchema(raw, searchResponseSchema, "search response");
-  }
-  async stats() {
-    const raw = await this.requestJson("/stats", { method: "GET" });
-    return this.parseWithSchema(raw, statsResponseSchema, "stats response");
+    return false;
   }
-  async registries() {
-    const raw = await this.requestJson("/registries", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      registriesResponseSchema,
-      "registries response"
-    );
+  /**
+   * Compares an Ed25519 key with a user's public key.
+   * @param keyData The Ed25519 key data to compare.
+   * @param userPublicKey The public key of the user to compare with.
+   * @returns A boolean indicating whether the key matches the user's public key.
+   */
+  compareEd25519Key(keyData, userPublicKey) {
+    try {
+      const decodedKey = PublicKey.fromBytes(Buffer.from(keyData));
+      return decodedKey.toString() === userPublicKey.toString();
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error comparing Ed25519 key: ${error.message}`;
+      this.logger.debug(logMessage);
+      return false;
+    }
   }
-  async getAdditionalRegistries() {
-    const raw = await this.requestJson(
-      "/register/additional-registries",
-      {
-        method: "GET"
+  /**
+   * Retrieves information about a scheduled transaction
+   * @param scheduleId The ID of the scheduled transaction
+   * @returns A promise that resolves to the scheduled transaction information
+   */
+  async getScheduleInfo(scheduleId) {
+    try {
+      this.logger.info(
+        `Getting information for scheduled transaction ${scheduleId}`
+      );
+      const data = await this._requestWithRetry(
+        `/api/v1/schedules/${scheduleId}`
+      );
+      if (data) {
+        return data;
       }
-    );
-    return this.parseWithSchema(
-      raw,
-      additionalRegistryCatalogResponseSchema,
-      "additional registry catalog response"
-    );
-  }
-  bootstrapEncryptionOptions(options) {
-    if (!options?.autoRegister || options.autoRegister.enabled === false) {
+      this.logger.warn(
+        `No schedule info found for ${scheduleId} after retries.`
+      );
+      return null;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching schedule info for ${scheduleId} after retries: ${error.message}`
+      );
       return null;
     }
-    return this.autoRegisterEncryptionKey(options.autoRegister).then(
-      () => void 0
-    );
   }
-  async autoRegisterEncryptionKey(config) {
-    const identity = this.normalizeAutoRegisterIdentity(config);
-    if (!identity) {
-      throw new Error(
-        "Auto-registration requires uaid, ledgerAccountId, or email"
+  /**
+   * Checks the status of a scheduled transaction
+   * @param scheduleId The schedule ID to check
+   * @returns Status of the scheduled transaction
+   */
+  async getScheduledTransactionStatus(scheduleId) {
+    try {
+      this.logger.info(
+        `Checking status of scheduled transaction ${scheduleId}`
       );
-    }
-    const material = await this.resolveAutoRegisterKeyMaterial(config);
-    if (!material) {
-      throw new Error(
-        "Unable to resolve encryption public key for auto-registration"
+      const scheduleInfo = await this.getScheduleInfo(scheduleId);
+      if (!scheduleInfo) {
+        throw new Error(`Schedule ${scheduleId} not found`);
+      }
+      return {
+        executed: Boolean(scheduleInfo.executed_timestamp),
+        executedDate: scheduleInfo.executed_timestamp ? new Date(Number(scheduleInfo.executed_timestamp) * 1e3) : void 0,
+        deleted: scheduleInfo.deleted || false
+      };
+    } catch (error) {
+      this.logger.error(
+        `Error checking scheduled transaction status: ${error}`
       );
+      throw error;
     }
-    await this.registerEncryptionKey({
-      keyType: config.keyType ?? "secp256k1",
-      publicKey: material.publicKey,
-      ...identity
-    });
-    return material;
   }
-  normalizeAutoRegisterIdentity(config) {
-    const identity = {};
-    if (config.uaid) {
-      identity.uaid = config.uaid;
-    }
-    if (config.ledgerAccountId) {
-      identity.ledgerAccountId = config.ledgerAccountId;
-      if (config.ledgerNetwork) {
-        identity.ledgerNetwork = config.ledgerNetwork;
+  /**
+   * Retrieves details for a given transaction ID or hash from the mirror node.
+   * @param transactionIdOrHash The ID or hash of the transaction.
+   * @returns A promise that resolves to the transaction details.
+   * @throws An error if the transaction ID/hash is invalid or details cannot be retrieved.
+   */
+  async getTransaction(transactionIdOrHash) {
+    this.logger.info(
+      `Getting transaction details for ID/hash: ${transactionIdOrHash}`
+    );
+    try {
+      const response = await this._requestWithRetry(`/api/v1/transactions/${transactionIdOrHash}`);
+      if (response?.transactions?.length > 0) {
+        this.logger.trace(
+          `Transaction details found for ${transactionIdOrHash}:`,
+          response.transactions[0]
+        );
+        return response.transactions[0];
       }
+      this.logger.warn(
+        `No transaction details found for ${transactionIdOrHash} or unexpected response structure.`
+      );
+      return null;
+    } catch (e) {
+      const error = e;
+      this.logger.error(
+        `Failed to get transaction details for ${transactionIdOrHash} after retries: ${error.message}`
+      );
+      return null;
     }
-    if (config.email) {
-      identity.email = config.email;
-    }
-    if (identity.uaid || identity.ledgerAccountId || identity.email) {
-      return identity;
-    }
-    return null;
   }
-  async resolveAutoRegisterKeyMaterial(config) {
-    if (config.publicKey?.trim()) {
-      return { publicKey: config.publicKey.trim() };
-    }
-    let privateKey = config.privateKey?.trim();
-    const envVar = config.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-    if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {
-      privateKey = process.env[envVar]?.trim();
-    }
-    if (!privateKey && config.generateIfMissing) {
-      const pair = await this.generateEncryptionKeyPair({
-        keyType: config.keyType ?? "secp256k1",
-        envVar,
-        envPath: config.envPath,
-        overwrite: config.overwriteEnv
-      });
-      if (envVar) {
-        process.env[envVar] = pair.privateKey;
+  /**
+   * Private helper to make GET requests with retry logic using Axios.
+   */
+  async _requestWithRetry(endpoint, axiosConfig) {
+    let attempt = 0;
+    let delay = this.initialDelayMs;
+    const url = this.constructUrl(endpoint);
+    const config = {
+      ...axiosConfig,
+      headers: {
+        ...this.customHeaders,
+        ...axiosConfig?.headers
       }
-      return { publicKey: pair.publicKey, privateKey: pair.privateKey };
-    }
-    if (privateKey) {
-      const publicKey = this.derivePublicKeyFromPrivateKey(privateKey);
-      return { publicKey, privateKey };
+    };
+    if (this.apiKey) {
+      config.headers = {
+        ...config.headers,
+        Authorization: `Bearer ${this.apiKey}`,
+        "X-API-Key": this.apiKey
+      };
     }
-    return null;
-  }
-  derivePublicKeyFromPrivateKey(privateKey) {
-    const normalized = this.hexToBuffer(privateKey);
-    const publicKey = secp256k1.getPublicKey(normalized, true);
-    return Buffer.from(publicKey).toString("hex");
-  }
-  ensureAgentEncryptionKey(options) {
-    return this.autoRegisterEncryptionKey({
-      ...options,
-      uaid: options.uaid,
-      enabled: true
-    });
-  }
-  async popularSearches() {
-    const raw = await this.requestJson("/popular", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      popularResponseSchema,
-      "popular searches response"
-    );
-  }
-  async resolveUaid(uaid) {
-    const raw = await this.requestJson(
-      `/resolve/${encodeURIComponent(uaid)}`,
-      {
-        method: "GET"
-      }
-    );
-    return this.parseWithSchema(
-      raw,
-      resolveResponseSchema,
-      "resolve UAID response"
-    );
-  }
-  async performRegisterAgent(payload) {
-    const raw = await this.requestJson("/register", {
-      method: "POST",
-      body: serialiseAgentRegistrationRequest(payload),
-      headers: { "content-type": "application/json" }
-    });
-    return this.parseWithSchema(
-      raw,
-      registerAgentResponseSchema,
-      "register agent response"
-    );
-  }
-  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) {
+    while (attempt < this.maxRetries) {
       try {
-        return await this.performRegisterAgent(payload);
+        const response = await axios.get(url, config);
+        return response.data;
       } catch (error) {
-        const shortfall = this.extractInsufficientCreditsDetails(error);
-        if (shortfall && !retried) {
-          await this.ensureCreditsForRegistration(payload, autoTopUp);
-          retried = true;
-          continue;
+        attempt++;
+        const isLastAttempt = attempt >= this.maxRetries;
+        const statusCode = error.response?.status;
+        if (statusCode && statusCode > 404 && statusCode < 500 && statusCode !== 429) {
+          this.logger.error(
+            `Client error for ${url} (status ${statusCode}): ${error.message}. Not retrying.`
+          );
+          throw error;
+        }
+        if (isLastAttempt) {
+          this.logger.error(
+            `Max retries (${this.maxRetries}) reached for ${url}. Last error: ${error.message}`
+          );
+          throw error;
         }
-        throw error;
+        this.logger.warn(
+          `Attempt ${attempt}/${this.maxRetries} failed for ${url}: ${error.message}. Retrying in ${delay}ms...`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * this.backoffFactor, this.maxDelayMs);
       }
     }
-  }
-  async getRegistrationQuote(payload) {
-    const raw = await this.requestJson("/register/quote", {
-      method: "POST",
-      body: serialiseAgentRegistrationRequest(payload),
-      headers: { "content-type": "application/json" }
-    });
-    return this.parseWithSchema(
-      raw,
-      registrationQuoteResponseSchema,
-      "registration quote response"
+    throw new Error(
+      `Failed to fetch data from ${url} after ${this.maxRetries} attempts.`
     );
   }
-  async updateAgent(uaid, payload) {
-    const raw = await this.requestJson(
-      `/register/${encodeURIComponent(uaid)}`,
-      {
-        method: "PUT",
-        body: serialiseAgentRegistrationRequest(payload),
-        headers: { "content-type": "application/json" }
+  /**
+   * Private helper to make fetch requests with retry logic.
+   */
+  async _fetchWithRetry(url, fetchOptions) {
+    let attempt = 0;
+    let delay = this.initialDelayMs;
+    const headers = {
+      ...this.customHeaders
+    };
+    if (fetchOptions?.headers) {
+      if (fetchOptions.headers instanceof Headers) {
+        fetchOptions.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(fetchOptions.headers)) {
+        fetchOptions.headers.forEach(([key, value]) => {
+          headers[key] = value;
+        });
+      } else {
+        Object.assign(headers, fetchOptions.headers);
       }
-    );
-    return this.parseWithSchema(
-      raw,
-      registerAgentResponseSchema,
-      "update agent response"
-    );
-  }
-  async getRegistrationProgress(attemptId) {
-    const normalisedAttemptId = attemptId.trim();
-    if (!normalisedAttemptId) {
-      throw new Error("attemptId is required");
     }
-    try {
-      const raw = await this.requestJson(
-        `/register/progress/${encodeURIComponent(normalisedAttemptId)}`,
-        { method: "GET" }
-      );
-      const parsed = this.parseWithSchema(
-        raw,
-        registrationProgressResponseSchema,
-        "registration progress response"
-      );
-      return parsed.progress;
-    } catch (error) {
-      if (error instanceof RegistryBrokerError && error.status === 404) {
-        return null;
-      }
-      throw error;
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+      headers["X-API-Key"] = this.apiKey;
     }
-  }
-  async waitForRegistrationCompletion(attemptId, options = {}) {
-    const normalisedAttemptId = attemptId.trim();
-    if (!normalisedAttemptId) {
-      throw new Error("attemptId is required");
-    }
-    const interval = Math.max(
-      250,
-      options.intervalMs ?? DEFAULT_PROGRESS_INTERVAL_MS
-    );
-    const timeoutMs = options.timeoutMs ?? DEFAULT_PROGRESS_TIMEOUT_MS;
-    const throwOnFailure = options.throwOnFailure ?? true;
-    const signal = options.signal;
-    const startedAt = Date.now();
-    while (true) {
-      if (signal?.aborted) {
-        throw createAbortError();
-      }
-      const progress = await this.getRegistrationProgress(normalisedAttemptId);
-      if (progress) {
-        options.onProgress?.(progress);
-        if (progress.status === "completed") {
-          return progress;
-        }
-        if (progress.status === "partial" || progress.status === "failed") {
-          if (throwOnFailure) {
-            throw new RegistryBrokerError(
-              "Registration did not complete successfully",
-              {
-                status: 409,
-                statusText: progress.status,
-                body: progress
-              }
+    const options = {
+      ...fetchOptions,
+      headers
+    };
+    while (attempt < this.maxRetries) {
+      try {
+        const request = await fetch(url, options);
+        if (!request.ok) {
+          if (request.status >= 400 && request.status < 500 && request.status !== 429) {
+            this.logger.error(
+              `Client error for ${url} (status ${request.status}): ${request.statusText}. Not retrying.`
+            );
+            throw new Error(
+              `Fetch failed with status ${request.status}: ${request.statusText} for URL: ${url}`
             );
           }
-          return progress;
+          throw new Error(
+            `Fetch failed with status ${request.status}: ${request.statusText} for URL: ${url}`
+          );
         }
-      }
-      if (Date.now() - startedAt >= timeoutMs) {
-        throw new Error(
-          `Registration progress polling timed out after ${timeoutMs}ms`
+        const response = await request.json();
+        return response;
+      } catch (error) {
+        attempt++;
+        if (attempt >= this.maxRetries) {
+          this.logger.error(
+            `Max retries (${this.maxRetries}) reached for ${url}. Last error: ${error.message}`
+          );
+          throw error;
+        }
+        this.logger.warn(
+          `Attempt ${attempt}/${this.maxRetries} failed for ${url}: ${error.message}. Retrying in ${delay}ms...`
         );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * this.backoffFactor, this.maxDelayMs);
       }
-      await this.delay(interval, signal);
     }
-  }
-  async purchaseCreditsWithHbar(params) {
-    const body = {
-      accountId: params.accountId,
-      payerKey: params.privateKey,
-      hbarAmount: this.calculateHbarAmountParam(params.hbarAmount)
-    };
-    if (params.memo) {
-      body.memo = params.memo;
-    }
-    if (params.metadata) {
-      body.metadata = params.metadata;
-    }
-    const raw = await this.requestJson("/credits/purchase", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body
-    });
-    return this.parseWithSchema(
-      raw,
-      creditPurchaseResponseSchema,
-      "credit purchase response"
+    throw new Error(
+      `Failed to fetch data from ${url} after ${this.maxRetries} attempts.`
     );
   }
-  async getX402Minimums() {
-    const raw = await this.requestJson(
-      "/credits/purchase/x402/minimums",
-      { method: "GET" }
-    );
-    return this.parseWithSchema(
-      raw,
-      x402MinimumsResponseSchema,
-      "x402 minimums response"
-    );
-  }
-  async purchaseCreditsWithX402(params) {
-    if (!Number.isFinite(params.credits) || params.credits <= 0) {
-      throw new Error("credits must be a positive number");
-    }
-    if (params.usdAmount !== void 0 && (!Number.isFinite(params.usdAmount) || params.usdAmount <= 0)) {
-      throw new Error("usdAmount must be a positive number when provided");
-    }
-    const body = {
-      accountId: params.accountId,
-      credits: params.credits
-    };
-    if (params.usdAmount !== void 0) {
-      body.usdAmount = params.usdAmount;
-    }
-    if (params.description) {
-      body.description = params.description;
-    }
-    if (params.metadata) {
-      body.metadata = params.metadata;
-    }
-    const axiosClient = axios.create({
-      baseURL: this.baseUrl,
-      headers: {
-        ...this.getDefaultHeaders(),
-        "content-type": "application/json"
+  /**
+   * Retrieves the numerical balance (in HBAR) for a given account ID.
+   * @param accountId The ID of the account.
+   * @returns A promise that resolves to the HBAR balance or null if an error occurs.
+   */
+  async getAccountBalance(accountId) {
+    this.logger.info(`Getting balance for account ${accountId}`);
+    try {
+      const accountInfo = await this.requestAccount(accountId);
+      if (accountInfo && accountInfo.balance) {
+        const hbarBalance = accountInfo.balance.balance / 1e8;
+        return hbarBalance;
       }
-    });
-    const paymentClient = withPaymentInterceptor(
-      axiosClient,
-      params.walletClient
-    );
-    const response = await paymentClient.post("/credits/purchase/x402", body);
-    const parsed = this.parseWithSchema(
-      response.data,
-      x402CreditPurchaseResponseSchema,
-      "x402 credit purchase response"
-    );
-    const paymentHeader = typeof response.headers["x-payment-response"] === "string" ? response.headers["x-payment-response"] : void 0;
-    const decodedPayment = paymentHeader !== void 0 ? decodeXPaymentResponse(paymentHeader) : void 0;
-    return {
-      ...parsed,
-      paymentResponseHeader: paymentHeader,
-      paymentResponse: decodedPayment
-    };
-  }
-  async buyCreditsWithX402(params) {
-    const network = params.network ?? "base";
-    const normalizedKey = normalizeHexPrivateKey(params.evmPrivateKey);
-    const walletClient = await createSigner(network, normalizedKey);
-    return this.purchaseCreditsWithX402({
-      accountId: params.accountId,
-      credits: params.credits,
-      usdAmount: params.usdAmount,
-      description: params.description,
-      metadata: params.metadata,
-      walletClient
-    });
-  }
-  calculateHbarAmount(creditsToPurchase, creditsPerHbar) {
-    if (creditsPerHbar <= 0) {
-      throw new Error("creditsPerHbar must be positive");
-    }
-    if (creditsToPurchase <= 0) {
-      throw new Error("creditsToPurchase must be positive");
+      this.logger.warn(
+        `Could not retrieve balance for account ${accountId} from account info.`
+      );
+      return null;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching numerical balance for account ${accountId}: ${error.message}`
+      );
+      return null;
     }
-    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
+  /**
+   * Retrieves messages for a given topic ID with optional filters.
+   * @param topicId The ID of the topic.
+   * @param sequenceNumber Filter by sequence number (e.g., "gt:10", "lte:20").
+   * @param startTime Filter by consensus timestamp (e.g., "gt:1629400000.000000000").
+   * @param endTime Filter by consensus timestamp (e.g., "lt:1629500000.000000000").
+   * @param limit The maximum number of messages to return.
+   * @returns A promise that resolves to an array of HCSMessages or null.
+   */
+  async getTopicMessagesByFilter(topicId, options) {
+    this.logger.trace(
+      `Querying messages for topic ${topicId} with filters: ${JSON.stringify(
+        options
+      )}`
     );
-  }
-  calculateHbarAmountParam(hbarAmount) {
-    const tinybars = Math.ceil(hbarAmount * 1e8);
-    if (tinybars <= 0) {
-      throw new Error("Calculated purchase amount must be positive");
+    let nextUrl = `/api/v1/topics/${topicId}/messages`;
+    const params = new URLSearchParams();
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
     }
-    return tinybars / 1e8;
-  }
-  shouldAutoTopUpHistory(payload, error) {
-    if (!this.historyAutoTopUp || payload.historyTtlSeconds === void 0) {
-      return false;
+    if (options?.sequenceNumber) {
+      params.append("sequencenumber", options.sequenceNumber);
     }
-    if (!(error instanceof RegistryBrokerError)) {
-      return false;
+    if (options?.startTime) {
+      params.append("timestamp", `gte:${options.startTime}`);
     }
-    if (error.status !== 402) {
-      return false;
+    if (options?.endTime) {
+      params.append("timestamp", `lt:${options.endTime}`);
     }
-    const message = this.extractErrorMessage(error.body);
-    if (!message) {
-      return true;
+    if (options?.order) {
+      params.append("order", options.order);
     }
-    const normalised = message.toLowerCase();
-    return normalised.includes("history") || normalised.includes("chat history");
-  }
-  extractErrorMessage(body) {
-    if (typeof body === "string") {
-      return body;
+    const queryString = params.toString();
+    if (queryString) {
+      nextUrl += `?${queryString}`;
     }
-    if (isJsonObject(body) && typeof body.error === "string") {
-      return body.error;
-    }
-    if (isJsonObject(body) && typeof body.message === "string") {
-      return body.message;
-    }
-    return void 0;
-  }
-  async executeHistoryAutoTopUp(reason) {
-    if (!this.historyAutoTopUp) {
-      return;
-    }
-    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
-      }
-    });
-  }
-  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 messages = [];
+    let pagesFetched = 0;
+    const maxPages = 10;
+    try {
+      while (nextUrl && pagesFetched < maxPages) {
+        pagesFetched++;
+        const data = await this._requestWithRetry(nextUrl);
+        if (data.messages && data.messages.length > 0) {
+          for (const message of data.messages) {
+            try {
+              if (!message.message) {
+                continue;
+              }
+              let messageContent;
+              if (this.isServerEnvironment) {
+                messageContent = Buffer.from(
+                  message.message,
+                  "base64"
+                ).toString("utf-8");
+              } else {
+                messageContent = new TextDecoder().decode(
+                  Uint8Array.from(atob(message.message), (c) => c.charCodeAt(0))
+                );
+              }
+              let messageJson = {};
+              try {
+                messageJson = JSON.parse(messageContent);
+              } catch (parseError) {
+                this.logger.debug(
+                  `Message content is not valid JSON, using raw: ${messageContent}`
+                );
+                messageJson = { raw_content: messageContent };
+              }
+              const parsedContent = messageJson;
+              const hcsMsg = {
+                ...parsedContent,
+                consensus_timestamp: message.consensus_timestamp,
+                sequence_number: message.sequence_number,
+                payer_account_id: message.payer_account_id,
+                topic_id: message.topic_id,
+                running_hash: message.running_hash,
+                running_hash_version: message.running_hash_version,
+                chunk_info: message.chunk_info,
+                created: new Date(
+                  Number(message.consensus_timestamp.split(".")[0]) * 1e3 + Number(message.consensus_timestamp.split(".")[1] || 0) / 1e6
+                ),
+                payer: message.payer_account_id
+              };
+              messages.push(hcsMsg);
+            } catch (error) {
+              this.logger.error(
+                `Error processing individual message: ${error.message}`
+              );
+            }
+          }
+        }
+        if (options?.limit && messages.length >= options.limit) break;
+        nextUrl = data.links?.next ? `${data.links.next}` : "";
       }
-      const hbarAmount = this.calculateHbarAmount(
-        creditsToPurchase,
-        creditsPerHbar
+      return messages;
+    } catch (e) {
+      const error = e;
+      this.logger.error(
+        `Error querying filtered topic messages for ${topicId}: ${error.message}`
       );
-      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
-        }
-      });
-    }
-    const finalQuote = await this.getRegistrationQuote(payload);
-    if ((finalQuote.shortfallCredits ?? 0) > 0) {
-      throw new Error("Unable to purchase sufficient credits for registration");
-    }
-  }
-  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 };
-  }
-  async createLedgerChallenge(payload) {
-    const resolvedNetwork = canonicalizeLedgerNetwork(payload.network);
-    const network = resolvedNetwork.kind === "hedera" ? resolvedNetwork.hederaNetwork ?? resolvedNetwork.canonical : resolvedNetwork.canonical;
-    const raw = await this.requestJson("/auth/ledger/challenge", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: {
-        accountId: payload.accountId,
-        network
-      }
-    });
-    return this.parseWithSchema(
-      raw,
-      ledgerChallengeResponseSchema,
-      "ledger challenge response"
-    );
-  }
-  async verifyLedgerChallenge(payload) {
-    const resolvedNetwork = canonicalizeLedgerNetwork(payload.network);
-    const network = resolvedNetwork.kind === "hedera" ? resolvedNetwork.hederaNetwork ?? resolvedNetwork.canonical : resolvedNetwork.canonical;
-    const body = {
-      challengeId: payload.challengeId,
-      accountId: payload.accountId,
-      network,
-      signature: payload.signature
-    };
-    if (payload.signatureKind) {
-      body.signatureKind = payload.signatureKind;
-    }
-    if (payload.publicKey) {
-      body.publicKey = payload.publicKey;
-    }
-    if (typeof payload.expiresInMinutes === "number") {
-      body.expiresInMinutes = payload.expiresInMinutes;
-    }
-    const raw = await this.requestJson("/auth/ledger/verify", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body
-    });
-    const result = this.parseWithSchema(
-      raw,
-      ledgerVerifyResponseSchema,
-      "ledger verification response"
-    );
-    this.setLedgerApiKey(result.key);
-    return result;
-  }
-  async authenticateWithLedger(options) {
-    const challenge = await this.createLedgerChallenge({
-      accountId: options.accountId,
-      network: options.network
-    });
-    const signed = await this.resolveLedgerAuthSignature(
-      challenge.message,
-      options
-    );
-    const verification = await this.verifyLedgerChallenge({
-      challengeId: challenge.challengeId,
-      accountId: options.accountId,
-      network: options.network,
-      signature: signed.signature,
-      signatureKind: signed.signatureKind,
-      publicKey: signed.publicKey,
-      expiresInMinutes: options.expiresInMinutes
-    });
-    return verification;
   }
-  async resolveLedgerAuthSignature(message, options) {
-    if (typeof options.sign === "function") {
-      const result = await options.sign(message);
-      if (!result || typeof result.signature !== "string" || result.signature.length === 0) {
-        throw new Error("Custom ledger signer failed to produce a signature.");
+  /**
+   * Retrieves token balances for a given account ID.
+   * @param accountId The ID of the account.
+   * @param limit The maximum number of tokens to return.
+   * @returns A promise that resolves to an array of AccountTokenBalance or null.
+   */
+  async getAccountTokens(accountId, limit = 100) {
+    this.logger.info(`Getting tokens for account ${accountId}`);
+    let allTokens = [];
+    let endpoint = `/api/v1/accounts/${accountId}/tokens?limit=${limit}`;
+    try {
+      for (let i = 0; i < 10 && endpoint; i++) {
+        const response = await this._requestWithRetry(endpoint);
+        if (response && response.tokens) {
+          allTokens = allTokens.concat(response.tokens);
+        }
+        endpoint = response.links?.next || "";
+        if (!endpoint || limit && allTokens.length >= limit) {
+          if (limit && allTokens.length > limit) {
+            allTokens = allTokens.slice(0, limit);
+          }
+          break;
+        }
       }
-      return result;
-    }
-    if (!options.signer || typeof options.signer.sign !== "function") {
-      throw new Error(
-        "Ledger authentication requires a Hedera Signer or custom sign function."
+      return allTokens;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching tokens for account ${accountId}: ${error.message}`
       );
+      return null;
     }
-    const payload = Buffer.from(message, "utf8");
-    const signatures = await options.signer.sign([payload]);
-    const signatureEntry = signatures?.[0];
-    if (!signatureEntry) {
-      throw new Error("Signer did not return any signatures.");
-    }
-    let derivedPublicKey;
-    if (signatureEntry.publicKey) {
-      derivedPublicKey = signatureEntry.publicKey.toString();
-    } else if (typeof options.signer.getAccountKey === "function") {
-      const accountKey = await options.signer.getAccountKey();
-      if (accountKey && typeof accountKey.toString === "function") {
-        derivedPublicKey = accountKey.toString();
-      }
-    }
-    return {
-      signature: Buffer.from(signatureEntry.signature).toString("base64"),
-      signatureKind: "raw",
-      publicKey: derivedPublicKey
-    };
   }
-  async authenticateWithLedgerCredentials(options) {
-    const {
-      accountId,
-      network,
-      signer,
-      sign,
-      hederaPrivateKey,
-      evmPrivateKey,
-      expiresInMinutes,
-      setAccountHeader = true,
-      label,
-      logger
-    } = options;
-    const resolvedNetwork = canonicalizeLedgerNetwork(network);
-    const labelSuffix = label ? ` for ${label}` : "";
-    const networkPayload = resolvedNetwork.canonical;
-    const authOptions = {
-      accountId,
-      network: networkPayload,
-      expiresInMinutes
-    };
-    if (sign) {
-      authOptions.sign = sign;
-    } else if (signer) {
-      authOptions.signer = signer;
-    } else if (hederaPrivateKey) {
-      if (resolvedNetwork.kind !== "hedera" || !resolvedNetwork.hederaNetwork) {
-        throw new Error(
-          "hederaPrivateKey can only be used with hedera:mainnet or hedera:testnet networks."
-        );
-      }
-      authOptions.signer = createPrivateKeySigner({
-        accountId,
-        privateKey: hederaPrivateKey,
-        network: resolvedNetwork.hederaNetwork
-      });
-    } else if (evmPrivateKey) {
-      if (resolvedNetwork.kind !== "evm") {
-        throw new Error(
-          "evmPrivateKey can only be used with CAIP-2 EVM networks (eip155:<chainId>)."
-        );
-      }
-      const formattedKey = evmPrivateKey.startsWith("0x") ? evmPrivateKey : `0x${evmPrivateKey}`;
-      const account = privateKeyToAccount(formattedKey);
-      authOptions.sign = async (message) => ({
-        signature: await account.signMessage({ message }),
-        signatureKind: "evm",
-        publicKey: account.publicKey
-      });
-    } else {
-      throw new Error(
-        "Provide a signer, sign function, hederaPrivateKey, or evmPrivateKey to authenticate with the ledger."
+  /**
+   * Retrieves transaction details by consensus timestamp.
+   * @param timestamp The consensus timestamp of the transaction (e.g., "1629400000.000000000").
+   * @returns A promise that resolves to the transaction details or null.
+   */
+  async getTransactionByTimestamp(timestamp) {
+    this.logger.info(`Getting transaction by timestamp: ${timestamp}`);
+    try {
+      const response = await this._requestWithRetry(`/api/v1/transactions?timestamp=${timestamp}&limit=1`);
+      return response.transactions;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching transaction by timestamp ${timestamp}: ${error}`
       );
-    }
-    logger?.info?.(
-      `Authenticating ledger account ${accountId} (${resolvedNetwork.canonical})${labelSuffix}...`
+      return [];
+    }
+  }
+  /**
+   * Retrieves NFTs for a given account ID, optionally filtered by token ID.
+   * @param accountId The ID of the account.
+   * @param tokenId Optional ID of the token to filter NFTs by.
+   * @param limit The maximum number of NFTs to return per page (API has its own max).
+   * @returns A promise that resolves to an array of NftDetail or null.
+   */
+  async getAccountNfts(accountId, tokenId, limit = 100) {
+    this.logger.info(
+      `Getting NFTs for account ${accountId}${tokenId ? ` for token ${tokenId}` : ""}`
     );
-    const verification = await this.authenticateWithLedger(authOptions);
-    if (setAccountHeader) {
-      this.setDefaultHeader("x-account-id", verification.accountId);
+    let allNfts = [];
+    let endpoint = `/api/v1/accounts/${accountId}/nfts?limit=${limit}`;
+    if (tokenId) {
+      endpoint += `&token.id=${tokenId}`;
     }
-    logger?.info?.(
-      `Ledger authentication complete${labelSuffix}. Issued key prefix: ${verification.apiKey.prefix}…${verification.apiKey.lastFour}`
-    );
-    return verification;
-  }
-  async listProtocols() {
-    const raw = await this.requestJson("/protocols", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      protocolsResponseSchema,
-      "protocols response"
-    );
-  }
-  async detectProtocol(message) {
-    const raw = await this.requestJson("/detect-protocol", {
-      method: "POST",
-      body: { message },
-      headers: { "content-type": "application/json" }
-    });
-    return this.parseWithSchema(
-      raw,
-      detectProtocolResponseSchema,
-      "detect protocol response"
-    );
-  }
-  async registrySearchByNamespace(registry, query) {
-    const params = new URLSearchParams();
-    if (query) {
-      params.set("q", query);
-    }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(
-      `/registries/${encodeURIComponent(registry)}/search${suffix}`,
-      {
-        method: "GET"
-      }
-    );
-    return this.parseWithSchema(
-      raw,
-      registrySearchByNamespaceSchema,
-      "registry search response"
-    );
-  }
-  async vectorSearch(request) {
     try {
-      const raw = await this.requestJson("/search", {
-        method: "POST",
-        body: request,
-        headers: { "content-type": "application/json" }
-      });
-      return this.parseWithSchema(
-        raw,
-        vectorSearchResponseSchema,
-        "vector search response"
-      );
-    } catch (error) {
-      if (error instanceof RegistryBrokerError && error.status === 501) {
-        const fallback = await this.search(
-          this.buildVectorFallbackSearchParams(request)
-        );
-        return this.convertSearchResultToVectorResponse(fallback);
+      for (let i = 0; i < 10 && endpoint; i++) {
+        const response = await this._requestWithRetry(endpoint);
+        if (response && response.nfts) {
+          const nftsWithUri = response.nfts.map((nft) => {
+            let tokenUri = void 0;
+            if (nft.metadata) {
+              try {
+                if (this.isServerEnvironment) {
+                  tokenUri = Buffer.from(nft.metadata, "base64").toString(
+                    "utf-8"
+                  );
+                } else {
+                  tokenUri = new TextDecoder().decode(
+                    Uint8Array.from(atob(nft.metadata), (c) => c.charCodeAt(0))
+                  );
+                }
+              } catch (e) {
+                this.logger.warn(
+                  `Failed to decode metadata for NFT ${nft.token_id} SN ${nft.serial_number}: ${e.message}`
+                );
+              }
+            }
+            return { ...nft, token_uri: tokenUri };
+          });
+          allNfts = allNfts.concat(nftsWithUri);
+        }
+        endpoint = response.links?.next || "";
+        if (!endpoint) break;
       }
-      throw error;
+      return allNfts;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching NFTs for account ${accountId}: ${error.message}`
+      );
+      return null;
     }
   }
-  async searchStatus() {
-    const raw = await this.requestJson("/search/status", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      searchStatusResponseSchema,
-      "search status response"
-    );
-  }
-  async adaptersDetailed() {
-    const raw = await this.requestJson("/adapters/details", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      adapterDetailsResponseSchema,
-      "adapter details response"
-    );
-  }
-  async websocketStats() {
-    const raw = await this.requestJson("/websocket/stats", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      websocketStatsResponseSchema,
-      "websocket stats response"
-    );
-  }
-  async metricsSummary() {
-    const raw = await this.requestJson("/metrics", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      metricsSummaryResponseSchema,
-      "metrics summary response"
-    );
-  }
-  async validateUaid(uaid) {
-    const raw = await this.requestJson(
-      `/uaids/validate/${encodeURIComponent(uaid)}`,
-      {
-        method: "GET"
-      }
+  /**
+   * Validates NFT ownership by checking if a specific serial number of a token ID exists for an account.
+   * @param accountId The ID of the account.
+   * @param tokenId The ID of the NFT's token.
+   * @param serialNumber The serial number of the NFT.
+   * @returns A promise that resolves to the NftDetail if owned, or null otherwise.
+   */
+  async validateNFTOwnership(accountId, tokenId, serialNumber) {
+    this.logger.info(
+      `Validating ownership of NFT ${tokenId} SN ${serialNumber} for account ${accountId}`
     );
-    return this.parseWithSchema(
-      raw,
-      uaidValidationResponseSchema,
-      "UAID validation response"
-    );
-  }
-  async getUaidConnectionStatus(uaid) {
-    const raw = await this.requestJson(
-      `/uaids/connections/${encodeURIComponent(uaid)}/status`,
-      {
-        method: "GET"
+    try {
+      const nfts = await this.getAccountNfts(accountId, tokenId);
+      if (nfts) {
+        const foundNft = nfts.find(
+          (nft) => nft.token_id === tokenId && nft.serial_number === serialNumber
+        );
+        return foundNft || null;
       }
-    );
-    return this.parseWithSchema(
-      raw,
-      uaidConnectionStatusSchema,
-      "UAID connection status"
-    );
-  }
-  async closeUaidConnection(uaid) {
-    await this.request(`/uaids/connections/${encodeURIComponent(uaid)}`, {
-      method: "DELETE"
-    });
+      return null;
+    } catch (error) {
+      this.logger.error(`Error validating NFT ownership: ${error.message}`);
+      return null;
+    }
   }
-  async dashboardStats() {
-    const raw = await this.requestJson("/dashboard/stats", {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      dashboardStatsResponseSchema,
-      "dashboard stats response"
+  /**
+   * Performs a read-only query against a smart contract (eth_call like).
+   * @param contractIdOrAddress The contract ID (e.g., "0.0.123") or EVM address (e.g., "0x...").
+   * @param functionSelector The function selector and encoded parameters (e.g., "0xabcdef12...").
+   * @param payerAccountId The account ID of the payer (not strictly payer for read-only, but often required as 'from').
+   * @param estimate Whether this is an estimate call. Mirror node might not support this directly in /contracts/call for true estimation.
+   * @param block Block parameter, e.g., "latest", "pending", or block number.
+   * @param value The value in tinybars to send with the call (for payable view/pure functions, usually 0).
+   * @returns A promise that resolves to the contract call query response or null.
+   */
+  async readSmartContractQuery(contractIdOrAddress, functionSelector, payerAccountId, options) {
+    this.logger.info(
+      `Reading smart contract ${contractIdOrAddress} with selector ${functionSelector}`
     );
-  }
-  async adapters() {
-    const raw = await this.requestJson("/adapters", {
-      method: "GET"
+    const toAddress = contractIdOrAddress.startsWith("0x") ? contractIdOrAddress : `0x${AccountId.fromString(contractIdOrAddress).toSolidityAddress()}`;
+    const fromAddress = payerAccountId.startsWith("0x") ? payerAccountId : `0x${AccountId.fromString(payerAccountId).toSolidityAddress()}`;
+    const body = {
+      block: options?.block || "latest",
+      data: functionSelector,
+      estimate: options?.estimate || false,
+      from: fromAddress,
+      to: toAddress,
+      gas: options?.gas,
+      gasPrice: options?.gasPrice,
+      value: options?.value || 0
+    };
+    Object.keys(body).forEach((key) => {
+      const K = key;
+      if (body[K] === void 0) {
+        delete body[K];
+      }
     });
-    return this.parseWithSchema(
-      raw,
-      adaptersResponseSchema,
-      "adapters response"
-    );
-  }
-  async facets(adapter) {
-    const params = new URLSearchParams();
-    if (adapter) {
-      params.set("adapter", adapter);
+    try {
+      const url = this.constructUrl("/api/v1/contracts/call");
+      const response = await this._fetchWithRetry(
+        url,
+        {
+          method: "POST",
+          body: JSON.stringify(body),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error reading smart contract ${contractIdOrAddress}: ${error.message}`
+      );
+      return null;
     }
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const raw = await this.requestJson(`/search/facets${suffix}`, {
-      method: "GET"
-    });
-    return this.parseWithSchema(
-      raw,
-      searchFacetsResponseSchema,
-      "search facets response"
-    );
   }
-  async createSession(payload, allowHistoryAutoTopUp = true) {
-    const body = {};
-    if ("uaid" in payload && payload.uaid) {
-      body.uaid = payload.uaid;
+  /**
+   * Retrieves outstanding token airdrops sent by an account.
+   * @param accountId The ID of the account that sent the airdrops.
+   * @param options Optional parameters for filtering airdrops.
+   * @returns A promise that resolves to an array of TokenAirdrop or null.
+   */
+  async getOutstandingTokenAirdrops(accountId, options) {
+    this.logger.info(
+      `Getting outstanding token airdrops sent by account ${accountId}`
+    );
+    let endpoint = `/api/v1/accounts/${accountId}/airdrops/outstanding`;
+    const params = new URLSearchParams();
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
     }
-    if ("agentUrl" in payload && payload.agentUrl) {
-      body.agentUrl = payload.agentUrl;
+    if (options?.order) {
+      params.append("order", options.order);
     }
-    if (payload.auth) {
-      body.auth = serialiseAuthConfig(payload.auth);
+    if (options?.receiverId) {
+      params.append("receiver.id", options.receiverId);
     }
-    if (payload.historyTtlSeconds !== void 0) {
-      body.historyTtlSeconds = payload.historyTtlSeconds;
+    if (options?.serialNumber) {
+      params.append("serialnumber", options.serialNumber);
     }
-    if (payload.encryptionRequested !== void 0) {
-      body.encryptionRequested = payload.encryptionRequested;
+    if (options?.tokenId) {
+      params.append("token.id", options.tokenId);
     }
-    if (payload.senderUaid) {
-      body.senderUaid = payload.senderUaid;
+    const queryString = params.toString();
+    if (queryString) {
+      endpoint += `?${queryString}`;
     }
     try {
-      const raw = await this.requestJson("/chat/session", {
-        method: "POST",
-        body,
-        headers: { "content-type": "application/json" }
-      });
-      return this.parseWithSchema(
-        raw,
-        createSessionResponseSchema,
-        "chat session response"
-      );
+      const response = await this._requestWithRetry(endpoint);
+      return response.airdrops || [];
     } catch (error) {
-      if (allowHistoryAutoTopUp && this.shouldAutoTopUpHistory(payload, error)) {
-        await this.executeHistoryAutoTopUp("chat.session");
-        return this.createSession(payload, false);
-      }
-      throw error;
-    }
-  }
-  async startChat(options) {
-    if ("uaid" in options && options.uaid) {
-      return this.startConversation({
-        uaid: options.uaid,
-        senderUaid: options.senderUaid,
-        historyTtlSeconds: options.historyTtlSeconds,
-        auth: options.auth,
-        encryption: options.encryption,
-        onSessionCreated: options.onSessionCreated
-      });
-    }
-    if ("agentUrl" in options && options.agentUrl) {
-      const session = await this.createSession({
-        agentUrl: options.agentUrl,
-        auth: options.auth,
-        historyTtlSeconds: options.historyTtlSeconds,
-        senderUaid: options.senderUaid
-      });
-      options.onSessionCreated?.(session.sessionId);
-      return this.createPlaintextConversationHandle(
-        session.sessionId,
-        session.encryption ?? null,
-        options.auth,
-        { agentUrl: options.agentUrl, uaid: options.uaid }
+      this.logger.error(
+        `Error fetching outstanding token airdrops for account ${accountId}: ${error.message}`
       );
+      return null;
     }
-    throw new Error("startChat requires either uaid or agentUrl");
   }
-  async startConversation(options) {
-    const preference = options.encryption?.preference ?? "preferred";
-    const requestEncryption = preference !== "disabled";
-    if (!requestEncryption) {
-      const session = await this.createSession({
-        uaid: options.uaid,
-        auth: options.auth,
-        historyTtlSeconds: options.historyTtlSeconds,
-        senderUaid: options.senderUaid,
-        encryptionRequested: false
-      });
-      options.onSessionCreated?.(session.sessionId);
-      return this.createPlaintextConversationHandle(
-        session.sessionId,
-        session.encryption ?? null,
-        options.auth,
-        { uaid: options.uaid }
-      );
+  /**
+   * Retrieves pending token airdrops received by an account.
+   * @param accountId The ID of the account that received the airdrops.
+   * @param options Optional parameters for filtering airdrops.
+   * @returns A promise that resolves to an array of TokenAirdrop or null.
+   */
+  async getPendingTokenAirdrops(accountId, options) {
+    this.logger.info(
+      `Getting pending token airdrops received by account ${accountId}`
+    );
+    let endpoint = `/api/v1/accounts/${accountId}/airdrops/pending`;
+    const params = new URLSearchParams();
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.senderId) {
+      params.append("sender.id", options.senderId);
+    }
+    if (options?.serialNumber) {
+      params.append("serialnumber", options.serialNumber);
+    }
+    if (options?.tokenId) {
+      params.append("token.id", options.tokenId);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      endpoint += `?${queryString}`;
     }
     try {
-      const handle = await this.encryptedChatManager.startSession({
-        uaid: options.uaid,
-        senderUaid: options.senderUaid,
-        historyTtlSeconds: options.historyTtlSeconds,
-        handshakeTimeoutMs: options.encryption?.handshakeTimeoutMs,
-        pollIntervalMs: options.encryption?.pollIntervalMs,
-        onSessionCreated: (sessionId) => {
-          options.onSessionCreated?.(sessionId);
-        },
-        auth: options.auth
-      });
-      return handle;
+      const response = await this._requestWithRetry(endpoint);
+      return response.airdrops || [];
     } catch (error) {
-      if (error instanceof EncryptionUnavailableError) {
-        if (preference === "required") {
-          throw error;
-        }
-        return this.createPlaintextConversationHandle(
-          error.sessionId,
-          error.summary ?? null,
-          options.auth,
-          { uaid: options.uaid }
-        );
-      }
-      throw error;
+      this.logger.error(
+        `Error fetching pending token airdrops for account ${accountId}: ${error.message}`
+      );
+      return null;
     }
   }
-  async acceptConversation(options) {
-    const preference = options.encryption?.preference ?? "preferred";
-    if (preference === "disabled") {
-      return this.createPlaintextConversationHandle(options.sessionId, null);
+  /**
+   * Retrieves blocks from the network.
+   * @param options Optional parameters for filtering blocks.
+   * @returns A promise that resolves to an array of Block or null.
+   */
+  async getBlocks(options) {
+    this.logger.info("Getting blocks from the network");
+    let endpoint = `/api/v1/blocks`;
+    const params = new URLSearchParams();
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.blockNumber) {
+      params.append("block.number", options.blockNumber);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      endpoint += `?${queryString}`;
     }
     try {
-      const handle = await this.encryptedChatManager.acceptSession({
-        sessionId: options.sessionId,
-        responderUaid: options.responderUaid,
-        handshakeTimeoutMs: options.encryption?.handshakeTimeoutMs,
-        pollIntervalMs: options.encryption?.pollIntervalMs
-      });
-      return handle;
+      const response = await this._requestWithRetry(endpoint);
+      return response.blocks || [];
     } catch (error) {
-      if (error instanceof EncryptionUnavailableError && preference !== "required") {
-        return this.createPlaintextConversationHandle(
-          options.sessionId,
-          null,
-          void 0,
-          { uaid: options.responderUaid }
-        );
-      }
-      throw error;
+      this.logger.error(`Error fetching blocks: ${error.message}`);
+      return null;
     }
   }
-  async fetchHistorySnapshot(sessionId, options) {
-    if (!sessionId || sessionId.trim().length === 0) {
-      throw new Error("sessionId is required to fetch chat history");
-    }
-    const raw = await this.requestJson(
-      `/chat/session/${encodeURIComponent(sessionId)}/history`,
-      {
-        method: "GET"
-      }
-    );
-    const snapshot = this.parseWithSchema(
-      raw,
-      chatHistorySnapshotResponseSchema,
-      "chat history snapshot response"
-    );
-    return this.attachDecryptedHistory(sessionId, snapshot, options);
-  }
-  attachDecryptedHistory(sessionId, snapshot, options) {
-    const shouldDecrypt = options?.decrypt !== void 0 ? options.decrypt : this.encryptionOptions?.autoDecryptHistory === true;
-    if (!shouldDecrypt) {
-      return snapshot;
-    }
-    const context = this.resolveDecryptionContext(sessionId, options);
-    if (!context) {
-      throw new Error(
-        "Unable to decrypt chat history: encryption context unavailable"
+  /**
+   * Retrieves a specific block by number or hash.
+   * @param blockNumberOrHash The block number or hash.
+   * @returns A promise that resolves to a Block or null.
+   */
+  async getBlock(blockNumberOrHash) {
+    this.logger.info(`Getting block ${blockNumberOrHash}`);
+    try {
+      const response = await this._requestWithRetry(
+        `/api/v1/blocks/${blockNumberOrHash}`
+      );
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching block ${blockNumberOrHash}: ${error.message}`
       );
+      return null;
     }
-    const decryptedHistory = snapshot.history.map((entry) => ({
-      entry,
-      plaintext: this.decryptHistoryEntryFromContext(sessionId, entry, context)
-    }));
-    return { ...snapshot, decryptedHistory };
   }
-  registerConversationContext(context) {
-    const normalized = {
-      sessionId: context.sessionId,
-      sharedSecret: Buffer.from(context.sharedSecret),
-      identity: context.identity ? { ...context.identity } : void 0
-    };
-    const entries = this.conversationContexts.get(context.sessionId) ?? [];
-    const existingIndex = entries.findIndex(
-      (existing) => this.identitiesMatch(existing.identity, normalized.identity)
-    );
-    if (existingIndex >= 0) {
-      entries[existingIndex] = normalized;
-    } else {
-      entries.push(normalized);
+  /**
+   * Retrieves contract entities from the network.
+   * @param options Optional parameters for filtering contracts.
+   * @returns A promise that resolves to an array of ContractEntity or null.
+   */
+  async getContracts(options) {
+    this.logger.info("Getting contracts from the network");
+    let url = `/api/v1/contracts`;
+    const params = new URLSearchParams();
+    if (options?.contractId) {
+      params.append("contract.id", options.contractId);
     }
-    this.conversationContexts.set(context.sessionId, entries);
-  }
-  // Exposed for EncryptedChatManager to persist decryption context
-  registerConversationContextForEncryption(context) {
-    this.registerConversationContext(context);
-  }
-  resolveDecryptionContext(sessionId, options) {
-    if (options?.sharedSecret) {
-      return {
-        sessionId,
-        sharedSecret: this.normalizeSharedSecret(options.sharedSecret),
-        identity: options.identity
-      };
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
     }
-    const contexts = this.conversationContexts.get(sessionId);
-    if (!contexts || contexts.length === 0) {
-      return null;
+    if (options?.order) {
+      params.append("order", options.order);
     }
-    if (options?.identity) {
-      const match = contexts.find(
-        (context) => this.identitiesMatch(context.identity, options.identity)
-      );
-      if (match) {
-        return match;
-      }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.contracts || [];
+    } catch (error) {
+      this.logger.error(`Error fetching contracts: ${error.message}`);
+      return null;
     }
-    return contexts[0];
   }
-  decryptHistoryEntryFromContext(sessionId, entry, context) {
-    const envelope = entry.cipherEnvelope;
-    if (!envelope) {
-      return entry.content;
+  /**
+   * Retrieves a specific contract by ID or address.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param timestamp Optional timestamp for historical data.
+   * @returns A promise that resolves to a ContractEntity or null.
+   */
+  async getContract(contractIdOrAddress, timestamp) {
+    this.logger.info(`Getting contract ${contractIdOrAddress}`);
+    let url = `/api/v1/contracts/${contractIdOrAddress}`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
     }
-    const secret = Buffer.from(context.sharedSecret);
     try {
-      return this.encryption.decryptCipherEnvelope({
-        envelope,
-        sharedSecret: secret
-      });
-    } catch (_error) {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract ${contractIdOrAddress}: ${error.message}`
+      );
       return null;
     }
   }
-  identitiesMatch(a, b) {
-    if (!a && !b) {
-      return true;
+  /**
+   * Retrieves contract results from the network.
+   * @param options Optional parameters for filtering contract results.
+   * @returns A promise that resolves to an array of ContractResult or null.
+   */
+  async getContractResults(options) {
+    this.logger.info("Getting contract results from the network");
+    let url = `/api/v1/contracts/results`;
+    const params = new URLSearchParams();
+    if (options?.from) {
+      params.append("from", options.from);
     }
-    if (!a || !b) {
-      return false;
+    if (options?.blockHash) {
+      params.append("block.hash", options.blockHash);
     }
-    if (a.uaid && b.uaid && a.uaid.toLowerCase() === b.uaid.toLowerCase()) {
-      return true;
+    if (options?.blockNumber) {
+      params.append("block.number", options.blockNumber);
     }
-    if (a.ledgerAccountId && b.ledgerAccountId && a.ledgerAccountId.toLowerCase() === b.ledgerAccountId.toLowerCase()) {
-      return true;
+    if (options?.internal !== void 0) {
+      params.append("internal", options.internal.toString());
     }
-    if (a.userId && b.userId && a.userId === b.userId) {
-      return true;
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
     }
-    if (a.email && b.email && a.email.toLowerCase() === b.email.toLowerCase()) {
-      return true;
+    if (options?.order) {
+      params.append("order", options.order);
     }
-    return false;
-  }
-  identityMatchesRecipient(recipient, identity) {
-    if (identity.uaid && recipient.uaid?.toLowerCase() === identity.uaid.toLowerCase()) {
-      return true;
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
     }
-    if (identity.ledgerAccountId && recipient.ledgerAccountId?.toLowerCase() === identity.ledgerAccountId.toLowerCase()) {
-      return true;
+    if (options?.transactionIndex) {
+      params.append("transaction.index", options.transactionIndex.toString());
     }
-    if (identity.userId && recipient.userId === identity.userId) {
-      return true;
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
     }
-    if (identity.email && recipient.email?.toLowerCase() === identity.email.toLowerCase()) {
-      return true;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.results || [];
+    } catch (error) {
+      this.logger.error(`Error fetching contract results: ${error.message}`);
+      return null;
     }
-    return false;
-  }
-  createPlaintextConversationHandle(sessionId, summary, defaultAuth, context) {
-    const uaid = context?.uaid?.trim();
-    const agentUrl = context?.agentUrl?.trim();
-    return {
-      sessionId,
-      mode: "plaintext",
-      summary: summary ?? null,
-      send: async (options) => {
-        const plaintext = options.plaintext;
-        if (!plaintext || plaintext.trim().length === 0) {
-          throw new Error("plaintext is required for chat messages");
-        }
-        const message = options.message ?? plaintext;
-        return this.sendMessage({
-          sessionId,
-          message,
-          streaming: options.streaming,
-          auth: options.auth ?? defaultAuth,
-          uaid,
-          agentUrl
-        });
-      },
-      decryptHistoryEntry: (entry) => entry.content
-    };
-  }
-  async compactHistory(payload) {
-    if (!payload.sessionId || payload.sessionId.trim().length === 0) {
-      throw new Error("sessionId is required to compact chat history");
-    }
-    const body = {};
-    if (typeof payload.preserveEntries === "number" && Number.isFinite(payload.preserveEntries) && payload.preserveEntries >= 0) {
-      body.preserveEntries = Math.floor(payload.preserveEntries);
-    }
-    const raw = await this.requestJson(
-      `/chat/session/${encodeURIComponent(payload.sessionId)}/compact`,
-      {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body
-      }
-    );
-    return this.parseWithSchema(
-      raw,
-      chatHistoryCompactionResponseSchema,
-      "chat history compaction response"
-    );
-  }
-  async fetchEncryptionStatus(sessionId) {
-    if (!sessionId || sessionId.trim().length === 0) {
-      throw new Error("sessionId is required for encryption status");
-    }
-    const raw = await this.requestJson(
-      `/chat/session/${encodeURIComponent(sessionId)}/encryption`,
-      {
-        method: "GET"
-      }
-    );
-    return this.parseWithSchema(
-      raw,
-      sessionEncryptionStatusResponseSchema,
-      "session encryption status response"
-    );
   }
-  async postEncryptionHandshake(sessionId, payload) {
-    if (!sessionId || sessionId.trim().length === 0) {
-      throw new Error("sessionId is required for encryption handshake");
-    }
-    const raw = await this.requestJson(
-      `/chat/session/${encodeURIComponent(sessionId)}/encryption-handshake`,
-      {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: {
-          role: payload.role,
-          keyType: payload.keyType,
-          ephemeralPublicKey: payload.ephemeralPublicKey,
-          longTermPublicKey: payload.longTermPublicKey,
-          signature: payload.signature,
-          uaid: payload.uaid,
-          userId: payload.userId,
-          ledgerAccountId: payload.ledgerAccountId,
-          metadata: payload.metadata
-        }
-      }
-    );
-    const response = this.parseWithSchema(
-      raw,
-      encryptionHandshakeResponseSchema,
-      "encryption handshake response"
-    );
-    return response.handshake;
+  /**
+   * Retrieves a specific contract result by transaction ID or hash.
+   * @param transactionIdOrHash The transaction ID or hash.
+   * @param nonce Optional nonce filter.
+   * @returns A promise that resolves to a ContractResult or null.
+   */
+  async getContractResult(transactionIdOrHash, nonce) {
+    this.logger.info(`Getting contract result for ${transactionIdOrHash}`);
+    let url = `/api/v1/contracts/results/${transactionIdOrHash}`;
+    if (nonce !== void 0) {
+      url += `?nonce=${nonce}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract result for ${transactionIdOrHash}: ${error.message}`
+      );
+      return null;
+    }
   }
-  async registerEncryptionKey(payload) {
-    const raw = await this.requestJson("/encryption/keys", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: payload
-    });
-    return this.parseWithSchema(
-      raw,
-      registerEncryptionKeyResponseSchema,
-      "register encryption key response"
+  /**
+   * Retrieves contract results for a specific contract.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param options Optional parameters for filtering.
+   * @returns A promise that resolves to an array of ContractResult or null.
+   */
+  async getContractResultsByContract(contractIdOrAddress, options) {
+    this.logger.info(
+      `Getting contract results for contract ${contractIdOrAddress}`
     );
-  }
-  async sendMessage(payload) {
-    const body = {
-      message: payload.message
-    };
-    if (payload.streaming !== void 0) {
-      body.streaming = payload.streaming;
+    let url = `/api/v1/contracts/${contractIdOrAddress}/results`;
+    const params = new URLSearchParams();
+    if (options?.blockHash) {
+      params.append("block.hash", options.blockHash);
     }
-    if (payload.auth) {
-      body.auth = serialiseAuthConfig(payload.auth);
+    if (options?.blockNumber) {
+      params.append("block.number", options.blockNumber);
     }
-    if ("uaid" in payload) {
-      body.uaid = payload.uaid;
+    if (options?.from) {
+      params.append("from", options.from);
     }
-    if ("sessionId" in payload && payload.sessionId) {
-      body.sessionId = payload.sessionId;
+    if (options?.internal !== void 0) {
+      params.append("internal", options.internal.toString());
     }
-    if ("agentUrl" in payload && payload.agentUrl) {
-      body.agentUrl = payload.agentUrl;
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
     }
-    let cipherEnvelope = payload.cipherEnvelope ?? null;
-    if (payload.encryption) {
-      const sessionIdForEncryption = payload.encryption.sessionId ?? (typeof body.sessionId === "string" ? body.sessionId : void 0);
-      if (!sessionIdForEncryption) {
-        throw new Error(
-          "sessionId is required when using encrypted chat payloads"
-        );
-      }
-      if (!payload.encryption.recipients?.length) {
-        throw new Error("recipients are required for encrypted chat payloads");
-      }
-      cipherEnvelope = this.encryption.encryptCipherEnvelope({
-        ...payload.encryption,
-        sessionId: sessionIdForEncryption
-      });
-    }
-    if (cipherEnvelope) {
-      body.cipherEnvelope = cipherEnvelope;
-    }
-    delete body.encryption;
-    const raw = await this.requestJson("/chat/message", {
-      method: "POST",
-      body,
-      headers: { "content-type": "application/json" }
-    });
-    return this.parseWithSchema(
-      raw,
-      sendMessageResponseSchema,
-      "chat message response"
-    );
-  }
-  async endSession(sessionId) {
-    await this.request(`/chat/session/${encodeURIComponent(sessionId)}`, {
-      method: "DELETE"
-    });
-  }
-  async generateEncryptionKeyPair(options = {}) {
-    this.assertNodeRuntime("generateEncryptionKeyPair");
-    const keyType = options.keyType ?? "secp256k1";
-    if (keyType !== "secp256k1") {
-      throw new Error("Only secp256k1 key generation is supported currently");
-    }
-    const privateKeyBytes = randomBytes(32);
-    const privateKey = Buffer.from(privateKeyBytes).toString("hex");
-    const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
-    const publicKey = Buffer.from(publicKeyBytes).toString("hex");
-    const envVar = options.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-    const resolvedPath = options.envPath ? path.resolve(options.envPath) : void 0;
-    if (resolvedPath) {
-      const fsModule = getFs();
-      if (!fsModule) {
-        throw new Error(
-          "File system module is not available; cannot write encryption key env file"
-        );
-      }
-      const envLine = `${envVar}=${privateKey}`;
-      if (fsModule.existsSync(resolvedPath)) {
-        const content = fsModule.readFileSync(resolvedPath, "utf-8");
-        const lineRegex = new RegExp(`^${envVar}=.*$`, "m");
-        if (lineRegex.test(content)) {
-          if (!options.overwrite) {
-            throw new Error(
-              `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`
-            );
-          }
-          const updated = content.replace(lineRegex, envLine);
-          fsModule.writeFileSync(resolvedPath, updated);
-        } else {
-          const needsNewline = !content.endsWith("\n");
-          fsModule.appendFileSync(
-            resolvedPath,
-            `${needsNewline ? "\n" : ""}${envLine}
-`
-          );
-        }
-      } else {
-        fsModule.writeFileSync(resolvedPath, `${envLine}
-`);
-      }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.transactionIndex) {
+      params.append("transaction.index", options.transactionIndex.toString());
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.results || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract results for ${contractIdOrAddress}: ${error.message}`
+      );
+      return null;
     }
-    return {
-      privateKey,
-      publicKey,
-      envPath: resolvedPath,
-      envVar
-    };
-  }
-  buildUrl(path2) {
-    const normalisedPath = path2.startsWith("/") ? path2 : `/${path2}`;
-    return `${this.baseUrl}${normalisedPath}`;
   }
-  buildVectorFallbackSearchParams(request) {
-    const params = {
-      q: request.query
-    };
-    let effectiveLimit;
-    if (typeof request.limit === "number" && Number.isFinite(request.limit)) {
-      effectiveLimit = request.limit;
-      params.limit = request.limit;
+  /**
+   * Retrieves contract state for a specific contract.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param options Optional parameters for filtering.
+   * @returns A promise that resolves to an array of ContractState or null.
+   */
+  async getContractState(contractIdOrAddress, options) {
+    this.logger.info(`Getting contract state for ${contractIdOrAddress}`);
+    let url = `/api/v1/contracts/${contractIdOrAddress}/state`;
+    const params = new URLSearchParams();
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
     }
-    if (typeof request.offset === "number" && Number.isFinite(request.offset) && request.offset > 0) {
-      const limit = effectiveLimit && effectiveLimit > 0 ? effectiveLimit : 20;
-      params.limit = limit;
-      params.page = Math.floor(request.offset / limit) + 1;
+    if (options?.order) {
+      params.append("order", options.order);
     }
-    if (request.filter?.registry) {
-      params.registry = request.filter.registry;
+    if (options?.slot) {
+      params.append("slot", options.slot);
     }
-    if (request.filter?.protocols?.length) {
-      params.protocols = [...request.filter.protocols];
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
     }
-    if (request.filter?.adapter?.length) {
-      params.adapters = [...request.filter.adapter];
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
     }
-    if (request.filter?.capabilities?.length) {
-      params.capabilities = request.filter.capabilities.map(
-        (value) => typeof value === "number" ? value.toString(10) : value
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.state || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract state for ${contractIdOrAddress}: ${error.message}`
       );
+      return null;
     }
-    if (request.filter?.type) {
-      params.type = request.filter.type;
-    }
-    return params;
-  }
-  convertSearchResultToVectorResponse(result) {
-    const hits = result.hits.map((agent) => ({
-      agent,
-      score: 0,
-      highlights: {}
-    }));
-    const total = result.total;
-    const limit = result.limit;
-    const page = result.page;
-    const totalVisible = page * limit;
-    const limited = total > totalVisible || page > 1;
-    return {
-      hits,
-      total,
-      took: 0,
-      totalAvailable: total,
-      visible: hits.length,
-      limited,
-      credits_used: 0
-    };
   }
-  async delay(ms, signal) {
-    if (ms <= 0) {
-      if (signal?.aborted) {
-        throw createAbortError();
-      }
-      return;
+  /**
+   * Retrieves contract actions for a specific transaction.
+   * @param transactionIdOrHash The transaction ID or hash.
+   * @param options Optional parameters for filtering.
+   * @returns A promise that resolves to an array of ContractAction or null.
+   */
+  async getContractActions(transactionIdOrHash, options) {
+    this.logger.info(`Getting contract actions for ${transactionIdOrHash}`);
+    let url = `/api/v1/contracts/results/${transactionIdOrHash}/actions`;
+    const params = new URLSearchParams();
+    if (options?.index) {
+      params.append("index", options.index);
     }
-    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 });
-      }
-    });
-  }
-  async requestJson(path2, config) {
-    const response = await this.request(path2, 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
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.actions || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract actions for ${transactionIdOrHash}: ${error.message}`
       );
+      return null;
     }
-    return await response.json();
   }
-  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) };
-      }
+  /**
+   * Retrieves contract logs from the network.
+   * @param options Optional parameters for filtering logs.
+   * @returns A promise that resolves to an array of ContractLog or null.
+   */
+  async getContractLogs(options) {
+    this.logger.info("Getting contract logs from the network");
+    let url = `/api/v1/contracts/results/logs`;
+    const params = new URLSearchParams();
+    if (options?.index) {
+      params.append("index", options.index);
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.topic0) {
+      params.append("topic0", options.topic0);
+    }
+    if (options?.topic1) {
+      params.append("topic1", options.topic1);
+    }
+    if (options?.topic2) {
+      params.append("topic2", options.topic2);
+    }
+    if (options?.topic3) {
+      params.append("topic3", options.topic3);
+    }
+    if (options?.transactionHash) {
+      params.append("transaction.hash", options.transactionHash);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
     }
     try {
-      return await response.text();
+      const response = await this._requestWithRetry(url);
+      return response.logs || [];
     } catch (error) {
-      return { parseError: String(error) };
+      this.logger.error(`Error fetching contract logs: ${error.message}`);
+      return null;
     }
   }
-  parseWithSchema(value, schema, context) {
+  /**
+   * Retrieves contract logs for a specific contract.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param options Optional parameters for filtering logs.
+   * @returns A promise that resolves to an array of ContractLog or null.
+   */
+  async getContractLogsByContract(contractIdOrAddress, options) {
+    this.logger.info(
+      `Getting contract logs for contract ${contractIdOrAddress}`
+    );
+    let url = `/api/v1/contracts/${contractIdOrAddress}/results/logs`;
+    const params = new URLSearchParams();
+    if (options?.index) {
+      params.append("index", options.index);
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.topic0) {
+      params.append("topic0", options.topic0);
+    }
+    if (options?.topic1) {
+      params.append("topic1", options.topic1);
+    }
+    if (options?.topic2) {
+      params.append("topic2", options.topic2);
+    }
+    if (options?.topic3) {
+      params.append("topic3", options.topic3);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
     try {
-      return schema.parse(value);
+      const response = await this._requestWithRetry(url);
+      return response.logs || [];
     } catch (error) {
-      throw new RegistryBrokerParseError(
-        `Failed to parse ${context}`,
-        error instanceof ZodError || error instanceof Error ? error : String(error),
-        value
+      this.logger.error(
+        `Error fetching contract logs for ${contractIdOrAddress}: ${error.message}`
       );
+      return null;
     }
   }
-  assertNodeRuntime(feature) {
-    if (typeof process === "undefined" || !process.versions?.node) {
-      throw new Error(`${feature} is only available in Node.js environments`);
+  /**
+   * Retrieves NFT information by token ID and serial number.
+   * @param tokenId The token ID.
+   * @param serialNumber The serial number of the NFT.
+   * @returns A promise that resolves to an NftInfo or null.
+   */
+  async getNftInfo(tokenId, serialNumber) {
+    this.logger.info(`Getting NFT info for ${tokenId}/${serialNumber}`);
+    const url = `/api/v1/tokens/${tokenId}/nfts/${serialNumber}`;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching NFT info for ${tokenId}/${serialNumber}: ${error.message}`
+      );
+      return null;
     }
   }
-  createEphemeralKeyPair() {
-    this.assertNodeRuntime("generateEphemeralKeyPair");
-    const privateKeyBytes = randomBytes(32);
-    const publicKey = secp256k1.getPublicKey(privateKeyBytes, true);
-    return {
-      privateKey: Buffer.from(privateKeyBytes).toString("hex"),
-      publicKey: Buffer.from(publicKey).toString("hex")
-    };
-  }
-  deriveSharedSecret(options) {
-    this.assertNodeRuntime("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) {
-    this.assertNodeRuntime("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"));
-    }
-    const ciphertext = Buffer.concat([
-      cipher.update(Buffer.from(options.plaintext, "utf8")),
-      cipher.final()
-    ]);
-    const tag = cipher.getAuthTag();
-    const payload = Buffer.concat([ciphertext, tag]);
-    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: ""
-      }))
-    };
-  }
-  openCipherEnvelope(options) {
-    this.assertNodeRuntime("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);
+  /**
+   * Retrieves NFTs for a specific token.
+   * @param tokenId The token ID.
+   * @param options Optional parameters for filtering NFTs.
+   * @returns A promise that resolves to an array of NftInfo or null.
+   */
+  async getNftsByToken(tokenId, options) {
+    this.logger.info(`Getting NFTs for token ${tokenId}`);
+    let url = `/api/v1/tokens/${tokenId}/nfts`;
+    const params = new URLSearchParams();
+    if (options?.accountId) {
+      params.append("account.id", options.accountId);
     }
-    if (typeof input === "string") {
-      return this.bufferFromString(input);
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
     }
-    throw new Error("Unsupported shared secret input");
-  }
-  bufferFromString(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      throw new Error("sharedSecret string cannot be empty");
+    if (options?.order) {
+      params.append("order", options.order);
     }
-    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");
+    if (options?.serialNumber) {
+      params.append("serialnumber", options.serialNumber);
     }
-    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");
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
     }
-    return Buffer.from(normalized, "hex");
-  }
-}
-const isPendingRegisterAgentResponse = (response) => response.status === "pending";
-const isPartialRegisterAgentResponse = (response) => response.status === "partial" && response.success === false;
-const isSuccessRegisterAgentResponse = (response) => response.success === true && response.status !== "pending";
-class EncryptedChatManager {
-  constructor(client) {
-    this.client = client;
-  }
-  registerConversationContext(context) {
-    this.client.registerConversationContextForEncryption(context);
-  }
-  async startSession(options) {
-    await this.client.encryptionReady();
-    const session = await this.client.chat.createSession({
-      uaid: options.uaid,
-      senderUaid: options.senderUaid,
-      encryptionRequested: true,
-      historyTtlSeconds: options.historyTtlSeconds,
-      auth: options.auth
-    });
-    options.onSessionCreated?.(session.sessionId);
-    const summary = session.encryption;
-    if (!summary?.enabled) {
-      throw new EncryptionUnavailableError(
-        session.sessionId,
-        session.encryption ?? null
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.nfts || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching NFTs for token ${tokenId}: ${error.message}`
       );
+      return null;
     }
-    const handle = await this.establishRequesterContext({
-      sessionId: session.sessionId,
-      summary,
-      senderUaid: options.senderUaid,
-      handshakeTimeoutMs: options.handshakeTimeoutMs,
-      pollIntervalMs: options.pollIntervalMs
-    });
-    return handle;
-  }
-  async acceptSession(options) {
-    await this.client.encryptionReady();
-    const summary = await this.waitForEncryptionSummary(
-      options.sessionId,
-      options.handshakeTimeoutMs,
-      options.pollIntervalMs
-    );
-    const handle = await this.establishResponderContext({
-      sessionId: options.sessionId,
-      summary,
-      responderUaid: options.responderUaid,
-      handshakeTimeoutMs: options.handshakeTimeoutMs,
-      pollIntervalMs: options.pollIntervalMs
-    });
-    return handle;
-  }
-  async establishRequesterContext(params) {
-    const keyPair = this.client.encryption.generateEphemeralKeyPair();
-    await this.client.chat.submitEncryptionHandshake(params.sessionId, {
-      role: "requester",
-      keyType: "secp256k1",
-      ephemeralPublicKey: keyPair.publicKey,
-      uaid: params.senderUaid ?? params.summary.requester?.uaid ?? void 0
-    });
-    const { summary, record } = await this.waitForHandshakeCompletion(
-      params.sessionId,
-      params.handshakeTimeoutMs,
-      params.pollIntervalMs
-    );
-    const responderKey = record.responder?.ephemeralPublicKey;
-    if (!responderKey) {
-      throw new Error("Responder handshake was not completed in time");
-    }
-    const sharedSecret = this.client.encryption.deriveSharedSecret({
-      privateKey: keyPair.privateKey,
-      peerPublicKey: responderKey
-    }).subarray();
-    const recipients = this.buildRecipients(summary);
-    return this.createHandle({
-      sessionId: params.sessionId,
-      sharedSecret,
-      summary,
-      recipients,
-      identity: summary.requester ?? void 0
-    });
-  }
-  async establishResponderContext(params) {
-    const keyPair = this.client.encryption.generateEphemeralKeyPair();
-    await this.client.chat.submitEncryptionHandshake(params.sessionId, {
-      role: "responder",
-      keyType: "secp256k1",
-      ephemeralPublicKey: keyPair.publicKey,
-      uaid: params.responderUaid ?? params.summary.responder?.uaid ?? void 0
-    });
-    const { summary, record } = await this.waitForHandshakeCompletion(
-      params.sessionId,
-      params.handshakeTimeoutMs,
-      params.pollIntervalMs
-    );
-    const requesterKey = record.requester?.ephemeralPublicKey;
-    if (!requesterKey) {
-      throw new Error("Requester handshake was not detected in time");
-    }
-    const sharedSecret = this.client.encryption.deriveSharedSecret({
-      privateKey: keyPair.privateKey,
-      peerPublicKey: requesterKey
-    }).subarray();
-    const recipients = this.buildRecipients(summary);
-    return this.createHandle({
-      sessionId: params.sessionId,
-      sharedSecret,
-      summary,
-      recipients,
-      identity: summary.responder ?? void 0
-    });
   }
-  async waitForHandshakeCompletion(sessionId, timeoutMs = 3e4, pollIntervalMs = 1e3) {
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-      const status = await this.client.chat.getEncryptionStatus(sessionId);
-      const summary = status.encryption;
-      const record = summary?.handshake;
-      if (summary && record && record.status === "complete") {
-        return { summary, record };
-      }
-      if (Date.now() >= deadline) {
-        throw new Error("Timed out waiting for encrypted handshake completion");
-      }
-      await this.delay(pollIntervalMs);
+  /**
+   * Retrieves network information.
+   * @returns A promise that resolves to NetworkInfo or null.
+   */
+  async getNetworkInfo() {
+    this.logger.info("Getting network information");
+    const url = `/api/v1/network/nodes`;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network info: ${error.message}`);
+      return null;
     }
   }
-  async waitForEncryptionSummary(sessionId, _timeoutMs = 3e4, _pollIntervalMs = 1e3) {
-    const status = await this.client.chat.getEncryptionStatus(sessionId);
-    if (!status.encryption?.enabled) {
-      throw new EncryptionUnavailableError(
-        sessionId,
-        status.encryption ?? null
-      );
+  /**
+   * Retrieves network fees.
+   * @param timestamp Optional timestamp for historical fees.
+   * @returns A promise that resolves to NetworkFees or null.
+   */
+  async getNetworkFees(timestamp) {
+    this.logger.info("Getting network fees");
+    let url = `/api/v1/network/fees`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network fees: ${error.message}`);
+      return null;
     }
-    return status.encryption;
   }
-  buildRecipients(summary) {
-    const candidates = [summary.requester, summary.responder].filter(Boolean);
-    const normalized = candidates.map((candidate) => {
-      if (!candidate) {
-        return null;
-      }
-      const recipient = {};
-      if (candidate.uaid) {
-        recipient.uaid = candidate.uaid;
-      }
-      if (candidate.ledgerAccountId) {
-        recipient.ledgerAccountId = candidate.ledgerAccountId;
-      }
-      if (candidate.userId) {
-        recipient.userId = candidate.userId;
-      }
-      if (candidate.email) {
-        recipient.email = candidate.email;
-      }
-      return recipient;
-    }).filter(
-      (entry) => Boolean(
-        entry?.uaid || entry?.ledgerAccountId || entry?.userId || entry?.email
-      )
-    );
-    if (normalized.length > 0) {
-      return normalized;
+  /**
+   * Retrieves network supply information.
+   * @param timestamp Optional timestamp for historical supply data.
+   * @returns A promise that resolves to NetworkSupply or null.
+   */
+  async getNetworkSupply(timestamp) {
+    this.logger.info("Getting network supply");
+    let url = `/api/v1/network/supply`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
     }
-    if (summary.responder?.uaid) {
-      return [{ uaid: summary.responder.uaid }];
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network supply: ${error.message}`);
+      return null;
     }
-    return [];
   }
-  createHandle(context) {
-    const sharedSecret = context.sharedSecret;
-    const uaid = context.summary.requester?.uaid ?? context.summary.responder?.uaid ?? context.identity?.uaid;
-    const handle = {
-      sessionId: context.sessionId,
-      mode: "encrypted",
-      summary: context.summary,
-      send: async (options) => {
-        const recipients = options.recipients ?? context.recipients;
-        return this.client.chat.sendMessage({
-          sessionId: context.sessionId,
-          message: options.message ?? "[ciphertext omitted]",
-          streaming: options.streaming,
-          auth: options.auth,
-          uaid,
-          encryption: {
-            plaintext: options.plaintext,
-            sharedSecret: Buffer.from(sharedSecret),
-            recipients
-          }
-        });
-      },
-      decryptHistoryEntry: (entry) => this.decryptEntry(entry, context.identity, sharedSecret)
-    };
-    this.registerConversationContext({
-      sessionId: context.sessionId,
-      sharedSecret,
-      identity: context.identity
-    });
-    return handle;
-  }
-  decryptEntry(entry, identity, fallbackSecret) {
-    const envelope = entry.cipherEnvelope;
-    if (!envelope) {
-      return null;
+  /**
+   * Retrieves network stake information.
+   * @param timestamp Optional timestamp for historical stake data.
+   * @returns A promise that resolves to NetworkStake or null.
+   */
+  async getNetworkStake(timestamp) {
+    this.logger.info("Getting network stake");
+    let url = `/api/v1/network/stake`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
     }
-    const secret = Buffer.from(fallbackSecret);
     try {
-      return this.client.encryption.decryptCipherEnvelope({
-        envelope,
-        sharedSecret: secret
-      });
-    } catch (_error) {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network stake: ${error.message}`);
       return null;
     }
   }
-  recipientMatches(candidate, target) {
-    if (target.uaid && candidate.uaid?.toLowerCase() === target.uaid.toLowerCase()) {
-      return true;
+  /**
+   * Retrieves opcode traces for a specific transaction.
+   * @param transactionIdOrHash The transaction ID or hash.
+   * @param options Optional parameters for trace details.
+   * @returns A promise that resolves to an OpcodesResponse or null.
+   */
+  async getOpcodeTraces(transactionIdOrHash, options) {
+    this.logger.info(`Getting opcode traces for ${transactionIdOrHash}`);
+    let url = `/api/v1/contracts/results/${transactionIdOrHash}/opcodes`;
+    const params = new URLSearchParams();
+    if (options?.stack !== void 0) {
+      params.append("stack", options.stack.toString());
     }
-    if (target.ledgerAccountId && candidate.ledgerAccountId?.toLowerCase() === target.ledgerAccountId.toLowerCase()) {
-      return true;
+    if (options?.memory !== void 0) {
+      params.append("memory", options.memory.toString());
     }
-    if (target.userId && candidate.userId === target.userId) {
-      return true;
+    if (options?.storage !== void 0) {
+      params.append("storage", options.storage.toString());
     }
-    if (target.email && candidate.email?.toLowerCase() === target.email.toLowerCase()) {
-      return true;
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
     }
-    return false;
-  }
-  async delay(ms) {
-    if (ms <= 0) {
-      return;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching opcode traces for ${transactionIdOrHash}: ${error.message}`
+      );
+      return null;
     }
-    await new Promise((resolve) => setTimeout(resolve, ms));
-  }
-}
-class EncryptionUnavailableError extends Error {
-  constructor(sessionId, summary) {
-    super("Encryption is not enabled for this session");
-    this.sessionId = sessionId;
-    this.summary = summary;
   }
 }
 export {
-  RegistryBrokerClient,
-  RegistryBrokerError,
-  RegistryBrokerParseError,
-  isPartialRegisterAgentResponse,
-  isPendingRegisterAgentResponse,
-  isSuccessRegisterAgentResponse
+  HederaMirrorNode
 };
 //# sourceMappingURL=standards-sdk.es127.js.map