@aztec/sequencer-client 0.26.3 → 0.26.6

package/src/sequencer/sequencer.ts

@@ -180,7 +180,6 @@ export class Sequencer {
       this.log.info(`Building block ${newBlockNumber} with ${validTxs.length} transactions`);
       this.state = SequencerState.CREATING_BLOCK;
 
-      // Process txs and drop the ones that fail processing
       // We create a fresh processor each time to reset any cached state (eg storage writes)
       const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs));
@@ -255,12 +254,12 @@ export class Sequencer {
       return;
     }
 
-    const blockCalldataHash = block.body.getCalldataHash();
+    const txsEffectsHash = block.body.getTxsEffectsHash();
     this.log.info(`Publishing ${newContracts.length} contracts in block ${block.number}`);
 
     const publishedContractData = await this.publisher.processNewContractData(
       block.number,
-      blockCalldataHash,
+      txsEffectsHash,
       newContracts,
     );
 

package/src/sequencer/setup_phase_manager.ts

@@ -27,34 +27,20 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
-  // this is a no-op for now
-  async handle(
+  override async handle(
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
-  ): Promise<{
-    /**
-     * the output of the public kernel circuit for this phase
-     */
-    publicKernelOutput: PublicKernelCircuitPublicInputs;
-    /**
-     * the proof of the public kernel circuit for this phase
-     */
-    publicKernelProof: Proof;
-  }> {
+  ) {
     this.log(`Processing tx ${tx.getTxHash()}`);
-    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
-      tx,
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    );
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
 
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {

package/src/sequencer/tail_phase_manager.ts

@@ -0,0 +1,49 @@
+import { Tx } from '@aztec/circuit-types';
+import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
+import { MerkleTreeOperations } from '@aztec/world-state';
+
+import { PublicProver } from '../prover/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { FailedTx } from './processed_tx.js';
+
+export class TailPhaseManager extends AbstractPhaseManager {
+  constructor(
+    protected db: MerkleTreeOperations,
+    protected publicExecutor: PublicExecutor,
+    protected publicKernel: PublicKernelCircuitSimulator,
+    protected publicProver: PublicProver,
+    protected globalVariables: GlobalVariables,
+    protected historicalHeader: Header,
+    protected publicContractsDB: ContractsDataSourcePublicDB,
+    protected publicStateDB: PublicStateDB,
+    public readonly phase: PublicKernelPhase = PublicKernelPhase.TAIL,
+  ) {
+    super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
+  }
+
+  async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
+    this.log(`Processing tx ${tx.getTxHash()}`);
+    this.log(`Executing tail circuit for tx ${tx.getTxHash()}`);
+    const [publicKernelOutput, publicKernelProof] = await this.runKernelCircuit(
+      previousPublicKernelOutput,
+      previousPublicKernelProof,
+    );
+
+    // commit the state updates from this transaction
+    await this.publicStateDB.commit();
+
+    return { publicKernelOutput, publicKernelProof, revertReason: undefined };
+  }
+
+  async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
+    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
+    await this.publicStateDB.rollback();
+    return {
+      tx,
+      error: err instanceof Error ? err : new Error('Unknown error'),
+    };
+  }
+}

package/src/sequencer/teardown_phase_manager.ts

@@ -27,33 +27,20 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
-  async handle(
+  override async handle(
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
-  ): Promise<{
-    /**
-     * the output of the public kernel circuit for this phase
-     */
-    publicKernelOutput: PublicKernelCircuitPublicInputs;
-    /**
-     * the proof of the public kernel circuit for this phase
-     */
-    publicKernelProof: Proof;
-  }> {
+  ) {
     this.log(`Processing tx ${tx.getTxHash()}`);
-    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
-      tx,
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    );
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
 
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {

package/src/simulator/acvm_native.ts

@@ -0,0 +1,112 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WitnessMap } from '@noir-lang/types';
+import * as proc from 'child_process';
+import fs from 'fs/promises';
+
+import { SimulationProvider } from './simulation_provider.js';
+
+/**
+ * Parses a TOML format witness map string into a Map structure
+ * @param outputString - The witness map in TOML format
+ * @returns The parsed witness map
+ */
+function parseIntoWitnessMap(outputString: string) {
+  const lines = outputString.split('\n');
+  return new Map<number, string>(
+    lines
+      .filter((line: string) => line.length)
+      .map((line: string) => {
+        const pair = line.replaceAll(' ', '').split('=');
+        return [Number(pair[0]), pair[1].replaceAll('"', '')];
+      }),
+  );
+}
+
+/**
+ *
+ * @param inputWitness - The circuit's input witness
+ * @param bytecode - The circuit buytecode
+ * @param workingDirectory - A directory to use for temporary files by the ACVM
+ * @param pathToAcvm - The path to the ACVm binary
+ * @returns The completed partial witness outputted from the circuit
+ */
+export async function executeNativeCircuit(
+  inputWitness: WitnessMap,
+  bytecode: Buffer,
+  workingDirectory: string,
+  pathToAcvm: string,
+) {
+  const bytecodeFilename = 'bytecode';
+  const witnessFilename = 'input_witness.toml';
+
+  // convert the witness map to TOML format
+  let witnessMap = '';
+  inputWitness.forEach((value: string, key: number) => {
+    witnessMap = witnessMap.concat(`${key} = '${value}'\n`);
+  });
+
+  // In case the directory is still around from some time previously, remove it
+  await fs.rm(workingDirectory, { recursive: true, force: true });
+  // Create the new working directory
+  await fs.mkdir(workingDirectory, { recursive: true });
+  // Write the bytecode and input witness to the working directory
+  await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
+  await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
+
+  // Execute the ACVM using the given args
+  const args = [
+    `execute`,
+    `--working-directory`,
+    `${workingDirectory}`,
+    `--bytecode`,
+    `${bytecodeFilename}`,
+    `--input-witness`,
+    `${witnessFilename}`,
+    `--print`,
+  ];
+  const processPromise = new Promise<string>((resolve, reject) => {
+    let outputWitness = Buffer.alloc(0);
+    let errorBuffer = Buffer.alloc(0);
+    const acvm = proc.spawn(pathToAcvm, args);
+    acvm.stdout.on('data', data => {
+      outputWitness = Buffer.concat([outputWitness, data]);
+    });
+    acvm.stderr.on('data', data => {
+      errorBuffer = Buffer.concat([errorBuffer, data]);
+    });
+    acvm.on('close', code => {
+      if (code === 0) {
+        resolve(outputWitness.toString('utf-8'));
+      } else {
+        reject(errorBuffer.toString('utf-8'));
+      }
+    });
+  });
+
+  try {
+    const output = await processPromise;
+    return parseIntoWitnessMap(output);
+  } finally {
+    // Clean up the working directory before we leave
+    await fs.rm(workingDirectory, { recursive: true, force: true });
+  }
+}
+
+export class NativeACVMSimulator implements SimulationProvider {
+  constructor(private workingDirectory: string, private pathToAcvm: string) {}
+  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    // Execute the circuit on those initial witness values
+
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
+    // Provide a unique working directory so we don't get clashes with parallel executions
+    const directory = `${this.workingDirectory}/${randomBytes(32).toString('hex')}`;
+    // Execute the circuit
+    const _witnessMap = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm);
+
+    return _witnessMap;
+  }
+}

package/src/simulator/acvm_wasm.ts

@@ -0,0 +1,31 @@
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WasmBlackBoxFunctionSolver, createBlackBoxSolver, executeCircuitWithBlackBoxSolver } from '@noir-lang/acvm_js';
+import { WitnessMap } from '@noir-lang/types';
+
+import { SimulationProvider } from './simulation_provider.js';
+
+let solver: Promise<WasmBlackBoxFunctionSolver>;
+
+const getSolver = (): Promise<WasmBlackBoxFunctionSolver> => {
+  if (!solver) {
+    solver = createBlackBoxSolver();
+  }
+  return solver;
+};
+
+export class WASMSimulator implements SimulationProvider {
+  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    // Execute the circuit on those initial witness values
+    //
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+    //
+    // Execute the circuit
+    const _witnessMap = await executeCircuitWithBlackBoxSolver(await getSolver(), decodedBytecode, input, () => {
+      throw Error('unexpected oracle during execution');
+    });
+
+    return _witnessMap;
+  }
+}

package/src/simulator/index.ts

@@ -4,6 +4,7 @@ import {
   MergeRollupInputs,
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
@@ -54,4 +55,11 @@ export interface PublicKernelCircuitSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   publicKernelCircuitTeardown(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  /**
+   * Simulates the public kernel tail circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
 }
+export * from './acvm_wasm.js';

package/src/simulator/public_kernel.ts

@@ -1,14 +1,28 @@
 import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
-import { PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import {
+  PublicKernelCircuitPrivateInputs,
+  PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
+} from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
-  executePublicKernelAppLogic,
-  executePublicKernelSetup,
-  executePublicKernelTeardown,
+  PublicKernelAppLogicArtifact,
+  PublicKernelSetupArtifact,
+  PublicKernelTailArtifact,
+  PublicKernelTeardownArtifact,
+  convertPublicInnerRollupInputsToWitnessMap,
+  convertPublicInnerRollupOutputFromWitnessMap,
+  convertPublicSetupRollupInputsToWitnessMap,
+  convertPublicSetupRollupOutputFromWitnessMap,
+  convertPublicTailInputsToWitnessMap,
+  convertPublicTailOutputFromWitnessMap,
+  convertPublicTeardownRollupInputsToWitnessMap,
+  convertPublicTeardownRollupOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 
-import { PublicKernelCircuitSimulator } from './index.js';
+import { PublicKernelCircuitSimulator, WASMSimulator } from './index.js';
+import { SimulationProvider } from './simulation_provider.js';
 
 /**
  * Implements the PublicKernelCircuitSimulator.
@@ -16,6 +30,11 @@ import { PublicKernelCircuitSimulator } from './index.js';
 export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimulator {
   private log = createDebugLogger('aztec:public-kernel-simulator');
 
+  // Some circuits are so small it is faster to use WASM
+  private wasmSimulator: WASMSimulator = new WASMSimulator();
+
+  constructor(private simulator: SimulationProvider) {}
+
   /**
    * Simulates the public kernel setup circuit from its inputs.
    * @param input - Inputs to the circuit.
@@ -27,7 +46,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsSetup) {
       throw new Error(`Expected previous kernel inputs to need setup`);
     }
-    const [duration, result] = await elapsed(() => executePublicKernelSetup(input));
+    const inputWitness = convertPublicSetupRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelSetupArtifact),
+    );
+    const result = convertPublicSetupRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel setup circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-setup',
@@ -49,7 +72,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsAppLogic) {
       throw new Error(`Expected previous kernel inputs to need app logic`);
     }
-    const [duration, result] = await elapsed(() => executePublicKernelAppLogic(input));
+    const inputWitness = convertPublicInnerRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelAppLogicArtifact),
+    );
+    const result = convertPublicInnerRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel app logic circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-app-logic',
@@ -71,7 +98,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsTeardown) {
       throw new Error(`Expected previous kernel inputs to need teardown`);
     }
-    const [duration, result] = await elapsed(() => executePublicKernelTeardown(input));
+    const inputWitness = convertPublicTeardownRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTeardownArtifact),
+    );
+    const result = convertPublicTeardownRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel teardown circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-teardown',
@@ -81,4 +112,27 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     } satisfies CircuitSimulationStats);
     return result;
   }
+
+  /**
+   * Simulates the public kernel tail circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitTail(
+    input: PublicKernelTailCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    const inputWitness = convertPublicTailInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTailArtifact),
+    );
+    const result = convertPublicTailOutputFromWitnessMap(witness);
+    this.log(`Simulated public kernel tail circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-tail',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
 }

package/src/simulator/rollup.ts

@@ -8,9 +8,20 @@ import {
 } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
-import { executeBaseRollup, executeMergeRollup, executeRootRollup } from '@aztec/noir-protocol-circuits-types';
+import {
+  BaseRollupArtifact,
+  MergeRollupArtifact,
+  RootRollupArtifact,
+  convertBaseRollupInputsToWitnessMap,
+  convertBaseRollupOutputsFromWitnessMap,
+  convertMergeRollupInputsToWitnessMap,
+  convertMergeRollupOutputsFromWitnessMap,
+  convertRootRollupInputsToWitnessMap,
+  convertRootRollupOutputsFromWitnessMap,
+} from '@aztec/noir-protocol-circuits-types';
 
-import { RollupSimulator } from './index.js';
+import { RollupSimulator, WASMSimulator } from './index.js';
+import { SimulationProvider } from './simulation_provider.js';
 
 /**
  * Implements the rollup circuit simulator.
@@ -18,21 +29,22 @@ import { RollupSimulator } from './index.js';
 export class RealRollupCircuitSimulator implements RollupSimulator {
   private log = createDebugLogger('aztec:rollup-simulator');
 
+  // Some circuits are so small it is faster to use WASM
+  private wasmSimulator: WASMSimulator = new WASMSimulator();
+
+  constructor(private simulationProvider: SimulationProvider) {}
+
   /**
    * Simulates the base rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
   public async baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
-    const [duration, result] = await elapsed(() => executeBaseRollup(input));
+    const witnessMap = convertBaseRollupInputsToWitnessMap(input);
 
-    this.log(`Simulated base rollup circuit`, {
-      eventName: 'circuit-simulation',
-      circuitName: 'base-rollup',
-      duration,
-      inputSize: input.toBuffer().length,
-      outputSize: result.toBuffer().length,
-    } satisfies CircuitSimulationStats);
+    const witness = await this.simulationProvider.simulateCircuit(witnessMap, BaseRollupArtifact);
+
+    const result = convertBaseRollupOutputsFromWitnessMap(witness);
 
     return Promise.resolve(result);
   }
@@ -42,15 +54,11 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   public async mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
-    const [duration, result] = await elapsed(() => executeMergeRollup(input));
+    const witnessMap = convertMergeRollupInputsToWitnessMap(input);
 
-    this.log(`Simulated merge rollup circuit`, {
-      eventName: 'circuit-simulation',
-      circuitName: 'merge-rollup',
-      duration,
-      inputSize: input.toBuffer().length,
-      outputSize: result.toBuffer().length,
-    } satisfies CircuitSimulationStats);
+    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, MergeRollupArtifact);
+
+    const result = convertMergeRollupOutputsFromWitnessMap(witness);
 
     return result;
   }
@@ -61,7 +69,11 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   public async rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs> {
-    const [duration, result] = await elapsed(() => executeRootRollup(input));
+    const witnessMap = convertRootRollupInputsToWitnessMap(input);
+
+    const [duration, witness] = await elapsed(() => this.wasmSimulator.simulateCircuit(witnessMap, RootRollupArtifact));
+
+    const result = convertRootRollupOutputsFromWitnessMap(witness);
 
     this.log(`Simulated root rollup circuit`, {
       eventName: 'circuit-simulation',

package/src/simulator/simulation_provider.ts

@@ -0,0 +1,10 @@
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WitnessMap } from '@noir-lang/types';
+
+/**
+ * Low level simulation interface
+ */
+export interface SimulationProvider {
+  simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap>;
+}