@hashgraphonline/standards-sdk 0.1.143 → 0.1.144-feat-solana-register.canary.d5edcec.80

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

@@ -1,176 +1,957 @@
-import { Logger } from "./standards-sdk.es106.js";
-class RedisCache {
-  constructor(config = {}) {
-    const {
-      host = "localhost",
-      port = 6379,
-      password,
-      db = 0,
-      keyPrefix = "",
-      tls = false,
-      connectTimeout = 5e3,
-      retryStrategy,
-      logLevel = "info"
-    } = config;
-    this.prefix = keyPrefix;
+import { Logger } from "./standards-sdk.es105.js";
+import { Registration } from "./standards-sdk.es20.js";
+import { HCS11Client } from "./standards-sdk.es27.js";
+import { PublicKey } from "@hashgraph/sdk";
+import { HederaMirrorNode } from "./standards-sdk.es126.js";
+import "./standards-sdk.es127.js";
+import "./standards-sdk.es128.js";
+import "./standards-sdk.es129.js";
+import "./standards-sdk.es130.js";
+import "./standards-sdk.es131.js";
+import "./standards-sdk.es132.js";
+import "./standards-sdk.es133.js";
+import "./standards-sdk.es134.js";
+import "buffer";
+import "crypto";
+import "@noble/curves/secp256k1.js";
+import "zod";
+import "./standards-sdk.es149.js";
+import "./standards-sdk.es138.js";
+import { buildHcs10SubmitConnectionRequestTx, buildHcs10OutboundConnectionRequestRecordTx, buildHcs10OutboundConnectionCreatedRecordTx } from "./standards-sdk.es22.js";
+import { HRLResolver } from "./standards-sdk.es109.js";
+var Hcs10MemoType = /* @__PURE__ */ ((Hcs10MemoType2) => {
+  Hcs10MemoType2["INBOUND"] = "inbound";
+  Hcs10MemoType2["OUTBOUND"] = "outbound";
+  Hcs10MemoType2["CONNECTION"] = "connection";
+  Hcs10MemoType2["REGISTRY"] = "registry";
+  return Hcs10MemoType2;
+})(Hcs10MemoType || {});
+class HCS10BaseClient extends Registration {
+  constructor(config) {
+    super();
+    this.network = config.network;
     this.logger = Logger.getInstance({
-      level: logLevel,
-      module: "RedisCache"
+      level: config.logLevel || "info",
+      module: "HCS10-BaseClient",
+      prettyPrint: config.prettyPrint,
+      silent: config.silent
     });
-    this.client = createRedisClient(
+    this.mirrorNode = new HederaMirrorNode(
+      config.network,
       this.logger,
-      {
-        host,
-        port,
-        password,
-        db,
-        tls: tls ? {} : void 0,
-        keyPrefix,
-        connectTimeout,
-        retryStrategy: retryStrategy || ((times) => {
-          const delay = Math.min(times * 50, 2e3);
-          return delay;
-        }),
-        maxRetriesPerRequest: 3
-      }
+      config.mirrorNode
     );
+    this.feeAmount = config.feeAmount || 1e-3;
+  }
+  /**
+   * Updates the mirror node configuration.
+   * @param config The new mirror node configuration.
+   */
+  configureMirrorNode(config) {
+    this.mirrorNode.configureMirrorNode(config);
+    this.logger.info("Mirror node configuration updated");
+  }
+  extractTopicFromOperatorId(operatorId) {
+    if (!operatorId) {
+      return "";
+    }
+    const parts = operatorId.split("@");
+    if (parts.length > 0) {
+      return parts[0];
+    }
+    return "";
   }
-  getKey(key) {
-    return `${this.prefix}${key}`;
+  extractAccountFromOperatorId(operatorId) {
+    if (!operatorId) {
+      return "";
+    }
+    const parts = operatorId.split("@");
+    if (parts.length > 1) {
+      return parts[1];
+    }
+    return "";
   }
-  async get(key) {
+  /**
+   * Get a stream of messages from a connection topic
+   * @param topicId The connection topic ID to get messages from
+   * @param options Optional filtering options for messages
+   * @returns A stream of filtered messages valid for connection topics
+   */
+  async getMessageStream(topicId, options) {
     try {
-      const value = await this.client.get(this.getKey(key));
-      return value || void 0;
+      const messages = await this.mirrorNode.getTopicMessages(topicId, options);
+      const validOps = ["message", "close_connection", "transaction"];
+      const filteredMessages = messages.filter((msg) => {
+        if (msg.p !== "hcs-10" || !validOps.includes(msg.op)) {
+          return false;
+        }
+        if (msg.op === "message" || msg.op === "close_connection") {
+          if (!msg.operator_id) {
+            return false;
+          }
+          if (!this.isValidOperatorId(msg.operator_id)) {
+            return false;
+          }
+          if (msg.op === "message" && !msg.data) {
+            return false;
+          }
+        }
+        if (msg.op === "transaction") {
+          if (!msg.operator_id || !msg.schedule_id) {
+            return false;
+          }
+          if (!this.isValidOperatorId(msg.operator_id)) {
+            return false;
+          }
+        }
+        return true;
+      });
+      return {
+        messages: filteredMessages
+      };
     } catch (error) {
-      this.logger.error("Redis get error:", error);
-      throw error;
+      if (this.logger) {
+        this.logger.error(`Error fetching messages: ${error.message}`);
+      }
+      return { messages: [] };
+    }
+  }
+  /**
+   * Public method to retrieve topic information using the internal mirror node client.
+   *
+   * @param topicId The ID of the topic to query.
+   * @returns Topic information or null if not found or an error occurs.
+   */
+  async getPublicTopicInfo(topicId) {
+    try {
+      return await this.mirrorNode.getTopicInfo(topicId);
+    } catch (error) {
+      this.logger.error(
+        `Error getting public topic info for ${topicId}:`,
+        error
+      );
+      return null;
     }
   }
-  async set(key, value, ttlSeconds) {
+  /**
+   * Checks if a user can submit to a topic and determines if a fee is required
+   * @param topicId The topic ID to check
+   * @param userAccountId The account ID of the user attempting to submit
+   * @returns Object with canSubmit, requiresFee, and optional reason
+   */
+  async canSubmitToTopic(topicId, userAccountId) {
     try {
-      const fullKey = this.getKey(key);
-      if (ttlSeconds) {
-        await this.client.setex(fullKey, ttlSeconds, value);
-      } else {
-        await this.client.set(fullKey, value);
+      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
+      if (!topicInfo) {
+        return {
+          canSubmit: false,
+          requiresFee: false,
+          reason: "Topic does not exist"
+        };
+      }
+      if (!topicInfo.submit_key?.key) {
+        return { canSubmit: true, requiresFee: false };
+      }
+      try {
+        const userPublicKey = await this.mirrorNode.getPublicKey(userAccountId);
+        if (topicInfo.submit_key._type === "ProtobufEncoded") {
+          const keyBytes = Buffer.from(topicInfo.submit_key.key, "hex");
+          const hasAccess = await this.mirrorNode.checkKeyListAccess(
+            keyBytes,
+            userPublicKey
+          );
+          if (hasAccess) {
+            return { canSubmit: true, requiresFee: false };
+          }
+        } else {
+          const topicSubmitKey = PublicKey.fromString(topicInfo.submit_key.key);
+          if (userPublicKey.toString() === topicSubmitKey.toString()) {
+            return { canSubmit: true, requiresFee: false };
+          }
+        }
+      } catch (error) {
+        this.logger.error(
+          `Key validation error: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
+      if (topicInfo.fee_schedule_key?.key && topicInfo.custom_fees?.fixed_fees?.length > 0) {
+        return {
+          canSubmit: true,
+          requiresFee: true,
+          reason: "Requires fee payment via HIP-991"
+        };
+      }
+      return {
+        canSubmit: false,
+        requiresFee: false,
+        reason: "User does not have submit permission for this topic"
+      };
     } catch (error) {
-      this.logger.error("Redis set error:", error);
-      throw error;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Topic submission validation error: ${errorMessage}`);
+      return {
+        canSubmit: false,
+        requiresFee: false,
+        reason: `Error: ${errorMessage}`
+      };
     }
   }
-  async delete(key) {
+  /**
+   * Get all messages from a topic
+   * @param topicId The topic ID to get messages from
+   * @param options Optional filtering options for messages
+   * @returns All messages from the topic
+   */
+  async getMessages(topicId, options) {
     try {
-      await this.client.del(this.getKey(key));
+      const messages = await this.mirrorNode.getTopicMessages(topicId, options);
+      const validatedMessages = messages.filter((msg) => {
+        if (msg.p !== "hcs-10") {
+          return false;
+        }
+        if (msg.op === "message") {
+          if (!msg.data) {
+            return false;
+          }
+          if (msg.operator_id) {
+            if (!this.isValidOperatorId(msg.operator_id)) {
+              return false;
+            }
+          }
+        }
+        return true;
+      });
+      return {
+        messages: validatedMessages
+      };
     } catch (error) {
-      this.logger.error("Redis delete error:", error);
-      throw error;
+      if (this.logger) {
+        this.logger.error(`Error fetching messages: ${error.message}`);
+      }
+      return { messages: [] };
     }
   }
-  async clear() {
+  /**
+   * Requests an account from the mirror node
+   * @param account The account ID to request
+   * @returns The account response
+   */
+  async requestAccount(account) {
     try {
-      const keys = await this.client.keys(`${this.prefix}*`);
-      if (keys.length > 0) {
-        await this.client.del(...keys);
+      if (!account) {
+        throw new Error("Account ID is required");
       }
-    } catch (error) {
-      this.logger.error("Redis clear error:", error);
+      return await this.mirrorNode.requestAccount(account);
+    } catch (e) {
+      this.logger.error("Failed to fetch account", e);
+      throw e;
+    }
+  }
+  /**
+   * Retrieves the memo for an account
+   * @param accountId The account ID to retrieve the memo for
+   * @returns The memo
+   */
+  async getAccountMemo(accountId) {
+    return await this.mirrorNode.getAccountMemo(accountId);
+  }
+  /**
+   * Retrieves the profile for an account
+   * @param accountId The account ID to retrieve the profile for
+   * @param disableCache Whether to disable caching of the result
+   * @param retryOptions Optional retry configuration
+   * @returns The profile
+   */
+  async retrieveProfile(accountId, disableCache, retryOptions) {
+    const maxRetries = retryOptions?.maxRetries ?? 0;
+    const retryDelay = retryOptions?.retryDelay ?? 3e3;
+    let retryCount = 0;
+    while (retryCount <= maxRetries) {
+      this.logger.debug(
+        `Retrieving profile for account: ${accountId}${retryCount > 0 ? ` (attempt ${retryCount + 1}/${maxRetries + 1})` : ""}`
+      );
+      const cacheKey = `${accountId}-${this.network}`;
+      if (!disableCache && retryCount === 0) {
+        const cachedProfileResponse = HCS10Cache.getInstance().get(cacheKey);
+        if (cachedProfileResponse) {
+          this.logger.debug(`Cache hit for profile: ${accountId}`);
+          return cachedProfileResponse;
+        }
+      }
+      try {
+        const hcs11Client = new HCS11Client({
+          network: this.network,
+          auth: {
+            operatorId: "0.0.0"
+          },
+          logLevel: this.logger.getLevel()
+        });
+        const profileResult = await hcs11Client.fetchProfileByAccountId(
+          accountId,
+          this.network
+        );
+        if (!profileResult?.success) {
+          if (retryCount < maxRetries) {
+            this.logger.info(
+              `Profile not found for account ${accountId}, retrying in ${retryDelay}ms... (${profileResult?.error})`
+            );
+            retryCount++;
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            continue;
+          }
+          this.logger.error(
+            `Failed to retrieve profile for account ID: ${accountId}`,
+            profileResult?.error
+          );
+          return {
+            profile: null,
+            success: false,
+            error: profileResult?.error || `Failed to retrieve profile for account ID: ${accountId}`
+          };
+        }
+        const profile = profileResult?.profile;
+        let topicInfo = null;
+        const inboundTopic = profileResult?.topicInfo?.inboundTopic || profile?.inboundTopicId || "";
+        const outboundTopic = profileResult?.topicInfo?.outboundTopic || profile?.outboundTopicId || "";
+        const profileTopicId = profileResult?.topicInfo?.profileTopicId || "";
+        if (inboundTopic && outboundTopic) {
+          topicInfo = {
+            inboundTopic,
+            outboundTopic,
+            profileTopicId
+          };
+        }
+        const responseToCache = {
+          profile,
+          topicInfo,
+          success: true
+        };
+        HCS10Cache.getInstance().set(cacheKey, responseToCache);
+        return responseToCache;
+      } catch (e) {
+        if (retryCount < maxRetries) {
+          this.logger.info(
+            `Error retrieving profile for account ${accountId}, retrying in ${retryDelay}ms... (${e.message})`
+          );
+          retryCount++;
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+          continue;
+        }
+        const error = e;
+        const logMessage = `Failed to retrieve profile: ${error.message}`;
+        this.logger.error(logMessage);
+        return {
+          profile: null,
+          success: false,
+          error: logMessage
+        };
+      }
+    }
+    return {
+      profile: null,
+      success: false,
+      error: "Unexpected error in profile retrieval"
+    };
+  }
+  /**
+   * @deprecated Use retrieveCommunicationTopics instead
+   * @param accountId The account ID to retrieve the outbound connect topic for
+   * @returns {TopicInfo} Topic Info from target profile.
+   */
+  async retrieveOutboundConnectTopic(accountId) {
+    return await this.retrieveCommunicationTopics(accountId, true);
+  }
+  /**
+   * Retrieves the communication topics for an account
+   * @param accountId The account ID to retrieve the communication topics for
+   * @param disableCache Whether to disable caching of the result
+   * @param retryOptions Optional retry configuration
+   * @returns {TopicInfo} Topic Info from target profile.
+   */
+  async retrieveCommunicationTopics(accountId, disableCache, retryOptions) {
+    try {
+      const profileResponse = await this.retrieveProfile(
+        accountId,
+        disableCache,
+        retryOptions
+      );
+      if (!profileResponse?.success) {
+        throw new Error(profileResponse.error || "Failed to retrieve profile");
+      }
+      const profile = profileResponse.profile;
+      if (!profile) {
+        throw new Error(
+          `Profile is null or undefined for account ${accountId}`
+        );
+      }
+      if (!profile.inboundTopicId || !profile.outboundTopicId) {
+        throw new Error(
+          `Invalid HCS-11 profile for HCS-10 agent: missing inboundTopicId or outboundTopicId`
+        );
+      }
+      if (!profileResponse.topicInfo) {
+        throw new Error(
+          `TopicInfo is missing in the profile for account ${accountId}`
+        );
+      }
+      return profileResponse.topicInfo;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Failed to retrieve topic info: ${error.message}`;
+      this.logger.error(logMessage);
       throw error;
     }
   }
-  async disconnect() {
-    await this.client.quit();
+  /**
+   * Retrieves outbound messages for an agent
+   * @param agentAccountId The account ID of the agent
+   * @param options Optional filtering options for messages
+   * @returns The outbound messages
+   */
+  async retrieveOutboundMessages(agentAccountId, options) {
+    try {
+      const topicInfo = await this.retrieveCommunicationTopics(agentAccountId);
+      if (!topicInfo) {
+        this.logger.warn(
+          `No outbound connect topic found for agentAccountId: ${agentAccountId}`
+        );
+        return [];
+      }
+      const response = await this.getMessages(topicInfo.outboundTopic, options);
+      return response.messages.filter(
+        (msg) => msg.p === "hcs-10" && (msg.op === "connection_request" || msg.op === "connection_created" || msg.op === "message")
+      );
+    } catch (e) {
+      const error = e;
+      const logMessage = `Failed to retrieve outbound messages: ${error.message}`;
+      this.logger.error(logMessage);
+      return [];
+    }
+  }
+  /**
+   * Checks if a connection has been created for an agent
+   * @param agentAccountId The account ID of the agent
+   * @param connectionId The ID of the connection
+   * @returns True if the connection has been created, false otherwise
+   */
+  async hasConnectionCreated(agentAccountId, connectionId) {
+    try {
+      const outBoundTopic = await this.retrieveCommunicationTopics(agentAccountId);
+      const messages = await this.retrieveOutboundMessages(
+        outBoundTopic.outboundTopic
+      );
+      return messages.some(
+        (msg) => msg.op === "connection_created" && msg.connection_id === connectionId
+      );
+    } catch (e) {
+      const error = e;
+      const logMessage = `Failed to check connection created: ${error.message}`;
+      this.logger.error(logMessage);
+      return false;
+    }
   }
-  setLogLevel(level) {
-    this.logger.setLogLevel(level);
+  /**
+   * Gets message content, resolving any HRL references if needed
+   * @param data The data string that may contain an HRL reference
+   * @param forceRaw Whether to force returning raw binary data
+   * @returns The resolved content
+   */
+  async getMessageContent(data, forceRaw = false) {
+    if (!data.match(/^hcs:\/\/(\d+)\/([0-9]+\.[0-9]+\.[0-9]+)$/)) {
+      return data;
+    }
+    try {
+      const resolver = new HRLResolver(this.logger.getLevel());
+      if (!resolver.isValidHRL(data)) {
+        return data;
+      }
+      const result = await resolver.resolveHRL(data, {
+        network: this.network,
+        returnRaw: forceRaw
+      });
+      return result.content;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error resolving HRL reference: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
   }
-}
-function createRedisClient(logger, options, logConnectEvents) {
-  const Redis = getRedisConstructor();
-  if (!Redis) {
-    logger.warn(
-      "ioredis is not installed; RedisCache will use an in-memory cache instead"
+  /**
+   * Gets message content with its content type, resolving any HRL references if needed
+   * @param data The data string that may contain an HRL reference
+   * @param forceRaw Whether to force returning raw binary data
+   * @returns The resolved content along with content type information
+   */
+  async getMessageContentWithType(data, forceRaw = false) {
+    if (!data.match(/^hcs:\/\/(\d+)\/([0-9]+\.[0-9]+\.[0-9]+)$/)) {
+      return {
+        content: data,
+        contentType: "text/plain",
+        isBinary: false
+      };
+    }
+    try {
+      const resolver = new HRLResolver(this.logger.getLevel());
+      return await resolver.getContentWithType(data, {
+        network: this.network,
+        returnRaw: forceRaw
+      });
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error resolving HRL reference with type: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
+  /**
+   * Submits a connection request to an inbound topic
+   * @param inboundTopicId The ID of the inbound topic
+   * @param memo An optional memo for the message
+   * @returns The transaction receipt
+   */
+  async submitConnectionRequest(inboundTopicId, memo) {
+    const accountResponse = this.getAccountAndSigner();
+    if (!accountResponse?.accountId) {
+      throw new Error("Operator account ID is not set");
+    }
+    const operatorId = await this.getOperatorId();
+    const accountId = accountResponse.accountId;
+    const submissionCheck = await this.canSubmitToTopic(
+      inboundTopicId,
+      accountId
     );
-    return createInMemoryRedisClient();
-  }
-  const client = new Redis({
-    host: options.host,
-    port: options.port,
-    password: options.password,
-    db: options.db,
-    tls: options.tls,
-    keyPrefix: options.keyPrefix,
-    connectTimeout: options.connectTimeout,
-    retryStrategy: options.retryStrategy,
-    maxRetriesPerRequest: options.maxRetriesPerRequest
-  });
-  {
-    client.on("error", (error) => {
-      logger.error("Redis connection error:", error);
+    if (!submissionCheck?.canSubmit) {
+      throw new Error(`Cannot submit to topic: ${submissionCheck.reason}`);
+    }
+    const inboundAccountOwner = await this.retrieveInboundAccountId(inboundTopicId);
+    if (!inboundAccountOwner) {
+      throw new Error("Failed to retrieve topic info account ID");
+    }
+    const requiresFee = submissionCheck.requiresFee;
+    const connectionRequestTx = buildHcs10SubmitConnectionRequestTx({
+      inboundTopicId,
+      operatorId,
+      memo
+    });
+    const response = await this.submitPayload(
+      connectionRequestTx,
+      void 0,
+      void 0,
+      requiresFee
+    );
+    this.logger.info(
+      `Submitted connection request to topic ID: ${inboundTopicId}`
+    );
+    const outboundTopic = await this.retrieveCommunicationTopics(accountId);
+    if (!outboundTopic) {
+      throw new Error("Failed to retrieve outbound topic");
+    }
+    const responseSequenceNumber = response.topicSequenceNumber?.toNumber();
+    if (!responseSequenceNumber) {
+      throw new Error("Failed to get response sequence number");
+    }
+    const requestorOperatorId = `${inboundTopicId}@${inboundAccountOwner}`;
+    const outboundRecordTx = buildHcs10OutboundConnectionRequestRecordTx({
+      outboundTopicId: outboundTopic.outboundTopic,
+      operatorId: requestorOperatorId,
+      connectionRequestId: responseSequenceNumber,
+      memo
     });
-    client.on("connect", () => {
-      logger.debug("Redis connected");
+    await this.submitPayload(outboundRecordTx);
+    return response;
+  }
+  /**
+   * Records an outbound connection confirmation
+   * @param outboundTopicId The ID of the outbound topic
+   * @param connectionRequestId The ID of the connection request
+   * @param confirmedRequestId The ID of the confirmed request
+   * @param connectionTopicId The ID of the connection topic
+   * @param operatorId The operator ID of the original message sender.
+   * @param memo An optional memo for the message
+   */
+  async recordOutboundConnectionConfirmation({
+    outboundTopicId,
+    requestorOutboundTopicId,
+    connectionRequestId,
+    confirmedRequestId,
+    connectionTopicId,
+    operatorId,
+    memo
+  }) {
+    const transaction = buildHcs10OutboundConnectionCreatedRecordTx({
+      outboundTopicId,
+      requestorOutboundTopicId,
+      connectionTopicId,
+      confirmedRequestId,
+      connectionRequestId,
+      operatorId,
+      memo
     });
+    return await this.submitPayload(transaction);
   }
-  return client;
-}
-function getRedisConstructor() {
-  if (typeof require !== "function") {
-    return null;
+  /**
+   * Waits for confirmation of a connection request
+   * @param inboundTopicId Inbound topic ID
+   * @param connectionRequestId Connection request ID
+   * @param maxAttempts Maximum number of attempts
+   * @param delayMs Delay between attempts in milliseconds
+   * @returns Connection confirmation details
+   */
+  async waitForConnectionConfirmation(inboundTopicId, connectionRequestId, maxAttempts = 60, delayMs = 2e3, recordConfirmation = true) {
+    this.logger.info(
+      `Waiting for connection confirmation on inbound topic ${inboundTopicId} for request ID ${connectionRequestId}`
+    );
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      this.logger.info(
+        `Attempt ${attempt + 1}/${maxAttempts} to find connection confirmation`
+      );
+      const messages = await this.mirrorNode.getTopicMessages(inboundTopicId, {
+        order: "desc",
+        limit: 100
+      });
+      const connectionCreatedMessages = messages.filter(
+        (m) => m.op === "connection_created"
+      );
+      this.logger.info(
+        `Found ${connectionCreatedMessages.length} connection_created messages`
+      );
+      if (connectionCreatedMessages.length > 0) {
+        for (const message of connectionCreatedMessages) {
+          if (Number(message.connection_id) === Number(connectionRequestId)) {
+            const confirmationResult = {
+              connectionTopicId: message.connection_topic_id,
+              sequence_number: Number(message.sequence_number),
+              confirmedBy: message.operator_id,
+              memo: message.m
+            };
+            const confirmedByAccountId = this.extractAccountFromOperatorId(
+              confirmationResult.confirmedBy
+            );
+            const account = this.getAccountAndSigner();
+            const confirmedByConnectionTopics = await this.retrieveCommunicationTopics(confirmedByAccountId);
+            const agentConnectionTopics = await this.retrieveCommunicationTopics(account.accountId);
+            this.logger.info(
+              "Connection confirmation found",
+              confirmationResult
+            );
+            if (recordConfirmation) {
+              await this.recordOutboundConnectionConfirmation({
+                requestorOutboundTopicId: confirmedByConnectionTopics.outboundTopic,
+                outboundTopicId: agentConnectionTopics.outboundTopic,
+                connectionRequestId,
+                confirmedRequestId: confirmationResult.sequence_number,
+                connectionTopicId: confirmationResult.connectionTopicId,
+                operatorId: confirmationResult.confirmedBy,
+                memo: confirmationResult.memo || "Connection confirmed"
+              });
+            }
+            return confirmationResult;
+          }
+        }
+      }
+      if (attempt < maxAttempts - 1) {
+        this.logger.info(
+          `No matching confirmation found, waiting ${delayMs}ms before retrying...`
+        );
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    throw new Error(
+      `Connection confirmation not found after ${maxAttempts} attempts for request ID ${connectionRequestId}`
+    );
+  }
+  /**
+   * Retrieves the operator ID for the current agent
+   * @param disableCache Whether to disable caching of the result
+   * @returns The operator ID
+   */
+  async getOperatorId(disableCache) {
+    if (this.operatorId && !disableCache) {
+      return this.operatorId;
+    }
+    const accountResponse = this.getAccountAndSigner();
+    if (!accountResponse?.accountId) {
+      throw new Error("Operator ID not found");
+    }
+    const profile = await this.retrieveProfile(accountResponse.accountId);
+    if (!profile?.success) {
+      throw new Error("Failed to retrieve profile");
+    }
+    if (!profile?.topicInfo?.inboundTopic) {
+      throw new Error("Failed to retrieve inbound topic");
+    }
+    const operatorId = `${profile.topicInfo?.inboundTopic}@${accountResponse.accountId}`;
+    this.operatorId = operatorId;
+    return operatorId;
   }
-  try {
-    const loaded = require("ioredis");
-    if (typeof loaded === "function") {
-      return loaded;
+  /**
+   * Retrieves the account ID of the owner of an inbound topic
+   * @param inboundTopicId The ID of the inbound topic
+   * @returns The account ID of the owner of the inbound topic
+   */
+  async retrieveInboundAccountId(inboundTopicId) {
+    const topicInfo = await this.mirrorNode.getTopicInfo(inboundTopicId);
+    if (!topicInfo?.memo) {
+      throw new Error("Failed to retrieve topic info");
     }
-    if (typeof loaded.default === "function") {
-      return loaded.default;
+    const topicInfoMemo = topicInfo.memo.toString();
+    const topicInfoParts = topicInfoMemo.split(":");
+    const inboundAccountOwner = topicInfoParts?.[4];
+    if (!inboundAccountOwner) {
+      throw new Error("Failed to retrieve topic info account ID");
     }
-  } catch {
-    return null;
+    return inboundAccountOwner;
   }
-  return null;
-}
-function createInMemoryRedisClient() {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    async get(key) {
-      return store.get(key) ?? null;
-    },
-    async set(key, value) {
-      store.set(key, value);
-      return "OK";
-    },
-    async setex(key, _seconds, value) {
-      store.set(key, value);
-      return "OK";
-    },
-    async del(...keys) {
-      let deleted = 0;
-      for (const key of keys) {
-        if (store.delete(key)) {
-          deleted += 1;
+  clearCache() {
+    HCS10Cache.getInstance().clear();
+  }
+  /**
+   * Generates a standard HCS-10 memo string.
+   * @param type The type of topic memo ('inbound', 'outbound', 'connection').
+   * @param options Configuration options for the memo.
+   * @returns The formatted memo string.
+   * @protected
+   */
+  _generateHcs10Memo(type, options) {
+    const ttl = options.ttl ?? 60;
+    switch (type) {
+      case "inbound":
+        if (!options.accountId) {
+          throw new Error("accountId is required for inbound memo");
         }
+        return `hcs-10:0:${ttl}:0:${options.accountId}`;
+      case "outbound":
+        return `hcs-10:0:${ttl}:1`;
+      case "connection":
+        if (!options.inboundTopicId || options.connectionId === void 0) {
+          throw new Error(
+            "inboundTopicId and connectionId are required for connection memo"
+          );
+        }
+        return `hcs-10:1:${ttl}:2:${options.inboundTopicId}:${options.connectionId}`;
+      default:
+        throw new Error(`Invalid HCS-10 memo type: ${type}`);
+    }
+  }
+  /**
+   * Reads a topic's memo and determines its HCS-10 type
+   * @param topicId The topic ID to check
+   * @returns The HCS-10 memo type or null if not an HCS-10 topic
+   */
+  async getTopicMemoType(topicId) {
+    try {
+      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
+      if (!topicInfo?.memo) {
+        this.logger.debug(`No memo found for topic ${topicId}`);
+        return null;
+      }
+      const memo = topicInfo.memo.toString();
+      if (!memo.startsWith("hcs-10:")) {
+        this.logger.debug(`Topic ${topicId} is not an HCS-10 topic`);
+        return null;
+      }
+      const parts = memo.split(":");
+      if (parts.length < 4) {
+        this.logger.warn(
+          `Invalid HCS-10 memo format for topic ${topicId}: ${memo}`
+        );
+        return null;
       }
-      return deleted;
-    },
-    async keys(pattern) {
-      if (pattern.endsWith("*")) {
-        const prefix = pattern.slice(0, -1);
-        return Array.from(store.keys()).filter((key) => key.startsWith(prefix));
-      }
-      return store.has(pattern) ? [pattern] : [];
-    },
-    async quit() {
-      store.clear();
-    },
-    on() {
-      return;
-    }
-  };
+      const typeEnum = parts[3];
+      switch (typeEnum) {
+        case "0":
+          return "inbound";
+        case "1":
+          return "outbound";
+        case "2":
+          return "connection";
+        case "3":
+          return "registry";
+        default:
+          this.logger.warn(
+            `Unknown HCS-10 type enum: ${typeEnum} for topic ${topicId}`
+          );
+          return null;
+      }
+    } catch (error) {
+      this.logger.error(`Error getting topic memo type for ${topicId}:`, error);
+      return null;
+    }
+  }
+  async checkRegistrationStatus(transactionId, network, baseUrl) {
+    try {
+      const response = await fetch(`${baseUrl}/api/request-confirm`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Network": network
+        },
+        body: JSON.stringify({ transaction_id: transactionId })
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to confirm registration: ${response.statusText}`
+        );
+      }
+      return await response.json();
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error checking registration status: ${error.message}`;
+      this.logger.error(logMessage);
+      throw error;
+    }
+  }
+  /**
+   * Validates if an operator_id follows the correct format (agentTopicId@accountId)
+   * @param operatorId The operator ID to validate
+   * @returns True if the format is valid, false otherwise
+   */
+  isValidOperatorId(operatorId) {
+    if (!operatorId) {
+      return false;
+    }
+    const parts = operatorId.split("@");
+    if (parts.length !== 2) {
+      return false;
+    }
+    const agentTopicId = parts[0];
+    const accountId = parts[1];
+    if (!agentTopicId) {
+      return false;
+    }
+    if (!accountId) {
+      return false;
+    }
+    const hederaIdPattern = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+    if (!hederaIdPattern.test(accountId)) {
+      return false;
+    }
+    if (!hederaIdPattern.test(agentTopicId)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Retrieves all transaction requests from a topic
+   * @param topicId The topic ID to retrieve transactions from
+   * @param options Optional filtering and retrieval options
+   * @returns Array of transaction requests sorted by timestamp (newest first)
+   */
+  async getTransactionRequests(topicId, options) {
+    this.logger.debug(`Retrieving transaction requests from topic ${topicId}`);
+    const { messages } = await this.getMessageStream(topicId, {
+      limit: options?.limit,
+      sequenceNumber: options?.sequenceNumber,
+      order: options?.order || "desc"
+    });
+    const transactOperations = messages.filter((m) => m.op === "transaction" && m.schedule_id).map((m) => ({
+      operator_id: m.operator_id || "",
+      schedule_id: m.schedule_id || "",
+      data: m.data || "",
+      memo: m.m,
+      sequence_number: Number(m.sequence_number)
+    })).sort((a, b) => {
+      if (a.sequence_number && b.sequence_number) {
+        return b.sequence_number - a.sequence_number;
+      }
+      return 0;
+    });
+    const result = options?.limit ? transactOperations.slice(0, options.limit) : transactOperations;
+    return result;
+  }
+  /**
+   * Gets the HCS-10 transaction memo for analytics based on the operation type
+   * @param payload The operation payload
+   * @returns The transaction memo in format hcs-10:op:{operation_enum}:{topic_type_enum}
+   */
+  getHcs10TransactionMemo(payload) {
+    if (typeof payload !== "object" || !("op" in payload)) {
+      return null;
+    }
+    const typedPayload = payload;
+    const operation = typedPayload.op;
+    let operationEnum;
+    let topicTypeEnum;
+    switch (operation) {
+      case "register":
+        operationEnum = "0";
+        topicTypeEnum = "0";
+        break;
+      case "delete":
+        operationEnum = "1";
+        topicTypeEnum = "0";
+        break;
+      case "migrate":
+        operationEnum = "2";
+        topicTypeEnum = "0";
+        break;
+      case "connection_request":
+        operationEnum = "3";
+        topicTypeEnum = typedPayload.outbound_topic_id ? "2" : "1";
+        break;
+      case "connection_created":
+        operationEnum = "4";
+        topicTypeEnum = typedPayload.outbound_topic_id ? "2" : "1";
+        break;
+      case "connection_closed":
+        operationEnum = "5";
+        topicTypeEnum = typedPayload.outbound_topic_id ? "2" : "3";
+        break;
+      case "message":
+        operationEnum = "6";
+        topicTypeEnum = "3";
+        break;
+      case "close_connection":
+        operationEnum = "5";
+        topicTypeEnum = "3";
+        break;
+      case "transaction":
+        operationEnum = "6";
+        topicTypeEnum = "3";
+        break;
+      default:
+        operationEnum = "6";
+        topicTypeEnum = "3";
+    }
+    return `hcs-10:op:${operationEnum}:${topicTypeEnum}`;
+  }
+}
+class HCS10Cache {
+  constructor() {
+    this.CACHE_TTL = 36e5;
+    this.cache = /* @__PURE__ */ new Map();
+    this.cacheExpiry = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!HCS10Cache.instance) {
+      HCS10Cache.instance = new HCS10Cache();
+    }
+    return HCS10Cache.instance;
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+    this.cacheExpiry.set(key, Date.now() + this.CACHE_TTL);
+  }
+  get(key) {
+    const expiry = this.cacheExpiry.get(key);
+    if (expiry && expiry > Date.now()) {
+      return this.cache.get(key);
+    }
+    if (expiry) {
+      this.cache.delete(key);
+      this.cacheExpiry.delete(key);
+    }
+    return void 0;
+  }
+  clear() {
+    this.cache.clear();
+    this.cacheExpiry.clear();
+  }
 }
 export {
-  RedisCache
+  HCS10BaseClient,
+  HCS10Cache,
+  Hcs10MemoType
 };
 //# sourceMappingURL=standards-sdk.es16.js.map