@aztec/sequencer-client 0.27.1 → 0.28.0

package/src/sequencer/teardown_phase_manager.ts

@@ -7,7 +7,6 @@ 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';
 
 /**
  * The phase manager responsible for performing the fee preparation phase.
@@ -34,21 +33,15 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
   ) {
     this.log(`Processing tx ${tx.getTxHash()}`);
     const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
+        // the abstract phase manager throws if simulation gives error in a non-revertible phase
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
-
-    // commit the state updates from this transaction
-    await this.publicStateDB.commit();
-
+    await this.publicStateDB.checkpoint();
     return { publicKernelOutput, publicKernelProof, revertReason };
   }
-
-  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/utils.ts

@@ -0,0 +1,30 @@
+import { Tx } from '@aztec/circuit-types';
+import { CallRequest } from '@aztec/circuits.js';
+
+/**
+ * Looks at the side effects of a transaction and returns the highest counter
+ * @param tx - A transaction
+ * @returns The highest side effect counter in the transaction so far
+ */
+export function lastSideEffectCounter(tx: Tx): number {
+  const sideEffectCounters = [
+    ...tx.data.endNonRevertibleData.newNoteHashes,
+    ...tx.data.endNonRevertibleData.newNullifiers,
+    ...tx.data.endNonRevertibleData.publicCallStack,
+    ...tx.data.end.newNoteHashes,
+    ...tx.data.end.newNullifiers,
+    ...tx.data.end.publicCallStack,
+  ];
+
+  let max = 0;
+  for (const sideEffect of sideEffectCounters) {
+    if (sideEffect instanceof CallRequest) {
+      // look at both start and end counters because for enqueued public calls start > 0 while end === 0
+      max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
+    } else {
+      max = Math.max(max, sideEffect.counter.toNumber());
+    }
+  }
+
+  return max;
+}

package/src/simulator/index.ts

@@ -1,10 +1,13 @@
 import {
   BaseOrMergeRollupPublicInputs,
+  BaseParityInputs,
   BaseRollupInputs,
   MergeRollupInputs,
+  ParityPublicInputs,
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
   PublicKernelTailCircuitPrivateInputs,
+  RootParityInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
@@ -13,6 +16,18 @@ import {
  * Circuit simulator for the rollup circuits.
  */
 export interface RollupSimulator {
+  /**
+   * Simulates the base parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  baseParityCircuit(inputs: BaseParityInputs): Promise<ParityPublicInputs>;
+  /**
+   * Simulates the root parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  rootParityCircuit(inputs: RootParityInputs): Promise<ParityPublicInputs>;
   /**
    * Simulates the base rollup circuit from its inputs.
    * @param input - Inputs to the circuit.

package/src/simulator/public_executor.ts

@@ -79,6 +79,10 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     return Promise.resolve();
   }
 
+  public async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return this.instanceCache.get(address.toString()) ?? (await this.db.getContract(address));
+  }
+
   async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
     const contract = await this.#getContract(address);
     return contract?.getPublicFunction(selector)?.bytecode;
@@ -126,8 +130,9 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
  * Implements the PublicStateDB using a world-state database.
  */
 export class WorldStatePublicDB implements PublicStateDB {
-  private commitedWriteCache: Map<bigint, Fr> = new Map();
-  private uncommitedWriteCache: Map<bigint, Fr> = new Map();
+  private committedWriteCache: Map<bigint, Fr> = new Map();
+  private checkpointedWriteCache: Map<bigint, Fr> = new Map();
+  private uncommittedWriteCache: Map<bigint, Fr> = new Map();
 
   constructor(private db: MerkleTreeOperations) {}
 
@@ -139,13 +144,17 @@ export class WorldStatePublicDB implements PublicStateDB {
    */
   public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
     const leafSlot = computePublicDataTreeLeafSlot(contract, slot).value;
-    const uncommited = this.uncommitedWriteCache.get(leafSlot);
-    if (uncommited !== undefined) {
-      return uncommited;
+    const uncommitted = this.uncommittedWriteCache.get(leafSlot);
+    if (uncommitted !== undefined) {
+      return uncommitted;
+    }
+    const checkpointed = this.checkpointedWriteCache.get(leafSlot);
+    if (checkpointed !== undefined) {
+      return checkpointed;
     }
-    const commited = this.commitedWriteCache.get(leafSlot);
-    if (commited !== undefined) {
-      return commited;
+    const committed = this.committedWriteCache.get(leafSlot);
+    if (committed !== undefined) {
+      return committed;
     }
 
     const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
@@ -169,7 +178,7 @@ export class WorldStatePublicDB implements PublicStateDB {
    */
   public storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
     const index = computePublicDataTreeLeafSlot(contract, slot).value;
-    this.uncommitedWriteCache.set(index, newValue);
+    this.uncommittedWriteCache.set(index, newValue);
     return Promise.resolve();
   }
 
@@ -178,18 +187,36 @@ export class WorldStatePublicDB implements PublicStateDB {
    * @returns Nothing.
    */
   commit(): Promise<void> {
-    for (const [k, v] of this.uncommitedWriteCache) {
-      this.commitedWriteCache.set(k, v);
+    for (const [k, v] of this.checkpointedWriteCache) {
+      this.committedWriteCache.set(k, v);
     }
-    return this.rollback();
+    // uncommitted writes take precedence over checkpointed writes
+    // since they are the most recent
+    for (const [k, v] of this.uncommittedWriteCache) {
+      this.committedWriteCache.set(k, v);
+    }
+    return this.rollbackToCommit();
   }
 
   /**
    * Rollback the pending changes.
    * @returns Nothing.
    */
-  rollback(): Promise<void> {
-    this.uncommitedWriteCache = new Map<bigint, Fr>();
+  async rollbackToCommit(): Promise<void> {
+    await this.rollbackToCheckpoint();
+    this.checkpointedWriteCache = new Map<bigint, Fr>();
+    return Promise.resolve();
+  }
+
+  checkpoint(): Promise<void> {
+    for (const [k, v] of this.uncommittedWriteCache) {
+      this.checkpointedWriteCache.set(k, v);
+    }
+    return this.rollbackToCheckpoint();
+  }
+
+  rollbackToCheckpoint(): Promise<void> {
+    this.uncommittedWriteCache = new Map<bigint, Fr>();
     return Promise.resolve();
   }
 }

package/src/simulator/rollup.ts

@@ -1,21 +1,30 @@
 import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
   BaseOrMergeRollupPublicInputs,
+  BaseParityInputs,
   BaseRollupInputs,
   MergeRollupInputs,
+  ParityPublicInputs,
+  RootParityInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
+  BaseParityArtifact,
   BaseRollupArtifact,
   MergeRollupArtifact,
+  RootParityArtifact,
   RootRollupArtifact,
+  convertBaseParityInputsToWitnessMap,
+  convertBaseParityOutputsFromWitnessMap,
   convertBaseRollupInputsToWitnessMap,
   convertBaseRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
+  convertRootParityInputsToWitnessMap,
+  convertRootParityOutputsFromWitnessMap,
   convertRootRollupInputsToWitnessMap,
   convertRootRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
@@ -34,6 +43,36 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
 
   constructor(private simulationProvider: SimulationProvider) {}
 
+  /**
+   * Simulates the base parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  public async baseParityCircuit(inputs: BaseParityInputs): Promise<ParityPublicInputs> {
+    const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
+
+    const witness = await this.simulationProvider.simulateCircuit(witnessMap, BaseParityArtifact);
+
+    const result = convertBaseParityOutputsFromWitnessMap(witness);
+
+    return Promise.resolve(result);
+  }
+
+  /**
+   * Simulates the root parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  public async rootParityCircuit(inputs: RootParityInputs): Promise<ParityPublicInputs> {
+    const witnessMap = convertRootParityInputsToWitnessMap(inputs);
+
+    const witness = await this.simulationProvider.simulateCircuit(witnessMap, RootParityArtifact);
+
+    const result = convertRootParityOutputsFromWitnessMap(witness);
+
+    return Promise.resolve(result);
+  }
+
   /**
    * Simulates the base rollup circuit from its inputs.
    * @param input - Inputs to the circuit.