@aztec/sequencer-client 0.55.1 → 0.57.0

package/src/block_builder/index.ts

@@ -1,51 +1,7 @@
-import { TestCircuitProver } from '@aztec/bb-prover';
-import {
-  type BlockSimulator,
-  type MerkleTreeOperations,
-  type ProcessedTx,
-  type ProvingTicket,
-  type SimulationBlockResult,
-} from '@aztec/circuit-types';
-import { type Fr, type GlobalVariables } from '@aztec/circuits.js';
-import { ProvingOrchestrator } from '@aztec/prover-client/orchestrator';
-import { type SimulationProvider } from '@aztec/simulator';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+import { type BlockBuilder, type MerkleTreeOperations } from '@aztec/circuit-types';
 
-/**
- * Implements a block simulator using a test circuit prover under the hood, which just simulates circuits and outputs empty proofs.
- * This class is temporary and should die once we switch from tx effects to tx objects submissions, since sequencers won't have
- * the need to create L2 block headers to submit to L1. When we do that, we should also remove the references to the
- * prover-client and bb-prover packages from this package.
- */
-export class BlockBuilder implements BlockSimulator {
-  private orchestrator: ProvingOrchestrator;
-  constructor(db: MerkleTreeOperations, simulationProvider: SimulationProvider, telemetry: TelemetryClient) {
-    const testProver = new TestCircuitProver(telemetry, simulationProvider);
-    this.orchestrator = new ProvingOrchestrator(db, testProver, telemetry);
-  }
-
-  startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<ProvingTicket> {
-    return this.orchestrator.startNewBlock(numTxs, globalVariables, l1ToL2Messages);
-  }
-  cancelBlock(): void {
-    this.orchestrator.cancelBlock();
-  }
-  finaliseBlock(): Promise<SimulationBlockResult> {
-    return this.orchestrator.finaliseBlock();
-  }
-  setBlockCompleted(): Promise<void> {
-    return this.orchestrator.setBlockCompleted();
-  }
-  addNewTx(tx: ProcessedTx): Promise<void> {
-    return this.orchestrator.addNewTx(tx);
-  }
-}
-
-export class BlockBuilderFactory {
-  constructor(private simulationProvider: SimulationProvider, private telemetry?: TelemetryClient) {}
-
-  create(db: MerkleTreeOperations): BlockSimulator {
-    return new BlockBuilder(db, this.simulationProvider, this.telemetry ?? new NoopTelemetryClient());
-  }
+export * from './orchestrator.js';
+export * from './light.js';
+export interface BlockBuilderFactory {
+  create(db: MerkleTreeOperations): BlockBuilder;
 }

package/src/block_builder/light.ts

@@ -0,0 +1,102 @@
+import { createDebugLogger } from '@aztec/aztec.js';
+import {
+  type BlockBuilder,
+  Body,
+  L2Block,
+  MerkleTreeId,
+  type MerkleTreeOperations,
+  type ProcessedTx,
+  type TxEffect,
+  makeEmptyProcessedTx,
+  toTxEffect,
+} from '@aztec/circuit-types';
+import {
+  Fr,
+  type GlobalVariables,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  VerificationKeyData,
+  makeEmptyRecursiveProof,
+} from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
+import { buildBaseRollupInput, buildHeaderFromTxEffects, getTreeSnapshot } from '@aztec/prover-client/helpers';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+
+/**
+ * Builds a block and its header from a set of processed tx without running any circuits.
+ */
+export class LightweightBlockBuilder implements BlockBuilder {
+  private numTxs?: number;
+  private globalVariables?: GlobalVariables;
+  private l1ToL2Messages?: Fr[];
+
+  private readonly txs: ProcessedTx[] = [];
+
+  private readonly logger = createDebugLogger('aztec:sequencer-client:block_builder_light');
+
+  constructor(private db: MerkleTreeOperations, private telemetry: TelemetryClient) {}
+
+  async startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void> {
+    this.logger.verbose('Starting new block', { numTxs, globalVariables, l1ToL2Messages });
+    this.numTxs = numTxs;
+    this.globalVariables = globalVariables;
+    this.l1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+
+    // Update L1 to L2 tree
+    await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.l1ToL2Messages!);
+  }
+
+  async addNewTx(tx: ProcessedTx): Promise<void> {
+    this.logger.verbose('Adding new tx to block', { txHash: tx.hash.toString() });
+    this.txs.push(tx);
+    await buildBaseRollupInput(
+      tx,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      this.globalVariables!,
+      this.db,
+      VerificationKeyData.makeFake(),
+    );
+  }
+
+  async setBlockCompleted(): Promise<L2Block> {
+    const paddingTxCount = this.numTxs! - this.txs.length;
+    this.logger.verbose(`Setting block as completed and adding ${paddingTxCount} padding txs`);
+    for (let i = 0; i < paddingTxCount; i++) {
+      await this.addNewTx(
+        makeEmptyProcessedTx(
+          this.db.getInitialHeader(),
+          this.globalVariables!.chainId,
+          this.globalVariables!.version,
+          getVKTreeRoot(),
+        ),
+      );
+    }
+
+    return this.buildBlock();
+  }
+
+  private async buildBlock(): Promise<L2Block> {
+    this.logger.verbose(`Finalising block`);
+    const nonEmptyTxEffects: TxEffect[] = this.txs
+      .map(tx => toTxEffect(tx, this.globalVariables!.gasFees))
+      .filter(txEffect => !txEffect.isEmpty());
+    const body = new Body(nonEmptyTxEffects);
+    const header = await buildHeaderFromTxEffects(body, this.globalVariables!, this.l1ToL2Messages!, this.db);
+
+    await this.db.updateArchive(header);
+    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
+
+    const block = new L2Block(newArchive, header, body);
+    return block;
+  }
+}
+
+export class LightweightBlockBuilderFactory {
+  constructor(private telemetry?: TelemetryClient) {}
+
+  create(db: MerkleTreeOperations): BlockBuilder {
+    return new LightweightBlockBuilder(db, this.telemetry ?? new NoopTelemetryClient());
+  }
+}

package/src/block_builder/orchestrator.ts

@@ -0,0 +1,38 @@
+import { TestCircuitProver } from '@aztec/bb-prover';
+import { type BlockBuilder, type L2Block, type MerkleTreeOperations, type ProcessedTx } from '@aztec/circuit-types';
+import { type Fr, type GlobalVariables } from '@aztec/circuits.js';
+import { ProvingOrchestrator } from '@aztec/prover-client/orchestrator';
+import { type SimulationProvider } from '@aztec/simulator';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+
+/**
+ * Implements a block simulator using a test circuit prover under the hood, which just simulates circuits and outputs empty proofs.
+ * This class is unused at the moment, but could be leveraged by a prover-node to ascertain that it can prove a block before
+ * committing to proving it by sending a quote.
+ */
+export class OrchestratorBlockBuilder implements BlockBuilder {
+  private orchestrator: ProvingOrchestrator;
+  constructor(db: MerkleTreeOperations, simulationProvider: SimulationProvider, telemetry: TelemetryClient) {
+    const testProver = new TestCircuitProver(telemetry, simulationProvider);
+    this.orchestrator = new ProvingOrchestrator(db, testProver, telemetry);
+  }
+
+  startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void> {
+    return this.orchestrator.startNewBlock(numTxs, globalVariables, l1ToL2Messages);
+  }
+  setBlockCompleted(): Promise<L2Block> {
+    return this.orchestrator.setBlockCompleted();
+  }
+  addNewTx(tx: ProcessedTx): Promise<void> {
+    return this.orchestrator.addNewTx(tx);
+  }
+}
+
+export class OrchestratorBlockBuilderFactory {
+  constructor(private simulationProvider: SimulationProvider, private telemetry?: TelemetryClient) {}
+
+  create(db: MerkleTreeOperations): BlockBuilder {
+    return new OrchestratorBlockBuilder(db, this.simulationProvider, this.telemetry ?? new NoopTelemetryClient());
+  }
+}

package/src/client/sequencer-client.ts

@@ -1,11 +1,12 @@
 import { type L1ToL2MessageSource, type L2BlockSource, type WorldStateSynchronizer } from '@aztec/circuit-types';
+import { type EthAddress } from '@aztec/foundation/eth-address';
 import { type P2P } from '@aztec/p2p';
 import { PublicProcessorFactory, type SimulationProvider } from '@aztec/simulator';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { type ContractDataSource } from '@aztec/types/contracts';
 import { type ValidatorClient } from '@aztec/validator-client';
 
-import { BlockBuilderFactory } from '../block_builder/index.js';
+import { LightweightBlockBuilderFactory } from '../block_builder/index.js';
 import { type SequencerClientConfig } from '../config.js';
 import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
 import { L1Publisher } from '../publisher/index.js';
@@ -59,7 +60,7 @@ export class SequencerClient {
       globalsBuilder,
       p2pClient,
       worldStateSynchronizer,
-      new BlockBuilderFactory(simulationProvider, telemetryClient),
+      new LightweightBlockBuilderFactory(telemetryClient),
       l2BlockSource,
       l1ToL2MessageSource,
       publicProcessorFactory,
@@ -99,7 +100,7 @@ export class SequencerClient {
     this.sequencer.restart();
   }
 
-  get coinbase() {
+  get coinbase(): EthAddress {
     return this.sequencer.coinbase;
   }
 

package/src/config.ts

@@ -117,9 +117,9 @@ export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
 
 export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {
   ...sequencerConfigMappings,
+  ...l1ReaderConfigMappings,
   ...getTxSenderConfigMappings('SEQ'),
   ...getPublisherConfigMappings('SEQ'),
-  ...l1ReaderConfigMappings,
   ...chainConfigMappings,
 };
 
@@ -189,16 +189,19 @@ function getDefaultAllowedSetupFunctions(): AllowedElement[] {
     // needed for claiming on the same tx as a spend
     {
       address: FeeJuiceAddress,
-      selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+      // We can't restrict the selector because public functions get routed via dispatch.
+      // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
     },
     // needed for private transfers via FPC
     {
       classId: getContractClassFromArtifact(TokenContractArtifact).id,
-      selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+      // We can't restrict the selector because public functions get routed via dispatch.
+      // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
     },
     {
       classId: getContractClassFromArtifact(FPCContract.artifact).id,
-      selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
+      // We can't restrict the selector because public functions get routed via dispatch.
+      // selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
     },
   ];
 }

package/src/global_variable_builder/global_builder.ts

@@ -39,6 +39,7 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     this.publicClient = createPublicClient({
       chain: chain.chainInfo,
       transport: http(chain.rpcUrl),
+      pollingInterval: config.viemPollingIntervalMS,
     });
 
     this.rollupContract = getContract({

package/src/publisher/config.ts

@@ -1,5 +1,5 @@
 import { type L1ReaderConfig, NULL_KEY } from '@aztec/ethereum';
-import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
 
 /**
  * The configuration of the rollup transaction publisher.
@@ -51,6 +51,11 @@ export const getTxSenderConfigMappings: (
     defaultValue: 1,
     description: 'The number of confirmations required.',
   },
+  viemPollingIntervalMS: {
+    env: `${scope}_VIEM_POLLING_INTERVAL_MS`,
+    description: 'The polling interval viem uses in ms',
+    ...numberConfigHelper(1_000),
+  },
 });
 
 export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'> {

package/src/publisher/index.ts

@@ -1,2 +1,2 @@
-export { L1Publisher } from './l1-publisher.js';
+export { L1Publisher, L1SubmitEpochProofArgs } from './l1-publisher.js';
 export * from './config.js';