@hashgraphonline/standards-agent-kit 0.2.136 → 0.2.138

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/builders/inscriber/inscriber-builder.ts

@@ -10,8 +10,10 @@ import {
   RetrievedInscriptionResult,
   HederaClientConfig,
   NetworkType,
+  getTopicId,
 } from '@hashgraphonline/standards-sdk';
 import { InscriptionSDK } from '@kiloscribe/inscription-sdk';
+import type { AgentOperationalMode } from 'hedera-agent-kit';
 
 /**
  * Type definition for DAppSigner interface compatible with inscription SDK
@@ -26,11 +28,80 @@ interface DAppSigner {
  */
 export class InscriberBuilder extends BaseServiceBuilder {
   protected inscriptionSDK?: InscriptionSDK;
+  private static signerProvider?: () => Promise<DAppSigner | null> | DAppSigner | null;
+  private static walletInfoResolver?: () => Promise<{ accountId: string; network: 'mainnet' | 'testnet' } | null> | { accountId: string; network: 'mainnet' | 'testnet' } | null;
+  private static startInscriptionDelegate?: (
+    request: Record<string, unknown>,
+    network: 'mainnet' | 'testnet'
+  ) => Promise<{
+    transactionBytes: string;
+    tx_id?: string;
+    topic_id?: string;
+    status?: string;
+    completed?: boolean;
+  }>;
+  private static walletExecutor?: (
+    base64: string,
+    network: 'mainnet' | 'testnet'
+  ) => Promise<{ transactionId: string }>;
+  /** When true, do not allow server fallback; require a wallet path in Provide Bytes */
+  private static preferWalletOnly = false;
 
   constructor(hederaKit: HederaAgentKit) {
     super(hederaKit);
   }
 
+  public getOperationalMode(): AgentOperationalMode {
+    return this.hederaKit.operationalMode as AgentOperationalMode;
+  }
+
+  static setSignerProvider(
+    provider: () => Promise<DAppSigner | null> | DAppSigner | null
+  ): void {
+    InscriberBuilder.signerProvider = provider;
+  }
+
+  static setWalletInfoResolver(
+    resolver: () => Promise<{ accountId: string; network: 'mainnet' | 'testnet' } | null> | { accountId: string; network: 'mainnet' | 'testnet' } | null
+  ): void {
+    InscriberBuilder.walletInfoResolver = resolver;
+  }
+
+  static setStartInscriptionDelegate(
+    delegate: (
+      request: Record<string, unknown>,
+      network: 'mainnet' | 'testnet'
+    ) => Promise<{ transactionBytes: string; tx_id?: string; topic_id?: string; status?: string; completed?: boolean }>
+  ): void {
+    InscriberBuilder.startInscriptionDelegate = delegate;
+  }
+
+  static setWalletExecutor(
+    executor: (base64: string, network: 'mainnet' | 'testnet') => Promise<{ transactionId: string }>
+  ): void {
+    InscriberBuilder.walletExecutor = executor;
+  }
+
+  /**
+   * Control fallback behavior. When true, wallet must be available for execution paths.
+   */
+  static setPreferWalletOnly(flag: boolean): void {
+    InscriberBuilder.preferWalletOnly = !!flag;
+  }
+
+  async getSigner(): Promise<DAppSigner | null> {
+    const provider = InscriberBuilder.signerProvider;
+    if (!provider) return null;
+    try {
+      const maybe = provider();
+      return (maybe && typeof (maybe as Promise<unknown>).then === 'function')
+        ? await (maybe as Promise<DAppSigner | null>)
+        : (maybe as DAppSigner | null);
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Get or create Inscription SDK - temporarily returns null since we don't have the actual SDK
    */
@@ -74,7 +145,169 @@ export class InscriberBuilder extends BaseServiceBuilder {
     signer: DAppSigner,
     options: InscriptionOptions
   ): Promise<InscriptionResponse> {
-    return await inscribeWithSigner(input, signer as unknown as Parameters<typeof inscribeWithSigner>[1], options);
+    return await inscribeWithSigner(
+      input,
+      signer as unknown as Parameters<typeof inscribeWithSigner>[1],
+      options
+    );
+  }
+
+  async inscribeAuto(
+    input: InscriptionInput,
+    options: InscriptionOptions
+  ): Promise<InscriptionResponse> {
+    const signer = await this.getSigner();
+    if (signer) {
+      return this.inscribeWithSigner(input, signer, options);
+    }
+
+    type WalletInfo = { accountId: string; network: 'mainnet' | 'testnet' };
+    type WalletStartResponse = {
+      transactionBytes: string;
+      tx_id?: string;
+      topic_id?: string;
+      status?: string;
+      completed?: boolean;
+    };
+    type WalletExecutorResponse = { transactionId: string };
+
+    const infoMaybe: WalletInfo | null = InscriberBuilder.walletInfoResolver
+      ? await InscriberBuilder.walletInfoResolver()
+      : null;
+
+    if (InscriberBuilder.preferWalletOnly && !infoMaybe) {
+      const err = new Error('Wallet unavailable: connect a wallet or switch to autonomous mode');
+      (err as unknown as { code: string }).code = 'wallet_unavailable';
+      throw err;
+    }
+
+    if (
+      infoMaybe &&
+      InscriberBuilder.startInscriptionDelegate &&
+      InscriberBuilder.walletExecutor
+    ) {
+      const holderId = infoMaybe.accountId;
+      const network: 'mainnet' | 'testnet' = infoMaybe.network;
+
+      type InscriptionOptionsExt = InscriptionOptions & {
+        fileStandard?: string;
+        chunkSize?: number;
+        jsonFileURL?: string;
+        metadata?: Record<string, unknown> & { creator?: string; description?: string };
+      };
+      const ext = options as InscriptionOptionsExt;
+
+      const baseRequest: Record<string, unknown> = {
+        holderId,
+        metadata: ext.metadata || {},
+        tags: options.tags || [],
+        mode: options.mode || 'file',
+      };
+      if (typeof ext.fileStandard !== 'undefined') {
+        (baseRequest as { fileStandard?: string }).fileStandard = ext.fileStandard;
+      }
+      if (typeof ext.chunkSize !== 'undefined') {
+        (baseRequest as { chunkSize?: number }).chunkSize = ext.chunkSize;
+      }
+
+      let request: Record<string, unknown> = { ...baseRequest };
+      switch (input.type) {
+        case 'url':
+          request = { ...baseRequest, file: { type: 'url', url: input.url } };
+          break;
+        case 'file':
+          request = { ...baseRequest, file: { type: 'path', path: input.path } };
+          break;
+        case 'buffer':
+          request = {
+            ...baseRequest,
+            file: {
+              type: 'base64',
+              base64: Buffer.from(input.buffer).toString('base64'),
+              fileName: input.fileName,
+              mimeType: input.mimeType,
+            },
+          };
+          break;
+      }
+
+      if (options.mode === 'hashinal') {
+        (request as { metadataObject?: unknown }).metadataObject = ext.metadata;
+        (request as { creator?: string }).creator = ext.metadata?.creator || holderId;
+        (request as { description?: string }).description = ext.metadata?.description;
+        if (typeof ext.jsonFileURL === 'string' && ext.jsonFileURL.length > 0) {
+          (request as { jsonFileURL?: string }).jsonFileURL = ext.jsonFileURL;
+        }
+      }
+
+      const start: WalletStartResponse = await InscriberBuilder.startInscriptionDelegate(
+        request,
+        network
+      );
+      if (!start || !start.transactionBytes) {
+        throw new Error('Failed to start inscription (no transaction bytes)');
+      }
+
+      const exec: WalletExecutorResponse = await InscriberBuilder.walletExecutor(
+        start.transactionBytes,
+        network
+      );
+      const transactionId = exec?.transactionId || '';
+
+      const shouldWait = options.quoteOnly ? false : options.waitForConfirmation ?? true;
+      if (shouldWait) {
+        const maxAttempts = (options as { waitMaxAttempts?: number }).waitMaxAttempts ?? 60;
+        const intervalMs = (options as { waitIntervalMs?: number }).waitIntervalMs ?? 5000;
+
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+          try {
+            const retrieved: RetrievedInscriptionResult = await this.retrieveInscription(
+              transactionId,
+              options
+            );
+            const topicIdFromInscription: string | undefined = getTopicId(retrieved as unknown);
+            const topicId: string | undefined = topicIdFromInscription ?? start.topic_id;
+            const status: string | undefined = (retrieved as { status?: string }).status;
+            const isDone = status === 'completed' || !!topicId;
+            if (isDone) {
+              const resultConfirmed: InscriptionResponse = {
+                quote: false,
+                confirmed: true,
+                result: {
+                  jobId: start.tx_id || '',
+                  transactionId,
+                  topicId,
+                },
+                inscription: retrieved,
+              } as unknown as InscriptionResponse;
+              return resultConfirmed;
+            }
+          } catch {
+          }
+          await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+      }
+
+      const partial: InscriptionResponse = {
+        quote: false,
+        confirmed: false,
+        result: {
+          jobId: start.tx_id || '',
+          transactionId,
+          status: start.status,
+          completed: start.completed,
+        },
+        inscription: start.topic_id ? { topic_id: start.topic_id } : undefined,
+      } as unknown as InscriptionResponse;
+      return partial;
+    }
+
+    if (InscriberBuilder.preferWalletOnly) {
+      const err = new Error('Wallet unavailable: connect a wallet or switch to autonomous mode');
+      (err as unknown as { code: string }).code = 'wallet_unavailable';
+      throw err;
+    }
+    return this.inscribe(input, options);
   }
 
   /**
@@ -102,4 +335,4 @@ export class InscriberBuilder extends BaseServiceBuilder {
   async close(): Promise<void> {
     this.inscriptionSDK = undefined;
   }
-}
+}

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>;