refactor(transactions): move TransactionValidator to forger

packages/constants/source/identifiers.ts

@@ -280,10 +280,6 @@ export const Identifiers = {
 	},
 	Transaction: {
 		Handler: Symbol("Transaction<Handler>"),
-		Validator: {
-			Factory: Symbol("Transaction<Validator.Factory>"),
-			Instance: Symbol("Transaction<Validator.Instance>"),
-		},
 	},
 	TransactionPool: {
 		API: {

packages/contracts/source/contracts/transactions.ts

@@ -1,5 +1,5 @@
 import type { Transaction, TransactionData } from "./crypto/index.js";
-import type { BlockContext, CommitKey, Instance, TransactionReceipt } from "./evm/index.js";
+import type { BlockContext, Instance, TransactionReceipt } from "./evm/index.js";
 import type { Wallet } from "./state/index.js";
 
 export type TransactionHandlerConstructor = new () => TransactionHandler;
@@ -36,17 +36,3 @@ export interface TransactionHandlerProvider {
 
 	registerHandlers(): void;
 }
-
-export interface TransactionValidatorContext {
-	commitKey: CommitKey;
-	gasLimit: number;
-	timestamp: number;
-	generatorAddress: string;
-}
-
-export interface TransactionValidator {
-	getEvm(): Instance;
-	validate(context: TransactionValidatorContext, transaction: Transaction): Promise<TransactionReceipt>;
-}
-
-export type TransactionValidatorFactory = () => TransactionValidator;

packages/forger/source/transaction-forger.ts

@@ -26,6 +26,10 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 	@inject(Identifiers.Cryptography.Configuration)
 	private readonly cryptoConfiguration!: Contracts.Crypto.Configuration;
 
+	@inject(Identifiers.Evm.Instance)
+	@tagged("instance", "validator")
+	private readonly evm!: Contracts.Evm.Instance;
+
 	@inject(Identifiers.State.Store)
 	protected readonly stateStore!: Contracts.State.Store;
 
@@ -35,8 +39,8 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 	@inject(Identifiers.BlockchainUtils.RoundCalculator)
 	private readonly roundCalculator!: Contracts.BlockchainUtils.RoundCalculator;
 
-	@inject(Identifiers.Transaction.Validator.Factory)
-	private readonly createTransactionValidator!: Contracts.Transactions.TransactionValidatorFactory;
+	@inject(Identifiers.Transaction.Handler)
+	private readonly transactionHandler!: Contracts.Transactions.TransactionHandler;
 
 	@inject(Identifiers.Services.Log.Service)
 	private readonly logger!: Contracts.Kernel.Logger;
@@ -50,8 +54,6 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 	#generatorAddress!: string;
 	#timestamp!: number;
 	#commitKey!: Contracts.Evm.CommitKey;
-	#validator!: Contracts.Transactions.TransactionValidator;
-	#evm!: Contracts.Evm.Instance;
 	#milestone!: Contracts.Crypto.Milestone;
 	#previousBlock!: Contracts.Crypto.Block;
 	#timeLimit!: number;
@@ -67,9 +69,6 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 		this.#timestamp = timestamp;
 		this.#commitKey = commitKey;
 
-		this.#validator = this.createTransactionValidator();
-		this.#evm = this.#validator.getEvm();
-
 		this.#milestone = this.cryptoConfiguration.getMilestone();
 		this.#previousBlock = this.stateStore.getLastBlock();
 
@@ -90,8 +89,8 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 		fee: bigint;
 	}> {
 		try {
-			await this.#evm.initializeGenesis(this.genesisInfo);
-			await this.#evm.prepareNextCommit({ commitKey: this.#commitKey });
+			await this.evm.initializeGenesis(this.genesisInfo);
+			await this.evm.prepareNextCommit({ commitKey: this.#commitKey });
 
 			const { fee, gasUsed, transactions } = await this.#processTransactions();
 
@@ -101,12 +100,12 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 			return {
 				fee,
 				gasUsed,
-				logsBloom: await this.#evm.logsBloom(this.#commitKey),
-				stateRoot: await this.#evm.stateRoot(this.#commitKey, this.#previousBlock.stateRoot),
+				logsBloom: await this.evm.logsBloom(this.#commitKey),
+				stateRoot: await this.evm.stateRoot(this.#commitKey, this.#previousBlock.stateRoot),
 				transactions,
 			};
 		} finally {
-			await this.#evm.dispose();
+			await this.evm.dispose();
 		}
 	}
 
@@ -157,7 +156,7 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 					`attempting optimistic execution of tx ${transaction.hash} (tx.gas=${transaction.gasLimit} gasLeft=${result.gasLeft})`,
 				);
 
-				await this.#evm.snapshot(this.#commitKey);
+				await this.evm.snapshot(this.#commitKey);
 			}
 
 			const validation = await this.#validateTransaction(transaction);
@@ -171,7 +170,7 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 				);
 
 				if (optimisticExecution) {
-					await this.#evm.rollback(this.#commitKey);
+					await this.evm.rollback(this.#commitKey);
 					return;
 				} else {
 					// In practice, this should never happen since the validator should reject transactions that exceed the block gas limit, but we check just in case.
@@ -190,12 +189,17 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 	}
 
 	async #validateTransaction(transaction: Contracts.Crypto.Transaction): Promise<Contracts.Evm.TransactionReceipt> {
-		return this.#validator.validate(
+		return await this.transactionHandler.apply(
 			{
-				commitKey: this.#commitKey,
-				gasLimit: this.#milestone.block.maxGasLimit,
-				generatorAddress: this.#generatorAddress,
-				timestamp: this.#timestamp,
+				evm: {
+					blockContext: {
+						commitKey: this.#commitKey,
+						gasLimit: BigInt(this.#milestone.block.maxGasLimit),
+						timestamp: BigInt(this.#timestamp),
+						validatorAddress: this.#generatorAddress,
+					},
+					instance: this.evm,
+				},
 			},
 			transaction,
 		);
@@ -209,7 +213,7 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 	}
 
 	async #updateRewardsAndVotes(): Promise<void> {
-		await this.#evm.updateRewardsAndVotes({
+		await this.evm.updateRewardsAndVotes({
 			blockReward: BigInt(this.#milestone.reward),
 			commitKey: this.#commitKey,
 			specId: this.#milestone.evmSpec,
@@ -222,7 +226,7 @@ export class TransactionForger implements Contracts.Forger.TransactionForger {
 		if (this.roundCalculator.isNewRound(this.#previousBlock.number + 2)) {
 			const { roundValidators } = this.cryptoConfiguration.getMilestone(this.#previousBlock.number + 2);
 
-			await this.#evm.calculateRoundValidators({
+			await this.evm.calculateRoundValidators({
 				commitKey: this.#commitKey,
 				roundValidators: BigInt(roundValidators),
 				specId: this.#milestone.evmSpec,

packages/forger/test/helpers/prepare-sandbox.ts

@@ -73,22 +73,22 @@ export const prepareSandbox = async (context: { app?: Application }): Promise<vo
 		getTransactionBytes: async () => [],
 	});
 
-	const validator = {
-		getEvm: () => ({
-			dispose: async () => {},
-			initializeGenesis: async () => {},
-			logsBloom: async () => "0".repeat(512),
-			prepareNextCommit: async () => {},
-			rollback: async () => {},
-			snapshot: async () => {},
-			stateRoot: async () => "0000000000000000000000000000000000000000000000000000000000000000",
-			updateRewardsAndVotes: async () => {},
-		}),
-		validate: async () => true,
+	const evm = {
+		dispose: async () => {},
+		initializeGenesis: async () => {},
+		logsBloom: async () => "0".repeat(512),
+		prepareNextCommit: async () => {},
+		rollback: async () => {},
+		snapshot: async () => {},
+		stateRoot: async () => "0000000000000000000000000000000000000000000000000000000000000000",
+		updateRewardsAndVotes: async () => {},
 	};
-	context.app.rebind(Identifiers.Transaction.Validator.Factory).toConstantValue(() => validator);
+	context.app.bind(Identifiers.Evm.Instance).toConstantValue(evm).whenTagged("instance", "validator");
+
+	context.app.rebind(Identifiers.Transaction.Handler).toConstantValue({
+		apply: async () => ({ gasRefunded: 0n, gasUsed: 0n, logs: [], status: 1 }),
+	});
 
-	context.app.bind(Identifiers.Evm.Instance).toConstantValue(() => {});
 	context.app.bind(EvmConsensusIdentifiers.Internal.GenesisInfo).toConstantValue({});
 
 	context.app.bind(Identifiers.State.Store).toConstantValue({

packages/transactions/source/service-provider.ts

@@ -1,25 +1,13 @@
-import type { Contracts } from "@mainsail/contracts";
-
 import { Identifiers } from "@mainsail/constants";
 import { injectable } from "@mainsail/container";
 import { Providers } from "@mainsail/kernel";
 
 import { TransactionHandler } from "./handlers/index.js";
-import { TransactionValidator } from "./transaction-validator.js";
 
 @injectable()
 export class ServiceProvider extends Providers.ServiceProvider {
 	public async register(): Promise<void> {
-		this.app.bind(Identifiers.Transaction.Validator.Instance).to(TransactionValidator);
-
 		this.app.bind(Identifiers.Transaction.Handler).to(TransactionHandler);
-
-		this.app
-			.bind<() => TransactionValidator>(Identifiers.Transaction.Validator.Factory)
-			.toFactory(
-				(context: Contracts.Kernel.Container.ResolutionContext) => () =>
-					context.get(Identifiers.Transaction.Validator.Instance),
-			);
 	}
 
 	public async required(): Promise<boolean> {

packages/validator/test/helpers/prepare-sandbox.ts

@@ -78,22 +78,22 @@ export const prepareSandbox = async (context: { app?: Application }): Promise<vo
 		}),
 	});
 
-	const validator = {
-		getEvm: () => ({
-			dispose: async () => {},
-			initializeGenesis: async () => {},
-			logsBloom: async () => "0".repeat(512),
-			prepareNextCommit: async () => {},
-			rollback: async () => {},
-			snapshot: async () => {},
-			stateRoot: async () => "0000000000000000000000000000000000000000000000000000000000000000",
-			updateRewardsAndVotes: async () => {},
-		}),
-		validate: async () => true,
+	const evm = {
+		dispose: async () => {},
+		initializeGenesis: async () => {},
+		logsBloom: async () => "0".repeat(512),
+		prepareNextCommit: async () => {},
+		rollback: async () => {},
+		snapshot: async () => {},
+		stateRoot: async () => "0000000000000000000000000000000000000000000000000000000000000000",
+		updateRewardsAndVotes: async () => {},
 	};
-	context.app.rebind(Identifiers.Transaction.Validator.Factory).toConstantValue(() => validator);
+	context.app.bind(Identifiers.Evm.Instance).toConstantValue(evm).whenTagged("instance", "validator");
+
+	context.app.rebind(Identifiers.Transaction.Handler).toConstantValue({
+		apply: async () => ({ gasRefunded: 0n, gasUsed: 0n, logs: [], status: 1 }),
+	});
 
-	context.app.bind(Identifiers.Evm.Instance).toConstantValue(() => {});
 	context.app.bind(EvmConsensusIdentifiers.Internal.GenesisInfo).toConstantValue({});
 
 	context.app.bind(Identifiers.State.Store).toConstantValue({