@hashgraphonline/standards-agent-kit 0.2.137 → 0.2.138

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
    */

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

@@ -14,6 +14,9 @@ import {
   HCS6CreateHashinalResponse,
   NetworkType,
 } from '@hashgraphonline/standards-sdk';
+import { SignerProviderRegistry, type NetworkString } from '../../signing/signer-provider';
+import type { HCS6TopicRegistrationResult, HCS6RegistryOperationResult, HCS6CreateHashinalResult } from '../../types/tx-results';
+import { CodedError } from '../../utils/CodedError';
 
 /**
  * Builder for HCS-6 operations that delegates to HCS6Client
@@ -57,7 +60,31 @@ export class HCS6Builder extends BaseServiceBuilder {
    */
   async createRegistry(
     options: HCS6CreateRegistryOptions = {}
-  ): Promise<HCS6TopicRegistrationResponse> {
+  ): Promise<HCS6TopicRegistrationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+
+    if (exec) {
+      const start = SignerProviderRegistry.startHCSDelegate;
+      if (start) {
+        try {
+          const request: Record<string, unknown> = { options };
+          const { transactionBytes } = await start('hcs6.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 hcs6.createRegistry');
+      }
+    }
+
     const client = await this.getHCS6Client();
     const sanitized = { ...options };
     if ('adminKey' in sanitized) {
@@ -72,7 +99,31 @@ export class HCS6Builder extends BaseServiceBuilder {
   async registerEntry(
     registryTopicId: string,
     options: HCS6RegisterEntryOptions
-  ): Promise<HCS6RegistryOperationResponse> {
+  ): Promise<HCS6RegistryOperationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+
+    if (exec) {
+      const start = SignerProviderRegistry.startHCSDelegate;
+      if (start) {
+        try {
+          const request: Record<string, unknown> = { registryTopicId, options };
+          const { transactionBytes } = await start('hcs6.registerEntry', 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 hcs6.registerEntry');
+      }
+    }
+
     const client = await this.getHCS6Client();
     return await client.registerEntry(registryTopicId, options);
   }
@@ -140,9 +191,33 @@ export class HCS6Builder extends BaseServiceBuilder {
   async submitMessage(
     topicId: string,
     payload: any
-  ): Promise<any> {
+  ): Promise<HCS6RegistryOperationResult> {
+    const exec = SignerProviderRegistry.walletExecutor;
+    const preferWallet = SignerProviderRegistry.preferWalletOnly;
+    const network = (this.hederaKit.client.network.toString().includes('mainnet') ? 'mainnet' : 'testnet') as NetworkString;
+
+    if (exec) {
+      const start = SignerProviderRegistry.startHCSDelegate;
+      if (start) {
+        try {
+          const request: Record<string, unknown> = { topicId, payload };
+          const { transactionBytes } = await start('hcs6.submitMessage', request, network);
+          if (transactionBytes) {
+            return { success: true, transactionBytes } as unknown as HCS6RegistryOperationResult;
+          }
+        } 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 hcs6.submitMessage');
+      }
+    }
+
     const client = await this.getHCS6Client();
-    return await client.submitMessage(topicId, payload);
+    return await client.submitMessage(topicId, payload) as unknown as HCS6RegistryOperationResult;
   }
 
   /**

package/src/hcs10/HCS10Client.ts

@@ -273,7 +273,7 @@ export class HCS10Client {
         topicId,
         data,
         memo,
-        submitKey
+        submitKey as any
       );
       return messageResponse.topicSequenceNumber?.toNumber();
     } catch (error) {

package/src/index.ts

@@ -8,4 +8,8 @@ export { HCS10Builder, HCS2Builder, HCS6Builder, InscriberBuilder } from './buil
 export type { ExecuteResult } from './builders';
 export { HCS10Client } from './hcs10';
 export type { ContentReferenceConfig } from './config/ContentReferenceConfig';
-export { loadConfig } from './config/ContentReferenceConfig';
+export { loadConfig } from './config/ContentReferenceConfig';
+export { SignerProviderRegistry } from './signing/signer-provider';
+export type { DAppSigner, WalletInfo, WalletExecutor, StartHCSDelegate, NetworkString } from './signing/signer-provider';
+export { ByteBuildRegistry } from './signing/bytes-registry';
+export type { ByteBuildHandler } from './signing/bytes-registry';

package/src/lib/zod-render/schema-extension.ts

@@ -1,7 +1,6 @@
 import { ZodType } from 'zod';
 import { RenderConfigSchema, EnhancedRenderConfig, ZodSchemaWithRender, FormFieldType, FieldMetadata, SelectOption } from './types';
 
-// Type definitions for extended Zod schemas - using Record to extend existing properties
 interface ExtendedZodSchema {
   description?: string;
   merge?: (other: ZodType<unknown>) => ZodType<unknown>;