@aztec/sequencer-client 0.55.1 → 0.57.0

package/src/sequencer/sequencer.ts

@@ -1,27 +1,28 @@
 import {
   type BlockAttestation,
+  type EpochProofQuote,
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
   type ProcessedTx,
-  Signature,
   Tx,
   type TxHash,
   type TxValidator,
   type WorldStateStatus,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
-import { type AllowedElement, BlockProofError, PROVING_STATUS } from '@aztec/circuit-types/interfaces';
+import { type AllowedElement, BlockProofError } from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
 import {
   AppendOnlyTreeSnapshot,
-  AztecAddress,
   ContentCommitment,
-  EthAddress,
   GENESIS_ARCHIVE_ROOT,
   Header,
   StateReference,
 } from '@aztec/circuits.js';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -31,10 +32,12 @@ import { type PublicProcessorFactory } from '@aztec/simulator';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 import { type ValidatorClient } from '@aztec/validator-client';
 
+import { inspect } from 'util';
+
 import { type BlockBuilderFactory } from '../block_builder/index.js';
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type L1Publisher } from '../publisher/l1-publisher.js';
-import { prettyLogVeimError } from '../publisher/utils.js';
+import { prettyLogViemError } from '../publisher/utils.js';
 import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
@@ -311,7 +314,7 @@ export class Sequencer {
       this.log.debug(`Can propose block ${proposalBlockNumber} at slot ${slot}`);
       return slot;
     } catch (err) {
-      prettyLogVeimError(err, this.log);
+      prettyLogViemError(err, this.log);
       throw err;
     }
   }
@@ -424,7 +427,7 @@ export class Sequencer {
 
     const blockBuildingTimer = new Timer();
     const blockBuilder = this.blockBuilderFactory.create(this.worldState.getLatest());
-    const blockTicket = await blockBuilder.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
+    await blockBuilder.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
 
     const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
       processor.process(validTxs, blockSize, blockBuilder, this.txValidatorFactory.validatorForProcessedTxs()),
@@ -443,23 +446,15 @@ export class Sequencer {
         processedTxsCount: processedTxs.length,
       })
     ) {
-      blockBuilder.cancelBlock();
+      // TODO: Roll back changes to world state
       throw new Error('Should not propose the block');
     }
 
     // All real transactions have been added, set the block as full and complete the proving.
-    await blockBuilder.setBlockCompleted();
+    const block = await blockBuilder.setBlockCompleted();
 
-    // Here we are now waiting for the block to be proven (using simulated[fake] proofs).
     // TODO(@PhilWindle) We should probably periodically check for things like another
     // block being published before ours instead of just waiting on our block
-    const result = await blockTicket.provingPromise;
-    if (result.status === PROVING_STATUS.FAILURE) {
-      throw new Error(`Block proving failed, reason: ${result.reason}`);
-    }
-
-    // Block is ready, now finalise
-    const { block } = await blockBuilder.finaliseBlock();
 
     await this.publisher.validateBlockForSubmission(block.header);
 
@@ -488,13 +483,17 @@ export class Sequencer {
     const attestations = await this.collectAttestations(block, txHashes);
     this.log.verbose('Attestations collected');
 
+    this.log.verbose('Collecting proof quotes');
+    const proofQuote = await this.createProofClaimForPreviousEpoch(newGlobalVariables.slotNumber.toBigInt());
+    this.log.verbose(proofQuote ? `Using proof quote ${inspect(proofQuote.payload)}` : 'No proof quote available');
+
     try {
-      await this.publishL2Block(block, attestations, txHashes);
+      await this.publishL2Block(block, attestations, txHashes, proofQuote);
       this.metrics.recordPublishedBlock(workDuration);
       this.log.info(
-        `Submitted rollup block ${block.number} with ${
-          processedTxs.length
-        } transactions duration=${workDuration}ms (Submitter: ${await this.publisher.getSenderAddress()})`,
+        `Submitted rollup block ${block.number} with ${processedTxs.length} transactions duration=${Math.ceil(
+          workDuration,
+        )}ms (Submitter: ${this.publisher.getSenderAddress()})`,
       );
     } catch (err) {
       this.metrics.recordFailedBlock();
@@ -537,7 +536,51 @@ export class Sequencer {
     this.log.verbose(`Collected attestations from validators, number of attestations: ${attestations.length}`);
 
     // note: the smart contract requires that the signatures are provided in the order of the committee
-    return await orderAttestations(attestations, committee);
+    return orderAttestations(attestations, committee);
+  }
+
+  protected async createProofClaimForPreviousEpoch(slotNumber: bigint): Promise<EpochProofQuote | undefined> {
+    try {
+      // Find out which epoch we are currently in
+      const epochForBlock = await this.publisher.getEpochForSlotNumber(slotNumber);
+      if (epochForBlock < 1n) {
+        // It's the 0th epoch, nothing to be proven yet
+        this.log.verbose(`First epoch has no claim`);
+        return undefined;
+      }
+      const epochToProve = epochForBlock - 1n;
+      // Find out the next epoch that can be claimed
+      const canClaim = await this.publisher.nextEpochToClaim();
+      if (canClaim != epochToProve) {
+        // It's not the one we are looking to claim
+        this.log.verbose(`Unable to claim previous epoch (${canClaim} != ${epochToProve})`);
+        return undefined;
+      }
+      // Get quotes for the epoch to be proven
+      const quotes = await this.p2pClient.getEpochProofQuotes(epochToProve);
+      this.log.verbose(`Retrieved ${quotes.length} quotes, slot: ${slotNumber}, epoch to prove: ${epochToProve}`);
+      for (const quote of quotes) {
+        this.log.verbose(inspect(quote.payload));
+      }
+      // ensure these quotes are still valid for the slot and have the contract validate them
+      const validQuotesPromise = Promise.all(
+        quotes.filter(x => x.payload.validUntilSlot >= slotNumber).map(x => this.publisher.validateProofQuote(x)),
+      );
+
+      const validQuotes = (await validQuotesPromise).filter((q): q is EpochProofQuote => !!q);
+      if (!validQuotes.length) {
+        this.log.verbose(`Failed to find any valid proof quotes`);
+        return undefined;
+      }
+      // pick the quote with the lowest fee
+      const sortedQuotes = validQuotes.sort(
+        (a: EpochProofQuote, b: EpochProofQuote) => a.payload.basisPointFee - b.payload.basisPointFee,
+      );
+      return sortedQuotes[0];
+    } catch (err) {
+      this.log.error(`Failed to create proof claim for previous epoch: ${err}`);
+      return undefined;
+    }
   }
 
   /**
@@ -547,11 +590,16 @@ export class Sequencer {
   @trackSpan('Sequencer.publishL2Block', block => ({
     [Attributes.BLOCK_NUMBER]: block.number,
   }))
-  protected async publishL2Block(block: L2Block, attestations?: Signature[], txHashes?: TxHash[]) {
+  protected async publishL2Block(
+    block: L2Block,
+    attestations?: Signature[],
+    txHashes?: TxHash[],
+    proofQuote?: EpochProofQuote,
+  ) {
     // Publishes new block to the network and awaits the tx to be mined
     this.state = SequencerState.PUBLISHING_BLOCK;
 
-    const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes);
+    const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote);
     if (publishedL2Block) {
       this.lastPublishedBlock = block.number;
     } else {
@@ -666,12 +714,12 @@ export enum SequencerState {
  *
  * @todo: perform this logic within the memory attestation store instead?
  */
-async function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): Promise<Signature[]> {
+function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): Signature[] {
   // Create a map of sender addresses to BlockAttestations
   const attestationMap = new Map<string, BlockAttestation>();
 
   for (const attestation of attestations) {
-    const sender = await attestation.getSender();
+    const sender = attestation.getSender();
     if (sender) {
       attestationMap.set(sender.toString(), attestation);
     }

package/src/tx_validator/gas_validator.ts

@@ -1,8 +1,7 @@
-import { PublicKernelType, type Tx, type TxValidator } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+import { PublicKernelPhase, type Tx, type TxValidator } from '@aztec/circuit-types';
+import { type AztecAddress, type Fr, FunctionSelector } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { FeeJuiceArtifact } from '@aztec/protocol-contracts/fee-juice';
-import { AbstractPhaseManager, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
+import { EnqueuedCallsProcessor, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
 export interface PublicStateSource {
@@ -34,6 +33,10 @@ export class GasTxValidator implements TxValidator<Tx> {
     return [validTxs, invalidTxs];
   }
 
+  validateTx(tx: Tx): Promise<boolean> {
+    return this.#validateTxFee(tx);
+  }
+
   async #validateTxFee(tx: Tx): Promise<boolean> {
     const feePayer = tx.data.feePayer;
     // TODO(@spalladino) Eventually remove the is_zero condition as we should always charge fees to every tx
@@ -55,20 +58,20 @@ export class GasTxValidator implements TxValidator<Tx> {
     );
 
     // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
-    const { [PublicKernelType.SETUP]: setupFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx);
+    const setupFns = EnqueuedCallsProcessor.getExecutionRequestsByPhase(tx, PublicKernelPhase.SETUP);
     const claimFunctionCall = setupFns.find(
       fn =>
         fn.contractAddress.equals(this.#feeJuiceAddress) &&
         fn.callContext.msgSender.equals(this.#feeJuiceAddress) &&
-        fn.callContext.functionSelector.equals(
-          FeeJuiceArtifact.functions.find(f => f.name === '_increase_public_balance')!,
-        ) &&
-        fn.args[0].equals(feePayer) &&
+        fn.args.length > 2 &&
+        // Public functions get routed through the dispatch function, whose first argument is the target function selector.
+        fn.args[0].equals(FunctionSelector.fromSignature('_increase_public_balance((Field),Field)').toField()) &&
+        fn.args[1].equals(feePayer) &&
         !fn.callContext.isStaticCall &&
         !fn.callContext.isDelegateCall,
     );
 
-    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[1]) : initialBalance;
+    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
     if (balance.lt(feeLimit)) {
       this.#log.info(`Rejecting transaction due to not enough fee payer balance`, { feePayer, balance, feeLimit });
       return false;

package/src/tx_validator/phases_validator.ts

@@ -1,12 +1,12 @@
 import {
   type AllowedElement,
   type PublicExecutionRequest,
-  PublicKernelType,
+  PublicKernelPhase,
   Tx,
   type TxValidator,
 } from '@aztec/circuit-types';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { AbstractPhaseManager, ContractsDataSourcePublicDB } from '@aztec/simulator';
+import { ContractsDataSourcePublicDB, EnqueuedCallsProcessor } from '@aztec/simulator';
 import { type ContractDataSource } from '@aztec/types/contracts';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
@@ -27,7 +27,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
       // which is what we're trying to do as part of the current txs.
       await this.contractDataSource.addNewContracts(tx);
 
-      if (await this.#validateTx(tx)) {
+      if (await this.validateTx(tx)) {
         validTxs.push(tx);
       } else {
         invalidTxs.push(tx);
@@ -39,14 +39,13 @@ export class PhasesTxValidator implements TxValidator<Tx> {
     return Promise.resolve([validTxs, invalidTxs]);
   }
 
-  async #validateTx(tx: Tx): Promise<boolean> {
+  async validateTx(tx: Tx): Promise<boolean> {
     if (!tx.data.forPublic) {
       this.#log.debug(`Tx ${Tx.getHash(tx)} does not contain enqueued public functions. Skipping phases validation.`);
       return true;
     }
 
-    const { [PublicKernelType.SETUP]: setupFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx);
-
+    const setupFns = EnqueuedCallsProcessor.getExecutionRequestsByPhase(tx, PublicKernelPhase.SETUP);
     for (const setupFn of setupFns) {
       if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
         this.#log.warn(

package/src/tx_validator/test_utils.ts

@@ -32,9 +32,9 @@ function patchFn(
   tx.enqueuedPublicFunctionCalls[index] = fn;
 
   const request = tx.data.forPublic![where].publicCallStack[index];
-  request.item.contractAddress = fn.contractAddress;
-  request.item.callContext = fn.callContext;
-  request.item.argsHash = computeVarArgsHash(fn.args);
+  request.contractAddress = fn.contractAddress;
+  request.callContext = fn.callContext;
+  request.argsHash = computeVarArgsHash(fn.args);
   tx.data.forPublic![where].publicCallStack[index] = request;
 
   return {

package/src/tx_validator/tx_validator_factory.ts

@@ -2,7 +2,7 @@ import { type AllowedElement, type ProcessedTx, type Tx, type TxValidator } from
 import { type GlobalVariables } from '@aztec/circuits.js';
 import { AggregateTxValidator, DataTxValidator, DoubleSpendTxValidator, MetadataTxValidator } from '@aztec/p2p';
 import { FeeJuiceAddress } from '@aztec/protocol-contracts/fee-juice';
-import { WorldStateDB, WorldStatePublicDB } from '@aztec/simulator';
+import { WorldStateDB } from '@aztec/simulator';
 import { type ContractDataSource } from '@aztec/types/contracts';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -17,16 +17,17 @@ export class TxValidatorFactory {
   ) {}
 
   validatorForNewTxs(globalVariables: GlobalVariables, setupAllowList: AllowedElement[]): TxValidator<Tx> {
+    const worldStateDB = new WorldStateDB(this.merkleTreeDb, this.contractDataSource);
     return new AggregateTxValidator(
       new DataTxValidator(),
       new MetadataTxValidator(globalVariables.chainId, globalVariables.blockNumber),
-      new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb)),
+      new DoubleSpendTxValidator(worldStateDB),
       new PhasesTxValidator(this.contractDataSource, setupAllowList),
-      new GasTxValidator(new WorldStatePublicDB(this.merkleTreeDb), FeeJuiceAddress, this.enforceFees),
+      new GasTxValidator(worldStateDB, FeeJuiceAddress, this.enforceFees),
     );
   }
 
   validatorForProcessedTxs(): TxValidator<ProcessedTx> {
-    return new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb));
+    return new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb, this.contractDataSource));
   }
 }