@hashgraphonline/standards-sdk 0.0.17 → 0.0.19

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

@@ -19,6 +19,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
 });
 var _names, _data, _dataLength, _Writer_instances, writeData_fn, _data2, _offset, _bytesRead, _parent, _maxInflation, _Reader_instances, incrementBytesRead_fn, peekBytes_fn, _options, _offset2, _tokens, _TokenString_instances, subTokenString_fn, _ParamType_instances, walkAsync_fn, _AbiCoder_instances, getCoder_fn, _errors, _events, _functions, _abiCoder, _Interface_instances, getFunction_fn, getEvent_fn;
 import { ContractId, AccountId, Client, PrivateKey, Transaction, PublicKey, Status, AccountUpdateTransaction, AccountCreateTransaction, Hbar, CustomFixedFee, KeyList, TopicCreateTransaction, TopicMessageSubmitTransaction, TopicId } from "@hashgraph/sdk";
+import { proto } from "@hashgraph/proto";
 let Logger$1 = class Logger {
   constructor(options = {}) {
     this.level = options.level || "info";
@@ -6223,11 +6224,11 @@ ieee754$1.write = function(buffer2, value, offset, isLE2, mLen, nBytes) {
   function typedArraySupport() {
     try {
       const arr = new GlobalUint8Array(1);
-      const proto = { foo: function() {
+      const proto2 = { foo: function() {
         return 42;
       } };
-      Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
-      Object.setPrototypeOf(arr, proto);
+      Object.setPrototypeOf(proto2, GlobalUint8Array.prototype);
+      Object.setPrototypeOf(arr, proto2);
       return arr.foo() === 42;
     } catch (e) {
       return false;
@@ -8017,11 +8018,11 @@ ieee754.write = function(buffer2, value, offset, isLE2, mLen, nBytes) {
   function typedArraySupport() {
     try {
       const arr = new GlobalUint8Array(1);
-      const proto = { foo: function() {
+      const proto2 = { foo: function() {
         return 42;
       } };
-      Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
-      Object.setPrototypeOf(arr, proto);
+      Object.setPrototypeOf(proto2, GlobalUint8Array.prototype);
+      Object.setPrototypeOf(arr, proto2);
       return arr.foo() === 42;
     } catch (e) {
       return false;
@@ -15496,10 +15497,8 @@ class HederaMirrorNode {
     if (this.logger) {
       this.logger.info(`Getting public key for account ${accountId}`);
     }
-    const accountInfoUrl = `${this.baseUrl}/api/v1/accounts/${accountId}`;
+    const accountInfo = await this.requestAccount(accountId);
     try {
-      const response = await axios.get(accountInfoUrl);
-      const accountInfo = response.data;
       if (!accountInfo || !accountInfo.key) {
         throw new Error(
           `Failed to retrieve public key for account ID: ${accountId}`
@@ -15514,11 +15513,9 @@ class HederaMirrorNode {
   }
   async getAccountMemo(accountId) {
     try {
-      const response = await axios.get(
-        `${this.baseUrl}/api/v1/accounts/${accountId}`
-      );
-      if (response.data && response.data.memo) {
-        return response.data.memo;
+      const accountInfo = await this.requestAccount(accountId);
+      if (accountInfo && accountInfo.memo) {
+        return accountInfo.memo;
       }
       return null;
     } catch (error) {
@@ -15611,20 +15608,65 @@ class HederaMirrorNode {
       throw new Error(`Failed to fetch account: ${error.message}`);
     }
   }
-  async getAccountInfo(accountId) {
+  async checkKeyListAccess(keyBytes, userPublicKey) {
     try {
-      const accountInfoUrl = `${this.baseUrl}/api/v1/accounts/${accountId}`;
-      const response = await axios.get(accountInfoUrl);
-      return response.data;
+      const key = proto.Key.decode(keyBytes);
+      return this.evaluateKeyAccess(key, userPublicKey);
     } catch (error) {
       if (this.logger) {
-        this.logger.error(
-          `Error retrieving account information: ${error.message}`
-        );
+        this.logger.error(`Error decoding protobuf key: ${error instanceof Error ? error.message : String(error)}`);
       }
-      throw new Error(
-        `Failed to retrieve account information: ${error.message}`
-      );
+      return false;
+    }
+  }
+  async evaluateKeyAccess(key, userPublicKey) {
+    if (key.ed25519) {
+      return this.compareEd25519Key(key.ed25519, userPublicKey);
+    }
+    if (key.keyList) {
+      return this.evaluateKeyList(key.keyList, userPublicKey);
+    }
+    if (key.thresholdKey && key.thresholdKey.keys) {
+      return this.evaluateKeyList(key.thresholdKey.keys, userPublicKey);
+    }
+    return false;
+  }
+  async evaluateKeyList(keyList, userPublicKey) {
+    const keys = keyList.keys || [];
+    for (const listKey of keys) {
+      if (!listKey) continue;
+      if (listKey.ed25519) {
+        if (this.compareEd25519Key(listKey.ed25519, userPublicKey)) {
+          return true;
+        }
+      } else if (listKey.keyList || listKey.thresholdKey) {
+        try {
+          const nestedKeyBytes = proto.Key.encode({
+            ...listKey.keyList ? { keyList: listKey.keyList } : {},
+            ...listKey.thresholdKey ? { thresholdKey: listKey.thresholdKey } : {}
+          }).finish();
+          const hasNestedAccess = await this.checkKeyListAccess(
+            Buffer2.from(nestedKeyBytes),
+            userPublicKey
+          );
+          if (hasNestedAccess) {
+            return true;
+          }
+        } catch (err) {
+          if (this.logger) {
+            this.logger.debug(`Error in nested key: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      }
+    }
+    return false;
+  }
+  compareEd25519Key(keyData, userPublicKey) {
+    try {
+      const decodedKey = PublicKey.fromBytes(Buffer2.from(keyData));
+      return decodedKey.toString() === userPublicKey.toString();
+    } catch (err) {
+      return false;
     }
   }
 }
@@ -15705,10 +15747,6 @@ class HCS10BaseClient extends Registration {
     return topicInfo;
   }
   async retrieveOutboundConnectTopic(accountId) {
-    const topicInfo = await this.getTopicInfo(accountId);
-    return (topicInfo == null ? void 0 : topicInfo.outboundTopic) ?? null;
-  }
-  async retrieveOutboundConnectTopicFromNetwork(accountId) {
     this.logger.info(`Retrieving topics for account: ${accountId}`);
     const cachedInfo = await this.getTopicInfo(accountId);
     if (cachedInfo) return cachedInfo;
@@ -15759,7 +15797,7 @@ class HCS10BaseClient extends Registration {
   }
   async retrieveOutboundMessages(agentAccountId) {
     try {
-      const topicInfo = await this.retrieveOutboundConnectTopicFromNetwork(
+      const topicInfo = await this.retrieveOutboundConnectTopic(
         agentAccountId
       );
       if (!topicInfo) {
@@ -15779,7 +15817,7 @@ class HCS10BaseClient extends Registration {
   }
   async hasConnectionCreated(agentAccountId, connectionId) {
     try {
-      const outBoundTopic = await this.retrieveOutboundConnectTopicFromNetwork(
+      const outBoundTopic = await this.retrieveOutboundConnectTopic(
         agentAccountId
       );
       const messages = await this.retrieveOutboundMessages(
@@ -31894,6 +31932,100 @@ async function accountIdsToExemptKeys(accountIds, network, logger) {
   }
   return exemptKeys;
 }
+class FeeConfigBuilder {
+  constructor() {
+    this.feeAmount = 0;
+    this.decimals = 0;
+    this.feeCollectorAccountId = "";
+    this.exemptAccountIds = [];
+  }
+  /**
+   * Static factory method to create a fee config with HBAR amount in one line
+   * @param hbarAmount Amount in HBAR
+   * @param collectorAccountId Account that will receive the fees
+   * @param exemptAccounts Optional array of exempt account IDs
+   * @returns A configured FeeConfigBuilder
+   */
+  static forHbar(hbarAmount, collectorAccountId, exemptAccounts = []) {
+    return new FeeConfigBuilder().setHbarAmount(hbarAmount).setFeeCollector(collectorAccountId).addExemptAccounts(exemptAccounts);
+  }
+  /**
+   * Sets the fee amount in HBAR (convenient method)
+   * @param hbarAmount The amount in HBAR (e.g., 5 for 5 HBAR)
+   * @returns This builder instance for method chaining
+   */
+  setHbarAmount(hbarAmount) {
+    if (hbarAmount <= 0) {
+      throw new Error("HBAR amount must be greater than zero");
+    }
+    this.feeAmount = hbarAmount * 1e8;
+    this.decimals = 0;
+    return this;
+  }
+  /**
+   * Sets the amount of the fee to be collected for topic submissions
+   * @param amount The fee amount (in tinybars or token units)
+   * @param decimals Decimal places for fixed point representation (default: 0)
+   * @returns This builder instance for method chaining
+   */
+  setFeeAmount(amount, decimals = 0) {
+    this.feeAmount = amount;
+    this.decimals = decimals;
+    return this;
+  }
+  /**
+   * Sets the Hedera account ID that will collect the fees
+   * @param accountId The fee collector's account ID (e.g., '0.0.12345')
+   * @returns This builder instance for method chaining
+   */
+  setFeeCollector(accountId) {
+    this.feeCollectorAccountId = accountId;
+    return this;
+  }
+  /**
+   * Adds an account ID to the list of accounts exempt from paying fees
+   * @param accountId The account ID to exempt from fees
+   * @returns This builder instance for method chaining
+   */
+  addExemptAccount(accountId) {
+    if (!this.exemptAccountIds.includes(accountId)) {
+      this.exemptAccountIds.push(accountId);
+    }
+    return this;
+  }
+  /**
+   * Adds multiple account IDs to the list of accounts exempt from paying fees
+   * @param accountIds Array of account IDs to exempt from fees
+   * @returns This builder instance for method chaining
+   */
+  addExemptAccounts(accountIds) {
+    for (const accountId of accountIds) {
+      this.addExemptAccount(accountId);
+    }
+    return this;
+  }
+  /**
+   * Builds and returns the final fee configuration object
+   * @throws Error if fee collector account ID is not set or if fee amount is not positive
+   * @returns A complete TopicFeeConfig object
+   */
+  build() {
+    if (!this.feeCollectorAccountId) {
+      throw new Error("Fee collector account ID is required");
+    }
+    if (this.feeAmount <= 0) {
+      throw new Error("Fee amount must be greater than zero");
+    }
+    return {
+      feeAmount: {
+        amount: this.feeAmount,
+        decimals: this.decimals
+      },
+      feeCollectorAccountId: this.feeCollectorAccountId,
+      exemptAccounts: this.exemptAccountIds
+    };
+  }
+}
 class HCS10Client extends HCS10BaseClient {
   constructor(config) {
     super({
@@ -31970,7 +32102,7 @@ class HCS10Client extends HCS10BaseClient {
         if (!feeConfig) {
           throw new Error("Fee configuration is required for fee-based topics");
         }
-        return this.createTopic(memo, true, true, feeConfig);
+        return this.createTopic(memo, true, true, feeConfig.build());
       default:
         throw new Error(`Unsupported inbound topic type: ${topicType}`);
     }
@@ -32147,6 +32279,7 @@ class HCS10Client extends HCS10BaseClient {
       ...feeConfig.exemptAccounts || [],
       ...additionalExemptAccounts
     ];
+    console.log("exemptAccountIds", exemptAccountIds);
     if (exemptAccountIds.length > 0) {
       const uniqueExemptAccountIds = Array.from(new Set(exemptAccountIds));
       const filteredExemptAccounts = uniqueExemptAccountIds.filter(
@@ -32202,13 +32335,10 @@ class HCS10Client extends HCS10BaseClient {
     let connectionTopicId;
     try {
       if (connectionFeeConfig) {
-        const additionalExemptAccounts = [requestingAccountId];
+        const feeConfig = connectionFeeConfig.build();
         const modifiedFeeConfig = {
-          ...connectionFeeConfig,
-          exemptAccounts: [
-            ...connectionFeeConfig.exemptAccounts || [],
-            ...additionalExemptAccounts
-          ]
+          ...feeConfig,
+          exemptAccounts: [...feeConfig.exemptAccounts || []]
         };
         connectionTopicId = await this.createTopic(
           memo,
@@ -32391,7 +32521,7 @@ class HCS10Client extends HCS10BaseClient {
     this.logger.info(
       `Submitted connection request to topic ID: ${inboundTopicId}`
     );
-    const outboundTopic = await this.retrieveOutboundConnectTopicFromNetwork(
+    const outboundTopic = await this.retrieveOutboundConnectTopic(
       requestingAccountId
     );
     const responseSequenceNumber = (_a = response.topicSequenceNumber) == null ? void 0 : _a.toNumber();
@@ -32493,27 +32623,15 @@ class HCS10Client extends HCS10BaseClient {
         `Attempt ${attempt + 1}/${maxAttempts} to find connection confirmation`
       );
       const messages = await this.mirrorNode.getTopicMessages(inboundTopicId);
-      this.logger.info(
-        `Retrieved ${messages.length} messages from topic ${inboundTopicId}`
-      );
-      messages.forEach((msg, index) => {
-        this.logger.info(`Message ${index}: ${JSON.stringify(msg)}`);
-      });
       const connectionCreatedMessages = messages.filter(
         (m) => m.op === "connection_created"
       );
       this.logger.info(
         `Found ${connectionCreatedMessages.length} connection_created messages`
       );
-      connectionCreatedMessages.forEach((msg, index) => {
-        this.logger.info(`Connection message ${index}: ${JSON.stringify(msg)}`);
-      });
       if (connectionCreatedMessages.length > 0) {
         for (const message of connectionCreatedMessages) {
-          this.logger.info(
-            `Checking if message connection_id (${message.connection_id}) matches request ID (${connectionRequestId})`
-          );
-          if (message.connection_id === connectionRequestId) {
+          if (Number(message.connection_id) === Number(connectionRequestId)) {
             this.logger.info("Connection confirmation found");
             return {
               connectionTopicId: message.connection_topic_id,
@@ -32541,7 +32659,14 @@ class HCS10Client extends HCS10BaseClient {
       signer: this.operatorPrivateKey
     };
   }
+  /**
+   * Checks if a user can submit to a topic and determines if a fee is required
+   * @param topicId The topic ID to check
+   * @param userAccountId The account ID of the user attempting to submit
+   * @returns Object with canSubmit, requiresFee, and optional reason
+   */
   async canSubmitToInboundTopic(topicId, userAccountId) {
+    var _a, _b, _c, _d;
     try {
       const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
       if (!topicInfo) {
@@ -32551,29 +32676,37 @@ class HCS10Client extends HCS10BaseClient {
           reason: "Topic does not exist"
         };
       }
-      const hasSubmitKey = topicInfo.submit_key && topicInfo.submit_key.key;
-      if (!hasSubmitKey) {
+      if (!((_a = topicInfo.submit_key) == null ? void 0 : _a.key)) {
         return { canSubmit: true, requiresFee: false };
       }
       try {
         const userPublicKey = await this.mirrorNode.getPublicKey(userAccountId);
-        const topicSubmitKey = PublicKey.fromString(topicInfo.submit_key.key);
-        if (userPublicKey.toString() === topicSubmitKey.toString()) {
-          return { canSubmit: true, requiresFee: false };
+        if (topicInfo.submit_key._type === "ProtobufEncoded") {
+          const keyBytes = Buffer2.from(topicInfo.submit_key.key, "hex");
+          const hasAccess = await this.mirrorNode.checkKeyListAccess(
+            keyBytes,
+            userPublicKey
+          );
+          if (hasAccess) {
+            return { canSubmit: true, requiresFee: false };
+          }
+        } else {
+          const topicSubmitKey = PublicKey.fromString(topicInfo.submit_key.key);
+          if (userPublicKey.toString() === topicSubmitKey.toString()) {
+            return { canSubmit: true, requiresFee: false };
+          }
         }
       } catch (error) {
-        this.logger.error(`Error comparing keys: ${error}`);
+        this.logger.error(
+          `Key validation error: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-      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) {
-          return {
-            canSubmit: true,
-            requiresFee: true,
-            reason: "Requires fee payment via HIP-991"
-          };
-        }
+      if (((_b = topicInfo.fee_schedule_key) == null ? void 0 : _b.key) && ((_d = (_c = topicInfo.custom_fees) == null ? void 0 : _c.fixed_fees) == null ? void 0 : _d.length) > 0) {
+        return {
+          canSubmit: true,
+          requiresFee: true,
+          reason: "Requires fee payment via HIP-991"
+        };
       }
       return {
         canSubmit: false,
@@ -32581,11 +32714,12 @@ class HCS10Client extends HCS10BaseClient {
         reason: "User does not have submit permission for this topic"
       };
     } catch (error) {
-      this.logger.error(`Error validating topic submission: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Topic submission validation error: ${errorMessage}`);
       return {
         canSubmit: false,
         requiresFee: false,
-        reason: `Error: ${error.message}`
+        reason: `Error: ${errorMessage}`
       };
     }
   }
@@ -32808,20 +32942,12 @@ class AgentBuilder {
     this.config.inboundTopicType = inboundTopicType;
     return this;
   }
-  setFeeConfig(feeAmount, feeCollectorAccountId, exemptAccounts) {
-    this.config.feeConfig = {
-      feeAmount,
-      feeCollectorAccountId,
-      exemptAccounts
-    };
+  setFeeConfig(feeConfigBuilder) {
+    this.config.feeConfig = feeConfigBuilder;
     return this;
   }
-  setConnectionFeeConfig(feeAmount, feeCollectorAccountId, exemptAccounts) {
-    this.config.connectionFeeConfig = {
-      feeAmount,
-      feeCollectorAccountId,
-      exemptAccounts
-    };
+  setConnectionFeeConfig(feeConfigBuilder) {
+    this.config.connectionFeeConfig = feeConfigBuilder;
     return this;
   }
   setExistingAccount(accountId, privateKey) {
@@ -32856,14 +32982,611 @@ class AgentBuilder {
     return this.config;
   }
 }
+class BrowserHCSClient extends HCS10BaseClient {
+  constructor(config) {
+    super({
+      network: config.network,
+      logLevel: config.logLevel
+    });
+    this.guardedRegistryBaseUrl = config.guardedRegistryBaseUrl || "https://moonscape.tech";
+    this.hwc = config.hwc;
+    this.logger = Logger$1.getInstance({
+      level: config.logLevel || "info",
+      module: "HCS-Browser"
+    });
+    const { accountId, signer } = this.getAccountAndSigner();
+    this.hcs11Client = new HCS11Client({
+      network: config.network,
+      auth: {
+        operatorId: accountId,
+        signer
+      },
+      logLevel: config.logLevel
+    });
+  }
+  async sendMessage(connectionTopicId, operatorId, data, memo) {
+    this.logger.info("Sending message");
+    const payload = {
+      p: "hcs-10",
+      op: "message",
+      operator_id: operatorId,
+      data,
+      m: memo
+    };
+    await this.submitPayload(connectionTopicId, payload);
+  }
+  async submitConnectionRequest(inboundTopicId, requestingAccountId, operatorId, memo) {
+    var _a, _b;
+    this.logger.info("Submitting connection request");
+    const connectionRequestMessage = {
+      p: "hcs-10",
+      op: "connection_request",
+      requesting_account_id: requestingAccountId,
+      operator_id: operatorId,
+      m: memo
+    };
+    const response = await this.submitPayload(
+      inboundTopicId,
+      connectionRequestMessage
+    );
+    this.logger.info(
+      `Submitted connection request to topic ID: ${inboundTopicId}`
+    );
+    const outboundTopic = await this.retrieveOutboundConnectTopic(
+      requestingAccountId
+    );
+    if (!(outboundTopic == null ? void 0 : outboundTopic.outboundTopic)) {
+      this.logger.error(
+        `Failed to retrieve outbound topic for account ID: ${requestingAccountId}`
+      );
+      throw new Error(
+        `Failed to retrieve outbound topic for account ID: ${requestingAccountId}`
+      );
+    }
+    this.logger.info(
+      `Retrieved outbound topic ID: ${outboundTopic.outboundTopic} for account ID: ${requestingAccountId}`
+    );
+    const responseSequenceNumber = (_b = (_a = response == null ? void 0 : response.result) == null ? void 0 : _a.topicSequenceNumber) == null ? void 0 : _b.toNumber();
+    if (!responseSequenceNumber) {
+      throw new Error("Failed to get response sequence number");
+    }
+    await this.submitPayload(outboundTopic.outboundTopic, {
+      ...connectionRequestMessage,
+      outbound_topic_id: inboundTopicId,
+      connection_request_id: responseSequenceNumber
+    });
+    return response.result;
+  }
+  async recordOutboundConnectionConfirmation({
+    outboundTopicId,
+    connectionRequestId,
+    confirmedRequestId,
+    connectionTopicId,
+    operatorId,
+    memo
+  }) {
+    const payload = {
+      p: "hcs-10",
+      op: "connection_created",
+      connection_topic_id: connectionTopicId,
+      outbound_topic_id: outboundTopicId,
+      confirmed_request_id: confirmedRequestId,
+      connection_request_id: connectionRequestId,
+      operator_id: operatorId,
+      m: memo
+    };
+    return await this.submitPayload(outboundTopicId, payload);
+  }
+  async getPublicKey(accountId) {
+    return await this.mirrorNode.getPublicKey(accountId);
+  }
+  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionId, connectionMemo = "Connection accepted. Looking forward to collaborating!") {
+    this.logger.info("Handling connection request");
+    const userAccountId = this.hwc.getAccountInfo().accountId;
+    if (!userAccountId) {
+      throw new Error("Failed to retrieve user account ID");
+    }
+    const requesterKey = await this.mirrorNode.getPublicKey(
+      requestingAccountId
+    );
+    const accountKey = await this.mirrorNode.getPublicKey(userAccountId);
+    if (!accountKey) {
+      throw new Error("Failed to retrieve public key");
+    }
+    const thresholdKey = new KeyList([accountKey, requesterKey], 1);
+    const memo = `hcs-10:${inboundTopicId}:${connectionId}`;
+    const transaction = new TopicCreateTransaction().setTopicMemo(memo).setAdminKey(thresholdKey).setSubmitKey(thresholdKey);
+    this.logger.debug("Executing topic creation transaction");
+    const receipt = await this.hwc.executeTransactionWithErrorHandling(
+      transaction,
+      false
+    );
+    if (receipt.error) {
+      this.logger.error(receipt.error);
+      throw new Error(receipt.error);
+    }
+    const result = receipt.result;
+    if (!(result == null ? void 0 : result.topicId)) {
+      this.logger.error("Failed to create topic: topicId is null");
+      throw new Error("Failed to create topic: topicId is null");
+    }
+    const connectionTopicId = result.topicId.toString();
+    const operatorId = `${inboundTopicId}@${userAccountId}`;
+    const confirmedConnectionSequenceNumber = await this.confirmConnection(
+      inboundTopicId,
+      connectionTopicId,
+      requestingAccountId,
+      connectionId,
+      operatorId,
+      connectionMemo
+    );
+    return {
+      connectionTopicId,
+      confirmedConnectionSequenceNumber,
+      operatorId
+    };
+  }
+  async confirmConnection(inboundTopicId, connectionTopicId, connectedAccountId, connectionId, operatorId, memo) {
+    var _a;
+    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 (!((_a = transactionResponse == null ? void 0 : transactionResponse.result) == null ? void 0 : _a.topicSequenceNumber)) {
+      this.logger.error(
+        "Failed to confirm connection: sequence number is null"
+      );
+      throw new Error("Failed to confirm connection: sequence number is null");
+    }
+    return transactionResponse.result.topicSequenceNumber.toNumber();
+  }
+  async submitMessage(topicId, content, metadata = {}, memo = "") {
+    this.logger.info("Submitting message");
+    const payload = {
+      p: "hcs-10",
+      op: "message",
+      data: {
+        content,
+        metadata
+      },
+      m: memo
+    };
+    return await this.submitPayload(topicId, payload);
+  }
+  async createAgent(pfpBuffer, pfpFileName, agentName, agentDescription, capabilities, metadata) {
+    try {
+      const outboundTopicResult = await this.createTopic(
+        "hcs-10:0:60:1",
+        true,
+        true
+      );
+      if (!outboundTopicResult.success || !outboundTopicResult.topicId) {
+        return {
+          outboundTopicId: "",
+          inboundTopicId: "",
+          pfpTopicId: "",
+          profileTopicId: "",
+          error: outboundTopicResult.error || "Failed to create outbound topic",
+          success: false
+        };
+      }
+      const inboundTopicResult = await this.createTopic(
+        `hcs-10:0:60:0:${outboundTopicResult.topicId}`
+      );
+      if (!inboundTopicResult.success || !inboundTopicResult.topicId) {
+        return {
+          outboundTopicId: outboundTopicResult.topicId,
+          inboundTopicId: "",
+          pfpTopicId: "",
+          profileTopicId: "",
+          error: inboundTopicResult.error || "Failed to create inbound topic",
+          success: false
+        };
+      }
+      const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
+      if (!pfpResult.success) {
+        return {
+          outboundTopicId: outboundTopicResult.topicId,
+          inboundTopicId: inboundTopicResult.topicId,
+          pfpTopicId: "",
+          profileTopicId: "",
+          error: pfpResult.error || "Failed to inscribe profile picture",
+          success: false
+        };
+      }
+      const profileResult = await this.storeHCS11Profile(
+        agentName,
+        agentDescription,
+        inboundTopicResult.topicId,
+        outboundTopicResult.topicId,
+        capabilities,
+        metadata,
+        pfpBuffer,
+        pfpFileName
+      );
+      if (!profileResult.success) {
+        return {
+          outboundTopicId: outboundTopicResult.topicId,
+          inboundTopicId: inboundTopicResult.topicId,
+          pfpTopicId: pfpResult.pfpTopicId,
+          profileTopicId: "",
+          error: profileResult.error || "Failed to store profile",
+          success: false
+        };
+      }
+      return {
+        outboundTopicId: outboundTopicResult.topicId,
+        inboundTopicId: inboundTopicResult.topicId,
+        pfpTopicId: pfpResult.pfpTopicId,
+        profileTopicId: profileResult.profileTopicId,
+        success: true
+      };
+    } catch (error) {
+      return {
+        outboundTopicId: "",
+        inboundTopicId: "",
+        pfpTopicId: "",
+        profileTopicId: "",
+        error: error.message,
+        success: false
+      };
+    }
+  }
+  async createAndRegisterAgent(name, description, capabilities, metadata, pfpBuffer, pfpFileName, network) {
+    const { accountId } = this.getAccountAndSigner();
+    const {
+      outboundTopicId,
+      inboundTopicId,
+      pfpTopicId,
+      profileTopicId,
+      error,
+      success
+    } = await this.createAgent(
+      pfpBuffer,
+      pfpFileName,
+      name,
+      description,
+      capabilities,
+      metadata
+    );
+    if (!success || error) {
+      throw new Error(error || "Failed to create agent");
+    }
+    const operatorId = `${inboundTopicId}@${accountId}`;
+    await this.registerAgentWithGuardedRegistry(
+      accountId,
+      inboundTopicId,
+      network
+    );
+    return {
+      accountId,
+      operatorId,
+      inboundTopicId,
+      outboundTopicId,
+      profileTopicId,
+      pfpTopicId,
+      client: this
+    };
+  }
+  async registerAgentWithGuardedRegistry(accountId, inboundTopicId, network = this.network, maxAttempts = 60, delayMs = 2e3) {
+    try {
+      this.logger.info("Registering agent with guarded registry");
+      const registrationResult = await this.executeRegistration(
+        accountId,
+        inboundTopicId,
+        network,
+        this.guardedRegistryBaseUrl,
+        this.logger
+      );
+      if (!registrationResult.success) {
+        return registrationResult;
+      }
+      if (registrationResult.transaction) {
+        const transaction = Transaction.fromBytes(
+          Buffer2.from(registrationResult.transaction, "base64")
+        );
+        this.logger.info(`Processing registration transaction`);
+        const txResult = await this.hwc.executeTransactionWithErrorHandling(
+          transaction,
+          false
+        );
+        if (txResult.error) {
+          return {
+            ...registrationResult,
+            error: txResult.error,
+            success: false
+          };
+        }
+        this.logger.info(`Successfully processed registration transaction`);
+      }
+      const confirmed = await this.waitForRegistrationConfirmation(
+        registrationResult.transactionId,
+        network,
+        this.guardedRegistryBaseUrl,
+        maxAttempts,
+        delayMs
+      );
+      return {
+        ...registrationResult,
+        confirmed
+      };
+    } catch (error) {
+      return {
+        error: `Error during registration: ${error.message}`,
+        success: false
+      };
+    }
+  }
+  async storeHCS11Profile(agentName, agentDescription, inboundTopicId, outboundTopicId, capabilities = [], metadata = {}, pfpBuffer, pfpFileName) {
+    try {
+      let pfpTopicId;
+      if (pfpBuffer && pfpFileName) {
+        const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
+        if (!pfpResult.success) {
+          this.logger.error(
+            "Failed to inscribe profile picture, continuing without PFP"
+          );
+        } else {
+          pfpTopicId = pfpResult.pfpTopicId;
+        }
+      }
+      const agentType = this.hcs11Client.getAgentTypeFromMetadata({
+        type: metadata.type || "autonomous"
+      });
+      const formattedSocials = [];
+      if (metadata.socials) {
+        if (metadata.socials.twitter) {
+          formattedSocials.push({
+            platform: "twitter",
+            handle: metadata.socials.twitter
+          });
+        }
+        if (metadata.socials.discord) {
+          formattedSocials.push({
+            platform: "discord",
+            handle: metadata.socials.discord
+          });
+        }
+        if (metadata.socials.github) {
+          formattedSocials.push({
+            platform: "github",
+            handle: metadata.socials.github
+          });
+        }
+        if (metadata.socials.website) {
+          formattedSocials.push({
+            platform: "website",
+            handle: metadata.socials.website
+          });
+        }
+        if (metadata.socials.x) {
+          formattedSocials.push({
+            platform: "twitter",
+            handle: metadata.socials.x
+          });
+        }
+        if (metadata.socials.linkedin) {
+          formattedSocials.push({
+            platform: "linkedin",
+            handle: metadata.socials.linkedin
+          });
+        }
+        if (metadata.socials.youtube) {
+          formattedSocials.push({
+            platform: "youtube",
+            handle: metadata.socials.youtube
+          });
+        }
+        if (metadata.socials.telegram) {
+          formattedSocials.push({
+            platform: "telegram",
+            handle: metadata.socials.telegram
+          });
+        }
+      }
+      const profile = this.hcs11Client.createAIAgentProfile(
+        agentName,
+        agentType,
+        capabilities,
+        metadata.model || "unknown",
+        {
+          alias: agentName.toLowerCase().replace(/\s+/g, "_"),
+          bio: agentDescription,
+          profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
+          socials: formattedSocials.length > 0 ? formattedSocials : void 0,
+          properties: {
+            description: agentDescription,
+            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 profileResult = await this.hcs11Client.createAndInscribeProfile(
+        profile,
+        true
+      );
+      if (!profileResult.success) {
+        return {
+          profileTopicId: "",
+          success: false,
+          error: profileResult.error || "Failed to inscribe profile"
+        };
+      }
+      return {
+        profileTopicId: profileResult.profileTopicId,
+        pfpTopicId,
+        success: true
+      };
+    } catch (error) {
+      return {
+        profileTopicId: "",
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  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 result = transactionResponse.result;
+    if (!(result == null ? void 0 : result.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: result.topicId.toString()
+    };
+  }
+  async submitPayload(topicId, payload) {
+    this.logger.debug("Submitting payload");
+    const transaction = new TopicMessageSubmitTransaction().setTopicId(topicId).setMessage(JSON.stringify(payload));
+    return await this.hwc.executeTransactionWithErrorHandling(
+      // @ts-ignore
+      transaction,
+      false
+    );
+  }
+  async inscribeFile(buffer2, fileName) {
+    const { accountId, signer } = this.getAccountAndSigner();
+    const mimeType = mimeTypes.lookup(fileName) || "application/octet-stream";
+    const sdk = await InscriptionSDK.createWithAuth({
+      type: "client",
+      accountId,
+      signer,
+      network: this.network
+    });
+    const result = await sdk.inscribe(
+      {
+        file: {
+          type: "base64",
+          base64: buffer2.toString("base64"),
+          fileName,
+          mimeType
+        },
+        holderId: accountId.toString(),
+        mode: "file",
+        network: this.network
+      },
+      signer
+    );
+    if (!result.transactionId || !result.jobId) {
+      this.logger.error("Failed to inscribe, no transaction ID or job ID.");
+      throw new Error("Failed to inscribe, no transaction ID or job ID.");
+    }
+    if (result.transactionId && result.jobId) {
+      this.logger.info(
+        `Transaction ID: ${result.transactionId}, Job ID: ${result.jobId}`
+      );
+    }
+    const status = await sdk.waitForInscription(result.jobId, 30, 4e3, true);
+    return status;
+  }
+  getAccountAndSigner() {
+    const accountInfo = this.hwc.getAccountInfo();
+    const accountId = accountInfo.accountId.toString();
+    const signer = this.hwc.dAppConnector.signers.find((s) => {
+      return s.getAccountId().toString() === accountId;
+    });
+    if (!signer) {
+      this.logger.error("Failed to find signer");
+      throw new Error("Failed to find signer");
+    }
+    return { accountId, signer };
+  }
+  /**
+   * Inscribes a profile picture file to the Hedera network
+   * @param buffer File buffer to inscribe
+   * @param fileName Filename for the inscription
+   * @returns Object containing the topic ID and success status
+   */
+  async inscribePfp(buffer2, fileName) {
+    try {
+      this.logger.info("Inscribing profile picture using HCS-11 client");
+      const imageResult = await this.hcs11Client.inscribeImage(
+        buffer2,
+        fileName
+      );
+      if (!imageResult.success) {
+        this.logger.error(
+          `Failed to inscribe profile picture: ${imageResult.error}`
+        );
+        return {
+          pfpTopicId: "",
+          success: false,
+          error: imageResult.error || "Failed to inscribe profile picture"
+        };
+      }
+      this.logger.info(
+        `Successfully inscribed profile picture with topic ID: ${imageResult.imageTopicId}`
+      );
+      return {
+        pfpTopicId: imageResult.imageTopicId,
+        success: true
+      };
+    } catch (error) {
+      this.logger.error(`Error inscribing profile picture: ${error.message}`);
+      return {
+        pfpTopicId: "",
+        success: false,
+        error: error.message
+      };
+    }
+  }
+}
 export {
   AIAgentCapability,
   AIAgentType,
   AccountCreationError,
   AgentBuilder,
+  BrowserHCSClient,
   ConnectionConfirmationError,
   EVMBridge,
   EndpointType,
+  FeeConfigBuilder,
   HCS,
   HCS10BaseClient,
   HCS10Cache,