@aztec/sequencer-client 0.8.9 → 0.8.11

package/src/publisher/index.ts

@@ -5,34 +5,6 @@ import { ViemTxSender } from './viem-tx-sender.js';
 export { L1Publisher } from './l1-publisher.js';
 export { PublisherConfig } from './config.js';
 
-/** Stats logged for each L1 rollup publish tx.*/
-export type L1PublishStats = {
-  /** Name of the event for metrics purposes */
-  eventName: 'rollup-published-to-l1';
-  /** Effective gas price of the tx. */
-  gasPrice: bigint;
-  /** Effective gas used in the tx. */
-  gasUsed: bigint;
-  /** Hash of the L1 tx. */
-  transactionHash: string;
-  /** Gas cost of the calldata. */
-  calldataGas: number;
-  /** Size in bytes of the calldata. */
-  calldataSize: number;
-  /** Number of txs in the L2 block. */
-  txCount: number;
-  /** Number of the L2 block. */
-  blockNumber: number;
-  /** Number of encrypted logs. */
-  encryptedLogCount?: number;
-  /** Number of unencrypted logs. */
-  unencryptedLogCount?: number;
-  /** Serialised size of encrypted logs. */
-  encryptedLogSize?: number;
-  /** Serialised size of unencrypted logs. */
-  unencryptedLogSize?: number;
-};
-
 /**
  * Returns a new instance of the L1Publisher.
  * @param config - Configuration to initialize the new instance.

package/src/publisher/l1-publisher.ts

@@ -1,12 +1,12 @@
 import { createDebugLogger } from '@aztec/foundation/log';
-import { InterruptableSleep } from '@aztec/foundation/sleep';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
 import { ExtendedContractData, L2Block } from '@aztec/types';
+import { L1PublishStats } from '@aztec/types/stats';
 
 import pick from 'lodash.pick';
 
 import { L2BlockReceiver } from '../receiver.js';
 import { PublisherConfig } from './config.js';
-import { L1PublishStats } from './index.js';
 
 /**
  * Stats for a sent transaction.
@@ -108,7 +108,7 @@ function isNotUndefined<T>(item: T | undefined): item is T {
  * Adapted from https://github.com/AztecProtocol/aztec2-internal/blob/master/falafel/src/rollup_publisher.ts.
  */
 export class L1Publisher implements L2BlockReceiver {
-  private interruptableSleep = new InterruptableSleep();
+  private interruptibleSleep = new InterruptibleSleep();
   private sleepTimeMs: number;
   private interrupted = false;
   private log = createDebugLogger('aztec:sequencer:publisher');
@@ -217,7 +217,7 @@ export class L1Publisher implements L2BlockReceiver {
    */
   public interrupt() {
     this.interrupted = true;
-    this.interruptableSleep.interrupt();
+    this.interruptibleSleep.interrupt();
   }
 
   /** Restarts the publisher after calling `interrupt`. */
@@ -276,6 +276,6 @@ export class L1Publisher implements L2BlockReceiver {
   }
 
   protected async sleepOrInterrupted() {
-    await this.interruptableSleep.sleep(this.sleepTimeMs);
+    await this.interruptibleSleep.sleep(this.sleepTimeMs);
   }
 }

package/src/sequencer/config.ts

@@ -14,14 +14,4 @@ export interface SequencerConfig {
    * The minimum number of txs to include in a block.
    */
   minTxsPerBlock?: number;
-
-  /**
-   * The chain id of the ethereum host.
-   */
-  chainId: number;
-
-  /**
-   * The version of the rollup.
-   */
-  version: number;
 }

package/src/sequencer/sequencer.ts

@@ -2,8 +2,10 @@ import { GlobalVariables } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { Timer, elapsed } from '@aztec/foundation/timer';
 import { P2P } from '@aztec/p2p';
 import { ContractDataSource, L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, Tx } from '@aztec/types';
+import { L2BlockBuiltStats } from '@aztec/types/stats';
 import { WorldStateStatus, WorldStateSynchronizer } from '@aztec/world-state';
 
 import times from 'lodash.times';
@@ -27,7 +29,7 @@ import { PublicProcessorFactory } from './public_processor.js';
  */
 export class Sequencer {
   private runningPromise?: RunningPromise;
-  private pollingIntervalMs: number;
+  private pollingIntervalMs: number = 1000;
   private maxTxsPerBlock = 32;
   private minTxsPerBLock = 1;
   private lastPublishedBlock = 0;
@@ -43,19 +45,23 @@ export class Sequencer {
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private contractDataSource: ContractDataSource,
     private publicProcessorFactory: PublicProcessorFactory,
-    config: SequencerConfig,
+    config: SequencerConfig = {},
     private log = createDebugLogger('aztec:sequencer'),
   ) {
-    this.pollingIntervalMs = config.transactionPollingIntervalMS ?? 1_000;
-    if (config.maxTxsPerBlock) {
-      this.maxTxsPerBlock = config.maxTxsPerBlock;
-    }
-    if (config.minTxsPerBlock) {
-      this.minTxsPerBLock = config.minTxsPerBlock;
-    }
+    this.updateConfig(config);
     this.log(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
   }
 
+  /**
+   * Updates sequencer config.
+   * @param config - New parameters.
+   */
+  public updateConfig(config: SequencerConfig) {
+    if (config.transactionPollingIntervalMS) this.pollingIntervalMs = config.transactionPollingIntervalMS;
+    if (config.maxTxsPerBlock) this.maxTxsPerBlock = config.maxTxsPerBlock;
+    if (config.minTxsPerBlock) this.minTxsPerBLock = config.minTxsPerBlock;
+  }
+
   /**
    * Starts the sequencer and moves to IDLE state. Blocks until the initial sync is complete.
    */
@@ -97,7 +103,7 @@ export class Sequencer {
   }
 
   protected async initialSync() {
-    // TODO: Should we wait for worldstate to be ready, or is the caller expected to run await start?
+    // TODO: Should we wait for world state to be ready, or is the caller expected to run await start?
     this.lastPublishedBlock = await this.worldState.status().then((s: WorldStateStatus) => s.syncedToL2Block);
   }
 
@@ -116,6 +122,7 @@ export class Sequencer {
       // Do not go forward with new block if the previous one has not been mined and processed
       if (!prevBlockSynced) return;
 
+      const workTimer = new Timer();
       this.state = SequencerState.WAITING_FOR_TXS;
 
       // Get txs to build the new block
@@ -123,23 +130,23 @@ export class Sequencer {
       if (pendingTxs.length < this.minTxsPerBLock) return;
       this.log.info(`Retrieved ${pendingTxs.length} txs from P2P pool`);
 
+      const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
+      const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(blockNumber));
+
       // Filter out invalid txs
       // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
-      const validTxs = await this.takeValidTxs(pendingTxs);
+      const validTxs = await this.takeValidTxs(pendingTxs, newGlobalVariables);
       if (validTxs.length < this.minTxsPerBLock) return;
 
-      const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
-
       this.log.info(`Building block ${blockNumber} with ${validTxs.length} transactions`);
       this.state = SequencerState.CREATING_BLOCK;
 
-      const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(blockNumber));
-      const prevGlobalVariables = (await this.l2BlockSource.getL2Block(-1))?.globalVariables ?? GlobalVariables.empty();
+      const prevGlobalVariables = (await this.l2BlockSource.getBlock(-1))?.globalVariables ?? GlobalVariables.empty();
 
       // 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(prevGlobalVariables, newGlobalVariables);
-      const [processedTxs, failedTxs] = await processor.process(validTxs);
+      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs));
       if (failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
         this.log(`Dropping failed txs ${(await Tx.getHashes(failedTxData)).join(', ')}`);
@@ -150,7 +157,7 @@ export class Sequencer {
       // public functions emitting nullifiers would pass earlier check but fail here.
       // Note that we're checking all nullifiers generated in the private execution twice,
       // we could store the ones already checked and skip them here as an optimisation.
-      const processedValidTxs = await this.takeValidTxs(processedTxs);
+      const processedValidTxs = await this.takeValidTxs(processedTxs, newGlobalVariables);
 
       if (processedValidTxs.length === 0) {
         this.log('No txs processed correctly to build block. Exiting');
@@ -166,8 +173,17 @@ export class Sequencer {
       this.log(`Assembling block with txs ${processedValidTxs.map(tx => tx.hash).join(', ')}`);
 
       const emptyTx = await processor.makeEmptyProcessedTx();
-      const block = await this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables);
-      this.log(`Assembled block ${block.number}`);
+      const [rollupCircuitsDuration, block] = await elapsed(() =>
+        this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables),
+      );
+
+      this.log(`Assembled block ${block.number}`, {
+        eventName: 'l2-block-built',
+        duration: workTimer.ms(),
+        publicProcessDuration: publicProcessorDuration,
+        rollupCircuitsDuration: rollupCircuitsDuration,
+        ...block.getStats(),
+      } satisfies L2BlockBuiltStats);
 
       await this.publishExtendedContractData(validTxs, block);
 
@@ -224,16 +240,25 @@ export class Sequencer {
     }
   }
 
-  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[]): Promise<T[]> {
+  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], globalVariables: GlobalVariables): Promise<T[]> {
     const validTxs: T[] = [];
-    const doubleSpendTxs = [];
+    const txsToDelete = [];
     const thisBlockNullifiers: Set<bigint> = new Set();
 
     // Process txs until we get to maxTxsPerBlock, rejecting double spends in the process
     for (const tx of txs) {
+      if (tx.data.constants.txContext.chainId.value !== globalVariables.chainId.value) {
+        this.log(
+          `Deleting tx for incorrect chain ${tx.data.constants.txContext.chainId.toString()}, tx hash ${await Tx.getHash(
+            tx,
+          )}`,
+        );
+        txsToDelete.push(tx);
+        continue;
+      }
       if (await this.isTxDoubleSpend(tx)) {
         this.log(`Deleting double spend tx ${await Tx.getHash(tx)}`);
-        doubleSpendTxs.push(tx);
+        txsToDelete.push(tx);
         continue;
       } else if (this.isTxDoubleSpendSameBlock(tx, thisBlockNullifiers)) {
         // We don't drop these txs from the p2p pool immediately since they become valid
@@ -248,8 +273,8 @@ export class Sequencer {
     }
 
     // Make sure we remove these from the tx pool so we do not consider it again
-    if (doubleSpendTxs.length > 0) {
-      await this.p2pClient.deleteTxs(await Tx.getHashes([...doubleSpendTxs]));
+    if (txsToDelete.length > 0) {
+      await this.p2pClient.deleteTxs(await Tx.getHashes([...txsToDelete]));
     }
 
     return validTxs;

package/src/simulator/public_executor.ts

@@ -6,8 +6,9 @@ import {
   PublicStateDB,
 } from '@aztec/acir-simulator';
 import { AztecAddress, CircuitsWasm, EthAddress, Fr, FunctionSelector, HistoricBlockData } from '@aztec/circuits.js';
+import { computePublicDataTreeIndex } from '@aztec/circuits.js/abis';
 import { ContractDataSource, ExtendedContractData, L1ToL2MessageSource, MerkleTreeId, Tx } from '@aztec/types';
-import { MerkleTreeOperations, computePublicDataTreeLeafIndex } from '@aztec/world-state';
+import { MerkleTreeOperations } from '@aztec/world-state';
 
 /**
  * Returns a new PublicExecutor simulator backed by the supplied merkle tree db and contract data source.
@@ -31,7 +32,7 @@ export function getPublicExecutor(
 
 /**
  * Implements the PublicContractsDB using a ContractDataSource.
- * Progresively records contracts in transaction as they are processed in a block.
+ * Progressively records contracts in transaction as they are processed in a block.
  */
 export class ContractsDataSourcePublicDB implements PublicContractsDB {
   cache = new Map<string, ExtendedContractData>();
@@ -106,7 +107,7 @@ class WorldStatePublicDB implements PublicStateDB {
    * @returns The current value in the storage slot.
    */
   public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
-    const index = computePublicDataTreeLeafIndex(contract, slot, await CircuitsWasm.get());
+    const index = computePublicDataTreeIndex(await CircuitsWasm.get(), contract, slot).value;
     const cached = this.writeCache.get(index);
     if (cached !== undefined) return cached;
     const value = await this.db.getLeafValue(MerkleTreeId.PUBLIC_DATA_TREE, index);
@@ -120,7 +121,7 @@ class WorldStatePublicDB implements PublicStateDB {
    * @param newValue - The new value to store.
    */
   public async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
-    const index = computePublicDataTreeLeafIndex(contract, slot, await CircuitsWasm.get());
+    const index = computePublicDataTreeIndex(await CircuitsWasm.get(), contract, slot).value;
     this.writeCache.set(index, newValue);
   }
 }

package/src/simulator/public_kernel.ts

@@ -1,6 +1,7 @@
 import { PublicKernelInputs, PublicKernelPublicInputs, simulatePublicKernelCircuit } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
+import { CircuitSimulationStats } from '@aztec/types/stats';
 
 import { PublicKernelCircuitSimulator } from './index.js';
 
@@ -17,14 +18,14 @@ export class WasmPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
    */
   public async publicKernelCircuitPrivateInput(input: PublicKernelInputs): Promise<PublicKernelPublicInputs> {
     if (!input.previousKernel.publicInputs.isPrivate) throw new Error(`Expected private kernel previous inputs`);
-    const [time, result] = await elapsed(() => simulatePublicKernelCircuit(input));
+    const [duration, result] = await elapsed(() => simulatePublicKernelCircuit(input));
     this.log(`Simulated public kernel circuit with private input`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-private-input',
-      duration: time.ms(),
+      duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    });
+    } satisfies CircuitSimulationStats);
     return result;
   }
 
@@ -35,14 +36,14 @@ export class WasmPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
    */
   public async publicKernelCircuitNonFirstIteration(input: PublicKernelInputs): Promise<PublicKernelPublicInputs> {
     if (input.previousKernel.publicInputs.isPrivate) throw new Error(`Expected public kernel previous inputs`);
-    const [time, result] = await elapsed(() => simulatePublicKernelCircuit(input));
+    const [duration, result] = await elapsed(() => simulatePublicKernelCircuit(input));
     this.log(`Simulated public kernel circuit non-first iteration`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-non-first-iteration',
-      duration: time.ms(),
+      duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    });
+    } satisfies CircuitSimulationStats);
     return result;
   }
 }

package/src/simulator/rollup.ts

@@ -12,6 +12,7 @@ import {
 } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
+import { CircuitSimulationStats } from '@aztec/types/stats';
 
 import { RollupSimulator } from './index.js';
 
@@ -28,7 +29,7 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
    */
   public async baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
     const wasm = await CircuitsWasm.get();
-    const [time, result] = await elapsed(() => baseRollupSim(wasm, input));
+    const [duration, result] = await elapsed(() => baseRollupSim(wasm, input));
     if (result instanceof CircuitError) {
       throw new CircuitError(result.code, result.message);
     }
@@ -36,10 +37,10 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
     this.log(`Simulated base rollup circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'base-rollup',
-      duration: time.ms(),
+      duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    });
+    } satisfies CircuitSimulationStats);
 
     return Promise.resolve(result);
   }
@@ -50,7 +51,7 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
    */
   public async mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
     const wasm = await CircuitsWasm.get();
-    const [time, result] = await elapsed(() => mergeRollupSim(wasm, input));
+    const [duration, result] = await elapsed(() => mergeRollupSim(wasm, input));
     if (result instanceof CircuitError) {
       throw new CircuitError(result.code, result.message);
     }
@@ -58,10 +59,10 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
     this.log(`Simulated merge rollup circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'merge-rollup',
-      duration: time.ms(),
+      duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    });
+    } satisfies CircuitSimulationStats);
 
     return result;
   }
@@ -73,7 +74,7 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
    */
   public async rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs> {
     const wasm = await CircuitsWasm.get();
-    const [time, result] = await elapsed(() => rootRollupSim(wasm, input));
+    const [duration, result] = await elapsed(() => rootRollupSim(wasm, input));
     if (result instanceof CircuitError) {
       throw new CircuitError(result.code, result.message);
     }
@@ -81,10 +82,10 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
     this.log(`Simulated root rollup circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'root-rollup',
-      duration: time.ms(),
+      duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    });
+    } satisfies CircuitSimulationStats);
 
     return result;
   }

package/src/utils.ts

@@ -1,10 +1,10 @@
 /**
- * Returns a promise that resolves after ms milliseconds, returning retval.
+ * Returns a promise that resolves after ms milliseconds, returning "returnValue".
  * @param ms - How many milliseconds to sleep.
- * @param retval - The return value of the promise.
+ * @param returnValue - The return value of the promise.
  */
-export function sleep<T>(ms: number, retval: T): Promise<T> {
-  return new Promise(resolve => setTimeout(() => resolve(retval), ms));
+export function sleep<T>(ms: number, returnValue: T): Promise<T> {
+  return new Promise(resolve => setTimeout(() => resolve(returnValue), ms));
 }
 
 /**