@hashgraphonline/standards-sdk 0.0.63 → 0.0.65

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

@@ -1,987 +1,489 @@
-import Buffer from "./standards-sdk.es19.js";
-import { Client, PrivateKey, AccountCreateTransaction, Hbar, CustomFixedFee, AccountId, KeyList, TopicCreateTransaction, PublicKey, TopicMessageSubmitTransaction, TopicId, Transaction } from "@hashgraph/sdk";
-import { AccountCreationError, TopicCreationError, ConnectionConfirmationError, PayloadSizeError } from "./standards-sdk.es6.js";
-import { InscriptionSDK } from "./standards-sdk.es24.js";
+import Buffer from "./standards-sdk.es21.js";
 import { Logger } from "./standards-sdk.es14.js";
-import { HCS10BaseClient, Hcs10MemoType } from "./standards-sdk.es8.js";
-import { m as mimeTypesExports } from "./standards-sdk.es20.js";
-import { InboundTopicType } from "./standards-sdk.es12.js";
-import { HCS11Client } from "./standards-sdk.es13.js";
-import { accountIdsToExemptKeys } from "./standards-sdk.es15.js";
-class HCS10Client extends HCS10BaseClient {
+import { Registration } from "./standards-sdk.es9.js";
+import { HCS11Client } from "./standards-sdk.es12.js";
+import { PublicKey } from "@hashgraph/sdk";
+import "./standards-sdk.es25.js";
+import { HederaMirrorNode } from "./standards-sdk.es18.js";
+import axios from "./standards-sdk.es26.js";
+var Hcs10MemoType = /* @__PURE__ */ ((Hcs10MemoType2) => {
+  Hcs10MemoType2["INBOUND"] = "inbound";
+  Hcs10MemoType2["OUTBOUND"] = "outbound";
+  Hcs10MemoType2["CONNECTION"] = "connection";
+  return Hcs10MemoType2;
+})(Hcs10MemoType || {});
+class HCS10BaseClient extends Registration {
   constructor(config) {
-    super({
-      network: config.network,
-      logLevel: config.logLevel,
-      prettyPrint: config.prettyPrint,
-      feeAmount: config.feeAmount
-    });
-    this.client = config.network === "mainnet" ? Client.forMainnet() : Client.forTestnet();
-    this.operatorPrivateKey = PrivateKey.fromString(config.operatorPrivateKey);
+    super();
     this.network = config.network;
-    this.client.setOperator(
-      config.operatorId,
-      this.operatorPrivateKey.toString()
-    );
     this.logger = Logger.getInstance({
       level: config.logLevel || "info",
-      module: "HCS-SDK"
-    });
-    this.guardedRegistryBaseUrl = config.guardedRegistryBaseUrl || "https://moonscape.tech";
-    this.hcs11Client = new HCS11Client({
-      network: config.network,
-      auth: {
-        operatorId: config.operatorId,
-        privateKey: config.operatorPrivateKey
-      },
-      logLevel: config.logLevel
+      module: "HCS10-BaseClient",
+      prettyPrint: config.prettyPrint
     });
-  }
-  getClient() {
-    return this.client;
-  }
-  /**
-   * Creates a new Hedera account
-   * @returns Object with account ID and private key
-   */
-  async createAccount() {
-    this.logger.info("Creating new account");
-    const newKey = PrivateKey.generate();
-    const accountTransaction = new AccountCreateTransaction().setKey(newKey.publicKey).setInitialBalance(new Hbar(10));
-    this.logger.debug("Executing account creation transaction");
-    const accountResponse = await accountTransaction.execute(this.client);
-    const accountReceipt = await accountResponse.getReceipt(this.client);
-    const newAccountId = accountReceipt.accountId;
-    if (!newAccountId) {
-      this.logger.error("Account creation failed: accountId is null");
-      throw new AccountCreationError(
-        "Failed to create account: accountId is null"
-      );
-    }
-    this.logger.info(
-      `Account created successfully: ${newAccountId.toString()}`
+    this.mirrorNode = new HederaMirrorNode(
+      config.network,
+      this.logger
     );
-    return {
-      accountId: newAccountId.toString(),
-      privateKey: newKey.toString()
-    };
+    this.feeAmount = config.feeAmount || 1e-3;
   }
   /**
-   * Creates an inbound topic for an agent
-   * @param accountId The account ID associated with the inbound topic
-   * @param topicType Type of inbound topic (public, controlled, or fee-based)
-   * @param ttl Optional Time-To-Live for the topic memo, defaults to 60
-   * @param feeConfigBuilder Optional fee configuration builder for fee-based topics
-   * @returns The topic ID of the created inbound topic
+   * Get a stream of messages from a connection topic
+   * @param topicId The connection topic ID to get messages from
+   * @returns A stream of filtered messages valid for connection topics
    */
-  async createInboundTopic(accountId, topicType, ttl = 60, feeConfigBuilder) {
-    const memo = this._generateHcs10Memo(Hcs10MemoType.INBOUND, {
-      accountId,
-      ttl
-    });
-    let submitKey;
-    let feeConfig;
-    switch (topicType) {
-      case InboundTopicType.PUBLIC:
-        submitKey = false;
-        break;
-      case InboundTopicType.CONTROLLED:
-        submitKey = true;
-        break;
-      case InboundTopicType.FEE_BASED:
-        submitKey = true;
-        if (!feeConfigBuilder) {
-          throw new Error(
-            "Fee configuration builder is required for fee-based topics"
-          );
+  async getMessageStream(topicId) {
+    try {
+      const messages = await this.mirrorNode.getTopicMessages(topicId);
+      const validOps = ["message", "close_connection"];
+      const filteredMessages = messages.filter((msg) => {
+        if (msg.p !== "hcs-10" || !validOps.includes(msg.op)) {
+          return false;
         }
-        feeConfig = feeConfigBuilder.build();
-        break;
-      default:
-        throw new Error(`Unsupported inbound topic type: ${topicType}`);
-    }
-    return this.createTopic(memo, true, submitKey, feeConfig);
-  }
-  /**
-   * Creates a new agent with inbound and outbound topics
-   * @param builder The agent builder object
-   * @param ttl Optional Time-To-Live for the topic memos, defaults to 60
-   * @returns Object with topic IDs
-   */
-  async createAgent(builder, ttl = 60) {
-    const config = builder.build();
-    const outboundMemo = this._generateHcs10Memo(Hcs10MemoType.OUTBOUND, {
-      ttl
-    });
-    const outboundTopicId = await this.createTopic(outboundMemo, true, true);
-    this.logger.info(`Created new outbound topic ID: ${outboundTopicId}`);
-    const accountId = this.client.operatorAccountId?.toString();
-    if (!accountId) {
-      throw new Error("Failed to retrieve operator account ID");
-    }
-    const inboundTopicId = await this.createInboundTopic(
-      accountId,
-      config.inboundTopicType,
-      ttl,
-      config.inboundTopicType === InboundTopicType.FEE_BASED ? config.feeConfig : void 0
-    );
-    let pfpTopicId = config.existingPfpTopicId || "";
-    if (!pfpTopicId && config.pfpBuffer && config.pfpBuffer.length > 0) {
-      this.logger.info("Inscribing new profile picture");
-      const pfpResult = await this.inscribePfp(
-        config.pfpBuffer,
-        config.pfpFileName
-      );
-      pfpTopicId = pfpResult.pfpTopicId;
-      this.logger.info(
-        `Profile picture inscribed with topic ID: ${pfpTopicId}`
-      );
-    } else if (config.existingPfpTopicId) {
-      this.logger.info(
-        `Using existing profile picture with topic ID: ${config.existingPfpTopicId}`
-      );
+        if (msg.op === "message") {
+          if (!msg.data) {
+            return false;
+          }
+          if (!msg.operator_id) {
+            return false;
+          }
+          if (!this.isValidOperatorId(msg.operator_id)) {
+            return false;
+          }
+        }
+        if (msg.op === "close_connection") {
+          if (!msg.operator_id) {
+            return false;
+          }
+          if (!this.isValidOperatorId(msg.operator_id)) {
+            return false;
+          }
+        }
+        return true;
+      });
+      return {
+        messages: filteredMessages
+      };
+    } catch (error) {
+      if (this.logger) {
+        this.logger.error(`Error fetching messages: ${error.message}`);
+      }
+      return { messages: [] };
     }
-    const profileResult = await this.storeHCS11Profile(
-      config.name,
-      config.description,
-      inboundTopicId,
-      outboundTopicId,
-      config.capabilities,
-      config.metadata,
-      config.pfpBuffer && config.pfpBuffer.length > 0 ? config.pfpBuffer : void 0,
-      config.pfpFileName,
-      config.existingPfpTopicId
-    );
-    const profileTopicId = profileResult.profileTopicId;
-    this.logger.info(`Profile stored with topic ID: ${profileTopicId}`);
-    return {
-      inboundTopicId,
-      outboundTopicId,
-      pfpTopicId,
-      profileTopicId
-    };
   }
   /**
-   * Inscribes a profile picture to Hedera
-   * @param buffer Profile picture buffer
-   * @param fileName Filename
-   * @returns Response with topic ID and transaction ID
+   * 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 inscribePfp(buffer, fileName) {
+  async canSubmitToTopic(topicId, userAccountId) {
     try {
-      this.logger.info("Inscribing profile picture using HCS-11 client");
-      const imageResult = await this.hcs11Client.inscribeImage(
-        buffer,
-        fileName
-      );
-      if (!imageResult.success) {
+      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(
-          `Failed to inscribe profile picture: ${imageResult.error}`
-        );
-        throw new Error(
-          imageResult?.error || "Failed to inscribe profile picture"
+          `Key validation error: ${error instanceof Error ? error.message : String(error)}`
         );
       }
-      this.logger.info(
-        `Successfully inscribed profile picture with topic ID: ${imageResult.imageTopicId}`
-      );
+      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 {
-        pfpTopicId: imageResult.imageTopicId,
-        transactionId: imageResult.transactionId,
-        success: true
+        canSubmit: false,
+        requiresFee: false,
+        reason: "User does not have submit permission for this topic"
       };
     } catch (error) {
-      this.logger.error(`Error inscribing profile picture: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Topic submission validation error: ${errorMessage}`);
       return {
-        pfpTopicId: "",
-        transactionId: "",
-        success: false,
-        error: error.message
+        canSubmit: false,
+        requiresFee: false,
+        reason: `Error: ${errorMessage}`
       };
     }
   }
   /**
-   * Stores an HCS-11 profile for an agent
-   * @param agentName Agent name
-   * @param agentDescription Agent description
-   * @param inboundTopicId Inbound topic ID
-   * @param outboundTopicId Outbound topic ID
-   * @param capabilities Agent capability tags
-   * @param metadata Additional metadata
-   * @param pfpBuffer Optional profile picture buffer
-   * @param pfpFileName Optional profile picture filename
-   * @returns Response with topic IDs and transaction ID
+   * Get all messages from a topic
+   * @param topicId The topic ID to get messages from
+   * @returns All messages from the topic
    */
-  async storeHCS11Profile(agentName, agentDescription, inboundTopicId, outboundTopicId, capabilities = [], metadata, pfpBuffer, pfpFileName, existingPfpTopicId) {
+  async getMessages(topicId) {
     try {
-      let pfpTopicId = existingPfpTopicId || "";
-      if (!pfpTopicId && pfpBuffer && pfpFileName) {
-        this.logger.info("Inscribing profile picture for HCS-11 profile");
-        const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
-        if (!pfpResult.success) {
-          this.logger.error(
-            "Failed to inscribe profile picture, continuing without PFP"
-          );
-        } else {
-          pfpTopicId = pfpResult.pfpTopicId;
+      const messages = await this.mirrorNode.getTopicMessages(topicId);
+      const validatedMessages = messages.filter((msg) => {
+        if (msg.p !== "hcs-10") {
+          return false;
         }
-      } else if (existingPfpTopicId) {
-        this.logger.info(
-          `Using existing profile picture with topic ID: ${existingPfpTopicId} for HCS-11 profile`
-        );
+        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) {
+      if (this.logger) {
+        this.logger.error(`Error fetching messages: ${error.message}`);
       }
-      const agentType = this.hcs11Client.getAgentTypeFromMetadata({
-        type: metadata.type || "autonomous"
+      return { messages: [] };
+    }
+  }
+  async requestAccount(account) {
+    try {
+      return await this.mirrorNode.requestAccount(account);
+    } catch (e) {
+      this.logger.error("Failed to fetch account", e);
+      throw e;
+    }
+  }
+  async getAccountMemo(accountId) {
+    return await this.mirrorNode.getAccountMemo(accountId);
+  }
+  async retrieveProfile(accountId) {
+    this.logger.info(`Retrieving profile for account: ${accountId}`);
+    try {
+      const hcs11Client = new HCS11Client({
+        network: this.network,
+        auth: {
+          operatorId: "0.0.0"
+          // Read-only operations only
+        },
+        logLevel: "info"
       });
-      const formattedSocials = metadata.socials ? Object.entries(metadata.socials).filter(([_, handle]) => handle).map(([platform, handle]) => ({
-        platform: platform === "x" ? "twitter" : platform,
-        handle
-      })) : void 0;
-      const profile = this.hcs11Client.createAIAgentProfile(
-        agentName,
-        agentType,
-        capabilities,
-        metadata.model || "unknown",
-        {
-          alias: agentName.toLowerCase().replace(/\s+/g, "_"),
-          bio: agentDescription,
-          profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
-          socials: formattedSocials,
-          properties: metadata.properties,
-          inboundTopicId,
-          outboundTopicId,
-          creator: metadata.creator
-        }
-      );
-      const profileResult = await this.hcs11Client.createAndInscribeProfile(
-        profile,
-        true
+      const profileResult = await hcs11Client.fetchProfileByAccountId(
+        accountId,
+        this.network
       );
-      if (!profileResult.success) {
-        this.logger.error(`Failed to inscribe profile: ${profileResult.error}`);
-        throw new Error(profileResult.error || "Failed to inscribe profile");
+      if (!profileResult?.success) {
+        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;
+      if (profileResult.topicInfo?.inboundTopic && profileResult.topicInfo?.outboundTopic && profileResult.topicInfo?.profileTopicId) {
+        topicInfo = {
+          inboundTopic: profileResult.topicInfo.inboundTopic,
+          outboundTopic: profileResult.topicInfo.outboundTopic,
+          profileTopicId: profileResult.topicInfo.profileTopicId
+        };
+        const cacheKey = `${accountId}-${this.network}`;
+        HCS10Cache.getInstance().set(cacheKey, topicInfo);
       }
-      this.logger.info(
-        `Profile inscribed with topic ID: ${profileResult.profileTopicId}, transaction ID: ${profileResult.transactionId}`
-      );
       return {
-        profileTopicId: profileResult.profileTopicId,
-        pfpTopicId,
-        transactionId: profileResult.transactionId,
+        profile,
+        topicInfo,
         success: true
       };
     } catch (error) {
-      this.logger.error(`Error storing HCS-11 profile: ${error.message}`);
+      this.logger.error("Failed to retrieve profile:", error);
       return {
-        profileTopicId: "",
-        pfpTopicId: "",
-        transactionId: "",
+        profile: null,
         success: false,
-        error: error.message
+        error: error instanceof Error ? error.message : String(error)
       };
     }
   }
-  async setupFees(transaction, feeConfig, additionalExemptAccounts = []) {
-    if (!this.client.operatorPublicKey) {
-      return;
-    }
-    this.logger.info("Setting up topic with custom fees");
-    const customFee = new CustomFixedFee().setAmount(Number(feeConfig.feeAmount.amount)).setFeeCollectorAccountId(
-      AccountId.fromString(feeConfig.feeCollectorAccountId)
-    );
-    let exemptAccountIds = [
-      ...feeConfig.exemptAccounts || [],
-      ...additionalExemptAccounts
-    ];
-    console.log("exemptAccountIds", exemptAccountIds);
-    if (exemptAccountIds.length > 0) {
-      const uniqueExemptAccountIds = Array.from(new Set(exemptAccountIds));
-      const filteredExemptAccounts = uniqueExemptAccountIds.filter(
-        (account) => account !== this.client.operatorAccountId?.toString()
-      );
-      let exemptKeys = [];
-      if (filteredExemptAccounts.length > 0) {
-        try {
-          exemptKeys = await accountIdsToExemptKeys(
-            filteredExemptAccounts,
-            this.network,
-            this.logger
-          );
-        } catch (error) {
-          this.logger.warn(
-            `Error getting exempt keys: ${error}, continuing without exempt keys`
-          );
-        }
+  async retrieveOutboundConnectTopic(accountId) {
+    this.logger.info(`Retrieving topics for account: ${accountId}`);
+    try {
+      const profileResponse = await this.retrieveProfile(accountId);
+      if (!profileResponse?.success) {
+        throw new Error(profileResponse.error || "Failed to retrieve profile");
       }
-      if (exemptKeys.length > 0) {
-        transaction.setFeeExemptKeys(exemptKeys);
+      const profile = profileResponse.profile;
+      if (!profile.inboundTopicId || !profile.outboundTopicId) {
+        throw new Error(
+          `Invalid HCS-11 profile for HCS-10 agent: missing inboundTopicId or outboundTopicId`
+        );
       }
+      const topicInfo = {
+        inboundTopic: profile.inboundTopicId,
+        outboundTopic: profile.outboundTopicId,
+        profileTopicId: profile.profileTopicId
+      };
+      const cacheKey = `${accountId}-${this.network}`;
+      HCS10Cache.getInstance().set(cacheKey, topicInfo);
+      return topicInfo;
+    } catch (error) {
+      this.logger.error("Failed to retrieve topic info:", error);
+      throw error;
     }
-    transaction.setFeeScheduleKey(this.client.operatorPublicKey).setCustomFees([customFee]);
   }
-  /**
-   * Handles a connection request from another account
-   * @param inboundTopicId Inbound topic ID
-   * @param requestingAccountId Requesting account ID
-   * @param connectionRequestId Connection request ID
-   * @param connectionFeeConfig Optional fee configuration for the connection topic
-   * @param ttl Optional ttl parameter with default
-   * @returns Response with connection details
-   */
-  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionRequestId, connectionFeeConfig, ttl = 60) {
-    const memo = this._generateHcs10Memo(Hcs10MemoType.CONNECTION, {
-      ttl,
-      inboundTopicId,
-      connectionId: connectionRequestId
-    });
-    this.logger.info(
-      `Handling connection request ${connectionRequestId} from ${requestingAccountId}`
-    );
-    const accountId = this.getClient().operatorAccountId?.toString();
-    if (!accountId) {
-      throw new Error("Failed to retrieve operator account ID");
-    }
-    let requesterKey = await this.mirrorNode.getPublicKey(requestingAccountId);
-    const accountKey = await this.mirrorNode.getPublicKey(accountId);
-    if (!accountKey) {
-      throw new Error("Failed to retrieve public key");
-    }
-    const thresholdKey = new KeyList([accountKey, requesterKey], 1);
-    let connectionTopicId;
+  async retrieveOutboundMessages(agentAccountId) {
     try {
-      if (connectionFeeConfig) {
-        const feeConfig = connectionFeeConfig.build();
-        const modifiedFeeConfig = {
-          ...feeConfig,
-          exemptAccounts: [...feeConfig.exemptAccounts || []]
-        };
-        connectionTopicId = await this.createTopic(
-          memo,
-          thresholdKey,
-          thresholdKey,
-          modifiedFeeConfig
-        );
-      } else {
-        connectionTopicId = await this.createTopic(
-          memo,
-          thresholdKey,
-          thresholdKey
+      const topicInfo = await this.retrieveOutboundConnectTopic(agentAccountId);
+      if (!topicInfo) {
+        this.logger.warn(
+          `No outbound connect topic found for agentAccountId: ${agentAccountId}`
         );
+        return [];
       }
-      this.logger.info(`Created new connection topic ID: ${connectionTopicId}`);
-    } catch (error) {
-      this.logger.error(`Failed to create connection topic: ${error}`);
-      throw new TopicCreationError(
-        `Failed to create connection topic: ${error}`
+      const response = await this.getMessages(topicInfo.outboundTopic);
+      return response.messages.filter(
+        (msg) => msg.p === "hcs-10" && (msg.op === "connection_request" || msg.op === "connection_created" || msg.op === "message")
       );
+    } catch (error) {
+      this.logger.error("Failed to retrieve outbound messages:", error);
+      return [];
     }
-    const operatorId = `${inboundTopicId}@${accountId}`;
-    const confirmedConnectionSequenceNumber = await this.confirmConnection(
-      inboundTopicId,
-      connectionTopicId,
-      requestingAccountId,
-      connectionRequestId,
-      "Connection accepted. Looking forward to collaborating!"
-    );
-    return {
-      connectionTopicId,
-      confirmedConnectionSequenceNumber,
-      operatorId
-    };
   }
-  async confirmConnection(inboundTopicId, connectionTopicId, connectedAccountId, connectionId, memo, submitKey) {
-    const operatorId = await this.getOperatorId();
-    this.logger.info(`Confirming connection with ID ${connectionId}`);
-    const payload = {
-      p: "hcs-10",
-      op: "connection_created",
-      connection_topic_id: connectionTopicId,
-      connected_account_id: connectedAccountId,
-      operator_id: operatorId,
-      connection_id: connectionId,
-      m: memo
-    };
-    const submissionCheck = await this.canSubmitToTopic(
-      inboundTopicId,
-      this.client.operatorAccountId?.toString() || ""
-    );
-    const result = await this.submitPayload(
-      inboundTopicId,
-      payload,
-      submitKey,
-      submissionCheck.requiresFee
-    );
-    const sequenceNumber = result.topicSequenceNumber?.toNumber();
-    if (!sequenceNumber) {
-      throw new ConnectionConfirmationError(
-        "Failed to confirm connection: sequence number is null"
+  async hasConnectionCreated(agentAccountId, connectionId) {
+    try {
+      const outBoundTopic = await this.retrieveOutboundConnectTopic(
+        agentAccountId
       );
-    }
-    return sequenceNumber;
-  }
-  async sendMessage(connectionTopicId, data, memo, submitKey) {
-    const submissionCheck = await this.canSubmitToTopic(
-      connectionTopicId,
-      this.client.operatorAccountId?.toString() || ""
-    );
-    const operatorId = await this.getOperatorId();
-    const payload = {
-      p: "hcs-10",
-      op: "message",
-      operator_id: operatorId,
-      data,
-      m: memo
-    };
-    const payloadString = JSON.stringify(payload);
-    const isLargePayload = Buffer.from(payloadString).length > 1e3;
-    if (isLargePayload) {
-      this.logger.info(
-        "Message payload exceeds 1000 bytes, storing via inscription"
+      const messages = await this.retrieveOutboundMessages(
+        outBoundTopic.outboundTopic
       );
-      try {
-        const contentBuffer = Buffer.from(data);
-        const fileName = `message-${Date.now()}.json`;
-        const inscriptionResult = await this.inscribeFile(
-          contentBuffer,
-          fileName
-        );
-        if (inscriptionResult?.topic_id) {
-          payload.data = `hcs://1/${inscriptionResult.topic_id}`;
-          this.logger.info(
-            `Large message inscribed with topic ID: ${inscriptionResult.topic_id}`
-          );
-        } else {
-          throw new Error("Failed to inscribe large message content");
-        }
-      } catch (error) {
-        this.logger.error("Error inscribing large message:", error);
-        throw new Error(
-          `Failed to handle large message: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
+      return messages.some(
+        (msg) => msg.op === "connection_created" && msg.connection_id === connectionId
+      );
+    } catch (error) {
+      this.logger.error("Failed to check connection created:", error);
+      return false;
     }
-    this.logger.info("Submitting message to connection topic", payload);
-    return await this.submitPayload(
-      connectionTopicId,
-      payload,
-      submitKey,
-      submissionCheck.requiresFee
-    );
   }
-  async createTopic(memo, adminKey, submitKey, feeConfig) {
-    this.logger.info("Creating topic");
-    const transaction = new TopicCreateTransaction().setTopicMemo(memo);
-    if (adminKey) {
-      if (typeof adminKey === "boolean" && adminKey && this.client.operatorPublicKey) {
-        transaction.setAdminKey(this.client.operatorPublicKey);
-        transaction.setAutoRenewAccountId(this.client.operatorAccountId);
-      } else if (adminKey instanceof PublicKey || adminKey instanceof KeyList) {
-        transaction.setAdminKey(adminKey);
-        if (this.client.operatorAccountId) {
-          transaction.setAutoRenewAccountId(this.client.operatorAccountId);
-        }
-      }
+  /**
+   * Gets message content, resolving any HRL references if needed
+   * @param data The message data which might be an HRL reference
+   * @returns The resolved content
+   */
+  async getMessageContent(data) {
+    const hrlPattern = /^hcs:\/\/(\d+)\/([0-9.]+)$/;
+    const match = data.match(hrlPattern);
+    if (!match) {
+      return data;
     }
-    if (submitKey) {
-      if (typeof submitKey === "boolean" && submitKey && this.client.operatorPublicKey) {
-        transaction.setSubmitKey(this.client.operatorPublicKey);
-      } else if (submitKey instanceof PublicKey || submitKey instanceof KeyList) {
-        transaction.setSubmitKey(submitKey);
+    const [_, standard, topicId] = match;
+    this.logger.info(
+      `Resolving HRL reference: standard=${standard}, topicId=${topicId}`
+    );
+    try {
+      const cdnUrl = `https://kiloscribe.com/api/inscription-cdn/${topicId}?network=${this.network}`;
+      const response = await axios.get(cdnUrl);
+      if (!response.data) {
+        throw new Error(`Failed to fetch content from topic: ${topicId}`);
       }
-    }
-    if (feeConfig) {
-      await this.setupFees(transaction, feeConfig);
-    }
-    this.logger.debug("Executing topic creation transaction");
-    const txResponse = await transaction.execute(this.client);
-    const receipt = await txResponse.getReceipt(this.client);
-    if (!receipt.topicId) {
-      this.logger.error("Failed to create topic: topicId is null");
-      throw new Error("Failed to create topic: topicId is null");
-    }
-    const topicId = receipt.topicId.toString();
-    return topicId;
-  }
-  async submitPayload(topicId, payload, submitKey, requiresFee = false) {
-    const message = typeof payload === "string" ? payload : JSON.stringify(payload);
-    const payloadSizeInBytes = Buffer.byteLength(message, "utf8");
-    if (payloadSizeInBytes > 1e3) {
-      throw new PayloadSizeError(
-        "Payload size exceeds 1000 bytes limit",
-        payloadSizeInBytes
+      return response.data.content || response.data.text || JSON.stringify(response.data);
+    } catch (error) {
+      this.logger.error(
+        `Error resolving HRL reference: ${error instanceof Error ? error.message : "Unknown error"}`
       );
-    }
-    const transaction = new TopicMessageSubmitTransaction().setTopicId(TopicId.fromString(topicId)).setMessage(message);
-    if (requiresFee) {
-      this.logger.info(
-        "Topic requires fee payment, setting max transaction fee"
+      throw new Error(
+        `Failed to resolve HRL reference: ${error instanceof Error ? error.message : "Unknown error"}`
       );
-      transaction.setMaxTransactionFee(new Hbar(this.feeAmount));
-      transaction.setTransactionMemo("HIP-991 Fee Payment");
-    }
-    let transactionResponse;
-    if (submitKey) {
-      const frozenTransaction = transaction.freezeWith(this.client);
-      const signedTransaction = await frozenTransaction.sign(submitKey);
-      transactionResponse = await signedTransaction.execute(this.client);
-    } else {
-      transactionResponse = await transaction.execute(this.client);
     }
-    const receipt = await transactionResponse.getReceipt(this.client);
-    if (!receipt) {
-      this.logger.error("Failed to submit message: receipt is null");
-      throw new Error("Failed to submit message: receipt is null");
-    }
-    this.logger.info("Message submitted successfully");
-    return 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
-    );
-    if (!submissionCheck.canSubmit) {
-      throw new Error(`Cannot submit to topic: ${submissionCheck.reason}`);
-    }
-    const connectionRequestMessage = {
+  /**
+   * 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 message sender
+   * @param memo An optional memo for the message
+   */
+  async recordOutboundConnectionConfirmation({
+    outboundTopicId,
+    connectionRequestId,
+    confirmedRequestId,
+    connectionTopicId,
+    operatorId,
+    memo
+  }) {
+    const payload = {
       p: "hcs-10",
-      op: "connection_request",
+      op: "connection_created",
+      connection_topic_id: connectionTopicId,
+      outbound_topic_id: outboundTopicId,
+      confirmed_request_id: confirmedRequestId,
+      connection_request_id: connectionRequestId,
       operator_id: operatorId,
       m: memo
     };
-    const requiresFee = submissionCheck.requiresFee;
-    const response = await this.submitPayload(
-      inboundTopicId,
-      connectionRequestMessage,
-      void 0,
-      requiresFee
-    );
-    this.logger.info(
-      `Submitted connection request to topic ID: ${inboundTopicId}`
-    );
-    const outboundTopic = await this.retrieveOutboundConnectTopic(accountId);
-    const responseSequenceNumber = response.topicSequenceNumber?.toNumber();
-    if (!responseSequenceNumber) {
-      throw new Error("Failed to get response sequence number");
-    }
-    await this.submitPayload(outboundTopic.outboundTopic, {
-      ...connectionRequestMessage,
-      outbound_topic_id: outboundTopic.outboundTopic,
-      connection_request_id: responseSequenceNumber
-    });
-    return response;
+    return await this.submitPayload(outboundTopicId, payload);
   }
-  async inscribeFile(buffer, fileName) {
-    this.logger.info("Inscribing file");
-    if (!this.client.operatorAccountId) {
-      this.logger.error("Operator account ID is not set");
-      throw new Error("Operator account ID is not set");
-    }
-    if (!this.operatorPrivateKey) {
-      this.logger.error("Operator private key is not set");
-      throw new Error("Operator private key is not set");
+  async getOperatorId(disableCache) {
+    if (this.operatorId && !disableCache) {
+      return this.operatorId;
     }
-    const mimeType = mimeTypesExports.lookup(fileName) || "application/octet-stream";
-    const sdk = await InscriptionSDK.createWithAuth({
-      type: "server",
-      accountId: this.client.operatorAccountId.toString(),
-      privateKey: this.operatorPrivateKey.toString(),
-      network: this.network
-    });
-    const result = await sdk.inscribeAndExecute(
-      {
-        file: {
-          type: "base64",
-          base64: buffer.toString("base64"),
-          fileName,
-          mimeType
-        },
-        holderId: this.client.operatorAccountId.toString(),
-        mode: "file",
-        network: this.network
-      },
-      {
-        accountId: this.client.operatorAccountId.toString(),
-        privateKey: this.operatorPrivateKey.toString(),
-        network: this.network
-      }
-    );
-    if (!result.transactionId || !result.jobId) {
-      this.logger.error("Failed to inscribe, no transaction ID or job ID.");
-      throw new Error("Failed to inscribe, no transaction ID or job ID.");
+    const accountResponse = this.getAccountAndSigner();
+    if (!accountResponse.accountId) {
+      throw new Error("Operator ID not found");
     }
-    if (result.transactionId && result.jobId) {
-      this.logger.info(
-        `Transaction ID: ${result.transactionId}, Job ID: ${result.jobId}`
-      );
+    const profile = await this.retrieveProfile(accountResponse.accountId);
+    if (!profile.success) {
+      throw new Error("Failed to retrieve profile");
     }
-    const status = await sdk.waitForInscription(result.jobId, 30, 4e3, true);
-    return status;
+    const operatorId = `${profile.topicInfo?.inboundTopic}@${accountResponse.accountId}`;
+    this.operatorId = operatorId;
+    return operatorId;
   }
-  /**
-   * 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) {
-    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);
-      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)) {
-            this.logger.info("Connection confirmation found");
-            return {
-              connectionTopicId: message.connection_topic_id,
-              sequence_number: Number(message.sequence_number),
-              confirmedBy: message.operator_id,
-              memo: message.m
-            };
-          }
-        }
-      }
-      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}`
-    );
-  }
-  getAccountAndSigner() {
-    return {
-      accountId: this.client.operatorAccountId.toString(),
-      signer: this.operatorPrivateKey
-    };
+  clearCache() {
+    HCS10Cache.getInstance().clear();
   }
   /**
-   * Creates and registers an agent with a Guarded registry.
-   *
-   * This function performs the following steps:
-   * 1. Creates a new account if no existing account is provided.
-   * 2. Initializes an HCS10 client with the new account.
-   * 3. Creates an agent on the client.
-   * 4. Registers the agent with the Hashgraph Online Guarded Registry.
-   *
-   * @param builder The agent builder object
-   * @param options Optional configuration including progress callback and state management
-   * @returns Agent registration result
+   * 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
    */
-  async createAndRegisterAgent(builder, options) {
-    try {
-      const config = builder.build();
-      const progressCallback = options?.progressCallback;
-      const baseUrl = options?.baseUrl || this.guardedRegistryBaseUrl;
-      let state = options?.existingState || void 0;
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Preparing agent registration",
-          progressPercent: 10,
-          details: { state }
-        });
-      }
-      const account = config.existingAccount || await this.createAccount();
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Created account or using existing account",
-          progressPercent: 20,
-          details: { state, account }
-        });
-      }
-      const agentClient = new HCS10Client({
-        network: config.network,
-        operatorId: account.accountId,
-        operatorPrivateKey: account.privateKey,
-        operatorPublicKey: PrivateKey.fromString(
-          account.privateKey
-        ).publicKey.toString(),
-        logLevel: "info",
-        guardedRegistryBaseUrl: baseUrl
-      });
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Initialized agent client",
-          progressPercent: 30,
-          details: { state }
-        });
-      }
-      const { outboundTopicId, inboundTopicId, pfpTopicId, profileTopicId } = await agentClient.createAgent(builder);
-      if (progressCallback) {
-        progressCallback({
-          stage: "submitting",
-          message: "Created agent with topics and profile",
-          progressPercent: 60,
-          details: {
-            state,
-            outboundTopicId,
-            inboundTopicId,
-            pfpTopicId,
-            profileTopicId
-          }
-        });
-      }
-      const operatorId = `${inboundTopicId}@${account.accountId}`;
-      const registrationResult = await agentClient.registerAgentWithGuardedRegistry(
-        account.accountId,
-        config.network,
-        {
-          progressCallback: (data) => {
-            const adjustedPercent = 60 + (data.progressPercent || 0) * 0.4;
-            if (progressCallback) {
-              progressCallback({
-                stage: data.stage,
-                message: data.message,
-                progressPercent: adjustedPercent,
-                details: {
-                  ...data.details,
-                  outboundTopicId,
-                  inboundTopicId,
-                  pfpTopicId,
-                  profileTopicId,
-                  operatorId,
-                  state: data.details?.state || state
-                }
-              });
-            }
-          },
-          existingState: state
+  _generateHcs10Memo(type, options) {
+    const ttl = options.ttl ?? 60;
+    switch (type) {
+      case "inbound":
+        if (!options.accountId) {
+          throw new Error("accountId is required for inbound memo");
         }
-      );
-      if (!registrationResult.success) {
-        return registrationResult;
-      }
-      if (progressCallback) {
-        progressCallback({
-          stage: "completed",
-          message: "Agent creation and registration complete",
-          progressPercent: 100,
-          details: {
-            outboundTopicId,
-            inboundTopicId,
-            pfpTopicId,
-            profileTopicId,
-            operatorId,
-            state: registrationResult.state
-          }
-        });
-      }
-      return {
-        ...registrationResult,
-        metadata: {
-          accountId: account.accountId,
-          privateKey: account.privateKey,
-          operatorId,
-          inboundTopicId,
-          outboundTopicId,
-          profileTopicId,
-          pfpTopicId
+        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"
+          );
         }
-      };
-    } catch (error) {
-      this.logger.error(
-        `Failed to create and register agent: ${error.message}`
-      );
-      return {
-        error: error.message,
-        success: false
-      };
+        return `hcs-10:1:${ttl}:2:${options.inboundTopicId}:${options.connectionId}`;
+      default:
+        throw new Error(`Invalid HCS-10 memo type: ${type}`);
     }
   }
-  /**
-   * Registers an agent with the guarded registry
-   * @param accountId Account ID to register
-   * @param inboundTopicId Inbound topic ID for the agent
-   * @param network Network type ('mainnet' or 'testnet')
-   * @param options Optional configuration including progress callback and confirmation settings
-   * @returns Registration result
-   */
-  async registerAgentWithGuardedRegistry(accountId, network = this.network, options) {
+  async checkRegistrationStatus(transactionId, network, baseUrl) {
     try {
-      this.logger.info("Registering agent with guarded registry");
-      const maxAttempts = options?.maxAttempts ?? 60;
-      const delayMs = options?.delayMs ?? 2e3;
-      const progressCallback = options?.progressCallback;
-      let state = options?.existingState || {
-        currentStage: "registration",
-        completedPercentage: 0,
-        createdResources: []
-      };
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Preparing agent registration",
-          progressPercent: 10,
-          details: {
-            state
-          }
-        });
-      }
-      const registrationResult = await this.executeRegistration(
-        accountId,
-        network,
-        this.guardedRegistryBaseUrl,
-        this.logger
-      );
-      if (!registrationResult.success) {
-        return {
-          ...registrationResult,
-          state
-        };
-      }
-      if (progressCallback) {
-        progressCallback({
-          stage: "submitting",
-          message: "Submitting registration to registry",
-          progressPercent: 30,
-          details: {
-            transactionId: registrationResult.transactionId,
-            state
-          }
-        });
-      }
-      if (registrationResult.transaction) {
-        const transaction = Transaction.fromBytes(
-          Buffer.from(registrationResult.transaction, "base64")
-        );
-        this.logger.info(`Processing registration transaction`);
-        await transaction.execute(this.client);
-        this.logger.info(`Successfully processed registration transaction`);
-      }
-      if (progressCallback) {
-        progressCallback({
-          stage: "confirming",
-          message: "Confirming registration transaction",
-          progressPercent: 60,
-          details: {
-            accountId,
-            transactionId: registrationResult.transactionId,
-            state
-          }
-        });
-      }
-      const confirmed = await this.waitForRegistrationConfirmation(
-        registrationResult.transactionId,
-        network,
-        this.guardedRegistryBaseUrl,
-        maxAttempts,
-        delayMs,
-        this.logger
-      );
-      state.currentStage = "complete";
-      state.completedPercentage = 100;
-      if (!state.createdResources) {
-        state.createdResources = [];
-      }
-      if (registrationResult.transactionId) {
-        state.createdResources.push(
-          `registration:${registrationResult.transactionId}`
+      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}`
         );
       }
-      if (progressCallback) {
-        progressCallback({
-          stage: "completed",
-          message: "Agent registration complete",
-          progressPercent: 100,
-          details: {
-            confirmed,
-            transactionId: registrationResult.transactionId,
-            state
-          }
-        });
-      }
-      return {
-        ...registrationResult,
-        confirmed,
-        state
-      };
+      return await response.json();
     } catch (error) {
-      this.logger.error(`Failed to register agent: ${error.message}`);
-      return {
-        error: error.message,
-        success: false
-      };
+      this.logger.error(`Error checking registration status: ${error}`);
+      throw error;
     }
   }
   /**
-   * Registers an agent with the guarded registry. Should be called by a registry.
-   * @param registryTopicId - The topic ID of the guarded registry.
-   * @param accountId - The account ID of the agent
-   * @param inboundTopicId - The topic ID of the inbound topic
-   * @param memo - The memo of the agent
-   * @param submitKey - The submit key of the agent
+   * 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
    */
-  async registerAgent(registryTopicId, accountId, inboundTopicId, memo, submitKey) {
-    this.logger.info("Registering agent");
-    const payload = {
-      p: "hcs-10",
-      op: "register",
-      account_id: accountId,
-      inbound_topic_id: inboundTopicId,
-      m: memo
-    };
-    await this.submitPayload(registryTopicId, payload, submitKey);
+  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;
   }
-  async getInboundTopicType(topicId) {
-    try {
-      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
-      if (!topicInfo) {
-        throw new Error("Topic does not exist");
-      }
-      const hasSubmitKey = topicInfo.submit_key && topicInfo.submit_key.key;
-      if (!hasSubmitKey) {
-        return InboundTopicType.PUBLIC;
-      }
-      const hasFeeScheduleKey = topicInfo.fee_schedule_key && topicInfo.fee_schedule_key.key;
-      if (hasFeeScheduleKey && topicInfo.custom_fees) {
-        const customFees = topicInfo.custom_fees;
-        if (customFees && customFees.fixed_fees && customFees.fixed_fees.length > 0) {
-          this.logger.info(
-            `Topic ${topicId} is fee-based with ${customFees.fixed_fees.length} custom fees`
-          );
-          return InboundTopicType.FEE_BASED;
-        }
-      }
-      return InboundTopicType.CONTROLLED;
-    } catch (error) {
-      this.logger.error(`Error determining topic type: ${error.message}`);
-      throw new Error(`Failed to determine topic type: ${error.message}`);
+}
+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);
   }
-  getNetwork() {
-    return this.network;
+  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;
   }
-  getLogger() {
-    return this.logger;
+  clear() {
+    this.cache.clear();
+    this.cacheExpiry.clear();
   }
 }
 export {
-  HCS10Client,
-  InboundTopicType
+  HCS10BaseClient,
+  HCS10Cache,
+  Hcs10MemoType
 };
 //# sourceMappingURL=standards-sdk.es5.js.map