@hashgraphonline/standards-agent-kit 0.2.112 → 0.2.113

package/dist/umd/tools/hcs6/CreateDynamicRegistryTool.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for creating a dynamic hashinal registry
+ */
+declare const CreateDynamicRegistrySchema: z.ZodObject<{
+    ttl: z.ZodDefault<z.ZodNumber>;
+    adminKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    submitKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+}, "strip", z.ZodTypeAny, {
+    ttl: number;
+    adminKey?: string | boolean | undefined;
+    submitKey?: string | boolean | undefined;
+}, {
+    ttl?: number | undefined;
+    adminKey?: string | boolean | undefined;
+    submitKey?: string | boolean | undefined;
+}>;
+export type CreateDynamicRegistryInput = z.infer<typeof CreateDynamicRegistrySchema>;
+/**
+ * Tool for creating HCS-6 dynamic registries
+ */
+export declare class CreateDynamicRegistryTool extends BaseHCS6TransactionTool<typeof CreateDynamicRegistrySchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        ttl: z.ZodDefault<z.ZodNumber>;
+        adminKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        submitKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    }, "strip", z.ZodTypeAny, {
+        ttl: number;
+        adminKey?: string | boolean | undefined;
+        submitKey?: string | boolean | undefined;
+    }, {
+        ttl?: number | undefined;
+        adminKey?: string | boolean | undefined;
+        submitKey?: string | boolean | undefined;
+    }>;
+    constructor(params: HCS6TransactionToolParams);
+    protected _call(params: CreateDynamicRegistryInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/umd/tools/hcs6/QueryDynamicRegistryTool.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for querying a dynamic registry
+ */
+declare const QueryDynamicRegistrySchema: z.ZodObject<{
+    topicId: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+    skip: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    topicId: string;
+    limit: number;
+    order: "asc" | "desc";
+    skip?: number | undefined;
+}, {
+    topicId: string;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    skip?: number | undefined;
+}>;
+export type QueryDynamicRegistryInput = z.infer<typeof QueryDynamicRegistrySchema>;
+/**
+ * Tool for querying HCS-6 dynamic registries
+ */
+export declare class QueryDynamicRegistryTool extends BaseHCS6QueryTool<typeof QueryDynamicRegistrySchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        topicId: z.ZodString;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        topicId: string;
+        limit: number;
+        order: "asc" | "desc";
+        skip?: number | undefined;
+    }, {
+        topicId: string;
+        limit?: number | undefined;
+        order?: "asc" | "desc" | undefined;
+        skip?: number | undefined;
+    }>;
+    constructor(params: HCS6QueryToolParams);
+    protected _call(params: QueryDynamicRegistryInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/umd/tools/hcs6/RegisterDynamicHashinalTool.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for registering a dynamic hashinal
+ */
+declare const RegisterDynamicHashinalSchema: z.ZodObject<{
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    data: z.ZodOptional<z.ZodObject<{
+        base64: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }>>;
+    memo: z.ZodOptional<z.ZodString>;
+    ttl: z.ZodDefault<z.ZodNumber>;
+    registryTopicId: z.ZodOptional<z.ZodString>;
+    submitKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+    ttl: number;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+    submitKey?: string | undefined;
+    registryTopicId?: string | undefined;
+}, {
+    metadata: Record<string, unknown>;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+    ttl?: number | undefined;
+    submitKey?: string | undefined;
+    registryTopicId?: string | undefined;
+}>;
+export type RegisterDynamicHashinalInput = z.infer<typeof RegisterDynamicHashinalSchema>;
+/**
+ * Tool for registering (creating) dynamic hashinals
+ */
+export declare class RegisterDynamicHashinalTool extends BaseHCS6TransactionTool<typeof RegisterDynamicHashinalSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        data: z.ZodOptional<z.ZodObject<{
+            base64: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }>>;
+        memo: z.ZodOptional<z.ZodString>;
+        ttl: z.ZodDefault<z.ZodNumber>;
+        registryTopicId: z.ZodOptional<z.ZodString>;
+        submitKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown>;
+        ttl: number;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+        submitKey?: string | undefined;
+        registryTopicId?: string | undefined;
+    }, {
+        metadata: Record<string, unknown>;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+        ttl?: number | undefined;
+        submitKey?: string | undefined;
+        registryTopicId?: string | undefined;
+    }>;
+    constructor(params: HCS6TransactionToolParams);
+    protected _call(params: RegisterDynamicHashinalInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/umd/tools/hcs6/UpdateDynamicHashinalTool.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for updating a dynamic hashinal
+ */
+declare const UpdateDynamicHashinalSchema: z.ZodObject<{
+    registryTopicId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    data: z.ZodOptional<z.ZodObject<{
+        base64: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }>>;
+    memo: z.ZodOptional<z.ZodString>;
+    submitKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+    submitKey: string;
+    registryTopicId: string;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+}, {
+    metadata: Record<string, unknown>;
+    submitKey: string;
+    registryTopicId: string;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+}>;
+export type UpdateDynamicHashinalInput = z.infer<typeof UpdateDynamicHashinalSchema>;
+/**
+ * Tool for updating dynamic hashinals
+ */
+export declare class UpdateDynamicHashinalTool extends BaseHCS6TransactionTool<typeof UpdateDynamicHashinalSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        registryTopicId: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        data: z.ZodOptional<z.ZodObject<{
+            base64: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }>>;
+        memo: z.ZodOptional<z.ZodString>;
+        submitKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown>;
+        submitKey: string;
+        registryTopicId: string;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+    }, {
+        metadata: Record<string, unknown>;
+        submitKey: string;
+        registryTopicId: string;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+    }>;
+    constructor(params: HCS6TransactionToolParams);
+    protected _call(params: UpdateDynamicHashinalInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/umd/tools/hcs6/base-hcs6-tools.d.ts

@@ -0,0 +1,28 @@
+import { BaseHederaTransactionTool, BaseHederaQueryTool, BaseServiceBuilder } from 'hedera-agent-kit';
+import { HCS6Builder } from '../../builders/hcs6/hcs6-builder';
+import { HCS6TransactionToolParams, HCS6QueryToolParams } from './hcs6-tool-params';
+import { z } from 'zod';
+/**
+ * Base class for HCS6 transaction tools
+ */
+export declare abstract class BaseHCS6TransactionTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny> = z.ZodObject<z.ZodRawShape>> extends BaseHederaTransactionTool<T> {
+    protected hcs6Builder: HCS6Builder;
+    namespace: "hcs6";
+    constructor(params: HCS6TransactionToolParams);
+    /**
+     * Override to return the HCS6Builder
+     */
+    protected getServiceBuilder(): BaseServiceBuilder;
+}
+/**
+ * Base class for HCS6 query tools
+ */
+export declare abstract class BaseHCS6QueryTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny> = z.ZodObject<z.ZodRawShape>> extends BaseHederaQueryTool<T> {
+    protected hcs6Builder: HCS6Builder;
+    namespace: "hcs6";
+    constructor(params: HCS6QueryToolParams);
+    /**
+     * Override to return the HCS6Builder
+     */
+    protected getServiceBuilder(): BaseServiceBuilder;
+}

package/dist/umd/tools/hcs6/hcs6-tool-params.d.ts

@@ -0,0 +1,18 @@
+import { HederaAgentKit, BasePluginContext } from 'hedera-agent-kit';
+import { HCS6Builder } from '../../builders/hcs6/hcs6-builder';
+/**
+ * Parameters for HCS6 transaction tools
+ */
+export interface HCS6TransactionToolParams {
+    hederaKit: HederaAgentKit;
+    hcs6Builder: HCS6Builder;
+    logger?: BasePluginContext['logger'];
+}
+/**
+ * Parameters for HCS6 query tools
+ */
+export interface HCS6QueryToolParams {
+    hederaKit: HederaAgentKit;
+    hcs6Builder: HCS6Builder;
+    logger?: BasePluginContext['logger'];
+}

package/dist/umd/tools/hcs6/index.d.ts

@@ -0,0 +1,6 @@
+export * from './base-hcs6-tools';
+export * from './hcs6-tool-params';
+export * from './CreateDynamicRegistryTool';
+export * from './RegisterDynamicHashinalTool';
+export * from './UpdateDynamicHashinalTool';
+export * from './QueryDynamicRegistryTool';

package/dist/umd/tools/index.d.ts

@@ -1,3 +1,4 @@
 export * from './hcs10';
 export * from './hcs2';
+export * from './hcs6';
 export * from './inscriber';

package/dist/umd/tools/inscriber/InscribeFromBufferTool.d.ts

@@ -20,23 +20,23 @@ declare const inscribeFromBufferSchema: z.ZodObject<{
     base64Data: string;
     tags?: string[] | undefined;
     metadata?: Record<string, unknown> | undefined;
+    mimeType?: string | undefined;
     mode?: "file" | "hashinal" | undefined;
     chunkSize?: number | undefined;
     waitForConfirmation?: boolean | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
-    mimeType?: string | undefined;
 }, {
     fileName: string;
     base64Data: string;
     tags?: string[] | undefined;
     metadata?: Record<string, unknown> | undefined;
+    mimeType?: string | undefined;
     mode?: "file" | "hashinal" | undefined;
     chunkSize?: number | undefined;
     waitForConfirmation?: boolean | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
-    mimeType?: string | undefined;
 }>;
 /**
  * Tool for inscribing content from buffer
@@ -60,23 +60,23 @@ export declare class InscribeFromBufferTool extends BaseInscriberQueryTool<typeo
         base64Data: string;
         tags?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;
+        mimeType?: string | undefined;
         mode?: "file" | "hashinal" | undefined;
         chunkSize?: number | undefined;
         waitForConfirmation?: boolean | undefined;
         apiKey?: string | undefined;
         timeoutMs?: number | undefined;
-        mimeType?: string | undefined;
     }, {
         fileName: string;
         base64Data: string;
         tags?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;
+        mimeType?: string | undefined;
         mode?: "file" | "hashinal" | undefined;
         chunkSize?: number | undefined;
         waitForConfirmation?: boolean | undefined;
         apiKey?: string | undefined;
         timeoutMs?: number | undefined;
-        mimeType?: string | undefined;
     }>;
     protected executeQuery(params: z.infer<typeof inscribeFromBufferSchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraphonline/standards-agent-kit",
-  "version": "0.2.112",
+  "version": "0.2.113",
   "description": "A modular SDK for building on-chain autonomous agents using Hashgraph Online Standards, including HCS-10 for agent discovery and communication.",
   "type": "module",
   "main": "./dist/cjs/standards-agent-kit.cjs",

package/src/index.ts

@@ -2,6 +2,6 @@ export * from './tools';
 export * from './state';
 export * from './init';
 export * from './plugins';
-export { HCS10Builder, HCS2Builder, InscriberBuilder } from './builders';
+export { HCS10Builder, HCS2Builder, HCS6Builder, InscriberBuilder } from './builders';
 export type { ExecuteResult } from './builders';
 export { HCS10Client } from './hcs10';

package/src/tools/hcs6/CreateDynamicRegistryTool.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import type { TransactionResponse } from 'hedera-agent-kit';
+
+/**
+ * Schema for creating a dynamic hashinal registry
+ */
+const CreateDynamicRegistrySchema = z.object({
+  ttl: z.number()
+    .min(3600)
+    .default(86400)
+    .describe('Time-to-live in seconds (minimum 3600 seconds/1 hour)'),
+  adminKey: z.union([z.boolean(), z.string()])
+    .optional()
+    .describe('Admin key for the registry topic. Can be boolean (use operator key) or a public key string'),
+  submitKey: z.union([z.boolean(), z.string()])
+    .optional()
+    .describe('Submit key for the registry topic. Can be boolean (use operator key) or a public key string'),
+});
+
+export type CreateDynamicRegistryInput = z.infer<typeof CreateDynamicRegistrySchema>;
+
+/**
+ * Tool for creating HCS-6 dynamic registries
+ */
+export class CreateDynamicRegistryTool extends BaseHCS6TransactionTool<typeof CreateDynamicRegistrySchema> {
+  name = 'createDynamicRegistry';
+  description = 'Create a new HCS-6 dynamic registry for managing evolving content';
+  schema = CreateDynamicRegistrySchema;
+
+  constructor(params: HCS6TransactionToolParams) {
+    super(params);
+  }
+
+  protected async _call(
+    params: CreateDynamicRegistryInput
+  ): Promise<TransactionResponse> {
+    try {
+      const result = await this.hcs6Builder.createRegistry({
+        ttl: params.ttl,
+        adminKey: params.adminKey,
+        submitKey: params.submitKey,
+      });
+
+      if (!result.success) {
+        throw new Error(result.error || 'Failed to create dynamic registry');
+      }
+
+      return {
+        status: 'success',
+        data: {
+          topicId: result.topicId,
+          transactionId: result.transactionId,
+          ttl: params.ttl,
+          memo: `hcs-6:1:${params.ttl}`,
+        },
+      };
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+}

package/src/tools/hcs6/QueryDynamicRegistryTool.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import type { TransactionResponse } from 'hedera-agent-kit';
+
+/**
+ * Schema for querying a dynamic registry
+ */
+const QueryDynamicRegistrySchema = z.object({
+  topicId: z.string()
+    .describe('The registry topic ID to query'),
+  limit: z.number()
+    .optional()
+    .default(100)
+    .describe('Maximum number of entries to retrieve'),
+  order: z.enum(['asc', 'desc'])
+    .optional()
+    .default('desc')
+    .describe('Order of entries (desc shows latest first)'),
+  skip: z.number()
+    .optional()
+    .describe('Number of entries to skip'),
+});
+
+export type QueryDynamicRegistryInput = z.infer<typeof QueryDynamicRegistrySchema>;
+
+/**
+ * Tool for querying HCS-6 dynamic registries
+ */
+export class QueryDynamicRegistryTool extends BaseHCS6QueryTool<typeof QueryDynamicRegistrySchema> {
+  name = 'queryDynamicRegistry';
+  description = 'Query a dynamic registry to get the current state of a dynamic hashinal';
+  schema = QueryDynamicRegistrySchema;
+
+  constructor(params: HCS6QueryToolParams) {
+    super(params);
+  }
+
+  protected async _call(
+    params: QueryDynamicRegistryInput
+  ): Promise<TransactionResponse> {
+    try {
+      const registry = await this.hcs6Builder.getRegistry(params.topicId, {
+        limit: params.limit,
+        order: params.order,
+        skip: params.skip,
+      });
+
+      return {
+        status: 'success',
+        data: {
+          topicId: registry.topicId,
+          registryType: 'NON_INDEXED',
+          ttl: registry.ttl,
+          latestEntry: registry.latestEntry ? {
+            topicId: registry.latestEntry.message.t_id,
+            timestamp: registry.latestEntry.timestamp,
+            memo: registry.latestEntry.message.m,
+            sequence: registry.latestEntry.sequence,
+            payer: registry.latestEntry.payer,
+          } : null,
+          totalEntries: registry.entries.length,
+        },
+      };
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+}

package/src/tools/hcs6/RegisterDynamicHashinalTool.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import type { TransactionResponse } from 'hedera-agent-kit';
+
+/**
+ * Schema for registering a dynamic hashinal
+ */
+const RegisterDynamicHashinalSchema = z.object({
+  metadata: z.record(z.unknown())
+    .describe('Metadata object for the hashinal (e.g., name, description, attributes)'),
+  data: z.object({
+    base64: z.string().optional().describe('Base64 encoded data for the hashinal'),
+    url: z.string().optional().describe('URL to fetch data from'),
+    mimeType: z.string().optional().describe('MIME type of the data'),
+  }).optional()
+    .describe('Data to inscribe with the hashinal'),
+  memo: z.string()
+    .optional()
+    .describe('Optional memo for the registration'),
+  ttl: z.number()
+    .min(3600)
+    .default(86400)
+    .describe('Time-to-live in seconds for the inscription'),
+  registryTopicId: z.string()
+    .optional()
+    .describe('Registry topic ID to use. If not provided, a new registry will be created'),
+  submitKey: z.string()
+    .optional()
+    .describe('Submit key for the registry (required if registry has a submit key)'),
+});
+
+export type RegisterDynamicHashinalInput = z.infer<typeof RegisterDynamicHashinalSchema>;
+
+/**
+ * Tool for registering (creating) dynamic hashinals
+ */
+export class RegisterDynamicHashinalTool extends BaseHCS6TransactionTool<typeof RegisterDynamicHashinalSchema> {
+  name = 'registerDynamicHashinal';
+  description = 'Create and register a new dynamic hashinal that can be updated over time';
+  schema = RegisterDynamicHashinalSchema;
+
+  constructor(params: HCS6TransactionToolParams) {
+    super(params);
+  }
+
+  protected async _call(
+    params: RegisterDynamicHashinalInput
+  ): Promise<TransactionResponse> {
+    try {
+      const result = await this.hcs6Builder.register({
+        metadata: params.metadata,
+        data: params.data,
+        memo: params.memo,
+        ttl: params.ttl,
+        registryTopicId: params.registryTopicId,
+        submitKey: params.submitKey,
+      });
+
+      if (!result.success || !result.registryTopicId || !result.inscriptionTopicId) {
+        throw new Error(result.error || 'Failed to register dynamic hashinal');
+      }
+
+      return {
+        status: 'success',
+        data: {
+          registryTopicId: result.registryTopicId,
+          inscriptionTopicId: result.inscriptionTopicId,
+          transactionId: result.transactionId,
+        },
+      };
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+}