feat(1541): batch plugin commands implementation

src/core/core-api/core-api.interface.ts

@@ -4,6 +4,7 @@
  */
 import type { AccountService } from '@/core/services/account/account-transaction-service.interface';
 import type { AliasService } from '@/core/services/alias/alias-service.interface';
+import type { BatchTransactionService } from '@/core/services/batch/batch-transaction-service.interface';
 import type { ConfigService } from '@/core/services/config/config-service.interface';
 import type { ContractCompilerService } from '@/core/services/contract-compiler/contract-compiler-service.interface';
 import type { ContractQueryService } from '@/core/services/contract-query/contract-query-service.interface';
@@ -109,4 +110,5 @@ export interface CoreApi {
   contractVerifier: ContractVerifierService;
   contractQuery: ContractQueryService;
   identityResolution: IdentityResolutionService;
+  batch: BatchTransactionService;
 }

src/core/core-api/core-api.ts

@@ -5,6 +5,7 @@
 import type { CoreApi } from '@/core';
 import type { AccountService } from '@/core/services/account/account-transaction-service.interface';
 import type { AliasService } from '@/core/services/alias/alias-service.interface';
+import type { BatchTransactionService } from '@/core/services/batch/batch-transaction-service.interface';
 import type { ConfigService } from '@/core/services/config/config-service.interface';
 import type { ContractCompilerService } from '@/core/services/contract-compiler/contract-compiler-service.interface';
 import type { ContractQueryService } from '@/core/services/contract-query/contract-query-service.interface';
@@ -30,6 +31,7 @@ import type { TxSignService } from '@/core/services/tx-sign/tx-sign-service.inte
 
 import { AccountServiceImpl } from '@/core/services/account/account-transaction-service';
 import { AliasServiceImpl } from '@/core/services/alias/alias-service';
+import { BatchTransactionServiceImpl } from '@/core/services/batch/batch-transaction-service';
 import { ConfigServiceImpl } from '@/core/services/config/config-service';
 import { ContractCompilerServiceImpl } from '@/core/services/contract-compiler/contract-compiler-service';
 import { ContractQueryServiceImpl } from '@/core/services/contract-query/contract-query-service';
@@ -72,6 +74,7 @@ export class CoreApiImplementation implements CoreApi {
   public contractVerifier: ContractVerifierService;
   public contractQuery: ContractQueryService;
   public identityResolution: IdentityResolutionService;
+  public batch: BatchTransactionService;
 
   constructor(storageDir?: string) {
     this.logger = new LoggerService();
@@ -128,6 +131,7 @@ export class CoreApiImplementation implements CoreApi {
       this.alias,
       this.mirror,
     );
+    this.batch = new BatchTransactionServiceImpl(this.logger);
   }
 }
 

src/core/plugins/plugin-manager.ts

@@ -366,8 +366,10 @@ export class PluginManager {
     let result: CommandResult;
     if (commandSpec.command) {
       result = await commandSpec.command.execute(handlerArgs);
-    } else {
+    } else if (commandSpec.handler) {
       result = await commandSpec.handler(handlerArgs);
+    } else {
+      throw new InternalError('Command handler not found');
     }
     const outputSchema = result.overrideSchema ?? commandSpec.output.schema;
     outputSchema.parse(result.result);

src/core/plugins/plugin.types.ts

@@ -61,7 +61,7 @@ export interface CommandSpec {
   description: string;
   options?: CommandOption[];
   command?: Command;
-  handler: CommandHandler;
+  handler?: CommandHandler;
   output: CommandOutputSpec;
   excessArguments?: boolean;
   registeredHooks?: string[];

src/core/services/batch/batch-transaction-service.interface.ts

@@ -0,0 +1,10 @@
+import type {
+  CreateBatchTransactionParams,
+  CreateBatchTransactionResult,
+} from '@/core/services/batch/types';
+
+export interface BatchTransactionService {
+  createBatchTransaction(
+    params: CreateBatchTransactionParams,
+  ): CreateBatchTransactionResult;
+}

src/core/services/batch/batch-transaction-service.ts

@@ -0,0 +1,31 @@
+import type { BatchTransactionService } from '@/core/services/batch/batch-transaction-service.interface';
+import type {
+  CreateBatchTransactionParams,
+  CreateBatchTransactionResult,
+} from '@/core/services/batch/types';
+import type { Logger } from '@/core/services/logger/logger-service.interface';
+
+import { BatchTransaction } from '@hashgraph/sdk';
+
+export class BatchTransactionServiceImpl implements BatchTransactionService {
+  private logger: Logger;
+
+  constructor(logger: Logger) {
+    this.logger = logger;
+  }
+
+  createBatchTransaction(
+    params: CreateBatchTransactionParams,
+  ): CreateBatchTransactionResult {
+    this.logger.debug(
+      `[BATCH TX] Creating batch transaction with ${params.transactions.length} inner transactions`,
+    );
+    const batchTransaction = new BatchTransaction();
+    params.transactions.forEach((tx) => {
+      batchTransaction.addInnerTransaction(tx);
+    });
+    return {
+      transaction: batchTransaction,
+    };
+  }
+}

src/core/services/batch/types.ts

@@ -0,0 +1,10 @@
+import type { BatchTransaction, Transaction } from '@hashgraph/sdk';
+
+export interface CreateBatchTransactionResult {
+  transaction: BatchTransaction;
+}
+
+// Parameter types for account operations
+export interface CreateBatchTransactionParams {
+  transactions: Transaction[];
+}

src/core/services/mirrornode/hedera-mirrornode-service.ts

@@ -358,7 +358,6 @@ export class HederaMirrornodeServiceDefaultImpl implements HederaMirrornodeServi
 
   async getTopicInfo(topicId: string): Promise<TopicInfo> {
     const url = `${this.getBaseUrl()}/topics/${topicId}`;
-    console.log(url);
     try {
       const response = await fetch(url);
 

src/core/shared/config/cli-options.ts

@@ -1,6 +1,7 @@
 import type { PluginManifest } from '@/core/plugins/plugin.types';
 
 import accountPluginManifest from '@/plugins/account/manifest';
+import batchPluginManifest from '@/plugins/batch/manifest';
 import configPluginManifest from '@/plugins/config/manifest';
 import contractPluginManifest from '@/plugins/contract/manifest';
 import contractErc20PluginManifest from '@/plugins/contract-erc20/manifest';
@@ -38,6 +39,7 @@ export const RESERVED_SHORT_OPTIONS = new Set<string>([
 
 export const DEFAULT_PLUGIN_STATE: PluginManifest[] = [
   accountPluginManifest,
+  batchPluginManifest,
   tokenPluginManifest,
   networkPluginManifest,
   pluginManagementManifest,

src/plugins/batch/commands/create/handler.ts

@@ -0,0 +1,52 @@
+/**
+ * Batch Create Command Handler
+ */
+import type { CommandHandlerArgs, CommandResult } from '@/core';
+import type { Command } from '@/core/commands/command.interface';
+import type { KeyManagerName } from '@/core/services/kms/kms-types.interface';
+import type { CreateBatchOutput } from './output';
+
+import { ValidationError } from '@/core/errors';
+import { ZustandBatchStateHelper } from '@/plugins/batch/zustand-state-helper';
+
+import { CreateBatchInputSchema } from './input';
+
+export class CreateBatchCommand implements Command {
+  async execute(args: CommandHandlerArgs): Promise<CommandResult> {
+    const { api, logger } = args;
+
+    const batchState = new ZustandBatchStateHelper(api.state, logger);
+    const validArgs = CreateBatchInputSchema.parse(args.args);
+
+    if (batchState.hasBatch(validArgs.name)) {
+      throw new ValidationError(
+        `Batch with name '${validArgs.name}' already exists`,
+      );
+    }
+
+    const keyManager =
+      validArgs.keyManager ||
+      api.config.getOption<KeyManagerName>('default_key_manager');
+
+    const resolved = await api.keyResolver.resolveSigningKey(
+      validArgs.key,
+      keyManager,
+      ['batch:signer'],
+    );
+
+    const batchData = {
+      name: validArgs.name,
+      keyRefId: resolved.keyRefId,
+      transactions: [],
+    };
+
+    batchState.saveBatch(validArgs.name, batchData);
+
+    const outputData: CreateBatchOutput = {
+      name: batchData.name,
+      keyRefId: batchData.keyRefId,
+    };
+
+    return { result: outputData };
+  }
+}

src/plugins/batch/commands/create/index.ts

@@ -0,0 +1,3 @@
+export { CreateBatchCommand } from './handler';
+export type { CreateBatchOutput } from './output';
+export { CREATE_BATCH_TEMPLATE, CreateBatchOutputSchema } from './output';

src/plugins/batch/commands/create/input.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+import {
+  AliasNameSchema,
+  KeyManagerTypeSchema,
+  PrivateKeySchema,
+} from '@/core/schemas';
+
+/**
+ * Input schema for batch create command
+ */
+export const CreateBatchInputSchema = z.object({
+  name: AliasNameSchema.describe('Batch name'),
+  key: PrivateKeySchema.describe(
+    'Key to sign transactions in the batch. Can be {accountId}:{privateKey} pair, account private key in {ed25519|ecdsa}:private:{private-key} format, key reference or account alias',
+  ),
+  keyManager: KeyManagerTypeSchema.optional().describe(
+    'Key manager type (defaults to config setting)',
+  ),
+});
+
+export type CreateBatchInput = z.infer<typeof CreateBatchInputSchema>;

src/plugins/batch/commands/create/output.ts

@@ -0,0 +1,23 @@
+/**
+ * Create Batch Command Output Schema and Template
+ */
+import { z } from 'zod';
+
+/**
+ * Create Batch Command Output Schema
+ */
+export const CreateBatchOutputSchema = z.object({
+  name: z.string().describe('Batch name'),
+  keyRefId: z.string().describe('Key reference ID for signing'),
+});
+
+export type CreateBatchOutput = z.infer<typeof CreateBatchOutputSchema>;
+
+/**
+ * Human-readable template for create batch output
+ */
+export const CREATE_BATCH_TEMPLATE = `
+✅ Batch created successfully
+   Name: {{name}}
+   Batch Key Reference ID: {{keyRefId}}
+`.trim();

src/plugins/batch/commands/execute/handler.ts

@@ -0,0 +1,124 @@
+/**
+ * Batch Execute Command Handler
+ */
+import type {
+  CommandHandlerArgs,
+  CommandResult,
+  TransactionResult,
+} from '@/core';
+import type {
+  BatchBuildTransactionResult,
+  BatchNormalisedParams,
+  BatchSignTransactionResult,
+} from '@/plugins/batch/commands/execute/types';
+import type { ExecuteBatchOutput } from './output';
+
+import { Transaction } from '@hashgraph/sdk';
+
+import { BaseTransactionCommand } from '@/core/commands/command';
+import { NotFoundError, TransactionError } from '@/core/errors';
+import { composeKey } from '@/core/utils/key-composer';
+import { ZustandBatchStateHelper } from '@/plugins/batch/zustand-state-helper';
+
+import { ExecuteBatchInputSchema } from './input';
+
+export class ExecuteBatchCommand extends BaseTransactionCommand<
+  BatchNormalisedParams,
+  BatchBuildTransactionResult,
+  BatchSignTransactionResult,
+  TransactionResult
+> {
+  async normalizeParams(
+    args: CommandHandlerArgs,
+  ): Promise<BatchNormalisedParams> {
+    const { api, logger } = args;
+    const batchState = new ZustandBatchStateHelper(api.state, logger);
+    const validArgs = ExecuteBatchInputSchema.parse(args.args);
+    const name = validArgs.name;
+    const network = api.network.getCurrentNetwork();
+    const key = composeKey(network, name);
+    const batchData = batchState.getBatch(key);
+    if (!batchData) {
+      throw new NotFoundError(`Batch not found: ${validArgs.name}`);
+    }
+    return {
+      name,
+      network,
+      batchData,
+    };
+  }
+  async buildTransaction(
+    args: CommandHandlerArgs,
+    normalisedParams: BatchNormalisedParams,
+  ): Promise<BatchBuildTransactionResult> {
+    void normalisedParams;
+    const { api } = args;
+    const innerTransactions = [...normalisedParams.batchData.transactions]
+      .sort((a, b) => a.order - b.order)
+      .map((txItem) => {
+        return Transaction.fromBytes(
+          //@todo ensure that transaction will be stored in hex format
+          Uint8Array.from(Buffer.from(txItem.transactionBytes, 'hex')),
+        );
+      });
+    const result = api.batch.createBatchTransaction({
+      transactions: innerTransactions,
+    });
+    return { transaction: result.transaction };
+  }
+  async signTransaction(
+    args: CommandHandlerArgs,
+    normalisedParams: BatchNormalisedParams,
+    buildTransactionResult: BatchBuildTransactionResult,
+  ): Promise<BatchSignTransactionResult> {
+    const { api } = args;
+    void normalisedParams;
+    const batchKey = normalisedParams.batchData.keyRefId;
+    const signedTransaction = await api.txSign.sign(
+      buildTransactionResult.transaction,
+      [batchKey],
+    );
+    return {
+      transaction: signedTransaction,
+    };
+  }
+  async executeTransaction(
+    args: CommandHandlerArgs,
+    normalisedParams: BatchNormalisedParams,
+    buildTransactionResult: BatchBuildTransactionResult,
+    signTransactionResult: BatchSignTransactionResult,
+  ): Promise<TransactionResult> {
+    void normalisedParams;
+    void buildTransactionResult;
+    const { api } = args;
+    const result = await api.txExecute.execute(
+      signTransactionResult.transaction,
+    );
+    if (!result.success) {
+      throw new TransactionError(
+        `Failed to execute batch (txId: ${result.transactionId})`,
+        false,
+      );
+    }
+    return result;
+  }
+  async outputPreparation(
+    args: CommandHandlerArgs,
+    normalisedParams: BatchNormalisedParams,
+    buildTransactionResult: BatchBuildTransactionResult,
+    signTransactionResult: BatchSignTransactionResult,
+    executeTransactionResult: TransactionResult,
+  ): Promise<CommandResult> {
+    void args;
+    void buildTransactionResult;
+    void signTransactionResult;
+    const outputData: ExecuteBatchOutput = {
+      batchName: normalisedParams.name,
+      transactionId: executeTransactionResult?.transactionId || '',
+      success: executeTransactionResult?.success || false,
+      network: normalisedParams.network,
+    };
+
+    return { result: outputData };
+  }
+}

src/plugins/batch/commands/execute/index.ts

@@ -0,0 +1,3 @@
+export { ExecuteBatchCommand } from './handler';
+export type { ExecuteBatchOutput } from './output';
+export { EXECUTE_BATCH_TEMPLATE, ExecuteBatchOutputSchema } from './output';

src/plugins/batch/commands/execute/input.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+import { AliasNameSchema } from '@/core/schemas';
+
+/**
+ * Input schema for batch execute command
+ */
+export const ExecuteBatchInputSchema = z.object({
+  name: AliasNameSchema.describe('Batch name'),
+});
+
+export type ExecuteBatchInput = z.infer<typeof ExecuteBatchInputSchema>;