@hashgraphonline/standards-agent-kit 0.2.136 → 0.2.138

package/src/builders/hcs10/hcs10-builder.ts

@@ -1,6 +1,7 @@
 import { BaseServiceBuilder } from 'hedera-agent-kit';
 import type { HederaAgentKit } from 'hedera-agent-kit';
 import { PrivateKey, TransactionReceipt } from '@hashgraph/sdk';
+import { SignerProviderRegistry, type DAppSigner, type NetworkString } from '../../signing/signer-provider';
 import { ActiveConnection, IStateManager } from '../../state/state-types';
 import { ExecuteResult } from '../types';
 import {
@@ -150,6 +151,7 @@ export class HCS10Builder extends BaseServiceBuilder {
     }
   ) {
     super(hederaKit);
+
     this.stateManager = stateManager;
 
     const network = this.hederaKit.client.network;
@@ -162,10 +164,27 @@ export class HCS10Builder extends BaseServiceBuilder {
       ? this.hederaKit.signer.getOperatorPrivateKey().toStringRaw()
       : '';
 
-    this.sdkLogger = new SDKLogger({
-      module: 'HCS10Builder',
-      level: options?.logLevel || 'info',
-    });
+    this.sdkLogger = ((): SDKLogger => {
+      try {
+        if (typeof SDKLogger === 'function') {
+          return new SDKLogger({
+            module: 'HCS10Builder',
+            level: options?.logLevel || 'info',
+          });
+        }
+      } catch {}
+      return {
+        debug: () => {},
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+        trace: () => {},
+        setLogLevel: () => {},
+        getLevel: () => 'info',
+        setSilent: () => {},
+        setModule: () => {},
+      } as unknown as SDKLogger;
+    })();
 
     this.standardClient = new HCS10Client({
       network: this.network,
@@ -278,6 +297,41 @@ export class HCS10Builder extends BaseServiceBuilder {
     inboundTopicId: string,
     memo: string
   ): Promise<TransactionReceipt> {
+    const start = SignerProviderRegistry.startHCSDelegate;
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network: NetworkString = this.network;
+
+    try {
+      const { ByteBuildRegistry } = await import('../../signing/bytes-registry');
+      if (exec && ByteBuildRegistry.has('submitConnectionRequest')) {
+        const built = await ByteBuildRegistry.build('submitConnectionRequest', this.hederaKit, { inboundTopicId, memo });
+        if (built && built.transactionBytes) {
+          const { transactionId } = await exec(built.transactionBytes, network);
+          return ({ transactionId } as unknown) as TransactionReceipt;
+        }
+      }
+    } catch {}
+
+    if (start && exec) {
+      try {
+        const request: Record<string, unknown> = { inboundTopicId, memo };
+        const { transactionBytes } = await start('submitConnectionRequest', request, network);
+        const { transactionId } = await exec(transactionBytes, network);
+        return ({ transactionId } as unknown) as TransactionReceipt;
+      } catch (err) {
+        if (preferWallet) {
+          const e = new Error(`wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`);
+          (e as unknown as { code: string }).code = 'wallet_submit_failed';
+          throw e;
+        }
+      }
+    } else if (preferWallet) {
+      const e = new Error('wallet_unavailable: connect a wallet or configure StartHCSDelegate and WalletExecutor');
+      (e as unknown as { code: string }).code = 'wallet_unavailable';
+      throw e;
+    }
+
     return this.standardClient.submitConnectionRequest(
       inboundTopicId,
       memo
@@ -294,6 +348,39 @@ export class HCS10Builder extends BaseServiceBuilder {
     feeConfig?: FeeConfigBuilderInterface
   ): Promise<HandleConnectionRequestResponse> {
     try {
+      const start = SignerProviderRegistry.startHCSDelegate;
+      const exec = SignerProviderRegistry.walletExecutor;
+      const preferWallet = SignerProviderRegistry.preferWalletOnly;
+      const network: NetworkString = this.network;
+
+      if (start && exec) {
+        try {
+          const request: Record<string, unknown> = {
+            inboundTopicId,
+            requestingAccountId,
+            connectionRequestId,
+            feeConfig: feeConfig ? 'configured' : undefined,
+          };
+          const { transactionBytes } = await start('handleConnectionRequest', request, network);
+          const { transactionId } = await exec(transactionBytes, network);
+          const minimal = {
+            success: true,
+            transactionId,
+          } as unknown as HandleConnectionRequestResponse;
+          return minimal;
+        } catch (err) {
+          if (preferWallet) {
+            const e = new Error(`wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`);
+            (e as unknown as { code: string }).code = 'wallet_submit_failed';
+            throw e;
+          }
+        }
+      } else if (preferWallet) {
+        const e = new Error('wallet_unavailable: connect a wallet or configure StartHCSDelegate and WalletExecutor');
+        (e as unknown as { code: string }).code = 'wallet_unavailable';
+        throw e;
+      }
+
       const result = await this.standardClient.handleConnectionRequest(
         inboundTopicId,
         requestingAccountId,
@@ -349,6 +436,58 @@ export class HCS10Builder extends BaseServiceBuilder {
     }
 
     try {
+      let prevMaxSeq = 0
+      try {
+        const prev = await this.getMessages(topicId)
+        prevMaxSeq = prev.messages.reduce((max, m) => Math.max(max, m.sequence_number || 0), 0)
+      } catch {}
+
+      const start = SignerProviderRegistry.startHCSDelegate;
+      const exec = SignerProviderRegistry.walletExecutor;
+      const preferWallet = SignerProviderRegistry.preferWalletOnly;
+      const network: NetworkString = this.network;
+
+      try {
+        const { ByteBuildRegistry } = await import('../../signing/bytes-registry');
+        if (exec && ByteBuildRegistry.has('sendMessage')) {
+          const built = await ByteBuildRegistry.build('sendMessage', this.hederaKit, { topicId, data, memo });
+          if (built && built.transactionBytes) {
+            const { transactionId } = await exec(built.transactionBytes, network);
+            const sequenceNumber = await this.pollForNewSequence(topicId, prevMaxSeq);
+            return {
+              sequenceNumber,
+              receipt: ({ transactionId } as unknown) as TransactionReceipt,
+              transactionId,
+            };
+          }
+        }
+      } catch {}
+
+      if (start && exec) {
+        try {
+          const request: Record<string, unknown> = { topicId, data, memo };
+          const { transactionBytes } = await start('sendMessage', request, network);
+          const { transactionId } = await exec(transactionBytes, network);
+
+          const sequenceNumber = await this.pollForNewSequence(topicId, prevMaxSeq);
+          return {
+            sequenceNumber,
+            receipt: ({ transactionId } as unknown) as TransactionReceipt,
+            transactionId,
+          };
+        } catch (err) {
+          if (preferWallet) {
+            const e = new Error(`wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`);
+            (e as unknown as { code: string }).code = 'wallet_submit_failed';
+            throw e;
+          }
+        }
+      } else if (preferWallet) {
+        const e = new Error('wallet_unavailable: connect a wallet or configure StartHCSDelegate and WalletExecutor');
+        (e as unknown as { code: string }).code = 'wallet_unavailable';
+        throw e;
+      }
+
       const messageResponse = await this.standardClient.sendMessage(
         topicId,
         data,
@@ -544,6 +683,20 @@ export class HCS10Builder extends BaseServiceBuilder {
     }
   }
 
+  private async pollForNewSequence(topicId: string, prevMax: number): Promise<number | undefined> {
+    const maxAttempts = 10
+    const delayMs = 1000
+    for (let i = 0; i < maxAttempts; i++) {
+      try {
+        const res = await this.getMessages(topicId)
+        const maxSeq = res.messages.reduce((m, msg) => Math.max(m, msg.sequence_number || 0), prevMax)
+        if (maxSeq > prevMax) return maxSeq
+      } catch {}
+      await new Promise((r) => setTimeout(r, delayMs))
+    }
+    return undefined
+  }
+
   /**
    * Create and register an agent
    */
@@ -695,6 +848,64 @@ export class HCS10Builder extends BaseServiceBuilder {
         );
       }
 
+      const preferWallet = SignerProviderRegistry.preferWalletOnly;
+      const browserClient = SignerProviderRegistry.getBrowserHCSClient(this.network as NetworkString) as
+        | { create: (builder: unknown, opts?: Record<string, unknown>) => Promise<unknown> }
+        | null;
+
+      if (browserClient) {
+        try {
+          const aBuilder = new AgentBuilder()
+            .setNetwork(this.network)
+            .setName(registrationData.name)
+            .setAlias(registrationData.alias || `${registrationData.name}-${Date.now()}`)
+            .setBio(registrationData.bio || '')
+            .setType(registrationData.type || 'autonomous')
+            .setModel(registrationData.model || 'agent-model-2024');
+
+          if (registrationData.capabilities?.length) {
+            aBuilder.setCapabilities(registrationData.capabilities as unknown as number[]);
+          }
+          if (registrationData.creator) aBuilder.setCreator(registrationData.creator);
+          if (registrationData.existingProfilePictureTopicId) {
+            aBuilder.setExistingProfilePicture(registrationData.existingProfilePictureTopicId);
+          }
+          if (registrationData.socials) {
+            Object.entries(registrationData.socials).forEach(([platform, handle]) => {
+              if (handle && typeof handle === 'string') {
+                aBuilder.addSocial(platform as SocialPlatform, handle);
+              }
+            });
+          }
+          if (registrationData.properties) {
+            Object.entries(registrationData.properties).forEach(([key, value]) => {
+              if (value != null) aBuilder.addProperty(key, value as unknown as string);
+            });
+          }
+
+          const resp = await browserClient.create(aBuilder, {
+            progressCallback: (_: unknown) => {},
+            updateAccountMemo: true,
+          });
+
+          this.executeResult = {
+            success: true,
+            transactionId: undefined,
+            receipt: undefined,
+            scheduleId: undefined,
+            rawResult: { result: resp, name: registrationData.name },
+          } as unknown as ExecuteResult & { rawResult?: unknown };
+
+          return this;
+        } catch (walletErr) {
+          if (preferWallet) {
+            throw new Error(`wallet_registration_failed: ${walletErr instanceof Error ? walletErr.message : String(walletErr)}`);
+          }
+        }
+      } else if (preferWallet) {
+        throw new Error('wallet_unavailable: BrowserHCSClient factory not provided');
+      }
+
       const result = await this.createAndRegisterAgent(registrationData);
 
       this.executeResult = {
@@ -886,6 +1097,21 @@ export class HCS10Builder extends BaseServiceBuilder {
         )?.toString();
       }
 
+      if (!connectionTopicId || typeof connectionTopicId !== 'string') {
+        try {
+          const refreshed = await this.stateManager?.getConnectionsManager()?.fetchConnectionData(currentAgent.accountId);
+          const established = (refreshed || []).find(
+            (c: unknown) => (c as { targetAccountId?: string; status?: string }).targetAccountId === targetAccountId &&
+              (c as { status?: string }).status === 'established'
+          ) as { connectionTopicId?: string } | undefined;
+          if (established?.connectionTopicId) {
+            connectionTopicId = established.connectionTopicId;
+          }
+        } catch (e) {
+          this.logger.debug('Could not refresh connections after acceptance to derive topic id:', e);
+        }
+      }
+
       if (!connectionTopicId || typeof connectionTopicId !== 'string') {
         throw new Error(
           `Failed to create connection topic. Got: ${JSON.stringify(
@@ -1102,13 +1328,20 @@ export class HCS10Builder extends BaseServiceBuilder {
 
       const operatorId = `${currentAgent.inboundTopicId}@${currentAgent.accountId}`;
 
+      let baseSeq = 0
+      try {
+        const prev = await this.getMessages(connectionTopicId)
+        baseSeq = prev.messages.reduce((max, m) => Math.max(max, m.sequence_number || 0), 0)
+      } catch {}
+
       const messageResult = await this.sendMessage(
         connectionTopicId,
         params.message,
         `Agent message from ${currentAgent.name}`
       );
 
-      if (!messageResult.sequenceNumber) {
+      const effectiveSeq = messageResult.sequenceNumber ?? baseSeq
+      if (effectiveSeq === 0) {
         throw new Error('Failed to send message');
       }
 
@@ -1117,7 +1350,7 @@ export class HCS10Builder extends BaseServiceBuilder {
         reply = await this.monitorResponses(
           connectionTopicId,
           operatorId,
-          messageResult.sequenceNumber
+          effectiveSeq
         );
       } else {
         this.addNote(

package/src/builders/hcs2/hcs2-builder.ts

@@ -13,7 +13,11 @@ import {
   RegistryOperationResponse,
   TopicRegistry,
   NetworkType,
+  HederaMirrorNode,
 } from '@hashgraphonline/standards-sdk';
+import { SignerProviderRegistry, type NetworkString } from '../../signing/signer-provider';
+import type { TopicRegistrationResult, RegistryOperationResult, SubmitMessageResult } from '../../types/tx-results';
+import { CodedError } from '../../utils/CodedError';
 
 /**
  * Builder for HCS-2 operations that delegates to HCS2Client
@@ -40,10 +44,23 @@ export class HCS2Builder extends BaseServiceBuilder {
         ? 'mainnet'
         : 'testnet';
 
+      let keyTypeHint: 'ed25519' | 'ecdsa' | undefined;
+      try {
+        const mirror = new HederaMirrorNode(networkType);
+        const info = await mirror.requestAccount(operatorId);
+        const t = (info as any)?.key?._type as string | undefined;
+        if (t) {
+          const upper = t.toUpperCase();
+          if (upper.includes('ED25519')) keyTypeHint = 'ed25519';
+          else if (upper.includes('ECDSA')) keyTypeHint = 'ecdsa';
+        }
+      } catch {}
+
       const config: SDKHCS2ClientConfig = {
         network: networkType,
         operatorId: operatorId,
         operatorKey: operatorPrivateKey,
+        ...(keyTypeHint ? { keyType: keyTypeHint } : {}),
       };
 
       this.hcs2Client = new HCS2Client(config);
@@ -57,18 +74,96 @@ export class HCS2Builder extends BaseServiceBuilder {
    */
   async createRegistry(
     options: CreateRegistryOptions = {}
-  ): Promise<TopicRegistrationResponse> {
+  ): Promise<TopicRegistrationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const hasPrivateKey = !!(this.hederaKit?.signer?.getOperatorPrivateKey && this.hederaKit.signer.getOperatorPrivateKey());
+
+    if (exec) {
+      const start = SignerProviderRegistry.startHCSDelegate;
+      if (start) {
+        try {
+          const request: Record<string, unknown> = { options };
+          const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+          const { transactionBytes } = await start('hcs2.createRegistry', request, network);
+          if (transactionBytes) {
+            return { success: true, transactionBytes };
+          }
+        } catch (err) {
+          if (preferWallet) {
+            throw new CodedError('wallet_submit_failed', `wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      }
+      if (preferWallet) {
+        throw new CodedError('wallet_unavailable', 'WalletExecutor not configured for hcs2.createRegistry');
+      }
+    }
+
+    if (!hasPrivateKey) {
+      throw new CodedError('wallet_unavailable', 'No wallet executor and no operator private key available for server execution');
+    }
     const client = await this.getHCS2Client();
     return await client.createRegistry(options);
   }
-
   /**
    * Register a new entry in an HCS-2 registry
    */
   async registerEntry(
     registryTopicId: string,
     options: RegisterEntryOptions
-  ): Promise<RegistryOperationResponse> {
+  ): Promise<RegistryOperationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+    const hasPrivateKey = !!(this.hederaKit?.signer?.getOperatorPrivateKey && this.hederaKit.signer.getOperatorPrivateKey());
+
+    try {
+      const { ByteBuildRegistry } = await import('../../signing/bytes-registry');
+      if (ByteBuildRegistry.has('hcs2.registerEntry')) {
+        const built = await ByteBuildRegistry.build('hcs2.registerEntry', this.hederaKit, { registryTopicId, options });
+        if (built && built.transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+        }
+      }
+    } catch {}
+
+    const start = SignerProviderRegistry.startHCSDelegate;
+    if (start) {
+      try {
+        const request: Record<string, unknown> = {
+          registryTopicId,
+          options,
+        };
+        const { transactionBytes } = await start('hcs2.registerEntry', request, network);
+        if (transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes };
+          }
+        }
+      } catch (err) {
+        if (preferWallet) {
+          const msg = `wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`;
+          throw new CodedError('wallet_submit_failed', msg);
+        }
+      }
+    }
+
+    if (preferWallet) {
+      throw new CodedError('wallet_unavailable', 'WalletExecutor not configured for hcs2.registerEntry');
+    }
+
+    if (!hasPrivateKey) {
+      throw new CodedError('wallet_unavailable', 'No wallet executor and no operator private key available for server execution');
+    }
     const client = await this.getHCS2Client();
     return await client.registerEntry(registryTopicId, options);
   }
@@ -79,7 +174,58 @@ export class HCS2Builder extends BaseServiceBuilder {
   async updateEntry(
     registryTopicId: string,
     options: UpdateEntryOptions
-  ): Promise<RegistryOperationResponse> {
+  ): Promise<RegistryOperationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+    const hasPrivateKey = !!(this.hederaKit?.signer?.getOperatorPrivateKey && this.hederaKit.signer.getOperatorPrivateKey());
+
+    try {
+      const { ByteBuildRegistry } = await import('../../signing/bytes-registry');
+      if (ByteBuildRegistry.has('hcs2.updateEntry')) {
+        const built = await ByteBuildRegistry.build('hcs2.updateEntry', this.hederaKit, { registryTopicId, options });
+        if (built && built.transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+        }
+      }
+    } catch {}
+
+    const start = SignerProviderRegistry.startHCSDelegate;
+    if (start) {
+      try {
+        const request: Record<string, unknown> = {
+          registryTopicId,
+          options,
+        };
+        const { transactionBytes } = await start('hcs2.updateEntry', request, network);
+        if (transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes };
+          }
+        }
+      } catch (err) {
+        if (preferWallet) {
+          const msg = `wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`;
+          throw new CodedError('wallet_submit_failed', msg);
+        }
+      }
+    }
+
+    if (preferWallet) {
+      throw new CodedError('wallet_unavailable', 'WalletExecutor not configured for hcs2.updateEntry');
+    }
+
+    if (!hasPrivateKey) {
+      throw new CodedError('wallet_unavailable', 'No wallet executor and no operator private key available for server execution');
+    }
     const client = await this.getHCS2Client();
     return await client.updateEntry(registryTopicId, options);
   }
@@ -90,7 +236,58 @@ export class HCS2Builder extends BaseServiceBuilder {
   async deleteEntry(
     registryTopicId: string,
     options: DeleteEntryOptions
-  ): Promise<RegistryOperationResponse> {
+  ): Promise<RegistryOperationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+    const hasPrivateKey = !!(this.hederaKit?.signer?.getOperatorPrivateKey && this.hederaKit.signer.getOperatorPrivateKey());
+
+    try {
+      const { ByteBuildRegistry } = await import('../../signing/bytes-registry');
+      if (ByteBuildRegistry.has('hcs2.deleteEntry')) {
+        const built = await ByteBuildRegistry.build('hcs2.deleteEntry', this.hederaKit, { registryTopicId, options });
+        if (built && built.transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+        }
+      }
+    } catch {}
+
+    const start = SignerProviderRegistry.startHCSDelegate;
+    if (start) {
+      try {
+        const request: Record<string, unknown> = {
+          registryTopicId,
+          options,
+        };
+        const { transactionBytes } = await start('hcs2.deleteEntry', request, network);
+        if (transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes };
+          }
+        }
+      } catch (err) {
+        if (preferWallet) {
+          const msg = `wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`;
+          throw new CodedError('wallet_submit_failed', msg);
+        }
+      }
+    }
+
+    if (preferWallet) {
+      throw new CodedError('wallet_unavailable', 'WalletExecutor not configured for hcs2.deleteEntry');
+    }
+
+    if (!hasPrivateKey) {
+      throw new CodedError('wallet_unavailable', 'No wallet executor and no operator private key available for server execution');
+    }
     const client = await this.getHCS2Client();
     return await client.deleteEntry(registryTopicId, options);
   }
@@ -101,7 +298,55 @@ export class HCS2Builder extends BaseServiceBuilder {
   async migrateRegistry(
     registryTopicId: string,
     options: MigrateTopicOptions
-  ): Promise<RegistryOperationResponse> {
+  ): Promise<RegistryOperationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const hasPrivateKey = !!(this.hederaKit?.signer?.getOperatorPrivateKey && this.hederaKit.signer.getOperatorPrivateKey());
+
+    try {
+      const { ByteBuildRegistry } = await import('../../signing/bytes-registry');
+      if (ByteBuildRegistry.has('hcs2.migrateRegistry')) {
+        const built = await ByteBuildRegistry.build('hcs2.migrateRegistry', this.hederaKit, { registryTopicId, options });
+        if (built && built.transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+        }
+      }
+    } catch {}
+
+    const start = SignerProviderRegistry.startHCSDelegate;
+    if (start) {
+      try {
+        const request: Record<string, unknown> = { registryTopicId, options };
+        const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+        const { transactionBytes } = await start('hcs2.migrateRegistry', request, network);
+        if (transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes };
+          }
+        }
+      } catch (err) {
+        if (preferWallet) {
+          const msg = `wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`;
+          throw new CodedError('wallet_submit_failed', msg);
+        }
+      }
+    }
+
+    if (preferWallet) {
+      throw new CodedError('wallet_unavailable', 'WalletExecutor not configured for hcs2.migrateRegistry');
+    }
+
+    if (!hasPrivateKey) {
+      throw new CodedError('wallet_unavailable', 'No wallet executor and no operator private key available for server execution');
+    }
     const client = await this.getHCS2Client();
     return await client.migrateRegistry(registryTopicId, options);
   }
@@ -123,11 +368,59 @@ export class HCS2Builder extends BaseServiceBuilder {
   async submitMessage(
     topicId: string,
     payload: any
-  ): Promise<any> {
+  ): Promise<SubmitMessageResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+    const hasPrivateKey = !!(this.hederaKit?.signer?.getOperatorPrivateKey && this.hederaKit.signer.getOperatorPrivateKey());
+
+    try {
+      const { ByteBuildRegistry } = await import('../../signing/bytes-registry');
+      if (ByteBuildRegistry.has('hcs2.submitMessage')) {
+        const built = await ByteBuildRegistry.build('hcs2.submitMessage', this.hederaKit, { topicId, payload });
+        if (built && built.transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes: built.transactionBytes };
+          }
+        }
+      }
+    } catch {}
+
+    const start = SignerProviderRegistry.startHCSDelegate;
+    if (start) {
+      try {
+        const request: Record<string, unknown> = { topicId, payload };
+        const { transactionBytes } = await start('hcs2.submitMessage', request, network);
+        if (transactionBytes) {
+          if (exec) {
+            return { success: true, transactionBytes };
+          }
+          if (!hasPrivateKey) {
+            return { success: true, transactionBytes };
+          }
+        }
+      } catch (err) {
+        if (preferWallet) {
+          const msg = `wallet_submit_failed: ${err instanceof Error ? err.message : String(err)}`;
+          throw new CodedError('wallet_submit_failed', msg);
+        }
+      }
+    }
+
+    if (preferWallet) {
+      throw new CodedError('wallet_unavailable', 'WalletExecutor not configured for hcs2.submitMessage');
+    }
+
+    if (!hasPrivateKey) {
+      throw new CodedError('wallet_unavailable', 'No wallet executor and no operator private key available for server execution');
+    }
     const client = await this.getHCS2Client();
-    return await client.submitMessage(topicId, payload);
+    await client.submitMessage(topicId, payload);
+    return { success: true };
   }
-
   /**
    * Get topic info from mirror node
    */