@aztec/sequencer-client 0.56.0 → 0.58.0

package/src/publisher/utils.ts

@@ -2,7 +2,7 @@ import { type Logger } from '@aztec/foundation/log';
 
 import { BaseError, ContractFunctionRevertedError } from 'viem';
 
-export function prettyLogVeimError(err: any, logger: Logger) {
+export function prettyLogViemError(err: any, logger: Logger) {
   if (err instanceof BaseError) {
     const revertError = err.walk(err => err instanceof ContractFunctionRevertedError);
     if (revertError instanceof ContractFunctionRevertedError) {

package/src/sequencer/sequencer.ts

@@ -1,5 +1,6 @@
 import {
   type BlockAttestation,
+  type EpochProofQuote,
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
@@ -7,10 +8,13 @@ import {
   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,
+  type WorldStateSynchronizerStatus,
+} from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
 import {
   AppendOnlyTreeSnapshot,
@@ -31,10 +35,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';
@@ -64,7 +70,6 @@ export class Sequencer {
   // TODO: zero values should not be allowed for the following 2 values in PROD
   private _coinbase = EthAddress.ZERO;
   private _feeRecipient = AztecAddress.ZERO;
-  private lastPublishedBlock = 0;
   private state = SequencerState.STOPPED;
   private allowedInSetup: AllowedElement[] = [];
   private allowedInTeardown: AllowedElement[] = [];
@@ -139,13 +144,12 @@ export class Sequencer {
   /**
    * Starts the sequencer and moves to IDLE state. Blocks until the initial sync is complete.
    */
-  public async start() {
-    await this.initialSync();
-
+  public start() {
     this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
     this.runningPromise.start();
     this.state = SequencerState.IDLE;
     this.log.info('Sequencer started');
+    return Promise.resolve();
   }
 
   /**
@@ -177,11 +181,6 @@ export class Sequencer {
     return { state: this.state };
   }
 
-  protected async initialSync() {
-    // 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);
-  }
-
   /**
    * @notice  Performs most of the sequencer duties:
    *          - Checks if we are up to date
@@ -276,15 +275,14 @@ export class Sequencer {
       // @note  It is very important that the following function will FAIL and not just return early
       //        if it have made any state changes. If not, we won't rollback the state, and you will
       //        be in for a world of pain.
-      await this.buildBlockAndPublish(validTxs, proposalHeader, historicalHeader);
+      await this.buildBlockAndAttemptToPublish(validTxs, proposalHeader, historicalHeader);
     } catch (err) {
       if (BlockProofError.isBlockProofError(err)) {
         const txHashes = err.txHashes.filter(h => !h.isZero());
         this.log.warn(`Proving block failed, removing ${txHashes.length} txs from pool`);
         await this.p2pClient.deleteTxs(txHashes);
       }
-      this.log.error(`Rolling back world state DB due to error assembling block`, (err as any).stack);
-      await this.worldState.getLatest().rollback();
+      this.log.error(`Error assembling block`, (err as any).stack);
     }
   }
 
@@ -311,7 +309,8 @@ export class Sequencer {
       this.log.debug(`Can propose block ${proposalBlockNumber} at slot ${slot}`);
       return slot;
     } catch (err) {
-      prettyLogVeimError(err, this.log);
+      this.log.verbose(`Rejected from being able to propose at next block with ${tipArchive}`);
+      prettyLogViemError(err, this.log);
       throw err;
     }
   }
@@ -392,10 +391,10 @@ export class Sequencer {
    * @param proposalHeader - The partial header constructed for the proposal
    * @param historicalHeader - The historical header of the parent
    */
-  @trackSpan('Sequencer.buildBlockAndPublish', (_validTxs, proposalHeader, _historicalHeader) => ({
+  @trackSpan('Sequencer.buildBlockAndAttemptToPublish', (_validTxs, proposalHeader, _historicalHeader) => ({
     [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
   }))
-  private async buildBlockAndPublish(
+  private async buildBlockAndAttemptToPublish(
     validTxs: Tx[],
     proposalHeader: Header,
     historicalHeader: Header | undefined,
@@ -416,89 +415,90 @@ export class Sequencer {
       `Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newGlobalVariables.blockNumber.toNumber()}`,
     );
 
-    // We create a fresh processor each time to reset any cached state (eg storage writes)
-    const processor = this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
-
     const numRealTxs = validTxs.length;
     const blockSize = Math.max(2, numRealTxs);
 
-    const blockBuildingTimer = new Timer();
-    const blockBuilder = this.blockBuilderFactory.create(this.worldState.getLatest());
-    const blockTicket = await blockBuilder.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
-
-    const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-      processor.process(validTxs, blockSize, blockBuilder, this.txValidatorFactory.validatorForProcessedTxs()),
-    );
-    if (failedTxs.length > 0) {
-      const failedTxData = failedTxs.map(fail => fail.tx);
-      this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
-      await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
-    }
-
-    await this.publisher.validateBlockForSubmission(proposalHeader);
-
-    if (
-      !this.shouldProposeBlock(historicalHeader, {
-        validTxsCount: validTxs.length,
-        processedTxsCount: processedTxs.length,
-      })
-    ) {
-      blockBuilder.cancel();
-      throw new Error('Should not propose the block');
-    }
+    const fork = await this.worldState.fork();
+    try {
+      // We create a fresh processor each time to reset any cached state (eg storage writes)
+      const processor = this.publicProcessorFactory.create(fork, historicalHeader, newGlobalVariables);
+      const blockBuildingTimer = new Timer();
+      const blockBuilder = this.blockBuilderFactory.create(fork);
+      await blockBuilder.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
+
+      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
+        processor.process(validTxs, blockSize, blockBuilder, this.txValidatorFactory.validatorForProcessedTxs(fork)),
+      );
+      if (failedTxs.length > 0) {
+        const failedTxData = failedTxs.map(fail => fail.tx);
+        this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
+        await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
+      }
 
-    // All real transactions have been added, set the block as full and complete the proving.
-    await blockBuilder.setBlockCompleted();
+      await this.publisher.validateBlockForSubmission(proposalHeader);
 
-    // 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}`);
-    }
+      if (
+        !this.shouldProposeBlock(historicalHeader, {
+          validTxsCount: validTxs.length,
+          processedTxsCount: processedTxs.length,
+        })
+      ) {
+        // TODO: Roll back changes to world state
+        throw new Error('Should not propose the block');
+      }
 
-    // Block is ready, now finalise
-    const { block } = await blockBuilder.finaliseBlock();
+      // All real transactions have been added, set the block as full and complete the proving.
+      const block = await blockBuilder.setBlockCompleted();
+
+      // TODO(@PhilWindle) We should probably periodically check for things like another
+      // block being published before ours instead of just waiting on our block
+
+      await this.publisher.validateBlockForSubmission(block.header);
+
+      const workDuration = workTimer.ms();
+      this.log.verbose(
+        `Assembled block ${block.number} (txEffectsHash: ${block.header.contentCommitment.txsEffectsHash.toString(
+          'hex',
+        )})`,
+        {
+          eventName: 'l2-block-built',
+          creator: this.publisher.getSenderAddress().toString(),
+          duration: workDuration,
+          publicProcessDuration: publicProcessorDuration,
+          rollupCircuitsDuration: blockBuildingTimer.ms(),
+          ...block.getStats(),
+        } satisfies L2BlockBuiltStats,
+      );
 
-    await this.publisher.validateBlockForSubmission(block.header);
+      if (this.isFlushing) {
+        this.log.verbose(`Flushing completed`);
+      }
 
-    const workDuration = workTimer.ms();
-    this.log.verbose(
-      `Assembled block ${block.number} (txEffectsHash: ${block.header.contentCommitment.txsEffectsHash.toString(
-        'hex',
-      )})`,
-      {
-        eventName: 'l2-block-built',
-        duration: workDuration,
-        publicProcessDuration: publicProcessorDuration,
-        rollupCircuitsDuration: blockBuildingTimer.ms(),
-        ...block.getStats(),
-      } satisfies L2BlockBuiltStats,
-    );
+      const txHashes = validTxs.map(tx => tx.getTxHash());
 
-    if (this.isFlushing) {
-      this.log.verbose(`Flushing completed`);
-    }
+      this.isFlushing = false;
+      this.log.verbose('Collecting attestations');
+      const attestations = await this.collectAttestations(block, txHashes);
+      this.log.verbose('Attestations collected');
 
-    const txHashes = validTxs.map(tx => tx.getTxHash());
+      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');
 
-    this.isFlushing = false;
-    this.log.verbose('Collecting attestations');
-    const attestations = await this.collectAttestations(block, txHashes);
-    this.log.verbose('Attestations collected');
-
-    try {
-      await this.publishL2Block(block, attestations, txHashes);
-      this.metrics.recordPublishedBlock(workDuration);
-      this.log.info(
-        `Submitted rollup block ${block.number} with ${
-          processedTxs.length
-        } transactions duration=${workDuration}ms (Submitter: ${await this.publisher.getSenderAddress()})`,
-      );
-    } catch (err) {
-      this.metrics.recordFailedBlock();
-      throw err;
+      try {
+        await this.publishL2Block(block, attestations, txHashes, proofQuote);
+        this.metrics.recordPublishedBlock(workDuration);
+        this.log.info(
+          `Submitted rollup block ${block.number} with ${processedTxs.length} transactions duration=${Math.ceil(
+            workDuration,
+          )}ms (Submitter: ${this.publisher.getSenderAddress()})`,
+        );
+      } catch (err) {
+        this.metrics.recordFailedBlock();
+        throw err;
+      }
+    } finally {
+      await fork.close();
     }
   }
 
@@ -507,6 +507,11 @@ export class Sequencer {
     this.isFlushing = true;
   }
 
+  @trackSpan('Sequencer.collectAttestations', (block, txHashes) => ({
+    [Attributes.BLOCK_NUMBER]: block.number,
+    [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
+    [Attributes.BLOCK_TXS_COUNT]: txHashes.length,
+  }))
   protected async collectAttestations(block: L2Block, txHashes: TxHash[]): Promise<Signature[] | undefined> {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962): inefficient to have a round trip in here - this should be cached
     const committee = await this.publisher.getCurrentEpochCommittee();
@@ -540,6 +545,50 @@ export class Sequencer {
     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;
+    }
+  }
+
   /**
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.
@@ -547,14 +596,17 @@ 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);
-    if (publishedL2Block) {
-      this.lastPublishedBlock = block.number;
-    } else {
+    const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote);
+    if (!publishedL2Block) {
       throw new Error(`Failed to publish block ${block.number}`);
     }
   }
@@ -590,24 +642,37 @@ export class Sequencer {
   }
 
   /**
-   * Returns whether the previous block sent has been mined, and all dependencies have caught up with it.
+   * Returns whether all dependencies have caught up.
+   * We don't check against the previous block submitted since it may have been reorg'd out.
    * @returns Boolean indicating if our dependencies are synced to the latest block.
    */
   protected async isBlockSynced() {
     const syncedBlocks = await Promise.all([
-      this.worldState.status().then((s: WorldStateStatus) => s.syncedToL2Block),
-      this.p2pClient.getStatus().then(s => s.syncedToL2Block),
-      this.l2BlockSource.getBlockNumber(),
+      this.worldState.status().then((s: WorldStateSynchronizerStatus) => s.syncedToL2Block),
+      this.l2BlockSource.getL2Tips().then(t => t.latest),
+      this.p2pClient.getStatus().then(s => s.syncedToL2Block.number),
       this.l1ToL2MessageSource.getBlockNumber(),
-    ]);
-    const min = Math.min(...syncedBlocks);
-    const [worldState, p2p, l2BlockSource, l1ToL2MessageSource] = syncedBlocks;
-    const result = min >= this.lastPublishedBlock;
-    this.log.debug(`Sync check to last published block ${this.lastPublishedBlock} ${result ? 'succeeded' : 'failed'}`, {
-      worldState,
-      p2p,
-      l2BlockSource,
-      l1ToL2MessageSource,
+    ] as const);
+    const [worldState, l2BlockSource, p2p, l1ToL2MessageSource] = syncedBlocks;
+    const result =
+      // check that world state has caught up with archiver
+      // note that the archiver reports undefined hash for the genesis block
+      // because it doesn't have access to world state to compute it (facepalm)
+      (l2BlockSource.hash === undefined || worldState.hash === l2BlockSource.hash) &&
+      // and p2p client and message source are at least at the same block
+      // this should change to hashes once p2p client handles reorgs
+      // and once we stop pretending that the l1tol2message source is not
+      // just the archiver under a different name
+      p2p >= l2BlockSource.number &&
+      l1ToL2MessageSource >= l2BlockSource.number;
+
+    this.log.verbose(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, {
+      worldStateNumber: worldState.number,
+      worldStateHash: worldState.hash,
+      l2BlockSourceNumber: l2BlockSource.number,
+      l2BlockSourceHash: l2BlockSource.hash,
+      p2pNumber: p2p,
+      l1ToL2MessageSourceNumber: l1ToL2MessageSource,
     });
     return result;
   }

package/src/tx_validator/gas_validator.ts

@@ -1,7 +1,6 @@
 import { PublicKernelPhase, type Tx, type TxValidator } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+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 { EnqueuedCallsProcessor, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
@@ -64,15 +63,15 @@ export class GasTxValidator implements TxValidator<Tx> {
       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

@@ -5,9 +5,9 @@ import {
   Tx,
   type TxValidator,
 } from '@aztec/circuit-types';
+import { type ContractDataSource } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { ContractsDataSourcePublicDB, EnqueuedCallsProcessor } from '@aztec/simulator';
-import { type ContractDataSource } from '@aztec/types/contracts';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createDebugLogger('aztec:sequencer:tx_validator:tx_phases');

package/src/tx_validator/tx_validator_factory.ts

@@ -1,33 +1,57 @@
-import { type AllowedElement, type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
-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 } from '@aztec/simulator';
-import { type ContractDataSource } from '@aztec/types/contracts';
-import { type MerkleTreeOperations } from '@aztec/world-state';
+import {
+  type AllowedElement,
+  MerkleTreeId,
+  type MerkleTreeReadOperations,
+  type ProcessedTx,
+  type Tx,
+  type TxValidator,
+} from '@aztec/circuit-types';
+import { type ContractDataSource, type GlobalVariables } from '@aztec/circuits.js';
+import {
+  AggregateTxValidator,
+  DataTxValidator,
+  DoubleSpendTxValidator,
+  MetadataTxValidator,
+  type NullifierSource,
+} from '@aztec/p2p';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { readPublicState } from '@aztec/simulator';
 
-import { GasTxValidator } from './gas_validator.js';
+import { GasTxValidator, type PublicStateSource } from './gas_validator.js';
 import { PhasesTxValidator } from './phases_validator.js';
 
 export class TxValidatorFactory {
+  nullifierSource: NullifierSource;
+  publicStateSource: PublicStateSource;
   constructor(
-    private merkleTreeDb: MerkleTreeOperations,
+    private committedDb: MerkleTreeReadOperations,
     private contractDataSource: ContractDataSource,
     private enforceFees: boolean,
-  ) {}
+  ) {
+    this.nullifierSource = {
+      getNullifierIndex: nullifier => this.committedDb.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer()),
+    };
+
+    this.publicStateSource = {
+      storageRead: (contractAddress, slot) => {
+        return readPublicState(this.committedDb, contractAddress, slot);
+      },
+    };
+  }
 
   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(worldStateDB),
+      new DoubleSpendTxValidator(this.nullifierSource),
       new PhasesTxValidator(this.contractDataSource, setupAllowList),
-      new GasTxValidator(worldStateDB, FeeJuiceAddress, this.enforceFees),
+      new GasTxValidator(this.publicStateSource, ProtocolContractAddress.FeeJuice, this.enforceFees),
     );
   }
 
-  validatorForProcessedTxs(): TxValidator<ProcessedTx> {
-    return new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb, this.contractDataSource));
+  validatorForProcessedTxs(fork: MerkleTreeReadOperations): TxValidator<ProcessedTx> {
+    return new DoubleSpendTxValidator({
+      getNullifierIndex: nullifier => fork.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer()),
+    });
   }
 }