@aztec/sequencer-client 0.26.3 → 0.26.6

package/src/block_builder/solo_block_builder.ts

@@ -1,4 +1,5 @@
-import { Body, ContractData, L2Block, MerkleTreeId, PublicDataWrite, TxEffect, TxL2Logs } from '@aztec/circuit-types';
+import { Body, L2Block, MerkleTreeId, TxEffect } from '@aztec/circuit-types';
+import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
@@ -6,13 +7,10 @@ import {
   BaseRollupInputs,
   CONTRACT_SUBTREE_HEIGHT,
   CONTRACT_SUBTREE_SIBLING_PATH_LENGTH,
-  CombinedAccumulatedData,
   ConstantRollupData,
   GlobalVariables,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
-  MAX_NEW_CONTRACTS_PER_TX,
-  MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_PUBLIC_DATA_READS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
@@ -39,8 +37,6 @@ import {
   RollupTypes,
   RootRollupInputs,
   RootRollupPublicInputs,
-  SideEffect,
-  SideEffectLinkedToNoteHash,
   StateDiffHints,
   StateReference,
   VK_TREE_HEIGHT,
@@ -52,13 +48,15 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { elapsed } from '@aztec/foundation/timer';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 import chunk from 'lodash.chunk';
+import { inspect } from 'util';
 
 import { VerificationKeys } from '../mocks/verification_keys.js';
 import { RollupProver } from '../prover/index.js';
-import { ProcessedTx } from '../sequencer/processed_tx.js';
+import { ProcessedTx, toTxEffect } from '../sequencer/processed_tx.js';
 import { RollupSimulator } from '../simulator/index.js';
 import { BlockBuilder } from './index.js';
 import { TreeNames } from './types.js';
@@ -105,30 +103,7 @@ export class SoloBlockBuilder implements BlockBuilder {
     const [circuitsOutput, proof] = await this.runCircuits(globalVariables, txs, newL1ToL2Messages);
 
     // Collect all new nullifiers, commitments, and contracts from all txs in this block
-    const txEffects: TxEffect[] = txs.map(
-      tx =>
-        new TxEffect(
-          tx.data.combinedData.newNoteHashes.map((c: SideEffect) => c.value) as Tuple<
-            Fr,
-            typeof MAX_NEW_NOTE_HASHES_PER_TX
-          >,
-          tx.data.combinedData.newNullifiers.map((n: SideEffectLinkedToNoteHash) => n.value) as Tuple<
-            Fr,
-            typeof MAX_NEW_NULLIFIERS_PER_TX
-          >,
-          tx.data.combinedData.newL2ToL1Msgs,
-          tx.data.combinedData.publicDataUpdateRequests.map(t => new PublicDataWrite(t.leafSlot, t.newValue)) as Tuple<
-            PublicDataWrite,
-            typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
-          >,
-          tx.data.combinedData.newContracts.map(cd => cd.hash()) as Tuple<Fr, typeof MAX_NEW_CONTRACTS_PER_TX>,
-          tx.data.combinedData.newContracts.map(
-            cd => new ContractData(cd.contractAddress, cd.portalContractAddress),
-          ) as Tuple<ContractData, typeof MAX_NEW_CONTRACTS_PER_TX>,
-          tx.encryptedLogs || new TxL2Logs([]),
-          tx.unencryptedLogs || new TxL2Logs([]),
-        ),
-    );
+    const txEffects: TxEffect[] = txs.map(tx => toTxEffect(tx));
 
     const blockBody = new Body(padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP), txEffects);
 
@@ -138,11 +113,12 @@ export class SoloBlockBuilder implements BlockBuilder {
       body: blockBody,
     });
 
-    if (!l2Block.body.getCalldataHash().equals(circuitsOutput.header.contentCommitment.txsHash)) {
+    if (!l2Block.body.getTxsEffectsHash().equals(circuitsOutput.header.contentCommitment.txsEffectsHash)) {
+      this.debug(inspect(blockBody));
       throw new Error(
-        `Calldata hash mismatch, ${l2Block.body
-          .getCalldataHash()
-          .toString('hex')} == ${circuitsOutput.header.contentCommitment.txsHash.toString('hex')} `,
+        `Txs effects hash mismatch, ${l2Block.body
+          .getTxsEffectsHash()
+          .toString('hex')} == ${circuitsOutput.header.contentCommitment.txsEffectsHash.toString('hex')} `,
       );
     }
 
@@ -189,22 +165,66 @@ export class SoloBlockBuilder implements BlockBuilder {
     // padArrayEnd throws if the array is already full. Otherwise it pads till we reach the required size
     const newL1ToL2MessagesTuple = padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
 
-    // Run the base rollup circuits for the txs
-    const baseRollupOutputs: [BaseOrMergeRollupPublicInputs, Proof][] = [];
+    // Perform all tree insertions and retrieve snapshots for all base rollups
+    const baseRollupInputs: BaseRollupInputs[] = [];
+    const treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>[] = [];
     for (const tx of txs) {
-      baseRollupOutputs.push(await this.baseRollupCircuit(tx, globalVariables));
+      const input = await this.buildBaseRollupInput(tx, globalVariables);
+      baseRollupInputs.push(input);
+      const promises = [
+        MerkleTreeId.NOTE_HASH_TREE,
+        MerkleTreeId.CONTRACT_TREE,
+        MerkleTreeId.NULLIFIER_TREE,
+        MerkleTreeId.PUBLIC_DATA_TREE,
+      ].map(async (id: MerkleTreeId) => {
+        return { key: id, value: await this.getTreeSnapshot(id) };
+      });
+      const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
+        (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
+      );
+      treeSnapshots.push(snapshots);
+    }
+
+    // Run the base rollup circuits for the txs in parallel
+    const baseRollupOutputs: Promise<[BaseOrMergeRollupPublicInputs, Proof]>[] = [];
+    for (let i = 0; i < txs.length; i++) {
+      baseRollupOutputs.push(this.baseRollupCircuit(txs[i], baseRollupInputs[i], treeSnapshots[i]));
     }
 
     // Run merge rollups in layers until we have only two outputs
-    let mergeRollupInputs: [BaseOrMergeRollupPublicInputs, Proof][] = baseRollupOutputs;
-    let mergeRollupOutputs: [BaseOrMergeRollupPublicInputs, Proof][] = [];
+    // All merge circuits for each layer are simulated in parallel
+    const [duration, mergeInputs] = await elapsed(() => Promise.all(baseRollupOutputs));
+    for (let i = 0; i < mergeInputs.length; i++) {
+      this.debug(`Simulated base rollup circuit`, {
+        eventName: 'circuit-simulation',
+        circuitName: 'base-rollup',
+        duration: duration / mergeInputs.length,
+        inputSize: baseRollupInputs[i].toBuffer().length,
+        outputSize: mergeInputs[i][0].toBuffer().length,
+      } satisfies CircuitSimulationStats);
+    }
+    let mergeRollupInputs: [BaseOrMergeRollupPublicInputs, Proof][] = mergeInputs;
     while (mergeRollupInputs.length > 2) {
+      const mergeInputStructs: MergeRollupInputs[] = [];
       for (const pair of chunk(mergeRollupInputs, 2)) {
         const [r1, r2] = pair;
-        mergeRollupOutputs.push(await this.mergeRollupCircuit(r1, r2));
+        mergeInputStructs.push(this.createMergeRollupInputs(r1, r2));
       }
-      mergeRollupInputs = mergeRollupOutputs;
-      mergeRollupOutputs = [];
+
+      const [duration, mergeOutputs] = await elapsed(() =>
+        Promise.all(mergeInputStructs.map(async input => await this.mergeRollupCircuit(input))),
+      );
+
+      for (let i = 0; i < mergeOutputs.length; i++) {
+        this.debug(`Simulated merge rollup circuit`, {
+          eventName: 'circuit-simulation',
+          circuitName: 'merge-rollup',
+          duration: duration / mergeOutputs.length,
+          inputSize: mergeInputStructs[i].toBuffer().length,
+          outputSize: mergeOutputs[i][0].toBuffer().length,
+        } satisfies CircuitSimulationStats);
+      }
+      mergeRollupInputs = mergeOutputs;
     }
 
     // Run the root rollup with the last two merge rollups (or base, if no merge layers)
@@ -214,26 +234,29 @@ export class SoloBlockBuilder implements BlockBuilder {
 
   protected async baseRollupCircuit(
     tx: ProcessedTx,
-    globalVariables: GlobalVariables,
+    inputs: BaseRollupInputs,
+    treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
   ): Promise<[BaseOrMergeRollupPublicInputs, Proof]> {
     this.debug(`Running base rollup for ${tx.hash}`);
-    const rollupInput = await this.buildBaseRollupInput(tx, globalVariables);
-    const rollupOutput = await this.simulator.baseRollupCircuit(rollupInput);
-    await this.validatePartialState(rollupOutput.end);
-    const proof = await this.prover.getBaseRollupProof(rollupInput, rollupOutput);
+    const rollupOutput = await this.simulator.baseRollupCircuit(inputs);
+    this.validatePartialState(rollupOutput.end, treeSnapshots);
+    const proof = await this.prover.getBaseRollupProof(inputs, rollupOutput);
     return [rollupOutput, proof];
   }
 
-  protected async mergeRollupCircuit(
+  protected createMergeRollupInputs(
     left: [BaseOrMergeRollupPublicInputs, Proof],
     right: [BaseOrMergeRollupPublicInputs, Proof],
-  ): Promise<[BaseOrMergeRollupPublicInputs, Proof]> {
+  ) {
     const vk = this.getVerificationKey(left[0].rollupType);
     const mergeInputs = new MergeRollupInputs([
       this.getPreviousRollupDataFromPublicInputs(left[0], left[1], vk),
       this.getPreviousRollupDataFromPublicInputs(right[0], right[1], vk),
     ]);
+    return mergeInputs;
+  }
 
+  protected async mergeRollupCircuit(mergeInputs: MergeRollupInputs): Promise<[BaseOrMergeRollupPublicInputs, Proof]> {
     this.debug(`Running merge rollup circuit`);
     const output = await this.simulator.mergeRollupCircuit(mergeInputs);
     const proof = await this.prover.getMergeRollupProof(mergeInputs, output);
@@ -279,40 +302,50 @@ export class SoloBlockBuilder implements BlockBuilder {
     return [rootOutput, rootProof];
   }
 
-  protected async validatePartialState(partialState: PartialStateReference) {
-    await Promise.all([
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE),
-        partialState.noteHashTree,
-        'NoteHashTree',
-      ),
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE),
-        partialState.nullifierTree,
-        'NullifierTree',
-      ),
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.CONTRACT_TREE),
-        partialState.contractTree,
-        'ContractTree',
-      ),
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE),
-        partialState.publicDataTree,
-        'PublicDataTree',
-      ),
-    ]);
+  protected validatePartialState(
+    partialState: PartialStateReference,
+    treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
+  ) {
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.NOTE_HASH_TREE)!,
+      partialState.noteHashTree,
+      'NoteHashTree',
+    );
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.NULLIFIER_TREE)!,
+      partialState.nullifierTree,
+      'NullifierTree',
+    );
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.CONTRACT_TREE)!,
+      partialState.contractTree,
+      'ContractTree',
+    );
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.PUBLIC_DATA_TREE)!,
+      partialState.publicDataTree,
+      'PublicDataTree',
+    );
   }
 
   protected async validateState(state: StateReference) {
-    await Promise.all([
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
-        state.l1ToL2MessageTree,
-        'L1ToL2MessageTree',
-      ),
-      this.validatePartialState(state.partial),
-    ]);
+    const promises = [
+      MerkleTreeId.NOTE_HASH_TREE,
+      MerkleTreeId.CONTRACT_TREE,
+      MerkleTreeId.NULLIFIER_TREE,
+      MerkleTreeId.PUBLIC_DATA_TREE,
+    ].map(async (id: MerkleTreeId) => {
+      return { key: id, value: await this.getTreeSnapshot(id) };
+    });
+    const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
+      (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
+    );
+    this.validatePartialState(state.partial, snapshots);
+    this.validateSimulatedTree(
+      await this.getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+      state.l1ToL2MessageTree,
+      'L1ToL2MessageTree',
+    );
   }
 
   // Validate that the roots of all local trees match the output of the root circuit simulation
@@ -420,7 +453,7 @@ export class SoloBlockBuilder implements BlockBuilder {
   protected getKernelDataFor(tx: ProcessedTx): RollupKernelData {
     const inputs = new RollupKernelCircuitPublicInputs(
       tx.data.aggregationObject,
-      CombinedAccumulatedData.recombine(tx.data.endNonRevertibleData, tx.data.end),
+      tx.data.combinedData,
       tx.data.constants,
     );
     return new RollupKernelData(

package/src/client/sequencer-client.ts

@@ -1,7 +1,10 @@
 import { ContractDataSource, L1ToL2MessageSource, L2BlockSource } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
 import { P2P } from '@aztec/p2p';
 import { WorldStateSynchronizer } from '@aztec/world-state';
 
+import * as fs from 'fs/promises';
+
 import { SoloBlockBuilder } from '../block_builder/solo_block_builder.js';
 import { SequencerClientConfig } from '../config.js';
 import { getGlobalVariableBuilder } from '../global_variable_builder/index.js';
@@ -10,7 +13,32 @@ import { EmptyRollupProver } from '../prover/empty.js';
 import { getL1Publisher } from '../publisher/index.js';
 import { Sequencer, SequencerConfig } from '../sequencer/index.js';
 import { PublicProcessorFactory } from '../sequencer/public_processor.js';
+import { NativeACVMSimulator } from '../simulator/acvm_native.js';
+import { WASMSimulator } from '../simulator/acvm_wasm.js';
 import { RealRollupCircuitSimulator } from '../simulator/rollup.js';
+import { SimulationProvider } from '../simulator/simulation_provider.js';
+
+const logger = createDebugLogger('aztec:sequencer-client');
+
+/**
+ * Factory function to create a simulation provider. Will attempt to use native binary simulation falling back to WASM if unavailable.
+ * @param config - The provided sequencer client configuration
+ * @returns The constructed simulation provider
+ */
+async function getSimulationProvider(config: SequencerClientConfig): Promise<SimulationProvider> {
+  if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
+    try {
+      await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
+      await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
+      logger(`Using native ACVM at ${config.acvmBinaryPath}`);
+      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+    } catch {
+      logger(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
+    }
+  }
+  logger('Using WASM ACVM simulation');
+  return new WASMSimulator();
+}
 
 /**
  * Encapsulates the full sequencer and publisher.
@@ -40,14 +68,21 @@ export class SequencerClient {
     const globalsBuilder = getGlobalVariableBuilder(config);
     const merkleTreeDb = worldStateSynchronizer.getLatest();
 
+    const simulationProvider = await getSimulationProvider(config);
+
     const blockBuilder = new SoloBlockBuilder(
       merkleTreeDb,
       getVerificationKeys(),
-      new RealRollupCircuitSimulator(),
+      new RealRollupCircuitSimulator(simulationProvider),
       new EmptyRollupProver(),
     );
 
-    const publicProcessorFactory = new PublicProcessorFactory(merkleTreeDb, contractDataSource, l1ToL2MessageSource);
+    const publicProcessorFactory = new PublicProcessorFactory(
+      merkleTreeDb,
+      contractDataSource,
+      l1ToL2MessageSource,
+      simulationProvider,
+    );
 
     const sequencer = new Sequencer(
       publisher,

package/src/config.ts

@@ -48,6 +48,8 @@ export function getConfigEnvVars(): SequencerClientConfig {
     OUTBOX_CONTRACT_ADDRESS,
     COINBASE,
     FEE_RECIPIENT,
+    ACVM_WORKING_DIRECTORY,
+    ACVM_BINARY_PATH,
   } = process.env;
 
   const publisherPrivateKey: Hex = SEQ_PUBLISHER_PRIVATE_KEY
@@ -82,5 +84,7 @@ export function getConfigEnvVars(): SequencerClientConfig {
     // TODO: undefined should not be allowed for the following 2 values in PROD
     coinbase: COINBASE ? EthAddress.fromString(COINBASE) : undefined,
     feeRecipient: FEE_RECIPIENT ? AztecAddress.fromString(FEE_RECIPIENT) : undefined,
+    acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
+    acvmBinaryPath: ACVM_BINARY_PATH ? ACVM_BINARY_PATH : undefined,
   };
 }

package/src/index.ts

@@ -1,15 +1,17 @@
-export * from './sequencer/index.js';
-export * from './config.js';
-export * from './publisher/index.js';
 export * from './client/index.js';
+export * from './config.js';
 export * from './mocks/verification_keys.js';
+export * from './publisher/index.js';
+export * from './sequencer/index.js';
 
 // Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
-export * from './sequencer/public_processor.js';
 export * from './global_variable_builder/index.js';
+export * from './sequencer/public_processor.js';
 
 // Used by publisher test in e2e
-export { RealRollupCircuitSimulator } from './simulator/rollup.js';
-export { EmptyRollupProver } from './prover/empty.js';
 export { SoloBlockBuilder } from './block_builder/solo_block_builder.js';
-export { makeProcessedTx, makeEmptyProcessedTx } from './sequencer/processed_tx.js';
+export { EmptyRollupProver } from './prover/empty.js';
+export { makeEmptyProcessedTx, makeProcessedTx, partitionReverts } from './sequencer/processed_tx.js';
+export { WASMSimulator } from './simulator/acvm_wasm.js';
+export { RealRollupCircuitSimulator } from './simulator/rollup.js';
+export { SimulationProvider } from './simulator/simulation_provider.js';

package/src/publisher/l1-publisher.ts

@@ -172,15 +172,15 @@ export class L1Publisher implements L2BlockReceiver {
       }
 
       if (receipt.status) {
-        let txsHash;
+        let txsEffectsHash;
         if (receipt.logs.length === 1) {
-          // txsHash from IAvailabilityOracle.TxsPublished event
-          txsHash = receipt.logs[0].data;
+          // txsEffectsHash from IAvailabilityOracle.TxsPublished event
+          txsEffectsHash = receipt.logs[0].data;
         } else {
           this.log(`Expected 1 log, got ${receipt.logs.length}`);
         }
 
-        this.log.info(`Block txs effects published, txsHash: ${txsHash}`);
+        this.log.info(`Block txs effects published, txsEffectsHash: ${txsEffectsHash}`);
         break;
       }
 

package/src/publisher/viem-tx-sender.ts

@@ -87,7 +87,7 @@ export class ViemTxSender implements L1PublisherTxSender {
   }
 
   checkIfTxsAreAvailable(block: L2Block): Promise<boolean> {
-    const args = [`0x${block.body.getCalldataHash().toString('hex')}`] as const;
+    const args = [`0x${block.body.getTxsEffectsHash().toString('hex')}`] as const;
     return this.availabilityOracleContract.read.isAvailable(args);
   }