@aztec/simulator 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/public/fixtures/custom_bytecode_tester.ts

@@ -0,0 +1,49 @@
+import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+/**
+ *
+ * Test custom bytecode (simulation or proving) with the provided bytecode.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use (simulation or proving)
+ * @param txLabel - The label of the transaction
+ * @param contractName - The name of the contract (default: 'CustomBytecodeContract')
+ */
+export async function testCustomBytecode(
+  bytecode: Buffer,
+  tester: PublicTxSimulationTester,
+  txLabel: string,
+  contractName: string = 'CustomBytecodeContract',
+): Promise<PublicTxResult> {
+  const deployer = AztecAddress.fromNumber(42);
+
+  const contractArtifact = emptyContractArtifact();
+  contractArtifact.name = contractName;
+  contractArtifact.functions = [emptyFunctionArtifact()];
+  contractArtifact.functions[0].name = 'public_dispatch';
+  contractArtifact.functions[0].functionType = FunctionType.PUBLIC;
+  contractArtifact.functions[0].bytecode = bytecode;
+
+  const testContract = await tester.registerAndDeployContract(
+    /*constructorArgs=*/ [],
+    deployer,
+    /*contractArtifact=*/ contractArtifact,
+  );
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  return await tester.executeTxWithLabel(
+    /*txLabel=*/ txLabel,
+    /*sender=*/ deployer,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: testContract.address,
+        fnName: 'public_dispatch',
+        args: [],
+      },
+    ],
+  );
+}

package/src/public/fixtures/custom_bytecode_tests.ts

@@ -0,0 +1,135 @@
+import { strict as assert } from 'assert';
+
+import { TypeTag } from '../avm/avm_memory_types.js';
+import { Addressing, AddressingMode } from '../avm/opcodes/addressing_mode.js';
+import { CalldataCopy, Jump, Return, Set } from '../avm/opcodes/index.js';
+import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
+import {
+  MAX_OPCODE_VALUE,
+  Opcode,
+  OperandType,
+  getOperandSize,
+} from '../avm/serialization/instruction_serialization.js';
+import { testCustomBytecode } from './custom_bytecode_tester.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+// First instruction resolved a base address (offset 0) which is uninitialized and therefore
+// of invalid tag (FF). This will trigger an exceptional halt.
+export async function addressingWithBaseTagIssueTest(isIndirect: boolean, tester: PublicTxSimulationTester) {
+  const addressingMode = Addressing.fromModes([
+    isIndirect ? AddressingMode.INDIRECT_RELATIVE : AddressingMode.RELATIVE,
+    AddressingMode.DIRECT,
+    AddressingMode.DIRECT,
+  ]);
+
+  const bytecode = encodeToBytecode([
+    new CalldataCopy(/*indirect=*/ addressingMode.toWire(), /*copySize=*/ 1, /*cdOffset=*/ 0, /*dstOffset=*/ 0),
+    new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  ]);
+
+  const txLabel = isIndirect ? 'AddressingWithBaseTagInvalidIndirect' : 'AddressingWithBaseTagInvalidDirect';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+export async function pcOutOfRangeTest(tester: PublicTxSimulationTester) {
+  const bytecode = encodeToBytecode([
+    new Jump(/*jumpOffset=*/ 123), // Jump to out-of-range pc offset.
+    new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  ]);
+
+  const txLabel = 'PcOutOfRange';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+export async function invalidOpcodeTest(tester: PublicTxSimulationTester) {
+  let bytecode = encodeToBytecode([
+    new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+  ]);
+
+  const offsetReturnOpcodeByte = bytecode.length;
+
+  bytecode = Buffer.concat([
+    bytecode,
+    encodeToBytecode([new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)]),
+  ]);
+
+  // Manipulate the Return opcode to make the opcode invalid (out of range).
+  bytecode[offsetReturnOpcodeByte] = MAX_OPCODE_VALUE + 1; // opcode is invalid.
+
+  const txLabel = 'InvalidOpcode';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Single invalid byte in the bytecode.
+export async function invalidByteTest(tester: PublicTxSimulationTester) {
+  const invalidOpcode = MAX_OPCODE_VALUE + 7;
+  assert(invalidOpcode < 256, 'Invalid opcode must fit in a single byte');
+  const bytecode = Buffer.from([invalidOpcode]);
+
+  const txLabel = 'InvalidByte';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Truncate the last instruction in the bytecode.
+export async function instructionTruncatedTest(tester: PublicTxSimulationTester) {
+  let bytecode = encodeToBytecode([
+    new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+  ]);
+
+  // Truncate the bytecode.
+  bytecode = bytecode.subarray(0, -1);
+
+  const txLabel = 'InstructionTruncated';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Invalid tag value byte in an instruction.
+export async function invalidTagValueTest(tester: PublicTxSimulationTester) {
+  const bytecode = encodeToBytecode([
+    new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+    new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  ]);
+
+  const tagOffset = getTagOffsetInInstruction(Set.wireFormat8);
+  assert(bytecode[tagOffset].valueOf() == TypeTag.UINT32.valueOf(), 'Set instruction tag should be UINT32 in test');
+  bytecode[tagOffset] = TypeTag.INVALID;
+
+  const txLabel = 'InvalidTagValue';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Combine an invalid tag in the last instruction that is truncated.
+export async function invalidTagValueAndInstructionTruncatedTest(tester: PublicTxSimulationTester) {
+  let bytecode = encodeToBytecode([
+    // Important: value argument must be a bigint otherwise a type error will be thrown.
+    new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT128, /*value=*/ 0n).as(Opcode.SET_128, Set.wireFormat128),
+  ]);
+
+  // Truncate the bytecode.
+  bytecode = bytecode.subarray(0, -5);
+  const tagOffset = getTagOffsetInInstruction(Set.wireFormat128);
+  assert(bytecode[tagOffset].valueOf() == TypeTag.UINT128.valueOf(), 'Set instruction tag should be UINT128 in test');
+  bytecode[tagOffset] = 0x6f; // Invalid tag value.
+
+  const txLabel = 'InvalidTagValueAndInstructionTruncated';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+/**
+ * Returns the offset of the tag in an instruction.
+ * @details Loops over the wire format operand type entries until it finds the tag.
+ * Returns the byte offset of the tag based on each operand size that is passed.
+ *
+ * @param wireFormat array of operand types
+ * @returns byte offset of the tag
+ */
+function getTagOffsetInInstruction(wireFormat: OperandType[]): number {
+  let offset = 0;
+  for (const operand of wireFormat) {
+    if (operand === OperandType.TAG) {
+      break;
+    }
+    offset += getOperandSize(operand);
+  }
+  return offset;
+}

package/src/public/fixtures/index.ts

@@ -1,8 +1,9 @@
 export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
 export * from './simple_contract_data_source.js';
-export { readAvmMinimalPublicTxInputsFromFile, createAvmMinimalPublicTx } from './minimal_public_tx.js';
+export { readAvmMinimalPublicTxInputsFromFile, executeAvmMinimalPublicTx } from './minimal_public_tx.js';
 export { TestExecutorMetrics } from '../test_executor_metrics.js';
 export { ammTest } from './amm_test.js';
 export { bulkTest, megaBulkTest } from './bulk_test.js';
 export { tokenTest } from './token_test.js';
+export * from './custom_bytecode_tests.js';

package/src/public/fixtures/minimal_public_tx.ts

@@ -1,6 +1,5 @@
-import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
 import { AvmCircuitInputs } from '@aztec/stdlib/avm';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ProtocolContracts } from '@aztec/stdlib/tx';
 
 import avmMinimalCircuitInputsJson from '../../../artifacts/avm_minimal_inputs.json' with { type: 'json' };
 import { TypeTag } from '../avm/avm_memory_types.js';
@@ -8,13 +7,10 @@ import { Add, Return, Set } from '../avm/opcodes/index.js';
 import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
 import { Opcode } from '../avm/serialization/instruction_serialization.js';
 import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { testCustomBytecode } from './custom_bytecode_tester.js';
 import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
 
-export async function createAvmMinimalPublicTx(): Promise<PublicTxResult> {
-  const deployer = AztecAddress.fromNumber(42);
-
-  const simTester = await PublicTxSimulationTester.create();
-
+export async function executeAvmMinimalPublicTx(tester: PublicTxSimulationTester): Promise<PublicTxResult> {
   const minimalBytecode = encodeToBytecode([
     new Set(/*indirect*/ 0, /*dstOffset*/ 0, TypeTag.UINT32, /*value*/ 1).as(Opcode.SET_8, Set.wireFormat8),
     new Set(/*indirect*/ 0, /*dstOffset*/ 1, TypeTag.UINT32, /*value*/ 2).as(Opcode.SET_8, Set.wireFormat8),
@@ -22,32 +18,13 @@ export async function createAvmMinimalPublicTx(): Promise<PublicTxResult> {
     new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 2),
   ]);
 
-  const minimalContractArtifact = emptyContractArtifact();
-  minimalContractArtifact.name = 'MinimalContract';
-  minimalContractArtifact.functions = [emptyFunctionArtifact()];
-  minimalContractArtifact.functions[0].name = 'public_dispatch';
-  minimalContractArtifact.functions[0].functionType = FunctionType.PUBLIC;
-  minimalContractArtifact.functions[0].bytecode = minimalBytecode;
+  const result = await testCustomBytecode(minimalBytecode, tester, 'MinimalTx', 'AvmMinimalContract');
 
-  const minimalTestContract = await simTester.registerAndDeployContract(
-    /*constructorArgs=*/ [],
-    deployer,
-    /*contractArtifact=*/ minimalContractArtifact,
-  );
+  // Modify the protocol contracts to be all zeros
+  result.avmProvingRequest.inputs.hints.protocolContracts = ProtocolContracts.empty();
+  result.avmProvingRequest.inputs.publicInputs.protocolContracts = ProtocolContracts.empty();
 
-  return await simTester.simulateTx(
-    /*sender=*/ deployer,
-    /*setupCalls=*/ [],
-    /*appCalls=*/ [
-      {
-        address: minimalTestContract.address,
-        fnName: 'public_dispatch',
-        args: [],
-      },
-    ],
-    /*teardownCall=*/ undefined,
-    /*feePayer=*/ deployer,
-  );
+  return result;
 }
 
 /**

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -16,8 +16,10 @@ import {
   getFunctionSelector,
 } from '../avm/fixtures/utils.js';
 import { PublicContractsDB } from '../public_db_sources.js';
+import { MeasuredCppPublicTxSimulatorHintedDbs } from '../public_tx_simulator/cpp_public_tx_simulator.js';
 import { MeasuredPublicTxSimulator } from '../public_tx_simulator/measured_public_tx_simulator.js';
 import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import type { MeasuredPublicTxSimulatorInterface } from '../public_tx_simulator/public_tx_simulator_interface.js';
 import { TestExecutorMetrics } from '../test_executor_metrics.js';
 import { SimpleContractDataSource } from './simple_contract_data_source.js';
 import { type TestPrivateInsertions, createTxForPublicCalls } from './utils.js';
@@ -40,7 +42,7 @@ export type TestEnqueuedCall = {
  */
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   protected txCount: number = 0;
-  private simulator: MeasuredPublicTxSimulator;
+  private simulator: MeasuredPublicTxSimulatorInterface;
   private metricsPrefix?: string;
 
   constructor(
@@ -48,28 +50,30 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     contractDataSource: SimpleContractDataSource,
     globals: GlobalVariables = defaultGlobals(),
     private metrics: TestExecutorMetrics = new TestExecutorMetrics(),
+    useCppSimulator: boolean = false,
   ) {
     super(contractDataSource, merkleTree);
 
     const contractsDB = new PublicContractsDB(contractDataSource);
-    this.simulator = new MeasuredPublicTxSimulator(
-      merkleTree,
-      contractsDB,
-      globals,
-      /*doMerkleOperations=*/ true,
-      /*skipFeeEnforcement=*/ false,
-      /*clientInitiatedSimulation=*/ true,
-      this.metrics,
-    );
+    const config = {
+      doMerkleOperations: true,
+      skipFeeEnforcement: false,
+      clientInitiatedSimulation: true,
+    };
+    this.simulator = useCppSimulator
+      ? new MeasuredCppPublicTxSimulatorHintedDbs(merkleTree, contractsDB, globals, this.metrics, config)
+      : new MeasuredPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
   }
 
   public static async create(
+    worldStateService: NativeWorldStateService, // make sure to close this later
     globals: GlobalVariables = defaultGlobals(),
     metrics: TestExecutorMetrics = new TestExecutorMetrics(),
+    useCppSimulator = false,
   ): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
-    const merkleTree = await (await NativeWorldStateService.tmp()).fork();
-    return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics);
+    const merkleTree = await worldStateService.fork();
+    return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics, useCppSimulator);
   }
 
   public setMetricsPrefix(prefix: string) {

package/src/public/fixtures/utils.ts

@@ -153,7 +153,7 @@ export async function createTxForPublicCalls(
 
   return await Tx.create({
     data: txData,
-    clientIvcProof: ClientIvcProof.empty(),
+    clientIvcProof: ClientIvcProof.random(),
     contractClassLogFields: [],
     publicFunctionCalldata: calldata,
   });

package/src/public/hinting_db_sources.ts

@@ -40,6 +40,7 @@ import {
 } from '@aztec/stdlib/trees';
 import { TreeSnapshots } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
+import type { WorldStateRevision } from '@aztec/stdlib/world-state';
 
 import { strict as assert } from 'assert';
 
@@ -449,6 +450,10 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
     return this.db.getInitialHeader();
   }
 
+  public getRevision(): WorldStateRevision {
+    return this.db.getRevision();
+  }
+
   public async updateArchive(header: any): Promise<void> {
     return await this.db.updateArchive(header);
   }

package/src/public/index.ts

@@ -1,5 +1,10 @@
 export { PublicContractsDB } from './public_db_sources.js';
 export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
-export { PublicTxSimulator, TelemetryPublicTxSimulator, type PublicTxResult } from './public_tx_simulator/index.js';
+export {
+  PublicTxSimulator,
+  type PublicTxSimulatorConfig,
+  TelemetryPublicTxSimulator,
+  type PublicTxResult,
+} from './public_tx_simulator/index.js';
 export { getCallRequestsWithCalldataByPhase } from './utils.js';

package/src/public/public_db_sources.ts

@@ -1,4 +1,9 @@
-import { NULLIFIER_SUBTREE_HEIGHT, PUBLIC_DATA_SUBTREE_HEIGHT } from '@aztec/constants';
+import {
+  L1_TO_L2_MSG_TREE_LEAF_COUNT,
+  NOTE_HASH_TREE_LEAF_COUNT,
+  NULLIFIER_SUBTREE_HEIGHT,
+  PUBLIC_DATA_SUBTREE_HEIGHT,
+} from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -27,7 +32,10 @@ import {
 import { TreeSnapshots, type Tx } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
+import { strict as assert } from 'assert';
+
 import type { PublicContractsDBInterface, PublicStateDBInterface } from './db_interfaces.js';
+import { L1ToL2MessageIndexOutOfRangeError, NoteHashIndexOutOfRangeError } from './side_effect_errors.js';
 import { TxContractCache } from './tx_contract_cache.js';
 
 /**
@@ -323,9 +331,13 @@ export class PublicTreesDB implements PublicStateDBInterface {
     } satisfies PublicDBAccessStats);
   }
 
-  public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined> {
+  public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr> {
     const timer = new Timer();
+    if (leafIndex > L1_TO_L2_MSG_TREE_LEAF_COUNT) {
+      throw new L1ToL2MessageIndexOutOfRangeError(Number(leafIndex));
+    }
     const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    assert(leafValue !== undefined, 'Unexpected null response from l1 to l2 message tree');
     // TODO: We need this for the hints. See class comment for more details.
     await this.db.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
 
@@ -337,9 +349,13 @@ export class PublicTreesDB implements PublicStateDBInterface {
     return leafValue;
   }
 
-  public async getNoteHash(leafIndex: bigint): Promise<Fr | undefined> {
+  public async getNoteHash(leafIndex: bigint): Promise<Fr> {
     const timer = new Timer();
+    if (leafIndex > NOTE_HASH_TREE_LEAF_COUNT) {
+      throw new NoteHashIndexOutOfRangeError(Number(leafIndex));
+    }
     const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+    assert(leafValue !== undefined, 'Unexpected null response from note hash tree');
     // TODO: We need this for the hints. See class comment for more details.
     await this.db.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
 

package/src/public/public_errors.ts

@@ -0,0 +1,14 @@
+/**
+ * Any known (and checked) error that can be thrown during public execution.
+ * Includes AvmExecutionErrors and SideEffectErrors.
+ *
+ * AvmSimulator catches any checked errors before returning a boolean "reverted".
+ * Unchecked errors are generally the result of a bug. They are propagated and
+ * ultimately will be the resonsibility of PublicProcessor to handle.
+ */
+export abstract class CheckedPublicExecutionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CheckedPublicExecutionError';
+  }
+}

package/src/public/public_processor/guarded_merkle_tree.ts

@@ -11,6 +11,7 @@ import type {
   TreeInfo,
 } from '@aztec/stdlib/trees';
 import type { BlockHeader, StateReference } from '@aztec/stdlib/tx';
+import type { WorldStateRevision } from '@aztec/stdlib/world-state';
 
 /**
  * Wraps an instance of `MerkleTreeWriteOperations` to allow the sequencer to gate access.
@@ -88,6 +89,9 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
   getInitialHeader(): BlockHeader {
     return this.target.getInitialHeader();
   }
+  public getRevision(): WorldStateRevision {
+    return this.target.getRevision();
+  }
   getSiblingPath<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<SiblingPath<TreeHeights[ID]>> {
     return this.guardAndPush(() => this.target.getSiblingPath(treeId, index));
   }

package/src/public/public_processor/public_processor.ts

@@ -27,7 +27,6 @@ import {
   StateReference,
   Tx,
   TxExecutionPhase,
-  type TxValidator,
   makeProcessedTxFromPrivateOnlyTx,
   makeProcessedTxFromTxWithPublicCalls,
 } from '@aztec/stdlib/tx';
@@ -41,8 +40,14 @@ import {
 } from '@aztec/telemetry-client';
 import { ForkCheckpoint } from '@aztec/world-state/native';
 
+import { AssertionError } from 'assert';
+
 import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
-import { type PublicTxSimulator, TelemetryPublicTxSimulator } from '../public_tx_simulator/index.js';
+import {
+  type PublicTxSimulator,
+  type PublicTxSimulatorConfig,
+  TelemetryPublicTxSimulator,
+} from '../public_tx_simulator/index.js';
 import { GuardedMerkleTreeOperations } from './guarded_merkle_tree.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
 
@@ -58,7 +63,6 @@ export class PublicProcessorFactory {
 
   /**
    * Creates a new instance of a PublicProcessor.
-   * @param historicalHeader - The header of a block previous to the one in which the tx is included.
    * @param globalVariables - The global variables for the block being processed.
    * @param skipFeeEnforcement - Allows disabling balance checks for fee estimations.
    * @returns A new instance of a PublicProcessor.
@@ -66,20 +70,23 @@ export class PublicProcessorFactory {
   public create(
     merkleTree: MerkleTreeWriteOperations,
     globalVariables: GlobalVariables,
-    skipFeeEnforcement: boolean,
-    clientInitiatedSimulation: boolean = false,
+    config: {
+      skipFeeEnforcement: boolean;
+      clientInitiatedSimulation: boolean;
+      proverId?: Fr;
+      maxDebugLogMemoryReads?: number;
+    },
   ): PublicProcessor {
     const contractsDB = new PublicContractsDB(this.contractDataSource);
 
     const guardedFork = new GuardedMerkleTreeOperations(merkleTree);
-    const publicTxSimulator = this.createPublicTxSimulator(
-      guardedFork,
-      contractsDB,
-      globalVariables,
-      /*doMerkleOperations=*/ true,
-      skipFeeEnforcement,
-      clientInitiatedSimulation,
-    );
+    const publicTxSimulator = this.createPublicTxSimulator(guardedFork, contractsDB, globalVariables, {
+      proverId: config.proverId,
+      doMerkleOperations: true,
+      skipFeeEnforcement: config.skipFeeEnforcement,
+      clientInitiatedSimulation: config.clientInitiatedSimulation,
+      maxDebugLogMemoryReads: config.maxDebugLogMemoryReads,
+    });
 
     return new PublicProcessor(
       globalVariables,
@@ -95,19 +102,9 @@ export class PublicProcessorFactory {
     merkleTree: MerkleTreeWriteOperations,
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
-    doMerkleOperations: boolean,
-    skipFeeEnforcement: boolean,
-    clientInitiatedSimulation: boolean,
+    config?: Partial<PublicTxSimulatorConfig>,
   ): PublicTxSimulator {
-    return new TelemetryPublicTxSimulator(
-      merkleTree,
-      contractsDB,
-      globalVariables,
-      doMerkleOperations,
-      skipFeeEnforcement,
-      clientInitiatedSimulation,
-      this.telemetryClient,
-    );
+    return new TelemetryPublicTxSimulator(merkleTree, contractsDB, globalVariables, this.telemetryClient, config);
   }
 }
 
@@ -154,7 +151,7 @@ export class PublicProcessor implements Traceable {
     limits: PublicProcessorLimits = {},
     validator: PublicProcessorValidator = {},
   ): Promise<[ProcessedTx[], FailedTx[], Tx[], NestedProcessReturnValues[]]> {
-    const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
+    const { maxTransactions, maxBlockSize, deadline, maxBlockGas, maxBlobFields } = limits;
     const { preprocessValidator, nullifierCache } = validator;
     const result: ProcessedTx[] = [];
     const usedTxs: Tx[] = [];
@@ -165,6 +162,7 @@ export class PublicProcessor implements Traceable {
     let returns: NestedProcessReturnValues[] = [];
     let totalPublicGas = new Gas(0, 0);
     let totalBlockGas = new Gas(0, 0);
+    let totalBlobFields = 0;
 
     for await (const origTx of txs) {
       // Only process up to the max tx limit
@@ -252,6 +250,23 @@ export class PublicProcessor implements Traceable {
           continue;
         }
 
+        // If the actual blob fields of this tx would exceed the limit, skip it
+        const txBlobFields = processedTx.txEffect.toBlobFields().length;
+        if (maxBlobFields !== undefined && totalBlobFields + txBlobFields > maxBlobFields) {
+          this.log.debug(
+            `Skipping processed tx ${txHash} with ${txBlobFields} blob fields due to max blob fields limit.`,
+            {
+              txHash,
+              txBlobFields,
+              totalBlobFields,
+              maxBlobFields,
+            },
+          );
+          // Need to revert the checkpoint here and don't go any further
+          await checkpoint.revert();
+          continue;
+        }
+
         // FIXME(fcarreiro): it's ugly to have to notify the validator of nullifiers.
         // I'd rather pass the validators the processedTx as well and let them deal with it.
         nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
@@ -262,6 +277,7 @@ export class PublicProcessor implements Traceable {
         totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
         totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
         totalSizeInBytes += txSize;
+        totalBlobFields += txBlobFields;
       } catch (err: any) {
         if (err?.name === 'PublicProcessorTimeoutError') {
           this.log.warn(`Stopping tx processing due to timeout.`);
@@ -292,7 +308,7 @@ export class PublicProcessor implements Traceable {
         // Roll back state to start of TX before proceeding to next TX
         await checkpoint.revert();
         await this.guardedMerkleTree.getUnderlyingFork().revertAllCheckpoints();
-        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+        const errorMessage = err instanceof Error || err instanceof AssertionError ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${txHash.toString()}: ${errorMessage} ${err?.stack}`);
         failed.push({ tx, error: err instanceof Error ? err : new Error(errorMessage) });
         returns.push(new NestedProcessReturnValues([]));
@@ -366,10 +382,7 @@ export class PublicProcessor implements Traceable {
     return [processedTx, returnValues ?? []];
   }
 
-  private async doTreeInsertionsForPrivateOnlyTx(
-    processedTx: ProcessedTx,
-    txValidator?: TxValidator<ProcessedTx>,
-  ): Promise<void> {
+  private async doTreeInsertionsForPrivateOnlyTx(processedTx: ProcessedTx): Promise<void> {
     const treeInsertionStart = process.hrtime.bigint();
 
     // Update the state so that the next tx in the loop has the correct .startState
@@ -388,14 +401,8 @@ export class PublicProcessor implements Traceable {
         padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
         NULLIFIER_SUBTREE_HEIGHT,
       );
-    } catch {
-      if (txValidator) {
-        // Ideally the validator has already caught this above, but just in case:
-        throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);
-      } else {
-        // We have no validator and assume this call should blindly process txs with duplicates being caught later
-        this.log.warn(`Detected duplicate nullifier after public processing for: ${processedTx.hash}.`);
-      }
+    } catch (cause) {
+      throw new Error(`Transaction ${processedTx.hash} failed with duplicate nullifiers`, { cause });
     }
 
     const treeInsertionEnd = process.hrtime.bigint();