@hashgraphonline/standards-sdk 0.1.144 → 0.1.145

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

@@ -1,12 +1,9 @@
-import "./standards-sdk.es2.js";
-import { Client, PrivateKey, AccountCreateTransaction, Hbar, CustomFixedFee, AccountId, TokenId, KeyList, TopicMessageSubmitTransaction, Transaction, ScheduleCreateTransaction, Timestamp } from "@hashgraph/sdk";
-import { AccountCreationError, TopicCreationError, ConnectionConfirmationError, PayloadSizeError } from "./standards-sdk.es18.js";
-import { InscriptionSDK } from "./standards-sdk.es147.js";
-import { Logger } from "./standards-sdk.es106.js";
-import { accountIdsToExemptKeys } from "./standards-sdk.es108.js";
-import { ProgressReporter } from "./standards-sdk.es109.js";
+import { KeyList, TopicCreateTransaction, AccountId, Transaction, TopicMessageSubmitTransaction, Hbar } from "@hashgraph/sdk";
+import { Logger } from "./standards-sdk.es105.js";
 import "axios";
 import "@hashgraph/proto";
+import { ProgressReporter } from "./standards-sdk.es108.js";
+import "./standards-sdk.es127.js";
 import "./standards-sdk.es128.js";
 import "./standards-sdk.es129.js";
 import "./standards-sdk.es130.js";
@@ -14,27 +11,24 @@ import "./standards-sdk.es131.js";
 import "./standards-sdk.es132.js";
 import "./standards-sdk.es133.js";
 import "./standards-sdk.es134.js";
-import "./standards-sdk.es135.js";
 import "buffer";
 import "crypto";
 import "@noble/curves/secp256k1.js";
 import "zod";
-import "./standards-sdk.es139.js";
+import "./standards-sdk.es149.js";
+import "./standards-sdk.es138.js";
 import "ethers";
-import "./standards-sdk.es123.js";
-import { detectKeyTypeFromString } from "./standards-sdk.es114.js";
-import { getTopicId } from "./standards-sdk.es115.js";
-import { createNodeOperatorContext, NodeOperatorResolver } from "./standards-sdk.es145.js";
-import { HCS10BaseClient, Hcs10MemoType } from "./standards-sdk.es17.js";
+import "./standards-sdk.es122.js";
+import "./standards-sdk.es113.js";
+import { getTopicId } from "./standards-sdk.es114.js";
+import { InscriptionSDK } from "./standards-sdk.es148.js";
+import { HCS10BaseClient, Hcs10MemoType } from "./standards-sdk.es16.js";
 import * as mime from "mime-types";
-import { AgentBuilder } from "./standards-sdk.es24.js";
-import { InboundTopicType } from "./standards-sdk.es29.js";
-import { HCS11Client } from "./standards-sdk.es28.js";
-import { inscribe } from "./standards-sdk.es125.js";
-import { addSeconds } from "date-fns";
-import { buildTopicCreateTx, buildMessageTx } from "./standards-sdk.es146.js";
-import { buildHcs10CreateInboundTopicTx, buildHcs10CreateConnectionTopicTx, buildHcs10ConfirmConnectionTx, buildHcs10SendMessageTx, buildHcs10RegistryRegisterTx, buildHcs10CreateOutboundTopicTx, buildHcs10CreateRegistryTopicTx } from "./standards-sdk.es23.js";
-class HCS10Client extends HCS10BaseClient {
+import { AgentBuilder } from "./standards-sdk.es23.js";
+import { HCS11Client } from "./standards-sdk.es27.js";
+import { inscribeWithSigner } from "./standards-sdk.es124.js";
+const isBrowser = typeof window !== "undefined";
+class BrowserHCSClient extends HCS10BaseClient {
   constructor(config) {
     super({
       network: config.network,
@@ -42,237 +36,194 @@ class HCS10Client extends HCS10BaseClient {
       prettyPrint: config.prettyPrint,
       feeAmount: config.feeAmount,
       mirrorNode: config.mirrorNode,
-      silent: config.silent,
-      keyType: config.keyType
+      silent: config.silent
     });
+    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: "HCS-SDK",
+      level: logLevel,
+      module: "HCS-Browser",
+      prettyPrint: config.prettyPrint,
       silent: config.silent
     });
-    this.operatorAccountId = config.operatorId;
-    this.operatorCtx = createNodeOperatorContext({
-      network: this.network,
-      operatorId: this.operatorAccountId,
-      operatorKey: config.operatorPrivateKey,
-      keyType: config.keyType,
-      mirrorNode: this.mirrorNode,
-      logger: this.logger,
-      client: config.network === "mainnet" ? Client.forMainnet() : Client.forTestnet()
-    });
-    this.client = this.operatorCtx.client;
-    this.network = config.network;
-    this.guardedRegistryBaseUrl = config.guardedRegistryBaseUrl || "https://moonscape.tech";
-    this.hcs11Client = new HCS11Client({
-      network: config.network,
-      auth: {
-        operatorId: config.operatorId,
-        privateKey: this.operatorCtx.operatorKey.toString()
-      },
-      logLevel: config.logLevel,
-      silent: config.silent,
-      keyType: config.keyType
-    });
-  }
-  async ensureInitialized() {
-    await this.operatorCtx.ensureInitialized();
-  }
-  getClient() {
-    return this.client;
+    if (isBrowser) {
+      try {
+        const { accountId, signer } = this.getAccountAndSigner();
+        this.hcs11Client = new HCS11Client({
+          network: config.network,
+          auth: {
+            operatorId: accountId,
+            signer
+          },
+          logLevel: config.logLevel,
+          silent: config.silent
+        });
+      } 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."
+      );
+    }
   }
-  /**
-   * Creates a new Hedera account
-   * @param initialBalance Optional initial balance in HBAR (default: 50)
-   * @returns Object with account ID and private key
-   */
-  async createAccount(initialBalance = 50) {
-    await this.ensureInitialized();
-    this.logger.info(
-      `Creating new account with ${initialBalance} HBAR initial balance`
+  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 newKey = PrivateKey.generateED25519();
-    const accountTransaction = new AccountCreateTransaction().setKeyWithoutAlias(newKey.publicKey).setInitialBalance(new Hbar(initialBalance));
-    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"
+    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 (getTopicId(inscriptionResult)) {
+          payload.data = `hcs://1/${getTopicId(inscriptionResult)}`;
+          this.logger.info(
+            `Large message inscribed with topic ID: ${getTopicId(inscriptionResult)}`
+          );
+        } 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"}`
+        );
+      }
     }
-    this.logger.info(
-      `Account created successfully: ${newAccountId.toString()}`
+    return await this.submitPayload(
+      connectionTopicId,
+      payload,
+      submitKey,
+      submissionCheck.requiresFee
     );
-    return {
-      accountId: newAccountId.toString(),
-      privateKey: newKey.toString()
-    };
   }
-  /**
-   * 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
-   */
-  async createInboundTopic(accountId, topicType, ttl = 60, feeConfigBuilder) {
-    await this.ensureInitialized();
-    this._generateHcs10Memo(Hcs10MemoType.INBOUND, {
-      accountId,
-      ttl
-    });
-    let submitKey;
-    let finalFeeConfig;
-    switch (topicType) {
-      case InboundTopicType.PUBLIC:
-        submitKey = false;
-        break;
-      case InboundTopicType.CONTROLLED:
-        submitKey = true;
-        break;
-      case InboundTopicType.FEE_BASED:
-        submitKey = false;
-        if (!feeConfigBuilder) {
-          throw new Error(
-            "Fee configuration builder is required for fee-based topics"
-          );
-        }
-        const internalFees = feeConfigBuilder.customFees;
-        internalFees.forEach((fee) => {
-          if (!fee.feeCollectorAccountId) {
-            fee.feeCollectorAccountId = accountId;
-          }
-        });
-        finalFeeConfig = feeConfigBuilder.build();
-        finalFeeConfig.customFees = finalFeeConfig.customFees.map((f) => ({
-          ...f,
-          feeCollectorAccountId: f.feeCollectorAccountId || accountId
-        }));
-        break;
-      default:
-        throw new Error(`Unsupported inbound topic type: ${topicType}`);
+  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 operatorPublicKey = this.client.operatorPublicKey || this.operatorCtx.operatorKey.publicKey;
-    const transaction = buildHcs10CreateInboundTopicTx({
-      accountId,
+    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,
-      adminKey: true,
-      submitKey,
-      operatorPublicKey
+      inboundTopicId,
+      connectionId
     });
-    this.logger.info("Creating inbound topic");
-    const { topicId } = await this.executeTopicCreateTransaction({
+    const transaction = new TopicCreateTransaction().setTopicMemo(memo).setAutoRenewAccountId(AccountId.fromString(userAccountId)).setAdminKey(thresholdKey).setSubmitKey(thresholdKey);
+    this.logger.debug("Executing topic creation transaction");
+    const txResponse = await this.hwc.executeTransactionWithErrorHandling(
       transaction,
-      feeConfig: finalFeeConfig
+      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
+    );
+    const accountTopics = await this.retrieveCommunicationTopics(userAccountId);
+    const requestingAccountTopics = await this.retrieveCommunicationTopics(requestingAccountId);
+    const requestingAccountOperatorId = `${requestingAccountTopics.inboundTopic}@${requestingAccountId}`;
+    await this.recordOutboundConnectionConfirmation({
+      outboundTopicId: accountTopics.outboundTopic,
+      requestorOutboundTopicId: requestingAccountTopics.outboundTopic,
+      connectionRequestId: connectionId,
+      confirmedRequestId: confirmedConnectionSequenceNumber,
+      connectionTopicId,
+      operatorId: requestingAccountOperatorId,
+      memo: `Connection established with ${requestingAccountId}`
     });
-    return topicId;
+    return {
+      connectionTopicId,
+      confirmedConnectionSequenceNumber,
+      operatorId
+    };
   }
-  /**
-   * 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
-   * @param existingState Optional existing state to resume from
-   * @returns Object with topic IDs
-   */
-  async createAgent(builder, ttl = 60, existingState, progressCallback) {
-    await this.ensureInitialized();
-    const config = builder.build();
-    const accountId = this.client.operatorAccountId?.toString();
-    if (!accountId) {
-      throw new Error("Failed to retrieve operator account ID");
-    }
-    const result = await this._createEntityTopics(
-      ttl,
-      {
-        outboundTopicId: existingState?.outboundTopicId || "",
-        inboundTopicId: existingState?.inboundTopicId || "",
-        pfpTopicId: existingState?.pfpTopicId || config.existingPfpTopicId || "",
-        profileTopicId: existingState?.profileTopicId || ""
-      },
-      accountId,
-      config.inboundTopicType,
-      config.feeConfig,
-      config.pfpBuffer,
-      config.pfpFileName,
-      progressCallback
+  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 (!result.profileTopicId) {
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Creating agent profile",
-          progressPercent: 60,
-          details: {
-            outboundTopicId: result.outboundTopicId,
-            inboundTopicId: result.inboundTopicId,
-            pfpTopicId: result.pfpTopicId,
-            state: {
-              currentStage: "profile",
-              completedPercentage: 60
-            }
-          }
-        });
-      }
-      const profileResult = await this.storeHCS11Profile(
-        config.name,
-        config.bio,
-        result.inboundTopicId,
-        result.outboundTopicId,
-        config.capabilities,
-        config.metadata,
-        config.pfpBuffer && config.pfpBuffer.length > 0 && !result.pfpTopicId ? config.pfpBuffer : void 0,
-        config.pfpFileName,
-        result.pfpTopicId
-      );
-      result.profileTopicId = profileResult.profileTopicId;
-      this.logger.info(
-        `Profile stored with topic ID: ${result.profileTopicId}`
-      );
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Agent profile created",
-          progressPercent: 70,
-          details: {
-            outboundTopicId: result.outboundTopicId,
-            inboundTopicId: result.inboundTopicId,
-            pfpTopicId: result.pfpTopicId,
-            profileTopicId: result.profileTopicId,
-            state: {
-              currentStage: "profile",
-              completedPercentage: 70
-            }
-          }
-        });
-      }
-    } else {
-      this.logger.info(
-        `Using existing profile topic ID: ${result.profileTopicId}`
+    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 result;
+    return transactionResponse.topicSequenceNumber.toNumber();
   }
-  /**
-   * Creates a profile (person or agent) with HCS-10 topics and HCS-11 profile.
-   * This method provides a unified interface for creating both person and agent profiles.
-   *
-   * @param builder - AgentBuilder or PersonBuilder instance
-   * @param options - Optional configuration including progress callback and state
-   * @returns Promise resolving to profile creation result
-   */
   async create(builder, options) {
     const progressCallback = options?.progressCallback;
     const progressReporter = new ProgressReporter({
       module: "ProfileCreate",
       logger: this.logger,
-      callback: progressCallback ? (d) => progressCallback({
-        stage: d.stage,
-        message: d.message,
-        progressPercent: d.progressPercent,
-        details: d.details
-      }) : void 0
+      callback: progressCallback
     });
     try {
       const isAgentBuilder = builder instanceof AgentBuilder;
@@ -300,19 +251,11 @@ class HCS10Client extends HCS10BaseClient {
           state
         }
       );
-      const accountId = this.client.operatorAccountId?.toString();
-      if (!accountId) {
-        throw new Error("Failed to retrieve operator account ID");
-      }
       const {
         inboundTopicId,
         outboundTopicId,
         state: updatedState
-      } = await this.createCommunicationTopics(
-        accountId,
-        options,
-        progressReporter
-      );
+      } = await this.createCommunicationTopics(options, progressReporter);
       state = updatedState;
       builder.setInboundTopicId(inboundTopicId);
       builder.setOutboundTopicId(outboundTopicId);
@@ -410,1289 +353,57 @@ class HCS10Client extends HCS10BaseClient {
       };
     }
   }
-  /**
-   * Inscribes a profile picture to Hedera
-   * @param buffer Profile picture buffer
-   * @param fileName Filename
-   * @returns Response with topic ID and transaction ID
-   */
-  async inscribePfp(buffer, fileName) {
-    try {
-      this.logger.info("Inscribing profile picture using HCS-11 client");
-      const imageResult = await this.hcs11Client.inscribeImage(
-        buffer,
-        fileName
-      );
-      if (!imageResult.success) {
-        this.logger.error(
-          `Failed to inscribe profile picture: ${imageResult.error}`
-        );
-        throw new Error(
-          imageResult?.error || "Failed to inscribe profile picture"
-        );
+  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;
       }
-      this.logger.info(
-        `Successfully inscribed profile picture with topic ID: ${imageResult.imageTopicId}`
-      );
-      return {
-        pfpTopicId: imageResult.imageTopicId,
-        transactionId: imageResult.transactionId,
-        success: true
-      };
-    } catch (e) {
-      const error = e;
-      const logMessage = `Error inscribing profile picture: ${error.message}`;
-      this.logger.error(logMessage);
-      return {
-        pfpTopicId: "",
-        transactionId: "",
-        success: false,
-        error: error.message
-      };
+      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;
   }
-  /**
-   * Stores an HCS-11 profile for an agent
-   * @param agentName Agent name
-   * @param agentBio 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
-   */
-  async storeHCS11Profile(agentName, agentBio, inboundTopicId, outboundTopicId, capabilities = [], metadata, pfpBuffer, pfpFileName, existingPfpTopicId) {
-    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.warn(
-            `Failed to inscribe profile picture: ${pfpResult.error}, proceeding without pfp`
-          );
-        } else {
-          pfpTopicId = pfpResult.pfpTopicId;
-        }
-      } else if (existingPfpTopicId) {
-        this.logger.info(
-          `Using existing profile picture with topic ID: ${existingPfpTopicId} for HCS-11 profile`
+  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
         );
-        pfpTopicId = existingPfpTopicId;
       }
-      const agentType = this.hcs11Client.getAgentTypeFromMetadata({
-        type: metadata.type || "autonomous"
-      });
-      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: metadata.properties,
-          inboundTopicId,
-          outboundTopicId,
-          creator: metadata.creator
-        }
-      );
-      const profileResult = await this.hcs11Client.createAndInscribeProfile(
-        profile,
-        true
-      );
-      if (!profileResult.success) {
-        this.logger.error(`Failed to inscribe profile: ${profileResult.error}`);
-        throw new Error(profileResult.error || "Failed to inscribe profile");
-      }
-      this.logger.info(
-        `Profile inscribed with topic ID: ${profileResult.profileTopicId}, transaction ID: ${profileResult.transactionId}`
-      );
-      return {
-        profileTopicId: profileResult.profileTopicId,
-        pfpTopicId,
-        transactionId: profileResult.transactionId,
-        success: true
-      };
-    } catch (e) {
-      const error = e;
-      const logMessage = `Error storing HCS-11 profile: ${error.message}`;
-      this.logger.error(logMessage);
-      return {
-        profileTopicId: "",
-        pfpTopicId: "",
-        transactionId: "",
-        success: false,
-        error: error.message
-      };
-    }
-  }
-  async setupFees(transaction, feeConfig, additionalExemptAccounts = []) {
-    let modifiedTransaction = transaction;
-    if (!this.client.operatorPublicKey) {
-      return modifiedTransaction;
-    }
-    if (!feeConfig.customFees || feeConfig.customFees.length === 0) {
-      this.logger.warn("No custom fees provided in fee config for setupFees");
-      return modifiedTransaction;
-    }
-    if (feeConfig.customFees.length > 10) {
-      this.logger.warn(
-        "More than 10 custom fees provided, only the first 10 will be used"
-      );
-      feeConfig.customFees = feeConfig.customFees.slice(0, 10);
-    }
-    const customFees = feeConfig.customFees.map((fee) => {
-      if (!fee.feeCollectorAccountId) {
-        this.logger.error(
-          "Internal Error: Fee collector ID missing in setupFees"
-        );
-        return null;
-      }
-      if (fee.type === "FIXED_FEE") {
-        const customFee = new CustomFixedFee().setAmount(Number(fee.feeAmount.amount)).setFeeCollectorAccountId(
-          AccountId.fromString(fee.feeCollectorAccountId)
-        );
-        if (fee.feeTokenId) {
-          customFee.setDenominatingTokenId(
-            TokenId.fromString(fee.feeTokenId)
-          );
-        }
-        return customFee;
-      }
-      return null;
-    }).filter(Boolean);
-    if (customFees.length === 0) {
-      this.logger.warn("No valid custom fees to apply in setupFees");
-      return modifiedTransaction;
-    }
-    const exemptAccountIds = [
-      ...feeConfig.exemptAccounts || [],
-      ...additionalExemptAccounts
-    ];
-    if (exemptAccountIds.length > 0) {
-      modifiedTransaction = await this.setupExemptKeys(
-        transaction,
-        exemptAccountIds
-      );
-    }
-    return modifiedTransaction.setFeeScheduleKey(this.client.operatorPublicKey).setCustomFees(customFees);
-  }
-  async setupExemptKeys(transaction, exemptAccountIds) {
-    let modifiedTransaction = transaction;
-    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 (e) {
-        const error = e;
-        const logMessage = `Error getting exempt keys: ${error.message}, continuing without exempt keys`;
-        this.logger.warn(logMessage);
-      }
-    }
-    if (exemptKeys.length > 0) {
-      modifiedTransaction = modifiedTransaction.setFeeExemptKeys(exemptKeys);
-    }
-    return modifiedTransaction;
-  }
-  /**
-   * Handles a connection request from another account
-   * @param inboundTopicId Inbound topic ID of your agent
-   * @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) {
-    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;
-    try {
-      const connectionTransaction = buildHcs10CreateConnectionTopicTx({
-        ttl,
-        inboundTopicId,
-        connectionId: connectionRequestId,
-        adminKey: thresholdKey,
-        submitKey: thresholdKey
-      });
-      if (connectionFeeConfig) {
-        const feeConfig = connectionFeeConfig.build();
-        const modifiedFeeConfig = {
-          ...feeConfig,
-          exemptAccounts: [...feeConfig.exemptAccounts || []]
-        };
-        const { topicId } = await this.executeTopicCreateTransaction({
-          transaction: connectionTransaction,
-          feeConfig: modifiedFeeConfig
-        });
-        connectionTopicId = topicId;
-      } else {
-        const { topicId } = await this.executeTopicCreateTransaction({
-          transaction: connectionTransaction
-        });
-        connectionTopicId = topicId;
-      }
-      this.logger.info(`Created new connection topic ID: ${connectionTopicId}`);
-    } catch (error) {
-      const logMessage = `Failed to create connection topic: ${error}`;
-      this.logger.error(logMessage);
-      throw new TopicCreationError(logMessage);
-    }
-    const operatorId = `${inboundTopicId}@${accountId}`;
-    const confirmedConnectionSequenceNumber = await this.confirmConnection(
-      inboundTopicId,
-      connectionTopicId,
-      requestingAccountId,
-      connectionRequestId,
-      "Connection accepted. Looking forward to collaborating!"
-    );
-    const accountTopics = await this.retrieveCommunicationTopics(accountId);
-    const requestingAccountTopics = await this.retrieveCommunicationTopics(requestingAccountId);
-    const requestingAccountOperatorId = `${requestingAccountTopics.inboundTopic}@${requestingAccountId}`;
-    await this.recordOutboundConnectionConfirmation({
-      outboundTopicId: accountTopics.outboundTopic,
-      requestorOutboundTopicId: requestingAccountTopics.outboundTopic,
-      connectionRequestId,
-      confirmedRequestId: confirmedConnectionSequenceNumber,
-      connectionTopicId,
-      operatorId: requestingAccountOperatorId,
-      memo: `Connection established with ${requestingAccountId}`
-    });
-    return {
-      connectionTopicId,
-      confirmedConnectionSequenceNumber,
-      operatorId
-    };
-  }
-  /**
-   * Confirms a connection request from another account
-   * @param inboundTopicId Inbound topic ID
-   * @param connectionTopicId Connection topic ID
-   * @param connectedAccountId Connected account ID
-   * @param connectionId Connection ID
-   * @param memo Memo for the connection request
-   * @param submitKey Optional submit key
-   * @returns Sequence number of the confirmed connection
-   */
-  async confirmConnection(inboundTopicId, connectionTopicId, connectedAccountId, connectionId, memo, submitKey) {
-    const operatorId = await this.getOperatorId();
-    this.logger.info(`Confirming connection with ID ${connectionId}`);
-    const submissionCheck = await this.canSubmitToTopic(
-      inboundTopicId,
-      this.client.operatorAccountId?.toString() || ""
-    );
-    const transaction = buildHcs10ConfirmConnectionTx({
-      inboundTopicId,
-      connectionTopicId,
-      connectedAccountId,
-      operatorId,
-      connectionId,
-      memo
-    });
-    const result = await this.submitPayload(
-      transaction,
-      void 0,
-      submitKey,
-      submissionCheck.requiresFee
-    );
-    const sequenceNumber = result.topicSequenceNumber?.toNumber();
-    if (!sequenceNumber) {
-      throw new ConnectionConfirmationError(
-        "Failed to confirm connection: sequence number is null"
-      );
-    }
-    return sequenceNumber;
-  }
-  async sendMessage(connectionTopicId, data, memo, submitKey, options) {
-    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"
-      );
-      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 (getTopicId(inscriptionResult)) {
-          payload.data = `hcs://1/${getTopicId(inscriptionResult)}`;
-          this.logger.info(
-            `Large message inscribed with topic ID: ${getTopicId(inscriptionResult)}`
-          );
-        } else {
-          throw new Error("Failed to inscribe large message content");
-        }
-      } catch (error) {
-        const err = error;
-        const logMessage = `Error inscribing large message: ${err.message}`;
-        this.logger.error(logMessage);
-        throw new Error(logMessage);
-      }
-    }
-    this.logger.info("Submitting message to connection topic", payload);
-    const transaction = buildHcs10SendMessageTx({
-      connectionTopicId,
-      operatorId,
-      data: payload.data,
-      memo
-    });
-    return await this.submitPayload(
-      transaction,
-      void 0,
-      submitKey,
-      submissionCheck.requiresFee
-    );
-  }
-  async executeTopicCreateTransaction(params) {
-    let workingTransaction = params.transaction;
-    if (params.feeConfig) {
-      workingTransaction = await this.setupFees(
-        workingTransaction,
-        params.feeConfig,
-        params.additionalExemptAccounts || []
-      );
-    }
-    try {
-      const response = await workingTransaction.execute(this.client);
-      const receipt = await response.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");
-      }
-      return {
-        topicId: receipt.topicId.toString(),
-        receipt,
-        response
-      };
-    } catch (error) {
-      this.logger.error("Topic creation failed", {
-        error: error.message,
-        transactionId: error.transactionId?.toString(),
-        operatorId: this.client.operatorAccountId?.toString()
-      });
-      throw error;
-    }
-  }
-  async createTopic(memo, adminKey, submitKey, feeConfig) {
-    this.logger.info("Creating topic");
-    const transaction = buildTopicCreateTx({
-      memo,
-      adminKey,
-      submitKey,
-      operatorPublicKey: this.client.operatorPublicKey || this.operatorCtx.operatorKey?.publicKey
-    });
-    const { topicId } = await this.executeTopicCreateTransaction({
-      transaction,
-      feeConfig
-    });
-    return topicId;
-  }
-  async submitPayload(topicOrTransaction, payload, submitKey, requiresFee = false) {
-    const isTransaction = topicOrTransaction instanceof TopicMessageSubmitTransaction || typeof topicOrTransaction !== "string" && typeof topicOrTransaction.getMessage === "function";
-    if (isTransaction) {
-      const transaction2 = topicOrTransaction instanceof TopicMessageSubmitTransaction ? topicOrTransaction : topicOrTransaction;
-      const messageBytes = transaction2.getMessage();
-      if (!messageBytes) {
-        throw new Error("Message payload is missing");
-      }
-      const payloadSizeInBytes2 = Buffer.from(messageBytes).length;
-      if (payloadSizeInBytes2 > 1e3) {
-        throw new PayloadSizeError(
-          "Payload size exceeds 1000 bytes limit",
-          payloadSizeInBytes2
-        );
-      }
-      if (requiresFee) {
-        this.logger.info(
-          "Topic requires fee payment, setting max transaction fee"
-        );
-        transaction2.setMaxTransactionFee(new Hbar(this.feeAmount));
-      }
-      let transactionResponse2;
-      if (submitKey) {
-        const frozenTransaction = transaction2.freezeWith(this.client);
-        const signedTransaction = await frozenTransaction.sign(submitKey);
-        transactionResponse2 = await signedTransaction.execute(this.client);
-      } else {
-        transactionResponse2 = await transaction2.execute(this.client);
-      }
-      const receipt2 = await transactionResponse2.getReceipt(this.client);
-      if (!receipt2) {
-        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 receipt2;
-    }
-    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
-      );
-    }
-    const transactionMemo = this.getHcs10TransactionMemo(payload);
-    const transaction = buildMessageTx({
-      topicId: topicOrTransaction,
-      message,
-      transactionMemo: transactionMemo || void 0
-    });
-    if (requiresFee) {
-      this.logger.info(
-        "Topic requires fee payment, setting max transaction fee"
-      );
-      transaction.setMaxTransactionFee(new Hbar(this.feeAmount));
-    }
-    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 inscribeFile(buffer, fileName, options) {
-    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.operatorCtx.operatorKey) {
-      this.logger.error("Operator private key is not set");
-      throw new Error("Operator private key is not set");
-    }
-    const mimeType = mime.lookup(fileName) || "application/octet-stream";
-    const privateKey = this.operatorCtx.operatorKey;
-    const sdk = await InscriptionSDK.createWithAuth({
-      type: "server",
-      accountId: this.client.operatorAccountId.toString(),
-      privateKey,
-      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"
-      }
-    };
-    const response = await inscribe(
-      {
-        type: "buffer",
-        buffer,
-        fileName,
-        mimeType
-      },
-      {
-        accountId: this.client.operatorAccountId.toString(),
-        privateKey,
-        network: this.network
-      },
-      inscriptionOptions,
-      sdk
-    );
-    if (!response.confirmed || !response.inscription) {
-      throw new Error("Inscription was not confirmed");
-    }
-    return response.inscription;
-  }
-  /**
-   * Waits for confirmation of a connection request
-   * @param inboundTopicId Inbound topic ID
-   * @param connectionRequestId Connection request ID
-   * @param maxAttempts Maximum number of attempts
-   * @param delayMs Delay between attempts in milliseconds
-   * @returns Connection confirmation details
-   */
-  async waitForConnectionConfirmation(inboundTopicId, connectionRequestId, maxAttempts = 60, delayMs = 2e3, recordConfirmation = true) {
-    this.logger.info(
-      `Waiting for connection confirmation on inbound topic ${inboundTopicId} for request ID ${connectionRequestId}`
-    );
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      this.logger.info(
-        `Attempt ${attempt + 1}/${maxAttempts} to find connection confirmation`
-      );
-      const messages = await this.mirrorNode.getTopicMessages(inboundTopicId);
-      const connectionCreatedMessages = messages.filter(
-        (m) => m.op === "connection_created"
-      );
-      this.logger.info(
-        `Found ${connectionCreatedMessages.length} connection_created messages`
-      );
-      if (connectionCreatedMessages.length > 0) {
-        for (const message of connectionCreatedMessages) {
-          if (Number(message.connection_id) === Number(connectionRequestId)) {
-            const confirmationResult = {
-              connectionTopicId: message.connection_topic_id,
-              sequence_number: Number(message.sequence_number),
-              confirmedBy: message.operator_id,
-              memo: message.m
-            };
-            const confirmedByAccountId = this.extractAccountFromOperatorId(
-              confirmationResult.confirmedBy
-            );
-            const account = this.getAccountAndSigner();
-            const confirmedByConnectionTopics = await this.retrieveCommunicationTopics(confirmedByAccountId);
-            const agentConnectionTopics = await this.retrieveCommunicationTopics(account.accountId);
-            this.logger.info(
-              "Connection confirmation found",
-              confirmationResult
-            );
-            if (recordConfirmation) {
-              await this.recordOutboundConnectionConfirmation({
-                requestorOutboundTopicId: confirmedByConnectionTopics.outboundTopic,
-                outboundTopicId: agentConnectionTopics.outboundTopic,
-                connectionRequestId,
-                confirmedRequestId: confirmationResult.sequence_number,
-                connectionTopicId: confirmationResult.connectionTopicId,
-                operatorId: confirmationResult.confirmedBy,
-                memo: confirmationResult.memo || "Connection confirmed"
-              });
-            }
-            return confirmationResult;
-          }
-        }
-      }
-      if (attempt < maxAttempts - 1) {
-        this.logger.info(
-          `No matching confirmation found, waiting ${delayMs}ms before retrying...`
-        );
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
-      }
-    }
-    throw new Error(
-      `Connection confirmation not found after ${maxAttempts} attempts for request ID ${connectionRequestId}`
-    );
-  }
-  getAccountAndSigner() {
-    const PK = this.operatorCtx.operatorKey;
-    return {
-      accountId: this.client.operatorAccountId.toString(),
-      signer: PK
-    };
-  }
-  /**
-   * 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
-   */
-  async createAndRegisterAgent(builder, options) {
-    try {
-      const config = builder.build();
-      const progressCallback = options?.progressCallback;
-      const baseUrl = options?.baseUrl || this.guardedRegistryBaseUrl;
-      let state = options?.existingState || {
-        currentStage: "init",
-        completedPercentage: 0,
-        createdResources: []
-      };
-      state.agentMetadata = config.metadata;
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Starting agent creation process",
-          progressPercent: 0,
-          details: { state }
-        });
-      }
-      let account = config.existingAccount;
-      let agentClient;
-      if (!state.inboundTopicId || !state.outboundTopicId || !state.profileTopicId) {
-        if (!account) {
-          if (state.createdResources && state.createdResources.some((r) => r.startsWith("account:"))) {
-            const accountResource = state.createdResources.find(
-              (r) => r.startsWith("account:")
-            );
-            const existingAccountId = accountResource?.split(":")[1];
-            if (existingAccountId && config.existingAccount) {
-              account = config.existingAccount;
-              this.logger.info(
-                `Resuming with existing account: ${existingAccountId}`
-              );
-            } else {
-              account = await this.createAccount(options?.initialBalance);
-              state.createdResources = state.createdResources || [];
-              state.createdResources.push(`account:${account.accountId}`);
-            }
-          } else {
-            account = await this.createAccount(options?.initialBalance);
-            state.createdResources = state.createdResources || [];
-            state.createdResources.push(`account:${account.accountId}`);
-          }
-        }
-        if (progressCallback) {
-          progressCallback({
-            stage: "preparing",
-            message: "Created account or using existing account",
-            progressPercent: 20,
-            details: { state, account }
-          });
-        }
-        const resolver = new NodeOperatorResolver({
-          mirrorNode: this.mirrorNode,
-          logger: this.logger
-        });
-        const keyInfo = await resolver.resolveOperatorKey(
-          account.accountId,
-          account.privateKey
-        );
-        const publicKey = keyInfo.privateKey.publicKey.toString();
-        agentClient = new HCS10Client({
-          network: config.network,
-          operatorId: account.accountId,
-          operatorPrivateKey: keyInfo.privateKey.toString(),
-          operatorPublicKey: publicKey,
-          keyType: keyInfo.keyType,
-          logLevel: "info",
-          guardedRegistryBaseUrl: baseUrl
-        });
-        if (progressCallback) {
-          progressCallback({
-            stage: "preparing",
-            message: "Initialized agent client",
-            progressPercent: 25,
-            details: { state }
-          });
-        }
-        let outboundTopicId = state.outboundTopicId;
-        let inboundTopicId = state.inboundTopicId;
-        let pfpTopicId = state.pfpTopicId;
-        let profileTopicId = state.profileTopicId;
-        if (!outboundTopicId || !inboundTopicId || !profileTopicId) {
-          if (pfpTopicId) {
-            builder.setExistingProfilePicture(pfpTopicId);
-          }
-          const createResult = await agentClient.createAgent(
-            builder,
-            60,
-            state,
-            (data) => {
-              if (progressCallback) {
-                progressCallback({
-                  stage: data.stage,
-                  message: data.message,
-                  progressPercent: data.progressPercent || 0,
-                  details: {
-                    ...data.details,
-                    state: {
-                      ...state,
-                      ...data.details?.state
-                    }
-                  }
-                });
-              }
-            }
-          );
-          outboundTopicId = createResult.outboundTopicId;
-          inboundTopicId = createResult.inboundTopicId;
-          pfpTopicId = createResult.pfpTopicId;
-          profileTopicId = createResult.profileTopicId;
-          state.outboundTopicId = outboundTopicId;
-          state.inboundTopicId = inboundTopicId;
-          state.pfpTopicId = pfpTopicId;
-          state.profileTopicId = profileTopicId;
-          if (!state.createdResources) {
-            state.createdResources = [];
-          }
-          if (pfpTopicId && !state.createdResources.includes(`pfp:${pfpTopicId}`)) {
-            state.createdResources.push(`pfp:${pfpTopicId}`);
-          }
-          if (!state.createdResources.includes(`inbound:${inboundTopicId}`)) {
-            state.createdResources.push(`inbound:${inboundTopicId}`);
-          }
-          if (!state.createdResources.includes(`outbound:${outboundTopicId}`)) {
-            state.createdResources.push(`outbound:${outboundTopicId}`);
-          }
-          if (!state.createdResources.includes(`profile:${profileTopicId}`)) {
-            state.createdResources.push(`profile:${profileTopicId}`);
-          }
-        }
-        state.currentStage = "profile";
-        state.completedPercentage = 60;
-        if (progressCallback) {
-          progressCallback({
-            stage: "submitting",
-            message: "Created agent with topics and profile",
-            progressPercent: 60,
-            details: {
-              state,
-              outboundTopicId,
-              inboundTopicId,
-              pfpTopicId,
-              profileTopicId
-            }
-          });
-        }
-      } else {
-        account = account || config.existingAccount;
-        if (!account) {
-          throw new Error(
-            "Cannot resume registration without account information"
-          );
-        }
-        const publicKey = this.operatorCtx.keyType === "ecdsa" ? PrivateKey.fromStringECDSA(
-          account.privateKey
-        ).publicKey.toString() : PrivateKey.fromStringED25519(
-          account.privateKey
-        ).publicKey.toString();
-        agentClient = new HCS10Client({
-          network: config.network,
-          operatorId: account.accountId,
-          operatorPrivateKey: account.privateKey,
-          operatorPublicKey: publicKey,
-          logLevel: "info",
-          guardedRegistryBaseUrl: baseUrl
-        });
-        this.logger.info("Resuming registration with existing state", {
-          inboundTopicId: state.inboundTopicId,
-          outboundTopicId: state.outboundTopicId,
-          profileTopicId: state.profileTopicId,
-          pfpTopicId: state.pfpTopicId
-        });
-      }
-      const operatorId = `${state.inboundTopicId}@${account.accountId}`;
-      if (state.currentStage !== "complete" || !state.createdResources?.includes(
-        `registration:${state.inboundTopicId}`
-      )) {
-        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: state.outboundTopicId,
-                    inboundTopicId: state.inboundTopicId,
-                    pfpTopicId: state.pfpTopicId,
-                    profileTopicId: state.profileTopicId,
-                    operatorId,
-                    state: data.details?.state || state
-                  }
-                });
-              }
-            },
-            existingState: state
-          }
-        );
-        if (!registrationResult.success) {
-          return {
-            ...registrationResult,
-            state
-          };
-        }
-        state = registrationResult.state || state;
-      }
-      if (progressCallback) {
-        progressCallback({
-          stage: "completed",
-          message: "Agent creation and registration complete",
-          progressPercent: 100,
-          details: {
-            outboundTopicId: state.outboundTopicId,
-            inboundTopicId: state.inboundTopicId,
-            pfpTopicId: state.pfpTopicId,
-            profileTopicId: state.profileTopicId,
-            operatorId,
-            state
-          }
-        });
-      }
-      return {
-        success: true,
-        state,
-        metadata: {
-          accountId: account.accountId,
-          privateKey: account.privateKey,
-          operatorId,
-          inboundTopicId: state.inboundTopicId,
-          outboundTopicId: state.outboundTopicId,
-          profileTopicId: state.profileTopicId,
-          pfpTopicId: state.pfpTopicId
-        }
-      };
-    } catch (e) {
-      const error = e;
-      const logMessage = `Failed to create and register agent: ${error.message}`;
-      this.logger.error(logMessage);
-      return {
-        error: error.message,
-        success: false,
-        state: options?.existingState || {
-          currentStage: "init",
-          completedPercentage: 0,
-          error: error.message
-        }
-      };
-    }
-  }
-  /**
-   * 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) {
-    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}`
-        );
-      }
-      if (progressCallback) {
-        progressCallback({
-          stage: "completed",
-          message: "Agent registration complete",
-          progressPercent: 100,
-          details: {
-            confirmed,
-            transactionId: registrationResult.transactionId,
-            state
-          }
-        });
-      }
-      return {
-        ...registrationResult,
-        confirmed,
-        state
-      };
-    } catch (e) {
-      const error = e;
-      const logMessage = `Failed to register agent: ${error.message}`;
-      this.logger.error(logMessage);
-      return {
-        error: error.message,
-        success: false
-      };
-    }
-  }
-  /**
-   * 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
-   */
-  async registerAgent(registryTopicId, accountId, inboundTopicId, memo, submitKey) {
-    this.logger.info("Registering agent");
-    const transaction = buildHcs10RegistryRegisterTx({
-      registryTopicId,
-      accountId,
-      inboundTopicId,
-      memo
-    });
-    await this.submitPayload(transaction, void 0, submitKey);
-  }
-  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 (e) {
-      const error = e;
-      const logMessage = `Error determining topic type: ${error.message}`;
-      this.logger.error(logMessage);
-      throw new Error(logMessage);
-    }
-  }
-  getNetwork() {
-    return this.network;
-  }
-  getLogger() {
-    return this.logger;
-  }
-  /**
-   * Public method to get the operator account ID configured for this client instance.
-   * @returns The operator account ID string, or null if not set.
-   */
-  getOperatorAccountId() {
-    return this.client.operatorAccountId?.toString() ?? null;
-  }
-  /**
-   * Creates a scheduled transaction from a transaction object
-   * @param transaction The transaction to schedule
-   * @param memo Optional memo to include with the scheduled transaction
-   * @param expirationTime Optional expiration time in seconds from now
-   * @returns Object with schedule ID and transaction ID
-   */
-  async createScheduledTransaction(transaction, memo, expirationTime, schedulePayerAccountId) {
-    this.logger.info("Creating scheduled transaction");
-    const scheduleTransaction = new ScheduleCreateTransaction().setScheduledTransaction(transaction).setPayerAccountId(
-      schedulePayerAccountId ? AccountId.fromString(schedulePayerAccountId) : this.client.operatorAccountId
-    );
-    if (memo) {
-      scheduleTransaction.setScheduleMemo(memo);
-    }
-    if (expirationTime) {
-      const expirationDate = addSeconds(/* @__PURE__ */ new Date(), expirationTime);
-      const timestamp = Timestamp.fromDate(expirationDate);
-      scheduleTransaction.setExpirationTime(timestamp);
-    }
-    const scheduleResponse = await scheduleTransaction.execute(this.client);
-    const scheduleReceipt = await scheduleResponse.getReceipt(this.client);
-    if (!scheduleReceipt.scheduleId) {
-      this.logger.error(
-        "Failed to create scheduled transaction: scheduleId is null"
-      );
-      throw new Error(
-        "Failed to create scheduled transaction: scheduleId is null"
-      );
-    }
-    const scheduleId = scheduleReceipt.scheduleId.toString();
-    const transactionId = scheduleResponse.transactionId.toString();
-    this.logger.info(
-      `Scheduled transaction created successfully: ${scheduleId}`
-    );
-    return {
-      scheduleId,
-      transactionId
-    };
-  }
-  /**
-   * Sends a transaction operation on a connection topic
-   * @param connectionTopicId Connection topic ID
-   * @param scheduleId Schedule ID of the scheduled transaction
-   * @param data Human-readable description of the transaction, can also be a JSON string or HRL
-   * @param submitKey Optional submit key
-   * @param options Optional parameters including memo (timestamp is no longer used here)
-   * @returns Transaction receipt
-   */
-  async sendTransactionOperation(connectionTopicId, scheduleId, data, submitKey, options) {
-    const submissionCheck = await this.canSubmitToTopic(
-      connectionTopicId,
-      this.client.operatorAccountId?.toString() || ""
-    );
-    const operatorId = await this.getOperatorId();
-    const payload = {
-      p: "hcs-10",
-      op: "transaction",
-      operator_id: operatorId,
-      schedule_id: scheduleId,
-      data,
-      m: options?.memo
-    };
-    this.logger.info(
-      "Submitting transaction operation to connection topic",
-      payload
-    );
-    return await this.submitPayload(
-      connectionTopicId,
-      payload,
-      submitKey,
-      submissionCheck.requiresFee
-    );
-  }
-  /**
-   * Creates and sends a transaction operation in one call
-   * @param connectionTopicId Connection topic ID for sending the transaction operation
-   * @param transaction The transaction to schedule
-   * @param data Human-readable description of the transaction, can also be a JSON string or HRL
-   * @param options Optional parameters for schedule creation and operation memo
-   * @returns Object with schedule details (including scheduleId and its transactionId) and HCS-10 operation receipt
-   */
-  async sendTransaction(connectionTopicId, transaction, data, options) {
-    this.logger.info(
-      "Creating scheduled transaction and sending transaction operation"
-    );
-    const { scheduleId, transactionId } = await this.createScheduledTransaction(
-      transaction,
-      options?.scheduleMemo,
-      options?.expirationTime,
-      options?.schedulePayerAccountId
-    );
-    const receipt = await this.sendTransactionOperation(
-      connectionTopicId,
-      scheduleId,
-      data,
-      options?.submitKey,
-      {
-        memo: options?.operationMemo
-      }
-    );
-    return {
-      scheduleId,
-      transactionId,
-      receipt
-    };
-  }
-  /**
-   * Creates communication topics (inbound and outbound) for a profile.
-   * Helper method used by the create method.
-   */
-  async createCommunicationTopics(accountId, options, progressReporter) {
-    let state = options?.existingState || {
-      currentStage: "init",
-      completedPercentage: 0,
-      createdResources: []
-    };
-    if (progressReporter) {
-      progressReporter.preparing("Starting communication topic creation", 0, {
-        state
-      });
-    }
-    if (!state.outboundTopicId) {
-      state.currentStage = "topics";
-      if (progressReporter) {
-        progressReporter.preparing("Creating outbound topic", 5, {
-          state
-        });
-      }
-      const operatorPublicKey = this.client.operatorPublicKey || this.operatorCtx.operatorKey.publicKey;
-      const outboundTopicTx = buildHcs10CreateOutboundTopicTx({
-        ttl: options?.ttl ?? 60,
-        adminKey: true,
-        submitKey: true,
-        operatorPublicKey
-      });
-      const { topicId: outboundTopicId } = await this.executeTopicCreateTransaction({
-        transaction: outboundTopicTx
-      });
-      state.outboundTopicId = outboundTopicId;
-      if (state.createdResources)
-        state.createdResources.push(`outbound:${state.outboundTopicId}`);
-    }
-    if (!state.inboundTopicId) {
-      state.currentStage = "topics";
-      if (progressReporter) {
-        progressReporter.preparing("Creating inbound topic", 10, {
-          state
-        });
-      }
-      const operatorPublicKey = this.client.operatorPublicKey || this.operatorCtx.operatorKey.publicKey;
-      const inboundTopicTx = buildHcs10CreateInboundTopicTx({
-        accountId,
-        ttl: options?.ttl ?? 60,
-        adminKey: true,
-        submitKey: false,
-        operatorPublicKey
-      });
-      const { topicId: inboundTopicId } = await this.executeTopicCreateTransaction({
-        transaction: inboundTopicTx
-      });
-      state.inboundTopicId = inboundTopicId;
-      if (state.createdResources)
-        state.createdResources.push(`inbound:${state.inboundTopicId}`);
-    }
-    return {
-      inboundTopicId: state.inboundTopicId,
-      outboundTopicId: state.outboundTopicId,
-      state
-    };
-  }
-  /**
-   * Handles profile picture creation by inscribing it.
-   * Helper method used by the create method.
-   */
-  async handleProfilePictureCreation(pfpBuffer, pfpFileName, state, progressReporter) {
-    state.currentStage = "pfp";
-    progressReporter.preparing("Creating profile picture", 30, {
-      state
-    });
-    progressReporter.createSubProgress({
-      minPercent: 30,
-      maxPercent: 50,
-      logPrefix: "PFP"
-    });
-    const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
-    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;
-  }
-  /**
-   * Creates and inscribes the HCS-11 profile.
-   * Helper method used by the create method.
-   */
-  async createAndInscribeProfile(isAgentBuilder, builder, pfpTopicId, state, inboundTopicId, outboundTopicId, options, progressReporter) {
-    this.logger.info("Creating and inscribing profile");
-    if (!state.profileTopicId) {
-      if (progressReporter) {
-        progressReporter.preparing(
-          `Storing HCS-11 ${isAgentBuilder ? "agent" : "person"} profile`,
-          80
-        );
-      }
-      progressReporter?.createSubProgress({
-        minPercent: 80,
-        maxPercent: 95,
-        logPrefix: "StoreProfile"
+      const profileProgress = progressReporter?.createSubProgress({
+        minPercent: 80,
+        maxPercent: 95,
+        logPrefix: "StoreProfile"
       });
       let hcs11Profile;
       if (isAgentBuilder) {
@@ -1737,7 +448,13 @@ class HCS10Client extends HCS10BaseClient {
       }
       const profileResult = await this.hcs11Client.createAndInscribeProfile(
         hcs11Profile,
-        options?.updateAccountMemo ?? true
+        options?.updateAccountMemo ?? true,
+        {
+          progressCallback: (data) => profileProgress?.report({
+            ...data,
+            progressPercent: data.progressPercent ?? 0
+          })
+        }
       );
       if (!profileResult.success) {
         if (progressReporter) {
@@ -1771,502 +488,249 @@ class HCS10Client extends HCS10BaseClient {
       );
     }
   }
-  /**
-   * Creates a new MCP server with inbound and outbound topics.
-   *
-   * This method creates communication topics and profiles required for an MCP server,
-   * registers the profile with the server's account, and handles profile picture
-   * inscriptions if provided.
-   *
-   * @param builder The MCP server builder object
-   * @param ttl Optional Time-To-Live for the topic memos, defaults to 60
-   * @param existingState Optional existing state to resume from
-   * @returns Object with topic IDs
-   */
-  async createMCPServer(builder, ttl = 60, existingState, progressCallback) {
-    await this.ensureInitialized();
-    const config = builder.build();
-    const accountId = this.client.operatorAccountId?.toString();
-    if (!accountId) {
-      throw new Error("Failed to retrieve operator account ID");
+  initializeRegistrationState(inboundTopicId, existingState) {
+    const state = existingState || {
+      inboundTopicId,
+      currentStage: "registration",
+      completedPercentage: 0,
+      createdResources: []
+    };
+    if (state.currentStage !== "registration" && state.currentStage !== "complete") {
+      state.currentStage = "registration";
     }
-    const result = await this._createEntityTopics(
-      ttl,
-      {
-        outboundTopicId: existingState?.outboundTopicId || "",
-        inboundTopicId: existingState?.inboundTopicId || "",
-        pfpTopicId: existingState?.pfpTopicId || config.existingPfpTopicId || "",
-        profileTopicId: existingState?.profileTopicId || ""
-      },
-      accountId,
-      InboundTopicType.PUBLIC,
-      void 0,
-      config.pfpBuffer,
-      config.pfpFileName,
-      progressCallback
-    );
-    if (!result.profileTopicId) {
-      this.logger.info("Creating and storing HCS-11 MCP server profile");
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Creating MCP server profile",
-          progressPercent: 60,
-          details: {
-            outboundTopicId: result.outboundTopicId,
-            inboundTopicId: result.inboundTopicId,
-            pfpTopicId: result.pfpTopicId,
-            state: {
-              currentStage: "profile",
-              completedPercentage: 60
-            }
-          }
-        });
-      }
-      await this.hcs11Client.initializeOperator();
-      const profile = this.hcs11Client.createMCPServerProfile(
-        config.name,
-        config.mcpServer,
-        {
-          alias: config.alias,
-          bio: config.bio,
-          socials: config.socials || [],
-          inboundTopicId: result.inboundTopicId,
-          outboundTopicId: result.outboundTopicId,
-          profileImage: result.pfpTopicId ? `hcs://1/${result.pfpTopicId}` : void 0
-        }
-      );
-      const profileResult = await this.hcs11Client.inscribeProfile(profile);
-      if (!profileResult.success) {
-        this.logger.error(
-          `Failed to inscribe MCP server profile: ${profileResult.error}`
-        );
-        throw new Error(
-          profileResult.error || "Failed to inscribe MCP server profile"
-        );
-      }
-      result.profileTopicId = profileResult.profileTopicId;
-      this.logger.info(
-        `MCP server profile stored with topic ID: ${result.profileTopicId}`
-      );
-      const memoResult = await this.hcs11Client.updateAccountMemoWithProfile(
-        accountId,
-        result.profileTopicId
-      );
-      if (!memoResult.success) {
-        this.logger.warn(
-          `Failed to update account memo: ${memoResult.error}, but continuing with MCP server creation`
-        );
+    return state;
+  }
+  updateStateForCompletedRegistration(state, inboundTopicId) {
+    state.currentStage = "complete";
+    state.completedPercentage = 100;
+    if (state.createdResources) {
+      state.createdResources.push(`registration:${inboundTopicId}`);
+    }
+  }
+  async registerAgentWithGuardedRegistry(accountId, network = this.network, options) {
+    try {
+      this.logger.info("Registering agent with guarded registry");
+      let inboundTopicId;
+      if (options?.existingState?.inboundTopicId) {
+        this.logger.info("Using inboundTopicId from existing state");
+        inboundTopicId = options.existingState.inboundTopicId;
       } else {
-        this.logger.info(`Updated account memo with profile reference`);
-      }
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "MCP server profile created",
-          progressPercent: 70,
-          details: {
-            outboundTopicId: result.outboundTopicId,
-            inboundTopicId: result.inboundTopicId,
-            pfpTopicId: result.pfpTopicId,
-            profileTopicId: result.profileTopicId,
+        const profileResponse = await this.retrieveProfile(accountId, false, {
+          maxRetries: 5,
+          retryDelay: 3e3
+        });
+        if (!profileResponse.success || !profileResponse.profile || !profileResponse.topicInfo) {
+          const errorMessage = profileResponse.error || `Failed to retrieve profile for account ${accountId}. Make sure the agent profile is created and memo is updated before registration.`;
+          this.logger.error(errorMessage);
+          return {
+            error: errorMessage,
+            success: false,
             state: {
-              currentStage: "profile",
-              completedPercentage: 70
+              currentStage: "registration",
+              completedPercentage: 0,
+              error: errorMessage
             }
-          }
-        });
+          };
+        }
+        inboundTopicId = profileResponse.topicInfo.inboundTopic;
       }
-    } else {
-      this.logger.info(
-        `Using existing profile topic ID: ${result.profileTopicId}`
+      const state = this.initializeRegistrationState(
+        inboundTopicId,
+        options?.existingState
       );
-    }
-    return result;
-  }
-  /**
-   * Creates the base topic structure for an entity (agent or MCP server).
-   *
-   * @param ttl Time-To-Live for topic memos
-   * @param existingTopics Object containing any existing topic IDs to reuse
-   * @param accountId The account ID associated with the entity
-   * @param inboundTopicType Type of inbound topic
-   * @param feeConfig Optional fee configuration for fee-based topics
-   * @param pfpBuffer Optional profile picture buffer
-   * @param pfpFileName Optional profile picture filename
-   * @param progressCallback Optional callback for reporting progress
-   * @returns Object with created topic IDs
-   */
-  async _createEntityTopics(ttl, existingTopics, accountId, inboundTopicType, feeConfig, pfpBuffer, pfpFileName, progressCallback) {
-    let { outboundTopicId, inboundTopicId, pfpTopicId, profileTopicId } = existingTopics;
-    if (!outboundTopicId) {
-      const operatorPublicKey = this.client.operatorPublicKey || this.operatorCtx.operatorKey.publicKey;
-      const outboundTransaction = buildHcs10CreateOutboundTopicTx({
-        ttl,
-        adminKey: true,
-        submitKey: true,
-        operatorPublicKey
+      const progressReporter = new ProgressReporter({
+        module: "AgentRegistration",
+        logger: this.logger,
+        callback: options?.progressCallback
       });
-      const { topicId } = await this.executeTopicCreateTransaction({
-        transaction: outboundTransaction
+      progressReporter.preparing("Preparing agent registration", 10, {
+        inboundTopicId,
+        accountId
       });
-      outboundTopicId = topicId;
-      this.logger.info(`Created new outbound topic ID: ${outboundTopicId}`);
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Created outbound topic",
-          progressPercent: 30,
-          details: {
-            outboundTopicId,
-            state: {
-              currentStage: "topics",
-              completedPercentage: 30
-            }
-          }
-        });
-      }
-    } else {
-      this.logger.info(`Using existing outbound topic ID: ${outboundTopicId}`);
-    }
-    if (!inboundTopicId) {
-      inboundTopicId = await this.createInboundTopic(
+      const registrationResult = await this.executeRegistration(
         accountId,
-        inboundTopicType,
-        ttl,
-        inboundTopicType === InboundTopicType.FEE_BASED ? feeConfig : void 0
+        network,
+        this.guardedRegistryBaseUrl,
+        this.logger
       );
-      this.logger.info(`Created new inbound topic ID: ${inboundTopicId}`);
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Created inbound topic",
-          progressPercent: 40,
-          details: {
-            outboundTopicId,
-            inboundTopicId,
-            state: {
-              currentStage: "topics",
-              completedPercentage: 40
-            }
-          }
-        });
-      }
-    } else {
-      this.logger.info(`Using existing inbound topic ID: ${inboundTopicId}`);
-    }
-    if (!pfpTopicId && pfpBuffer && pfpBuffer.length > 0 && pfpFileName) {
-      this.logger.info("Inscribing new profile picture");
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Inscribing profile picture",
-          progressPercent: 50,
-          details: {
-            outboundTopicId,
-            inboundTopicId,
-            state: {
-              currentStage: "pfp",
-              completedPercentage: 50
-            }
-          }
-        });
+      if (!registrationResult.success) {
+        return {
+          ...registrationResult,
+          state
+        };
       }
-      const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
-      pfpTopicId = pfpResult.pfpTopicId;
-      this.logger.info(
-        `Profile picture inscribed with topic ID: ${pfpTopicId}`
-      );
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Profile picture inscribed",
-          progressPercent: 55,
-          details: {
-            outboundTopicId,
-            inboundTopicId,
-            pfpTopicId,
-            state: {
-              currentStage: "pfp",
-              completedPercentage: 55
-            }
-          }
-        });
+      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`);
       }
-    } else if (pfpTopicId) {
-      this.logger.info(
-        `Using existing profile picture with topic ID: ${pfpTopicId}`
+      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 {
+        ...registrationResult,
+        confirmed,
+        state
+      };
+    } catch (error) {
+      this.logger.error(`Registration error: ${error.message}`);
+      return {
+        error: `Error during registration: ${error.message}`,
+        success: false,
+        state: {
+          currentStage: "registration",
+          completedPercentage: 0,
+          error: error.message
+        }
+      };
     }
-    return {
-      inboundTopicId,
-      outboundTopicId,
-      pfpTopicId,
-      profileTopicId
-    };
   }
-  /**
-   * Creates and registers an MCP server with a Guarded registry.
-   *
-   * This function creates a new account if needed, initializes an HCS10 client,
-   * creates an MCP server with inbound and outbound topics, and registers
-   * it with the Hashgraph Online Guarded Registry.
-   *
-   * @param builder The MCP server builder object with configuration
-   * @param options Optional settings for registration process
-   * @returns Registration result with success status and metadata
-   */
-  async createAndRegisterMCPServer(builder, options) {
+  async createAndRegisterAgent(builder, options) {
     try {
-      const config = builder.build();
+      const agentConfig = builder.build();
       const progressCallback = options?.progressCallback;
-      const baseUrl = options?.baseUrl || this.guardedRegistryBaseUrl;
+      const progressReporter = new ProgressReporter({
+        module: "AgentCreateRegister",
+        logger: this.logger,
+        callback: progressCallback
+      });
       let state = options?.existingState || {
         currentStage: "init",
         completedPercentage: 0,
         createdResources: []
       };
-      state.serverMetadata = {
-        name: config.name,
-        description: config.mcpServer.description,
-        services: config.mcpServer.services
-      };
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Starting MCP server creation process",
-          progressPercent: 0,
-          details: { state }
-        });
-      }
-      let account = config.existingAccount;
-      let serverClient;
-      if (!state.inboundTopicId || !state.outboundTopicId || !state.profileTopicId) {
-        if (!account) {
-          if (state.createdResources && state.createdResources.some((r) => r.startsWith("account:"))) {
-            const accountResource = state.createdResources.find(
-              (r) => r.startsWith("account:")
-            );
-            const existingAccountId = accountResource?.split(":")[1];
-            if (existingAccountId && config.existingAccount) {
-              account = config.existingAccount;
-              this.logger.info(
-                `Resuming with existing account: ${existingAccountId}`
-              );
-            } else {
-              account = await this.createAccount(options?.initialBalance);
-              state.createdResources = state.createdResources || [];
-              state.createdResources.push(`account:${account.accountId}`);
-            }
-          } else {
-            account = await this.createAccount(options?.initialBalance);
-            state.createdResources = state.createdResources || [];
-            state.createdResources.push(`account:${account.accountId}`);
-          }
-        }
-        if (progressCallback) {
-          progressCallback({
-            stage: "preparing",
-            message: "Created account or using existing account",
-            progressPercent: 20,
-            details: { state, account }
-          });
-        }
-        const resolver = new NodeOperatorResolver({
-          mirrorNode: this.mirrorNode,
-          logger: this.logger
-        });
-        const keyInfo = await resolver.resolveOperatorKey(
-          account.accountId,
-          account.privateKey
-        );
-        builder.setExistingAccount(account.accountId, account.privateKey);
-        const privateKey = keyInfo.keyType === "ed25519" ? PrivateKey.fromStringED25519(account.privateKey) : PrivateKey.fromStringECDSA(account.privateKey);
-        const publicKey = privateKey.publicKey.toString();
-        serverClient = new HCS10Client({
-          network: config.network,
-          operatorId: account.accountId,
-          operatorPrivateKey: account.privateKey,
-          operatorPublicKey: publicKey,
-          logLevel: "info",
-          guardedRegistryBaseUrl: baseUrl
-        });
-        if (progressCallback) {
-          progressCallback({
-            stage: "preparing",
-            message: "Initialized MCP server client",
-            progressPercent: 25,
-            details: { state }
-          });
-        }
-        let outboundTopicId = state.outboundTopicId;
-        let inboundTopicId = state.inboundTopicId;
-        let pfpTopicId = state.pfpTopicId;
-        let profileTopicId = state.profileTopicId;
-        if (!outboundTopicId || !inboundTopicId || !profileTopicId) {
-          if (pfpTopicId) {
-            builder.setExistingProfilePicture(pfpTopicId);
-          }
-          const createResult = await serverClient.createMCPServer(
-            builder,
-            60,
-            state,
-            (data) => {
-              if (progressCallback) {
-                progressCallback({
-                  stage: data.stage,
-                  message: data.message,
-                  progressPercent: data.progressPercent || 0,
-                  details: {
-                    ...data.details,
-                    state: {
-                      ...state,
-                      ...data.details?.state
-                    }
-                  }
-                });
-              }
-            }
-          );
-          outboundTopicId = createResult.outboundTopicId;
-          inboundTopicId = createResult.inboundTopicId;
-          pfpTopicId = createResult.pfpTopicId;
-          profileTopicId = createResult.profileTopicId;
-          state.outboundTopicId = outboundTopicId;
-          state.inboundTopicId = inboundTopicId;
-          state.pfpTopicId = pfpTopicId;
-          state.profileTopicId = profileTopicId;
-          if (!state.createdResources) {
-            state.createdResources = [];
-          }
-          if (pfpTopicId && !state.createdResources.includes(`pfp:${pfpTopicId}`)) {
-            state.createdResources.push(`pfp:${pfpTopicId}`);
-          }
-          if (!state.createdResources.includes(`inbound:${inboundTopicId}`)) {
-            state.createdResources.push(`inbound:${inboundTopicId}`);
-          }
-          if (!state.createdResources.includes(`outbound:${outboundTopicId}`)) {
-            state.createdResources.push(`outbound:${outboundTopicId}`);
-          }
-          if (!state.createdResources.includes(`profile:${profileTopicId}`)) {
-            state.createdResources.push(`profile:${profileTopicId}`);
-          }
-        }
-        state.currentStage = "profile";
-        state.completedPercentage = 60;
-        if (progressCallback) {
-          progressCallback({
-            stage: "submitting",
-            message: "Created MCP server with topics and profile",
-            progressPercent: 60,
-            details: {
-              state,
-              outboundTopicId,
-              inboundTopicId,
-              pfpTopicId,
-              profileTopicId
-            }
-          });
+      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: true
+        });
+        if (!("state" in createResult)) {
+          throw new Error("Create method did not return expected agent state.");
         }
-      } else {
-        account = account || config.existingAccount;
-        if (!account) {
+        if (!createResult.success) {
           throw new Error(
-            "Cannot resume registration without account information"
+            createResult.error || "Failed to create agent resources"
           );
         }
-        const keyType = detectKeyTypeFromString(account.privateKey);
-        const privateKey = keyType.detectedType === "ed25519" ? PrivateKey.fromStringED25519(account.privateKey) : PrivateKey.fromStringECDSA(account.privateKey);
-        const publicKey = privateKey.publicKey.toString();
-        serverClient = new HCS10Client({
-          network: config.network,
-          operatorId: account.accountId,
-          operatorPrivateKey: account.privateKey,
-          operatorPublicKey: publicKey,
-          keyType: keyType.detectedType,
-          logLevel: "info",
-          guardedRegistryBaseUrl: baseUrl
-        });
-        this.logger.info("Resuming registration with existing state", {
-          inboundTopicId: state.inboundTopicId,
-          outboundTopicId: state.outboundTopicId,
-          profileTopicId: state.profileTopicId,
-          pfpTopicId: state.pfpTopicId
-        });
+        state = createResult.state;
+        state.agentMetadata = agentConfig.metadata;
+        this.logger.info("Waiting for account memo update to propagate...");
+        await new Promise((resolve) => setTimeout(resolve, 5e3));
       }
-      const operatorId = `${state.inboundTopicId}@${account.accountId}`;
+      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}`
       )) {
-        const registrationResult = await serverClient.registerAgentWithGuardedRegistry(
-          account.accountId,
-          config.network,
+        if (options?.baseUrl) {
+          this.guardedRegistryBaseUrl = options.baseUrl;
+        }
+        const registrationResult = await this.registerAgentWithGuardedRegistry(
+          accountId,
+          agentConfig.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: state.outboundTopicId,
-                    inboundTopicId: state.inboundTopicId,
-                    pfpTopicId: state.pfpTopicId,
-                    profileTopicId: state.profileTopicId,
-                    operatorId,
-                    state: data.details?.state || state
-                  }
-                });
-              }
+            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) {
-          return {
-            ...registrationResult,
-            state
-          };
+          throw new Error(
+            registrationResult.error || "Failed to register agent with registry"
+          );
         }
-        state = registrationResult.state || state;
-      }
-      if (progressCallback) {
-        progressCallback({
-          stage: "completed",
-          message: "MCP server creation and registration complete",
-          progressPercent: 100,
-          details: {
-            outboundTopicId: state.outboundTopicId,
-            inboundTopicId: state.inboundTopicId,
-            pfpTopicId: state.pfpTopicId,
-            profileTopicId: state.profileTopicId,
-            operatorId,
-            state
-          }
-        });
+        state = registrationResult.state;
       }
+      progressReporter.completed("Agent creation and registration complete", {
+        state
+      });
       return {
         success: true,
         state,
         metadata: {
-          accountId: account.accountId,
-          privateKey: account.privateKey,
-          operatorId,
+          accountId,
+          operatorId: `${state.inboundTopicId}@${accountId}`,
           inboundTopicId: state.inboundTopicId,
           outboundTopicId: state.outboundTopicId,
           profileTopicId: state.profileTopicId,
-          pfpTopicId: state.pfpTopicId
+          pfpTopicId: state.pfpTopicId,
+          privateKey: null,
+          ...state.agentMetadata
         }
       };
-    } catch (e) {
-      const error = e;
-      const logMessage = `Failed to create and register MCP server: ${error.message}`;
-      this.logger.error(logMessage);
+    } catch (error) {
+      this.logger.error(
+        `Failed to create and register agent: ${error.message}`
+      );
       return {
-        error: error.message,
         success: false,
+        error: `Failed to create and register agent: ${error.message}`,
         state: options?.existingState || {
           currentStage: "init",
           completedPercentage: 0,
@@ -2275,137 +739,419 @@ class HCS10Client extends HCS10BaseClient {
       };
     }
   }
-  /**
-   * Creates a new HCS-10 registry topic with optional metadata stored via HCS-1.
-   *
-   * Registry topics serve as directories for AI agent discovery and follow the
-   * HCS-10 memo format: hcs-10:0:{ttl}:3:[metadataTopicId]
-   *
-   * @param options Configuration options for registry creation
-   * @returns Promise resolving to registry creation result
-   */
-  async createRegistryTopic(options = {}) {
-    const {
-      ttl = 86400,
-      metadata,
-      adminKey = false,
-      submitKey = false,
-      waitForConfirmation = true,
-      waitMaxAttempts = 30,
-      waitIntervalMs = 4e3,
-      progressCallback
-    } = options;
+  async storeHCS11Profile(agentName, agentBio, inboundTopicId, outboundTopicId, capabilities = [], metadata = {}, pfpBuffer, pfpFileName, existingPfpTopicId, options) {
     try {
-      await this.ensureInitialized();
-      if (progressCallback) {
-        progressCallback({
-          stage: "preparing",
-          message: "Preparing registry topic creation",
-          progressPercent: 10,
-          details: { metadata: !!metadata }
+      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"
         });
-      }
-      let metadataTopicId;
-      if (metadata) {
-        this.logger.info("Creating metadata inscription for registry");
-        if (progressCallback) {
-          progressCallback({
-            stage: "submitting",
-            message: "Creating registry metadata inscription",
-            progressPercent: 30,
-            details: { metadataName: metadata.name }
-          });
-        }
-        const metadataBuffer = Buffer.from(JSON.stringify(metadata, null, 2));
-        const inscriptionOptions = {
-          mode: "file",
-          waitForConfirmation,
-          waitMaxAttempts,
-          waitIntervalMs,
-          logging: {
-            level: this.logger.getLevel ? this.logger.getLevel() : "info"
+        const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName, {
+          progressCallback: (data) => {
+            pfpProgress.report({
+              stage: data.stage,
+              message: data.message,
+              progressPercent: data.progressPercent || 0,
+              details: data.details
+            });
           }
-        };
-        const inscription = await inscribe(
-          {
-            type: "buffer",
-            buffer: metadataBuffer,
-            fileName: `registry-metadata-${Date.now()}.json`,
-            mimeType: "application/json"
-          },
-          {
-            accountId: this.client.operatorAccountId.toString(),
-            privateKey: this.operatorCtx.operatorKey,
-            network: this.network
-          },
-          inscriptionOptions
-        );
-        if (!inscription.confirmed || !inscription.inscription) {
-          throw new Error("Metadata inscription was not confirmed");
+        });
+        if (!pfpResult.success) {
+          progressReporter.failed(
+            "Failed to inscribe profile picture, continuing without PFP"
+          );
+        } else {
+          pfpTopicId = pfpResult.pfpTopicId;
         }
-        metadataTopicId = getTopicId(inscription.inscription);
-        this.logger.info(`Metadata inscribed to topic: ${metadataTopicId}`);
+      } else if (existingPfpTopicId) {
+        progressReporter.preparing(
+          `Using existing profile picture: ${existingPfpTopicId}`,
+          30
+        );
+      } else {
+        progressReporter.preparing("No profile picture provided", 30);
       }
-      if (progressCallback) {
-        progressCallback({
-          stage: "submitting",
-          message: "Creating registry topic",
-          progressPercent: 60,
-          details: { metadataTopicId }
-        });
+      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 operatorKey = this.operatorCtx.operatorKey;
-      const operatorPublicKey = this.client.operatorPublicKey || operatorKey.publicKey;
-      const transaction = buildHcs10CreateRegistryTopicTx({
-        ttl,
-        metadataTopicId,
-        adminKey,
-        submitKey,
-        operatorPublicKey
+      const agentType = this.hcs11Client.getAgentTypeFromMetadata({
+        type: metadata.type || "autonomous"
       });
-      const { topicId, response: txResponse } = await this.executeTopicCreateTransaction({
-        transaction
+      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"
       });
-      if (progressCallback) {
-        progressCallback({
-          stage: "completed",
-          message: "Registry topic created successfully",
-          progressPercent: 100,
-          details: {
-            topicId,
-            metadataTopicId,
-            transactionId: txResponse.transactionId.toString()
+      const profileResult = await this.hcs11Client.createAndInscribeProfile(
+        profile,
+        options?.updateAccountMemo ?? 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 || ""
+        };
       }
-      this.logger.info(`Registry topic created successfully: ${topicId}`);
+      progressReporter.completed("Profile stored successfully", {
+        profileTopicId: profileResult.profileTopicId
+      });
       return {
+        profileTopicId: profileResult.profileTopicId,
+        pfpTopicId,
         success: true,
-        topicId,
-        transactionId: txResponse.transactionId.toString(),
-        metadataTopicId
+        transactionId: profileResult.transactionId || ""
       };
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (progressCallback) {
-        progressCallback({
-          stage: "failed",
-          message: `Registry creation failed: ${errorMessage}`,
-          progressPercent: 0,
-          details: { error: errorMessage }
+      this.logger.error(`Error storing HCS11 profile: ${error.message}`);
+      return {
+        profileTopicId: "",
+        success: false,
+        error: error.message,
+        transactionId: ""
+      };
+    }
+  }
+  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);
+    const transactionMemo = this.getHcs10TransactionMemo(payload);
+    if (transactionMemo) {
+      transaction.setTransactionMemo(transactionMemo);
+    }
+    let transactionResponse;
+    if (requiresFee) {
+      this.logger.info(
+        "Topic requires fee payment, setting max transaction fee"
+      );
+      transaction.setMaxTransactionFee(new Hbar(this.feeAmount));
+    }
+    if (submitKey) {
+      const { signer } = this.getAccountAndSigner();
+      transaction.freezeWithSigner(signer);
+      const signedTransaction = await transaction.sign(submitKey);
+      transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
+        signedTransaction,
+        true
+      );
+    } else {
+      transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
+        transaction,
+        false
+      );
+    }
+    if (transactionResponse?.error) {
+      this.logger.error(
+        `Failed to submit payload: ${transactionResponse.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;
+  }
+  async inscribeFile(buffer, fileName, options) {
+    const { accountId, signer } = this.getAccountAndSigner();
+    const mimeType = mime.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"
+      }
+    };
+    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");
+    }
+    return response.inscription;
+  }
+  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", {
+        accountId,
+        signers: this?.hwc?.dAppConnector?.signers,
+        accountInfo
+      });
+      throw new Error("Failed to find signer");
+    }
+    return { accountId, signer };
+  }
+  /**
+   * 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.
+   */
+  async inscribePfp(buffer, fileName, options) {
+    try {
+      const progressCallback = options?.progressCallback;
+      const progressReporter = new ProgressReporter({
+        module: "PFP-Inscription",
+        logger: this.logger,
+        callback: progressCallback
+      });
+      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
+        };
       }
-      this.logger.error("Failed to create registry topic", {
-        error: errorMessage
+      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 inscribing profile picture: ${error.message}`);
       return {
+        pfpTopicId: "",
         success: false,
-        error: errorMessage
+        error: error.message,
+        transactionId: ""
       };
     }
   }
+  async createCommunicationTopics(options, progressReporter) {
+    let state = options?.existingState || {
+      currentStage: "init",
+      completedPercentage: 0,
+      createdResources: []
+    };
+    if (progressReporter) {
+      progressReporter.preparing("Starting communication topic creation", 0, {
+        state
+      });
+    }
+    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 (!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 {
+      inboundTopicId: state.inboundTopicId,
+      outboundTopicId: state.outboundTopicId,
+      state
+    };
+  }
 }
 export {
-  HCS10Client
+  BrowserHCSClient
 };
 //# sourceMappingURL=standards-sdk.es19.js.map