@hashgraphonline/standards-sdk 0.0.17 → 0.0.18

package/dist/es/hcs-10/agent-builder.d.ts

@@ -1,7 +1,25 @@
-import { InboundTopicType, NetworkType, AgentConfiguration, FeeAmount } from './types.d';
+import { InboundTopicType, NetworkType, FeeConfigBuilderInterface, AgentConfiguration } from './types.d';
 import { AIAgentCapability } from '../hcs-11';
 import { AgentMetadata } from './sdk';
 type SocialPlatform = 'twitter' | 'discord' | 'github' | 'website' | 'x' | 'linkedin' | 'youtube' | 'telegram';
+/**
+ * AgentBuilder is a builder class for creating agent configurations.
+ * It provides a fluent interface for setting various properties of the agent.
+ *
+ * Example usage:
+ * ```typescript
+ * const agentBuilder = new AgentBuilder();
+ * agentBuilder.setName('My Agent');
+ * agentBuilder.setDescription('This is my agent');
+ * agentBuilder.setCapabilities([AIAgentCapability.CREATE_CONTENT]);
+ * agentBuilder.setModel('gpt-4o');
+ * agentBuilder.setCreator('John Doe');
+ * agentBuilder.addSocial('twitter', 'JohnDoe');
+ * agentBuilder.addProperty('key', 'value');
+ * const agentConfig = agentBuilder.build();
+ * ```
+ *
+ */
 export declare class AgentBuilder {
     private config;
     setName(name: string): AgentBuilder;
@@ -16,8 +34,8 @@ export declare class AgentBuilder {
     setProfilePicture(pfpBuffer: Buffer, pfpFileName: string): AgentBuilder;
     setNetwork(network: NetworkType): AgentBuilder;
     setInboundTopicType(inboundTopicType: InboundTopicType): AgentBuilder;
-    setFeeConfig(feeAmount: FeeAmount, feeCollectorAccountId: string, exemptAccounts?: string[]): AgentBuilder;
-    setConnectionFeeConfig(feeAmount: FeeAmount, feeCollectorAccountId: string, exemptAccounts?: string[]): AgentBuilder;
+    setFeeConfig(feeConfigBuilder: FeeConfigBuilderInterface): AgentBuilder;
+    setConnectionFeeConfig(feeConfigBuilder: FeeConfigBuilderInterface): AgentBuilder;
     setExistingAccount(accountId: string, privateKey: string): AgentBuilder;
     build(): AgentConfiguration;
 }

package/dist/es/hcs-10/base-client.d.ts

@@ -1,6 +1,6 @@
 import { Logger, LogLevel } from '../utils/logger';
 import { Registration } from './registrations';
-import { HederaMirrorNode, TopicInfo, AccountResponse } from '../utils/mirror-node-utils';
+import { HederaMirrorNode, TopicInfo, AccountResponse } from '../services/mirror-node';
 export interface HCS10Config {
     network: 'mainnet' | 'testnet';
     logLevel?: LogLevel;
@@ -42,8 +42,7 @@ export declare abstract class HCS10BaseClient extends Registration {
     getAccountMemo(accountId: string): Promise<string | null>;
     protected getTopicInfoFromMemo(memo: string): Promise<TopicInfo | null>;
     getTopicInfo(accountId: string): Promise<TopicInfo | null>;
-    retrieveOutboundConnectTopic(accountId: string): Promise<string | null>;
-    retrieveOutboundConnectTopicFromNetwork(accountId: string): Promise<TopicInfo>;
+    retrieveOutboundConnectTopic(accountId: string): Promise<TopicInfo>;
     retrieveOutboundMessages(agentAccountId: string): Promise<HCSMessage[]>;
     hasConnectionCreated(agentAccountId: string, connectionId: number): Promise<boolean>;
     clearCache(): void;

package/dist/es/hcs-10/fee-config-builder.d.ts

@@ -0,0 +1,66 @@
+import { FeeConfigBuilderInterface, TopicFeeConfig } from './types.d';
+/**
+ * FeeConfigBuilder provides a fluent interface for creating fee configurations
+ * for HCS-10 topics. This makes it easy to configure fees without dealing with
+ * the complexity of the underlying fee structure.
+ *
+ * Example usage:
+ * ```typescript
+ * const feeConfig = new FeeConfigBuilder()
+ *   .setHbarAmount(1) // 1 HBAR
+ *   .setFeeCollector('0.0.12345')
+ *   .addExemptAccount('0.0.67890')
+ *   .build();
+ * ```
+ */
+export declare class FeeConfigBuilder implements FeeConfigBuilderInterface {
+    private feeAmount;
+    private decimals;
+    private feeCollectorAccountId;
+    private 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: number, collectorAccountId: string, exemptAccounts?: string[]): FeeConfigBuilder;
+    /**
+     * 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: number): FeeConfigBuilder;
+    /**
+     * 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: number, decimals?: number): FeeConfigBuilder;
+    /**
+     * 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: string): FeeConfigBuilder;
+    /**
+     * 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: string): FeeConfigBuilder;
+    /**
+     * 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: string[]): FeeConfigBuilder;
+    /**
+     * 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(): TopicFeeConfig;
+}

package/dist/es/hcs-10/sdk.d.ts

@@ -2,9 +2,10 @@ import { Client, PrivateKey, KeyList, TransactionReceipt, PublicKey } from '@has
 import { RetrievedInscriptionResult } from '@kiloscribe/inscription-sdk';
 import { Logger } from '../utils/logger';
 import { HCS10BaseClient } from './base-client';
-import { HCSClientConfig, AgentConfig, CreateAccountResponse, CreateAgentResponse, InscribePfpResponse, StoreHCS11ProfileResponse, AgentRegistrationResult, HandleConnectionRequestResponse, WaitForConnectionConfirmationResponse, GetAccountAndSignerResponse, InboundTopicType, TopicFeeConfig } from './types.d';
+import { HCSClientConfig, AgentConfig, CreateAccountResponse, CreateAgentResponse, InscribePfpResponse, StoreHCS11ProfileResponse, AgentRegistrationResult, HandleConnectionRequestResponse, WaitForConnectionConfirmationResponse, GetAccountAndSignerResponse, InboundTopicType, TopicFeeConfig, FeeConfigBuilderInterface } from './types.d';
 import { AgentBuilder } from './agent-builder';
 export { InboundTopicType } from './types.d';
+export { FeeConfigBuilder } from './fee-config-builder';
 export interface AgentMetadata {
     type: 'autonomous' | 'manual';
     model?: string;
@@ -43,7 +44,7 @@ export declare class HCS10Client extends HCS10BaseClient {
      * @param feeConfig Optional fee configuration for fee-based topics
      * @returns The topic ID of the created inbound topic
      */
-    createInboundTopic(accountId: string, topicType: InboundTopicType, feeConfig?: TopicFeeConfig): Promise<string>;
+    createInboundTopic(accountId: string, topicType: InboundTopicType, feeConfig?: FeeConfigBuilderInterface): Promise<string>;
     /**
      * Creates a new agent with inbound and outbound topics
      * @param builder The agent builder object
@@ -79,7 +80,7 @@ export declare class HCS10Client extends HCS10BaseClient {
      * @param connectionFeeConfig Optional fee configuration for the connection topic
      * @returns Response with connection details
      */
-    handleConnectionRequest(inboundTopicId: string, requestingAccountId: string, connectionRequestId: number, connectionFeeConfig?: TopicFeeConfig): Promise<HandleConnectionRequestResponse>;
+    handleConnectionRequest(inboundTopicId: string, requestingAccountId: string, connectionRequestId: number, connectionFeeConfig?: FeeConfigBuilderInterface): Promise<HandleConnectionRequestResponse>;
     confirmConnection(inboundTopicId: string, connectionTopicId: string, connectedAccountId: string, connectionId: number, operatorId: string, memo: string, submitKey?: PrivateKey): Promise<number>;
     sendMessage(connectionTopicId: string, operatorId: string, data: string, memo?: string, submitKey?: PrivateKey): Promise<void>;
     createTopic(memo: string, adminKey?: boolean | PublicKey | KeyList, submitKey?: boolean | PublicKey | KeyList, feeConfig?: TopicFeeConfig): Promise<string>;
@@ -105,6 +106,12 @@ export declare class HCS10Client extends HCS10BaseClient {
      */
     waitForConnectionConfirmation(inboundTopicId: string, connectionRequestId: number, maxAttempts?: number, delayMs?: number): Promise<WaitForConnectionConfirmationResponse>;
     getAccountAndSigner(): GetAccountAndSignerResponse;
+    /**
+     * 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
+     */
     canSubmitToInboundTopic(topicId: string, userAccountId: string): Promise<{
         canSubmit: boolean;
         requiresFee: boolean;

package/dist/es/index.d.ts

@@ -4,3 +4,4 @@ export * from './hcs-10';
 export * from './hcs-11';
 export * from './utils';
 export * from './inscribe';
+export * from './services';

package/dist/es/services/index.d.ts

@@ -0,0 +1 @@
+export * from './mirror-node';

package/dist/es/{utils/mirror-node-utils.d.ts → services/mirror-node.d.ts}

@@ -1,5 +1,5 @@
 import { PublicKey } from '@hashgraph/sdk';
-import { Logger } from './logger';
+import { Logger } from '../utils/logger';
 import { HCSMessage } from '../hcs-10/base-client';
 export interface Balance {
     balance: number;
@@ -99,20 +99,20 @@ export interface TopicMessagesResponse {
     };
 }
 export interface TopicResponse {
-    admin_key: AdminKey;
+    admin_key: Key;
     auto_renew_account: string;
     auto_renew_period: number;
     created_timestamp: string;
     custom_fees: CustomFees;
     deleted: boolean;
-    fee_exempt_key_list: AdminKey[];
-    fee_schedule_key: AdminKey;
+    fee_exempt_key_list: Key[];
+    fee_schedule_key: Key;
     memo: string;
-    submit_key: AdminKey;
+    submit_key: Key;
     timestamp: Timestamp;
     topic_id: string;
 }
-export interface AdminKey {
+export interface Key {
     _type: string;
     key: string;
 }
@@ -142,5 +142,8 @@ export declare class HederaMirrorNode {
     getTopicFees(topicId: string): Promise<CustomFees | null>;
     getTopicMessages(topicId: string): Promise<HCSMessage[]>;
     requestAccount(accountId: string): Promise<AccountResponse>;
-    getAccountInfo(accountId: string): Promise<AccountResponse>;
+    checkKeyListAccess(keyBytes: Buffer, userPublicKey: PublicKey): Promise<boolean>;
+    private evaluateKeyAccess;
+    private evaluateKeyList;
+    private compareEd25519Key;
 }

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) {
@@ -32864,6 +32990,7 @@ export {
   ConnectionConfirmationError,
   EVMBridge,
   EndpointType,
+  FeeConfigBuilder,
   HCS,
   HCS10BaseClient,
   HCS10Cache,