@hashgraphonline/standards-sdk 0.0.64 → 0.0.66

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

@@ -1,489 +1,1145 @@
-import Buffer from "./standards-sdk.es19.js";
-import { HederaMirrorNode } from "./standards-sdk.es18.js";
+import Buffer from "./standards-sdk.es20.js";
+import { KeyList, TopicCreateTransaction, Transaction, TopicMessageSubmitTransaction, Hbar } from "@hashgraph/sdk";
 import { Logger } from "./standards-sdk.es14.js";
-import { Registration } from "./standards-sdk.es9.js";
-import { HCS11Client } from "./standards-sdk.es13.js";
-import { PublicKey } from "@hashgraph/sdk";
-import "./standards-sdk.es23.js";
-import axios from "./standards-sdk.es24.js";
-var Hcs10MemoType = /* @__PURE__ */ ((Hcs10MemoType2) => {
-  Hcs10MemoType2["INBOUND"] = "inbound";
-  Hcs10MemoType2["OUTBOUND"] = "outbound";
-  Hcs10MemoType2["CONNECTION"] = "connection";
-  return Hcs10MemoType2;
-})(Hcs10MemoType || {});
-class HCS10BaseClient extends Registration {
+import { InscriptionSDK } from "./standards-sdk.es23.js";
+import { HCS10BaseClient, Hcs10MemoType } from "./standards-sdk.es5.js";
+import { m as mimeTypesExports } from "./standards-sdk.es24.js";
+import { AgentBuilder } from "./standards-sdk.es10.js";
+import { HCS11Client } from "./standards-sdk.es12.js";
+import { ProgressReporter } from "./standards-sdk.es16.js";
+import { inscribeWithSigner } from "./standards-sdk.es17.js";
+const isBrowser = typeof window !== "undefined";
+class BrowserHCSClient extends HCS10BaseClient {
   constructor(config) {
-    super();
-    this.network = config.network;
+    super({
+      network: config.network,
+      logLevel: config.logLevel,
+      prettyPrint: config.prettyPrint,
+      feeAmount: config.feeAmount
+    });
+    this.hcs11Client = null;
+    this.hwc = config.hwc;
+    if (!config.guardedRegistryBaseUrl) {
+      this.guardedRegistryBaseUrl = "https://moonscape.tech";
+    } else {
+      this.guardedRegistryBaseUrl = config.guardedRegistryBaseUrl;
+    }
+    let logLevel;
+    if (config.logLevel) {
+      logLevel = config.logLevel;
+    } else {
+      logLevel = "info";
+    }
     this.logger = Logger.getInstance({
-      level: config.logLevel || "info",
-      module: "HCS10-BaseClient",
+      level: logLevel,
+      module: "HCS-Browser",
       prettyPrint: config.prettyPrint
     });
-    this.mirrorNode = new HederaMirrorNode(
-      config.network,
-      this.logger
-    );
-    this.feeAmount = config.feeAmount || 1e-3;
+    if (isBrowser) {
+      try {
+        const { accountId, signer } = this.getAccountAndSigner();
+        this.hcs11Client = new HCS11Client({
+          network: config.network,
+          auth: {
+            operatorId: accountId,
+            signer
+          },
+          logLevel: config.logLevel
+        });
+      } catch (err) {
+        this.logger.warn(`Failed to initialize HCS11Client: ${err}`);
+      }
+    } else {
+      this.logger.error(
+        "BrowserHCSClient initialized in server environment - browser-specific features will not be available. Use HCS10Client instead."
+      );
+    }
   }
-  /**
-   * 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 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;
-        }
-        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;
+  async sendMessage(connectionTopicId, data, memo, submitKey, options) {
+    this.logger.info("Sending message");
+    const operatorId = await this.getOperatorId();
+    const payload = {
+      p: "hcs-10",
+      op: "message",
+      operator_id: operatorId,
+      data,
+      m: memo
+    };
+    const submissionCheck = await this.canSubmitToTopic(
+      connectionTopicId,
+      this.hwc.getAccountInfo().accountId
+    );
+    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"
+      );
+      try {
+        const contentBuffer = Buffer.from(data);
+        const fileName = `message-${Date.now()}.json`;
+        const inscriptionResult = await this.inscribeFile(
+          contentBuffer,
+          fileName,
+          {
+            progressCallback: options?.progressCallback,
+            waitMaxAttempts: options?.waitMaxAttempts,
+            waitIntervalMs: options?.waitIntervalMs
           }
+        );
+        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");
         }
-        return true;
-      });
-      return {
-        messages: filteredMessages
-      };
-    } catch (error) {
-      if (this.logger) {
-        this.logger.error(`Error fetching messages: ${error.message}`);
+      } 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: [] };
     }
+    return await this.submitPayload(
+      connectionTopicId,
+      payload,
+      submitKey,
+      submissionCheck.requiresFee
+    );
   }
-  /**
-   * 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) {
+  async submitConnectionRequest(inboundTopicId, memo) {
+    this.logger.info("Submitting connection request");
+    const accountResponse = this.getAccountAndSigner();
+    if (!accountResponse.accountId) {
+      throw new Error("Failed to retrieve user account ID");
+    }
+    const operatorId = await this.getOperatorId();
+    const accountId = accountResponse.accountId;
+    const connectionRequestMessage = {
+      p: "hcs-10",
+      op: "connection_request",
+      operator_id: operatorId,
+      m: memo
+    };
+    const response = await this.submitPayload(
+      inboundTopicId,
+      connectionRequestMessage
+    );
+    this.logger.info(
+      `Submitted connection request to topic ID: ${inboundTopicId}`
+    );
+    const outboundTopic = await this.retrieveOutboundConnectTopic(accountId);
+    if (!outboundTopic?.outboundTopic) {
+      this.logger.error(
+        `Failed to retrieve outbound topic for account ID: ${accountId}`
+      );
+      throw new Error(
+        `Failed to retrieve outbound topic for account ID: ${accountId}`
+      );
+    }
+    this.logger.info(
+      `Retrieved outbound topic ID: ${outboundTopic.outboundTopic} for account ID: ${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: inboundTopicId,
+      connection_request_id: responseSequenceNumber
+    });
+    return response;
+  }
+  async getPublicKey(accountId) {
+    return await this.mirrorNode.getPublicKey(accountId);
+  }
+  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionId, connectionMemo = "Connection accepted. Looking forward to collaborating!", ttl = 60) {
+    this.logger.info("Handling connection request");
+    const userAccountId = this.hwc.getAccountInfo().accountId;
+    if (!userAccountId) {
+      throw new Error("Failed to retrieve user account ID");
+    }
+    const requesterKey = await this.mirrorNode.getPublicKey(
+      requestingAccountId
+    );
+    const accountKey = await this.mirrorNode.getPublicKey(userAccountId);
+    if (!accountKey) {
+      throw new Error("Failed to retrieve public key");
+    }
+    const thresholdKey = new KeyList([accountKey, requesterKey], 1);
+    const memo = this._generateHcs10Memo(Hcs10MemoType.CONNECTION, {
+      ttl,
+      inboundTopicId,
+      connectionId
+    });
+    const transaction = new TopicCreateTransaction().setTopicMemo(memo).setAdminKey(thresholdKey).setSubmitKey(thresholdKey);
+    this.logger.debug("Executing topic creation transaction");
+    const txResponse = await this.hwc.executeTransactionWithErrorHandling(
+      transaction,
+      false
+    );
+    if (txResponse.error) {
+      this.logger.error(txResponse.error);
+      throw new Error(txResponse.error);
+    }
+    const resultReceipt = txResponse.result;
+    if (!resultReceipt?.topicId) {
+      this.logger.error("Failed to create topic: topicId is null");
+      throw new Error("Failed to create topic: topicId is null");
+    }
+    const connectionTopicId = resultReceipt.topicId.toString();
+    const operatorId = `${inboundTopicId}@${userAccountId}`;
+    const confirmedConnectionSequenceNumber = await this.confirmConnection(
+      inboundTopicId,
+      connectionTopicId,
+      requestingAccountId,
+      connectionId,
+      operatorId,
+      connectionMemo
+    );
+    return {
+      connectionTopicId,
+      confirmedConnectionSequenceNumber,
+      operatorId
+    };
+  }
+  async confirmConnection(inboundTopicId, connectionTopicId, connectedAccountId, connectionId, operatorId, memo) {
+    this.logger.info("Confirming connection");
+    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 transactionResponse = await this.submitPayload(
+      inboundTopicId,
+      payload
+    );
+    if (!transactionResponse?.topicSequenceNumber) {
+      this.logger.error(
+        "Failed to confirm connection: sequence number is null"
+      );
+      throw new Error("Failed to confirm connection: sequence number is null");
+    }
+    return transactionResponse.topicSequenceNumber.toNumber();
+  }
+  async create(builder, options) {
+    const progressCallback = options?.progressCallback;
+    const progressReporter = new ProgressReporter({
+      module: "ProfileCreate",
+      logger: this.logger,
+      callback: progressCallback
+    });
     try {
-      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
-      if (!topicInfo) {
-        return {
-          canSubmit: false,
-          requiresFee: false,
-          reason: "Topic does not exist"
+      const isAgentBuilder = builder instanceof AgentBuilder;
+      let state;
+      if (options?.existingState) {
+        state = options.existingState;
+      } else {
+        state = {
+          currentStage: "init",
+          completedPercentage: 0,
+          createdResources: []
         };
       }
-      if (!topicInfo.submit_key?.key) {
-        return { canSubmit: true, requiresFee: false };
+      if (isAgentBuilder) {
+        this.logger.info("Creating Agent Profile and HCS-10 Topics");
+        const agentConfig = builder.build();
+        state.agentMetadata = agentConfig.metadata;
+      } else {
+        this.logger.info("Creating Person HCS-11 Profile");
       }
-      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 };
-          }
+      progressReporter.preparing(
+        `Starting ${isAgentBuilder ? "agent" : "person"} resource creation`,
+        0,
+        {
+          state
         }
-      } catch (error) {
-        this.logger.error(
-          `Key validation error: ${error instanceof Error ? error.message : String(error)}`
+      );
+      const {
+        inboundTopicId,
+        outboundTopicId,
+        state: updatedState
+      } = await this.createCommunicationTopics(options, progressReporter);
+      state = updatedState;
+      if (!isAgentBuilder) {
+        builder.setInboundTopicId(inboundTopicId);
+        builder.setOutboundTopicId(outboundTopicId);
+      }
+      let pfpTopicId;
+      let hasPfpBuffer;
+      let pfpFileName;
+      if (isAgentBuilder) {
+        const agentProfile = builder.build();
+        pfpTopicId = agentProfile.existingPfpTopicId || state.pfpTopicId;
+        hasPfpBuffer = agentProfile.pfpBuffer;
+        pfpFileName = agentProfile.pfpFileName || "pfp.png";
+      } else {
+        const personProfile = builder.build();
+        pfpTopicId = state.pfpTopicId;
+        hasPfpBuffer = personProfile.pfpBuffer;
+        pfpFileName = personProfile.pfpFileName;
+      }
+      if (!pfpTopicId && hasPfpBuffer && pfpFileName) {
+        pfpTopicId = await this.handleProfilePictureCreation(
+          hasPfpBuffer,
+          pfpFileName,
+          state,
+          progressReporter
+        );
+      } else if (pfpTopicId) {
+        progressReporter.preparing(
+          `Using existing profile picture: ${pfpTopicId}`,
+          50,
+          { state }
         );
+        state.pfpTopicId = pfpTopicId;
       }
-      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"
-        };
+      await this.createAndInscribeProfile(
+        isAgentBuilder,
+        builder,
+        pfpTopicId,
+        state,
+        inboundTopicId,
+        outboundTopicId,
+        options,
+        progressReporter
+      );
+      state.currentStage = "complete";
+      state.completedPercentage = 100;
+      progressReporter.completed(
+        `${isAgentBuilder ? "Agent" : "Person"} profile created successfully`,
+        {
+          profileTopicId: state.profileTopicId,
+          inboundTopicId,
+          outboundTopicId,
+          pfpTopicId,
+          state
+        }
+      );
+      let outTopicId = "";
+      if (state.outboundTopicId) {
+        outTopicId = state.outboundTopicId;
+      }
+      let inTopicId = "";
+      if (state.inboundTopicId) {
+        inTopicId = state.inboundTopicId;
+      }
+      let profilePicTopicId = "";
+      if (state.pfpTopicId) {
+        profilePicTopicId = state.pfpTopicId;
+      }
+      let profTopicId = "";
+      if (state.profileTopicId) {
+        profTopicId = state.profileTopicId;
       }
       return {
-        canSubmit: false,
-        requiresFee: false,
-        reason: "User does not have submit permission for this topic"
+        outboundTopicId: outTopicId,
+        inboundTopicId: inTopicId,
+        pfpTopicId: profilePicTopicId,
+        profileTopicId: profTopicId,
+        success: true,
+        state
       };
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Topic submission validation error: ${errorMessage}`);
+      progressReporter.failed("Error during profile creation", {
+        error: error.message
+      });
       return {
-        canSubmit: false,
-        requiresFee: false,
-        reason: `Error: ${errorMessage}`
+        outboundTopicId: "",
+        inboundTopicId: "",
+        pfpTopicId: "",
+        profileTopicId: "",
+        success: false,
+        error: error.message,
+        state: {
+          currentStage: "init",
+          completedPercentage: 0,
+          error: error.message
+        }
       };
     }
   }
-  /**
-   * Get all messages from a topic
-   * @param topicId The topic ID to get messages from
-   * @returns All messages from the topic
-   */
-  async getMessages(topicId) {
-    try {
-      const messages = await this.mirrorNode.getTopicMessages(topicId);
-      const validatedMessages = messages.filter((msg) => {
-        if (msg.p !== "hcs-10") {
-          return false;
-        }
-        if (msg.op === "message") {
-          if (!msg.data) {
-            return false;
+  async handleProfilePictureCreation(pfpBuffer, pfpFileName, state, progressReporter) {
+    state.currentStage = "pfp";
+    progressReporter.preparing("Creating profile picture", 30, {
+      state
+    });
+    const pfpProgress = progressReporter.createSubProgress({
+      minPercent: 30,
+      maxPercent: 50,
+      logPrefix: "PFP"
+    });
+    const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName, {
+      progressCallback: (data) => pfpProgress.report({
+        ...data,
+        progressPercent: data.progressPercent ?? 0,
+        details: { ...data.details, state }
+      })
+    });
+    if (!pfpResult.success) {
+      let errorMessage = "Failed to inscribe profile picture";
+      if (pfpResult.error) {
+        errorMessage = pfpResult.error;
+      }
+      throw new Error(errorMessage);
+    }
+    const pfpTopicId = pfpResult.pfpTopicId;
+    state.pfpTopicId = pfpTopicId;
+    if (state.createdResources) {
+      state.createdResources.push(`pfp:${state.pfpTopicId}`);
+    }
+    progressReporter.preparing("Profile picture created", 50, { state });
+    return pfpTopicId;
+  }
+  async createAndInscribeProfile(isAgentBuilder, builder, pfpTopicId, state, inboundTopicId, outboundTopicId, options, progressReporter) {
+    if (!this.hcs11Client) {
+      if (progressReporter) {
+        progressReporter.failed("HCS11Client is not available");
+      }
+      throw new Error("HCS11Client is not available");
+    }
+    this.logger.info("Creating and inscribing profile");
+    if (!state.profileTopicId) {
+      if (progressReporter) {
+        progressReporter.preparing(
+          `Storing HCS-11 ${isAgentBuilder ? "agent" : "person"} profile`,
+          80
+        );
+      }
+      const profileProgress = progressReporter?.createSubProgress({
+        minPercent: 80,
+        maxPercent: 95,
+        logPrefix: "StoreProfile"
+      });
+      let hcs11Profile;
+      if (isAgentBuilder) {
+        const agentProfile = builder.build();
+        const socialLinks = agentProfile.metadata?.socials ? Object.entries(agentProfile.metadata.socials).map(
+          ([platform, handle]) => ({
+            platform,
+            handle
+          })
+        ) : [];
+        hcs11Profile = this.hcs11Client.createAIAgentProfile(
+          agentProfile.name,
+          agentProfile.metadata?.type === "manual" ? 0 : 1,
+          agentProfile.capabilities || [],
+          agentProfile.metadata?.model || "unknown",
+          {
+            alias: agentProfile.name.toLowerCase().replace(/\s+/g, "_"),
+            bio: agentProfile.bio,
+            profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
+            socials: socialLinks,
+            properties: agentProfile.metadata?.properties || {},
+            inboundTopicId,
+            outboundTopicId,
+            creator: agentProfile.metadata?.creator
           }
-          if (msg.operator_id) {
-            if (!this.isValidOperatorId(msg.operator_id)) {
-              return false;
-            }
+        );
+      } else {
+        const personProfile = builder.build();
+        const { pfpBuffer, pfpFileName, ...cleanProfile } = personProfile;
+        hcs11Profile = this.hcs11Client.createPersonalProfile(
+          personProfile.display_name,
+          {
+            alias: personProfile.alias,
+            bio: personProfile.bio,
+            socials: personProfile.socials,
+            profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : personProfile.profileImage,
+            properties: personProfile.properties,
+            inboundTopicId,
+            outboundTopicId
           }
+        );
+      }
+      const profileResult = await this.hcs11Client.createAndInscribeProfile(
+        hcs11Profile,
+        options?.updateAccountMemo ?? true,
+        {
+          progressCallback: (data) => profileProgress?.report({
+            ...data,
+            progressPercent: data.progressPercent ?? 0
+          })
         }
-        return true;
-      });
-      return {
-        messages: validatedMessages
-      };
-    } catch (error) {
-      if (this.logger) {
-        this.logger.error(`Error fetching messages: ${error.message}`);
+      );
+      if (!profileResult.success) {
+        if (progressReporter) {
+          progressReporter.failed(
+            `Failed to inscribe ${isAgentBuilder ? "agent" : "person"} profile`,
+            {
+              error: profileResult.error
+            }
+          );
+        }
+        let errorMessage = `Failed to inscribe ${isAgentBuilder ? "agent" : "person"} profile`;
+        if (profileResult.error) {
+          errorMessage = profileResult.error;
+        }
+        throw new Error(errorMessage);
+      }
+      state.profileTopicId = profileResult.profileTopicId;
+      if (state.createdResources) {
+        state.createdResources.push(`profile:${profileResult.profileTopicId}`);
       }
-      return { messages: [] };
+      if (progressReporter) {
+        progressReporter.preparing("HCS-11 Profile stored", 95, { state });
+      }
+    } else if (progressReporter) {
+      progressReporter.preparing(
+        `Using existing ${isAgentBuilder ? "agent" : "person"} profile`,
+        95,
+        {
+          state
+        }
+      );
     }
   }
-  async requestAccount(account) {
-    try {
-      return await this.mirrorNode.requestAccount(account);
-    } catch (e) {
-      this.logger.error("Failed to fetch account", e);
-      throw e;
+  initializeRegistrationState(inboundTopicId, existingState) {
+    const state = existingState || {
+      inboundTopicId,
+      currentStage: "registration",
+      completedPercentage: 0,
+      createdResources: []
+    };
+    if (state.currentStage !== "registration" && state.currentStage !== "complete") {
+      state.currentStage = "registration";
     }
+    return state;
   }
-  async getAccountMemo(accountId) {
-    return await this.mirrorNode.getAccountMemo(accountId);
+  updateStateForCompletedRegistration(state, inboundTopicId) {
+    state.currentStage = "complete";
+    state.completedPercentage = 100;
+    if (state.createdResources) {
+      state.createdResources.push(`registration:${inboundTopicId}`);
+    }
   }
-  async retrieveProfile(accountId) {
-    this.logger.info(`Retrieving profile for account: ${accountId}`);
+  async registerAgentWithGuardedRegistry(accountId, network = this.network, options) {
     try {
-      const hcs11Client = new HCS11Client({
-        network: this.network,
-        auth: {
-          operatorId: "0.0.0"
-          // Read-only operations only
-        },
-        logLevel: "info"
+      this.logger.info("Registering agent with guarded registry");
+      const agentProfile = await this.retrieveProfile(accountId);
+      const inboundTopicId = agentProfile.topicInfo.inboundTopic;
+      const state = this.initializeRegistrationState(
+        inboundTopicId,
+        options?.existingState
+      );
+      const progressReporter = new ProgressReporter({
+        module: "AgentRegistration",
+        logger: this.logger,
+        callback: options?.progressCallback
+      });
+      progressReporter.preparing("Preparing agent registration", 10, {
+        inboundTopicId,
+        accountId
       });
-      const profileResult = await hcs11Client.fetchProfileByAccountId(
+      const registrationResult = await this.executeRegistration(
         accountId,
-        this.network
+        network,
+        this.guardedRegistryBaseUrl,
+        this.logger
       );
-      if (!profileResult?.success) {
-        this.logger.error(
-          `Failed to retrieve profile for account ID: ${accountId}`,
-          profileResult?.error
-        );
+      if (!registrationResult.success) {
         return {
-          profile: null,
-          success: false,
-          error: profileResult?.error || `Failed to retrieve profile for account ID: ${accountId}`
+          ...registrationResult,
+          state
         };
       }
-      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);
+      progressReporter.submitting("Submitting registration to registry", 30, {
+        transactionId: registrationResult.transactionId
+      });
+      if (registrationResult.transaction) {
+        const transaction = Transaction.fromBytes(
+          Buffer.from(registrationResult.transaction, "base64")
+        );
+        this.logger.info(`Processing registration transaction`);
+        const txResult = await this.hwc.executeTransactionWithErrorHandling(
+          transaction,
+          true
+        );
+        if (txResult.error) {
+          return {
+            ...registrationResult,
+            error: txResult.error,
+            success: false,
+            state
+          };
+        }
+        this.logger.info(`Successfully processed registration transaction`);
       }
+      progressReporter.confirming("Confirming registration transaction", 60, {
+        accountId,
+        inboundTopicId,
+        transactionId: registrationResult.transactionId
+      });
+      const maxAttempts = options?.maxAttempts ?? 60;
+      const delayMs = options?.delayMs ?? 2e3;
+      const confirmed = await this.waitForRegistrationConfirmation(
+        registrationResult.transactionId,
+        network,
+        this.guardedRegistryBaseUrl,
+        maxAttempts,
+        delayMs,
+        this.logger
+      );
+      this.updateStateForCompletedRegistration(state, inboundTopicId);
+      progressReporter.completed("Agent registration complete", {
+        transactionId: registrationResult.transactionId,
+        inboundTopicId,
+        state,
+        confirmed
+      });
       return {
-        profile,
-        topicInfo,
-        success: true
+        ...registrationResult,
+        confirmed,
+        state
       };
     } catch (error) {
-      this.logger.error("Failed to retrieve profile:", error);
+      this.logger.error(`Registration error: ${error.message}`);
       return {
-        profile: null,
+        error: `Error during registration: ${error.message}`,
         success: false,
-        error: error instanceof Error ? error.message : String(error)
+        state: {
+          currentStage: "registration",
+          completedPercentage: 0,
+          error: error.message
+        }
       };
     }
   }
-  async retrieveOutboundConnectTopic(accountId) {
-    this.logger.info(`Retrieving topics for account: ${accountId}`);
+  async createAndRegisterAgent(builder, options) {
     try {
-      const profileResponse = await this.retrieveProfile(accountId);
-      if (!profileResponse?.success) {
-        throw new Error(profileResponse.error || "Failed to retrieve profile");
+      const agentConfig = builder.build();
+      const progressCallback = options?.progressCallback;
+      const progressReporter = new ProgressReporter({
+        module: "AgentCreateRegister",
+        logger: this.logger,
+        callback: progressCallback
+      });
+      let state = options?.existingState || {
+        currentStage: "init",
+        completedPercentage: 0,
+        createdResources: []
+      };
+      state.agentMetadata = agentConfig.metadata;
+      progressReporter.preparing("Starting agent creation process", 0, {
+        state
+      });
+      if (state.currentStage !== "complete" || !state.inboundTopicId || !state.outboundTopicId || !state.profileTopicId) {
+        const createResult = await this.create(builder, {
+          progressCallback: (progress) => {
+            const adjustedPercent = (progress.progressPercent || 0) * 0.3;
+            progressReporter.report({
+              ...progress,
+              progressPercent: adjustedPercent,
+              details: {
+                ...progress.details,
+                state: progress.details?.state || state
+              }
+            });
+          },
+          existingState: state,
+          updateAccountMemo: false
+        });
+        if (!("state" in createResult)) {
+          throw new Error("Create method did not return expected agent state.");
+        }
+        if (!createResult.success) {
+          throw new Error(
+            createResult.error || "Failed to create agent resources"
+          );
+        }
+        state = createResult.state;
+        state.agentMetadata = agentConfig.metadata;
       }
-      const profile = profileResponse.profile;
-      if (!profile.inboundTopicId || !profile.outboundTopicId) {
-        throw new Error(
-          `Invalid HCS-11 profile for HCS-10 agent: missing inboundTopicId or outboundTopicId`
+      progressReporter.preparing(
+        `Agent creation status: ${state.currentStage}, ${state.completedPercentage}%`,
+        30,
+        { state }
+      );
+      const { accountId } = this.getAccountAndSigner();
+      if (state.currentStage !== "complete" || !state.createdResources?.includes(
+        `registration:${state.inboundTopicId}`
+      )) {
+        if (options?.baseUrl) {
+          this.guardedRegistryBaseUrl = options.baseUrl;
+        }
+        const registrationResult = await this.registerAgentWithGuardedRegistry(
+          accountId,
+          agentConfig.network,
+          {
+            progressCallback: (progress) => {
+              const adjustedPercent = 30 + (progress.progressPercent || 0) * 0.7;
+              progressReporter.report({
+                ...progress,
+                progressPercent: adjustedPercent,
+                details: {
+                  ...progress.details,
+                  state: progress.details?.state || state
+                }
+              });
+            },
+            maxAttempts: options?.maxAttempts,
+            delayMs: options?.delayMs,
+            existingState: state
+          }
         );
+        if (!registrationResult.success) {
+          throw new Error(
+            registrationResult.error || "Failed to register agent with registry"
+          );
+        }
+        state = registrationResult.state;
+        if (state.profileTopicId) {
+          await this.hcs11Client?.updateAccountMemoWithProfile(
+            accountId,
+            state.profileTopicId
+          );
+        }
       }
-      const topicInfo = {
-        inboundTopic: profile.inboundTopicId,
-        outboundTopic: profile.outboundTopicId,
-        profileTopicId: profile.profileTopicId
+      progressReporter.completed("Agent creation and registration complete", {
+        state
+      });
+      return {
+        success: true,
+        state,
+        metadata: {
+          accountId,
+          operatorId: `${state.inboundTopicId}@${accountId}`,
+          inboundTopicId: state.inboundTopicId,
+          outboundTopicId: state.outboundTopicId,
+          profileTopicId: state.profileTopicId,
+          pfpTopicId: state.pfpTopicId,
+          privateKey: null,
+          ...state.agentMetadata
+        }
       };
-      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;
+      this.logger.error(
+        `Failed to create and register agent: ${error.message}`
+      );
+      return {
+        success: false,
+        error: `Failed to create and register agent: ${error.message}`,
+        state: options?.existingState || {
+          currentStage: "init",
+          completedPercentage: 0,
+          error: error.message
+        }
+      };
     }
   }
-  async retrieveOutboundMessages(agentAccountId) {
+  async storeHCS11Profile(agentName, agentBio, inboundTopicId, outboundTopicId, capabilities = [], metadata = {}, pfpBuffer, pfpFileName, existingPfpTopicId, options) {
     try {
-      const topicInfo = await this.retrieveOutboundConnectTopic(agentAccountId);
-      if (!topicInfo) {
-        this.logger.warn(
-          `No outbound connect topic found for agentAccountId: ${agentAccountId}`
+      const progressCallback = options?.progressCallback;
+      const progressReporter = new ProgressReporter({
+        module: "StoreHCS11Profile",
+        logger: this.logger,
+        callback: progressCallback
+      });
+      progressReporter.preparing("Preparing agent profile data", 0);
+      let pfpTopicId = existingPfpTopicId;
+      if (!pfpTopicId && pfpBuffer && pfpFileName) {
+        const pfpProgress = progressReporter.createSubProgress({
+          minPercent: 0,
+          maxPercent: 60,
+          logPrefix: "PFP"
+        });
+        const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName, {
+          progressCallback: (data) => {
+            pfpProgress.report({
+              stage: data.stage,
+              message: data.message,
+              progressPercent: data.progressPercent || 0,
+              details: data.details
+            });
+          }
+        });
+        if (!pfpResult.success) {
+          progressReporter.failed(
+            "Failed to inscribe profile picture, continuing without PFP"
+          );
+        } else {
+          pfpTopicId = pfpResult.pfpTopicId;
+        }
+      } else if (existingPfpTopicId) {
+        progressReporter.preparing(
+          `Using existing profile picture: ${existingPfpTopicId}`,
+          30
         );
-        return [];
+      } else {
+        progressReporter.preparing("No profile picture provided", 30);
       }
-      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")
+      if (!this.hcs11Client) {
+        progressReporter.failed(
+          "HCS11Client is not available in this environment"
+        );
+        return {
+          profileTopicId: "",
+          success: false,
+          error: "HCS11Client is not available in this environment",
+          transactionId: ""
+        };
+      }
+      const agentType = this.hcs11Client.getAgentTypeFromMetadata({
+        type: metadata.type || "autonomous"
+      });
+      progressReporter.preparing("Building agent profile", 65);
+      const formattedSocials = metadata.socials ? Object.entries(metadata.socials).filter(([_, handle]) => handle).map(([platform, handle]) => ({
+        platform,
+        handle
+      })) : void 0;
+      const profile = this.hcs11Client.createAIAgentProfile(
+        agentName,
+        agentType,
+        capabilities,
+        metadata.model || "unknown",
+        {
+          alias: agentName.toLowerCase().replace(/\s+/g, "_"),
+          bio: agentBio,
+          profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
+          socials: formattedSocials,
+          properties: {
+            version: metadata.version || "1.0.0",
+            creator: metadata.creator || "Unknown",
+            supported_languages: metadata.supported_languages || ["en"],
+            permissions: metadata.permissions || [],
+            model_details: metadata.model_details,
+            training: metadata.training,
+            capabilities_description: metadata.capabilities_description,
+            ...metadata
+          },
+          inboundTopicId,
+          outboundTopicId,
+          creator: metadata.creator
+        }
       );
+      const profileProgress = progressReporter.createSubProgress({
+        minPercent: 65,
+        maxPercent: 100,
+        logPrefix: "Profile"
+      });
+      const profileResult = await this.hcs11Client.createAndInscribeProfile(
+        profile,
+        true,
+        {
+          progressCallback: (profileData) => {
+            profileProgress.report({
+              stage: profileData.stage,
+              message: profileData.message,
+              progressPercent: profileData.progressPercent || 0,
+              details: profileData.details
+            });
+          }
+        }
+      );
+      if (!profileResult.success) {
+        progressReporter.failed("Failed to inscribe profile");
+        return {
+          profileTopicId: "",
+          success: false,
+          error: profileResult.error || "Failed to inscribe profile",
+          transactionId: profileResult.transactionId || ""
+        };
+      }
+      progressReporter.completed("Profile stored successfully", {
+        profileTopicId: profileResult.profileTopicId
+      });
+      return {
+        profileTopicId: profileResult.profileTopicId,
+        pfpTopicId,
+        success: true,
+        transactionId: profileResult.transactionId || ""
+      };
     } catch (error) {
-      this.logger.error("Failed to retrieve outbound messages:", error);
-      return [];
+      this.logger.error(`Error storing HCS11 profile: ${error.message}`);
+      return {
+        profileTopicId: "",
+        success: false,
+        error: error.message,
+        transactionId: ""
+      };
     }
   }
-  async hasConnectionCreated(agentAccountId, connectionId) {
-    try {
-      const outBoundTopic = await this.retrieveOutboundConnectTopic(
-        agentAccountId
+  async createTopic(memo, adminKey, submitKey) {
+    this.logger.info("Creating topic");
+    const { accountId, signer } = this.getAccountAndSigner();
+    const transaction = new TopicCreateTransaction().setTopicMemo(memo);
+    const publicKey = await this.mirrorNode.getPublicKey(accountId);
+    if (adminKey && publicKey) {
+      transaction.setAdminKey(publicKey);
+      transaction.setAutoRenewAccountId(accountId);
+    }
+    if (submitKey && publicKey) {
+      transaction.setSubmitKey(publicKey);
+    }
+    const transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
+      transaction,
+      false
+    );
+    const error = transactionResponse.error;
+    if (error) {
+      this.logger.error(error);
+      return {
+        success: false,
+        error
+      };
+    }
+    const resultReceipt = transactionResponse.result;
+    if (!resultReceipt?.topicId) {
+      this.logger.error("Failed to create topic: topicId is null");
+      return {
+        success: false,
+        error: "Failed to create topic: topicId is null"
+      };
+    }
+    return {
+      success: true,
+      topicId: resultReceipt.topicId.toString()
+    };
+  }
+  async submitPayload(topicId, payload, submitKey, requiresFee) {
+    this.logger.debug(`Submitting payload to topic ${topicId}`);
+    let message;
+    if (typeof payload === "string") {
+      message = payload;
+    } else {
+      message = JSON.stringify(payload);
+    }
+    const transaction = new TopicMessageSubmitTransaction().setTopicId(topicId).setMessage(message);
+    let transactionResponse;
+    if (requiresFee) {
+      this.logger.info(
+        "Topic requires fee payment, setting max transaction fee"
       );
-      const messages = await this.retrieveOutboundMessages(
-        outBoundTopic.outboundTopic
+      transaction.setMaxTransactionFee(new Hbar(this.feeAmount));
+      transaction.setTransactionMemo("HIP-991 Fee Payment");
+    }
+    if (submitKey) {
+      const { accountId, signer } = this.getAccountAndSigner();
+      transaction.freezeWithSigner(signer);
+      const signedTransaction = await transaction.sign(submitKey);
+      transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
+        signedTransaction,
+        true
       );
-      return messages.some(
-        (msg) => msg.op === "connection_created" && msg.connection_id === connectionId
+    } else {
+      transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
+        transaction,
+        false
       );
-    } catch (error) {
-      this.logger.error("Failed to check connection created:", error);
-      return false;
     }
-  }
-  /**
-   * 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;
-    }
-    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}`);
-      }
-      return response.data.content || response.data.text || JSON.stringify(response.data);
-    } catch (error) {
+    if (transactionResponse?.error) {
       this.logger.error(
-        `Error resolving HRL reference: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to submit payload: ${transactionResponse.error}`
       );
-      throw new Error(
-        `Failed to resolve HRL reference: ${error instanceof Error ? error.message : "Unknown error"}`
+      throw new Error(`Failed to submit payload: ${transactionResponse.error}`);
+    }
+    if (!transactionResponse?.result) {
+      this.logger.error(
+        "Failed to submit message: receipt is null or undefined"
       );
+      throw new Error("Failed to submit message: receipt is null or undefined");
     }
+    this.logger.debug("Payload submitted successfully via HWC");
+    return transactionResponse.result;
   }
-  /**
-   * 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_created",
-      connection_topic_id: connectionTopicId,
-      outbound_topic_id: outboundTopicId,
-      confirmed_request_id: confirmedRequestId,
-      connection_request_id: connectionRequestId,
-      operator_id: operatorId,
-      m: memo
+  async inscribeFile(buffer, fileName, options) {
+    const { accountId, signer } = this.getAccountAndSigner();
+    const mimeType = mimeTypesExports.lookup(fileName) || "application/octet-stream";
+    const sdk = await InscriptionSDK.createWithAuth({
+      type: "client",
+      accountId,
+      signer,
+      network: this.network
+    });
+    const inscriptionOptions = {
+      mode: "file",
+      waitForConfirmation: true,
+      waitMaxAttempts: options?.waitMaxAttempts || 30,
+      waitIntervalMs: options?.waitIntervalMs || 4e3,
+      progressCallback: options?.progressCallback,
+      logging: {
+        level: this.logger.getLevel ? this.logger.getLevel() : "info"
+      }
     };
-    return await this.submitPayload(outboundTopicId, payload);
-  }
-  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");
+    const response = await inscribeWithSigner(
+      {
+        type: "buffer",
+        buffer,
+        fileName,
+        mimeType
+      },
+      signer,
+      {
+        ...inscriptionOptions,
+        network: this.network
+      },
+      sdk
+    );
+    if (!response.confirmed || !response.inscription) {
+      throw new Error("Inscription was not confirmed");
     }
-    const operatorId = `${profile.topicInfo?.inboundTopic}@${accountResponse.accountId}`;
-    this.operatorId = operatorId;
-    return operatorId;
+    return response.inscription;
   }
-  clearCache() {
-    HCS10Cache.getInstance().clear();
+  getAccountAndSigner() {
+    const accountInfo = this.hwc.getAccountInfo();
+    const accountId = accountInfo.accountId.toString();
+    const signer = this.hwc.dAppConnector.signers.find((s) => {
+      return s.getAccountId().toString() === accountId;
+    });
+    if (!signer) {
+      this.logger.error("Failed to find signer");
+      throw new Error("Failed to find signer");
+    }
+    return { accountId, signer };
   }
   /**
-   * 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
+   * Inscribes a profile picture (PFP) on HCS-11.
+   *
+   * @param buffer - The buffer containing the PFP image.
+   * @param fileName - The name of the file containing the PFP image.
+   * @param options - Optional configuration options.
+   * @returns A promise that resolves to the topic ID of the inscribed PFP.
    */
-  _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}`);
-    }
-  }
-  async checkRegistrationStatus(transactionId, network, baseUrl) {
+  async inscribePfp(buffer, fileName, options) {
     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 })
+      const progressCallback = options?.progressCallback;
+      const progressReporter = new ProgressReporter({
+        module: "PFP-Inscription",
+        logger: this.logger,
+        callback: progressCallback
       });
-      if (!response.ok) {
-        throw new Error(
-          `Failed to confirm registration: ${response.statusText}`
+      if (!this.hcs11Client) {
+        progressReporter.failed(
+          "HCS11Client is not available in this environment"
         );
+        return {
+          pfpTopicId: "",
+          success: false,
+          error: "HCS11Client is not available in this environment",
+          transactionId: ""
+        };
+      }
+      progressReporter.preparing("Preparing to inscribe profile picture", 10);
+      this.logger.info("Inscribing profile picture using HCS-11 client");
+      const wrappedProgressCallback = (data) => {
+        progressReporter.report({
+          stage: data.stage || "confirming",
+          message: data.message || "Processing PFP inscription",
+          progressPercent: data.progressPercent || 50,
+          details: data.details
+        });
+      };
+      const imageResult = await this.hcs11Client.inscribeImage(
+        buffer,
+        fileName,
+        { progressCallback: wrappedProgressCallback }
+      );
+      if (!imageResult.success) {
+        let errorMessage = "Failed to inscribe profile picture";
+        if (imageResult.error) {
+          errorMessage = imageResult.error;
+        }
+        let txId = "";
+        if (imageResult.transactionId) {
+          txId = imageResult.transactionId;
+        }
+        return {
+          pfpTopicId: "",
+          success: false,
+          error: errorMessage,
+          transactionId: txId
+        };
       }
-      return await response.json();
+      progressReporter.completed("Successfully inscribed profile picture", {
+        pfpTopicId: imageResult.imageTopicId
+      });
+      this.logger.info(
+        `Successfully inscribed profile picture with topic ID: ${imageResult.imageTopicId}`
+      );
+      return {
+        pfpTopicId: imageResult.imageTopicId,
+        success: true,
+        transactionId: imageResult.transactionId || ""
+      };
     } catch (error) {
-      this.logger.error(`Error checking registration status: ${error}`);
-      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;
+      this.logger.error(`Error inscribing profile picture: ${error.message}`);
+      return {
+        pfpTopicId: "",
+        success: false,
+        error: error.message,
+        transactionId: ""
+      };
     }
-    return true;
-  }
-}
-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();
+  async createCommunicationTopics(options, progressReporter) {
+    let state = options?.existingState || {
+      currentStage: "init",
+      completedPercentage: 0,
+      createdResources: []
+    };
+    if (progressReporter) {
+      progressReporter.preparing("Starting communication topic creation", 0, {
+        state
+      });
     }
-    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);
+    const { accountId } = this.getAccountAndSigner();
+    if (!state.outboundTopicId) {
+      state.currentStage = "topics";
+      if (progressReporter) {
+        progressReporter.preparing("Creating outbound topic", 5, {
+          state
+        });
+      }
+      const outboundMemo = this._generateHcs10Memo(Hcs10MemoType.OUTBOUND, {
+        ttl: options?.ttl,
+        accountId
+      });
+      const outboundResult = await this.createTopic(outboundMemo, true, true);
+      if (!outboundResult.success || !outboundResult.topicId) {
+        throw new Error(
+          outboundResult.error || "Failed to create outbound topic"
+        );
+      }
+      state.outboundTopicId = outboundResult.topicId;
+      if (state.createdResources)
+        state.createdResources.push(`outbound:${state.outboundTopicId}`);
     }
-    if (expiry) {
-      this.cache.delete(key);
-      this.cacheExpiry.delete(key);
+    if (!state.inboundTopicId) {
+      state.currentStage = "topics";
+      if (progressReporter) {
+        progressReporter.preparing("Creating inbound topic", 10, {
+          state
+        });
+      }
+      const inboundMemo = this._generateHcs10Memo(Hcs10MemoType.INBOUND, {
+        ttl: options?.ttl,
+        accountId
+      });
+      const inboundResult = await this.createTopic(inboundMemo, true, false);
+      if (!inboundResult.success || !inboundResult.topicId) {
+        throw new Error(
+          inboundResult.error || "Failed to create inbound topic"
+        );
+      }
+      state.inboundTopicId = inboundResult.topicId;
+      if (state.createdResources)
+        state.createdResources.push(`inbound:${state.inboundTopicId}`);
     }
-    return void 0;
-  }
-  clear() {
-    this.cache.clear();
-    this.cacheExpiry.clear();
+    return {
+      inboundTopicId: state.inboundTopicId,
+      outboundTopicId: state.outboundTopicId,
+      state
+    };
   }
 }
 export {
-  HCS10BaseClient,
-  HCS10Cache,
-  Hcs10MemoType
+  BrowserHCSClient
 };
 //# sourceMappingURL=standards-sdk.es8.js.map