@aztec/sequencer-client 0.1.0-alpha11

package/src/sequencer/public_processor.test.ts

@@ -0,0 +1,225 @@
+import { PublicExecution, PublicExecutionResult, PublicExecutor } from '@aztec/acir-simulator';
+import {
+  ARGS_LENGTH,
+  CallContext,
+  CircuitsWasm,
+  EthAddress,
+  Fr,
+  FunctionData,
+  GlobalVariables,
+  KERNEL_PRIVATE_CALL_STACK_LENGTH,
+  KERNEL_PUBLIC_CALL_STACK_LENGTH,
+  PUBLIC_DATA_TREE_HEIGHT,
+  Proof,
+  PublicCallRequest,
+  makeEmptyProof,
+  makeTuple,
+} from '@aztec/circuits.js';
+import { computeCallStackItemHash } from '@aztec/circuits.js/abis';
+import {
+  makeAztecAddress,
+  makeKernelPublicInputs,
+  makePublicCallRequest,
+  makeSelector,
+} from '@aztec/circuits.js/factories';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { SiblingPath } from '@aztec/merkle-tree';
+import {
+  ContractDataSource,
+  ContractPublicData,
+  EncodedContractFunction,
+  ExecutionRequest,
+  FunctionL2Logs,
+  Tx,
+  TxL2Logs,
+} from '@aztec/types';
+import { MerkleTreeOperations, TreeInfo } from '@aztec/world-state';
+import { MockProxy, mock } from 'jest-mock-extended';
+import pick from 'lodash.pick';
+import times from 'lodash.times';
+import { makeTx } from '../index.js';
+import { PublicProver } from '../prover/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
+import { PublicProcessor } from './public_processor.js';
+
+describe('public_processor', () => {
+  let db: MockProxy<MerkleTreeOperations>;
+  let publicExecutor: MockProxy<PublicExecutor>;
+  let publicProver: MockProxy<PublicProver>;
+  let contractDataSource: MockProxy<ContractDataSource>;
+
+  let publicFunction: EncodedContractFunction;
+  let contractData: ContractPublicData;
+  let proof: Proof;
+  let root: Buffer;
+
+  let processor: PublicProcessor;
+
+  beforeEach(() => {
+    db = mock<MerkleTreeOperations>();
+    publicExecutor = mock<PublicExecutor>();
+    publicProver = mock<PublicProver>();
+    contractDataSource = mock<ContractDataSource>();
+
+    contractData = ContractPublicData.random();
+    publicFunction = EncodedContractFunction.random();
+    proof = makeEmptyProof();
+    root = Buffer.alloc(32, 5);
+
+    publicProver.getPublicCircuitProof.mockResolvedValue(proof);
+    publicProver.getPublicKernelCircuitProof.mockResolvedValue(proof);
+    db.getTreeInfo.mockResolvedValue({ root } as TreeInfo);
+    contractDataSource.getL2ContractPublicData.mockResolvedValue(contractData);
+    contractDataSource.getPublicFunction.mockResolvedValue(publicFunction);
+  });
+
+  describe('with mock circuits', () => {
+    let publicKernel: MockProxy<PublicKernelCircuitSimulator>;
+
+    beforeEach(() => {
+      publicKernel = mock<PublicKernelCircuitSimulator>();
+      processor = new PublicProcessor(db, publicExecutor, publicKernel, publicProver, contractDataSource);
+    });
+
+    it('skips txs without public execution requests', async function () {
+      const tx = makeTx();
+      tx.data.end.publicCallStack = makeTuple(KERNEL_PUBLIC_CALL_STACK_LENGTH, Fr.zero);
+      const hash = await tx.getTxHash();
+      const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+
+      expect(processed).toEqual([
+        { isEmpty: false, hash, ...pick(tx, 'data', 'proof', 'encryptedLogs', 'unencryptedLogs') },
+      ]);
+      expect(failed).toEqual([]);
+    });
+
+    it('returns failed txs without aborting entire operation', async function () {
+      publicExecutor.execute.mockRejectedValue(new Error(`Failed`));
+
+      const tx = makeTx();
+      const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+
+      expect(processed).toEqual([]);
+      expect(failed).toEqual([tx]);
+    });
+  });
+
+  describe('with actual circuits', () => {
+    let publicKernel: PublicKernelCircuitSimulator;
+    let wasm: CircuitsWasm;
+
+    beforeAll(async () => {
+      wasm = await CircuitsWasm.get();
+    });
+
+    beforeEach(() => {
+      const path = times(PUBLIC_DATA_TREE_HEIGHT, i => Buffer.alloc(32, i));
+      db.getSiblingPath.mockResolvedValue(new SiblingPath<number>(PUBLIC_DATA_TREE_HEIGHT, path));
+      publicKernel = new WasmPublicKernelCircuitSimulator();
+      processor = new PublicProcessor(db, publicExecutor, publicKernel, publicProver, contractDataSource);
+    });
+
+    const expectedTxByHash = async (tx: Tx) =>
+      expect.objectContaining({
+        hash: await tx.getTxHash(),
+        proof,
+      });
+
+    it('runs a tx with enqueued public calls', async function () {
+      const callRequests: PublicCallRequest[] = [makePublicCallRequest(0x100), makePublicCallRequest(0x100)];
+      const callStackItems = await Promise.all(callRequests.map(call => call.toPublicCallStackItem()));
+      const callStackHashes = callStackItems.map(call => computeCallStackItemHash(wasm, call));
+
+      const kernelOutput = makeKernelPublicInputs(0x10);
+      kernelOutput.end.publicCallStack = padArrayEnd(callStackHashes, Fr.ZERO, KERNEL_PUBLIC_CALL_STACK_LENGTH);
+      kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, KERNEL_PRIVATE_CALL_STACK_LENGTH);
+
+      const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), [], callRequests);
+
+      publicExecutor.execute.mockImplementation(execution => {
+        for (const request of callRequests) {
+          if (execution.contractAddress.equals(request.contractAddress)) {
+            return Promise.resolve(makePublicExecutionResultFromRequest(request));
+          }
+        }
+        throw new Error(`Unexpected execution request: ${execution}`);
+      });
+
+      const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+
+      expect(processed).toHaveLength(1);
+      expect(processed).toEqual([await expectedTxByHash(tx)]);
+      expect(failed).toHaveLength(0);
+      expect(publicExecutor.execute).toHaveBeenCalledTimes(2);
+    });
+
+    it('runs a tx with an enqueued public call with nested execution', async function () {
+      const callRequest: PublicCallRequest = makePublicCallRequest(0x100);
+      const callStackItem = await callRequest.toPublicCallStackItem();
+      const callStackHash = computeCallStackItemHash(wasm, callStackItem);
+
+      const kernelOutput = makeKernelPublicInputs(0x10);
+      kernelOutput.end.publicCallStack = padArrayEnd([callStackHash], Fr.ZERO, KERNEL_PUBLIC_CALL_STACK_LENGTH);
+      kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, KERNEL_PRIVATE_CALL_STACK_LENGTH);
+
+      const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), [], [callRequest]);
+
+      const publicExecutionResult = makePublicExecutionResultFromRequest(callRequest);
+      publicExecutionResult.nestedExecutions = [
+        makePublicExecutionResult({
+          from: publicExecutionResult.execution.contractAddress,
+          to: makeAztecAddress(30),
+          functionData: new FunctionData(makeSelector(5), false, false),
+          args: new Array(ARGS_LENGTH).fill(Fr.ZERO),
+        }),
+      ];
+      publicExecutor.execute.mockResolvedValue(publicExecutionResult);
+
+      const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+
+      expect(processed).toHaveLength(1);
+      expect(processed).toEqual([await expectedTxByHash(tx)]);
+      expect(failed).toHaveLength(0);
+      expect(publicExecutor.execute).toHaveBeenCalledTimes(1);
+    });
+  });
+});
+
+function makePublicExecutionResultFromRequest(item: PublicCallRequest): PublicExecutionResult {
+  return {
+    execution: item,
+    nestedExecutions: [],
+    returnValues: [new Fr(1n)],
+    newCommitments: [],
+    newL2ToL1Messages: [],
+    newNullifiers: [],
+    contractStorageReads: [],
+    contractStorageUpdateRequests: [],
+    unencryptedLogs: new FunctionL2Logs([]),
+  };
+}
+
+function makePublicExecutionResult(
+  tx: ExecutionRequest,
+  nestedExecutions: PublicExecutionResult[] = [],
+): PublicExecutionResult {
+  const callContext = new CallContext(tx.from, tx.to, EthAddress.ZERO, false, false, false);
+  const execution: PublicExecution = {
+    callContext,
+    contractAddress: tx.to,
+    functionData: tx.functionData,
+    args: tx.args,
+  };
+  return {
+    execution,
+    nestedExecutions,
+    returnValues: [],
+    newCommitments: [],
+    newNullifiers: [],
+    newL2ToL1Messages: [],
+    contractStorageReads: [],
+    contractStorageUpdateRequests: [],
+    unencryptedLogs: new FunctionL2Logs([]),
+  };
+}

package/src/sequencer/public_processor.ts

@@ -0,0 +1,280 @@
+import { PublicExecution, PublicExecutionResult, PublicExecutor, isPublicExecutionResult } from '@aztec/acir-simulator';
+import {
+  AztecAddress,
+  CircuitsWasm,
+  ContractStorageRead,
+  ContractStorageUpdateRequest,
+  Fr,
+  GlobalVariables,
+  KERNEL_PUBLIC_DATA_READS_LENGTH,
+  KERNEL_PUBLIC_DATA_UPDATE_REQUESTS_LENGTH,
+  KernelCircuitPublicInputs,
+  MembershipWitness,
+  NEW_COMMITMENTS_LENGTH,
+  NEW_L2_TO_L1_MSGS_LENGTH,
+  NEW_NULLIFIERS_LENGTH,
+  PUBLIC_CALL_STACK_LENGTH,
+  PreviousKernelData,
+  Proof,
+  PublicCallData,
+  PublicCallStackItem,
+  PublicCircuitPublicInputs,
+  PublicKernelInputs,
+  PublicKernelPublicInputs,
+  RETURN_VALUES_LENGTH,
+  VK_TREE_HEIGHT,
+} from '@aztec/circuits.js';
+import { computeCallStackItemHash, computeVarArgsHash } from '@aztec/circuits.js/abis';
+import { isArrayEmpty, padArrayEnd, padArrayStart } from '@aztec/foundation/collection';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { Tuple, mapTuple, to2Fields } from '@aztec/foundation/serialize';
+import { ContractDataSource, FunctionL2Logs, L1ToL2MessageSource, MerkleTreeId, Tx } from '@aztec/types';
+import { MerkleTreeOperations } from '@aztec/world-state';
+import { getVerificationKeys } from '../index.js';
+import { EmptyPublicProver } from '../prover/empty.js';
+import { PublicProver } from '../prover/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { getPublicExecutor } from '../simulator/public_executor.js';
+import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
+import { ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
+import { getCombinedHistoricTreeRoots } from './utils.js';
+
+/**
+ * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
+ */
+export class PublicProcessorFactory {
+  constructor(
+    private merkleTree: MerkleTreeOperations,
+    private contractDataSource: ContractDataSource,
+    private l1Tol2MessagesDataSource: L1ToL2MessageSource,
+  ) {}
+
+  /**
+   * Creates a new instance of a PublicProcessor.
+   * @returns A new instance of a PublicProcessor.
+   */
+  public create() {
+    return new PublicProcessor(
+      this.merkleTree,
+      getPublicExecutor(this.merkleTree, this.contractDataSource, this.l1Tol2MessagesDataSource),
+      new WasmPublicKernelCircuitSimulator(),
+      new EmptyPublicProver(),
+      this.contractDataSource,
+    );
+  }
+}
+
+/**
+ * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
+ * any public function calls in them. Txs with private calls only are unaffected.
+ */
+export class PublicProcessor {
+  constructor(
+    protected db: MerkleTreeOperations,
+    protected publicExecutor: PublicExecutor,
+    protected publicKernel: PublicKernelCircuitSimulator,
+    protected publicProver: PublicProver,
+    protected contractDataSource: ContractDataSource,
+
+    private log = createDebugLogger('aztec:sequencer:public-processor'),
+  ) {}
+
+  /**
+   * Run each tx through the public circuit and the public kernel circuit if needed.
+   * @param txs - Txs to process.
+   * @param globalVariables - The global variables for the block.
+   * @returns The list of processed txs with their circuit simulation outputs.
+   */
+  public async process(txs: Tx[], globalVariables: GlobalVariables): Promise<[ProcessedTx[], Tx[]]> {
+    const result: ProcessedTx[] = [];
+    const failed: Tx[] = [];
+
+    for (const tx of txs) {
+      this.log(`Processing tx ${await tx.getTxHash()}`);
+      try {
+        result.push(await this.processTx(tx, globalVariables));
+      } catch (err) {
+        this.log(`Error processing tx ${await tx.getTxHash()}: ${err}`);
+        failed.push(tx);
+      }
+    }
+    return [result, failed];
+  }
+
+  /**
+   * Makes an empty processed tx. Useful for padding a block to a power of two number of txs.
+   * @param chainId - The chain id of the rollup.
+   * @param version - The version of the rollup.
+   * @returns A processed tx with empty data.
+   */
+  public async makeEmptyProcessedTx(chainId: Fr, version: Fr): Promise<ProcessedTx> {
+    const historicTreeRoots = await getCombinedHistoricTreeRoots(this.db);
+    return makeEmptyProcessedTx(historicTreeRoots, chainId, version);
+  }
+
+  protected async processTx(tx: Tx, globalVariables: GlobalVariables): Promise<ProcessedTx> {
+    if (!isArrayEmpty(tx.data.end.publicCallStack, item => item.isZero())) {
+      const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
+        tx,
+        globalVariables,
+      );
+      tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+
+      return makeProcessedTx(tx, publicKernelOutput, publicKernelProof);
+    } else {
+      return makeProcessedTx(tx);
+    }
+  }
+
+  protected async processEnqueuedPublicCalls(
+    tx: Tx,
+    globalVariables: GlobalVariables,
+  ): Promise<[PublicKernelPublicInputs, Proof, FunctionL2Logs[]]> {
+    this.log(`Executing enqueued public calls for tx ${await tx.getTxHash()}`);
+    if (!tx.enqueuedPublicFunctionCalls) throw new Error(`Missing preimages for enqueued public calls`);
+
+    // We execute the requests in order, which means reversing the input as the stack pops from the end of the array
+    const executionStack: (PublicExecution | PublicExecutionResult)[] = [...tx.enqueuedPublicFunctionCalls].reverse();
+
+    let kernelOutput = tx.data;
+    let kernelProof = tx.proof;
+    const newUnencryptedFunctionLogs: FunctionL2Logs[] = [];
+
+    while (executionStack.length) {
+      const current = executionStack.pop()!;
+      const isExecutionRequest = !isPublicExecutionResult(current);
+      const result = isExecutionRequest ? await this.publicExecutor.execute(current, globalVariables) : current;
+      newUnencryptedFunctionLogs.push(result.unencryptedLogs);
+      const functionSelector = result.execution.functionData.functionSelectorBuffer.toString('hex');
+      this.log(`Running public kernel circuit for ${functionSelector}@${result.execution.contractAddress.toString()}`);
+      executionStack.push(...result.nestedExecutions);
+      const preimages = await this.getPublicCallStackPreimages(result);
+      const callData = await this.getPublicCallData(result, preimages, isExecutionRequest);
+      [kernelOutput, kernelProof] = await this.runKernelCircuit(callData, kernelOutput, kernelProof);
+    }
+
+    return [kernelOutput, kernelProof, newUnencryptedFunctionLogs];
+  }
+
+  protected async runKernelCircuit(
+    callData: PublicCallData,
+    previousOutput: KernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<[KernelCircuitPublicInputs, Proof]> {
+    const output = await this.getKernelCircuitOutput(callData, previousOutput, previousProof);
+    const proof = await this.publicProver.getPublicKernelCircuitProof(output);
+    return [output, proof];
+  }
+
+  protected getKernelCircuitOutput(
+    callData: PublicCallData,
+    previousOutput: KernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<KernelCircuitPublicInputs> {
+    if (previousOutput?.isPrivate && previousProof) {
+      // Run the public kernel circuit with previous private kernel
+      const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+      const inputs = new PublicKernelInputs(previousKernel, callData);
+      return this.publicKernel.publicKernelCircuitPrivateInput(inputs);
+    } else if (previousOutput && previousProof) {
+      // Run the public kernel circuit with previous public kernel
+      const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+      const inputs = new PublicKernelInputs(previousKernel, callData);
+      return this.publicKernel.publicKernelCircuitNonFirstIteration(inputs);
+    } else {
+      throw new Error(`No public kernel circuit for inputs`);
+    }
+  }
+
+  protected getPreviousKernelData(previousOutput: KernelCircuitPublicInputs, previousProof: Proof): PreviousKernelData {
+    const vk = getVerificationKeys().publicKernelCircuit;
+    const vkIndex = 0;
+    const vkSiblingPath = MembershipWitness.random(VK_TREE_HEIGHT).siblingPath;
+    return new PreviousKernelData(previousOutput, previousProof, vk, vkIndex, vkSiblingPath);
+  }
+
+  protected async getPublicCircuitPublicInputs(result: PublicExecutionResult) {
+    const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
+    const historicPublicDataTreeRoot = Fr.fromBuffer(publicDataTreeInfo.root);
+    const callStackPreimages = await this.getPublicCallStackPreimages(result);
+    const wasm = await CircuitsWasm.get();
+    const publicCallStack = mapTuple(callStackPreimages, item =>
+      item.isEmpty() ? Fr.zero() : computeCallStackItemHash(wasm, item),
+    );
+
+    // TODO(#1347): Noir fails with too many unknowns error when public inputs struct contains too many members.
+    const unencryptedLogsHash = to2Fields(result.unencryptedLogs.hash());
+    const unencryptedLogPreimagesLength = new Fr(result.unencryptedLogs.getSerializedLength());
+
+    return PublicCircuitPublicInputs.from({
+      callContext: result.execution.callContext,
+      proverAddress: AztecAddress.random(),
+      argsHash: await computeVarArgsHash(wasm, result.execution.args),
+      newCommitments: padArrayEnd(result.newCommitments, Fr.ZERO, NEW_COMMITMENTS_LENGTH),
+      newNullifiers: padArrayEnd(result.newNullifiers, Fr.ZERO, NEW_NULLIFIERS_LENGTH),
+      newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, Fr.ZERO, NEW_L2_TO_L1_MSGS_LENGTH),
+      returnValues: padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH),
+      contractStorageReads: padArrayEnd(
+        result.contractStorageReads,
+        ContractStorageRead.empty(),
+        KERNEL_PUBLIC_DATA_READS_LENGTH,
+      ),
+      contractStorageUpdateRequests: padArrayEnd(
+        result.contractStorageUpdateRequests,
+        ContractStorageUpdateRequest.empty(),
+        KERNEL_PUBLIC_DATA_UPDATE_REQUESTS_LENGTH,
+      ),
+      publicCallStack,
+      unencryptedLogsHash,
+      unencryptedLogPreimagesLength,
+      historicPublicDataTreeRoot,
+    });
+  }
+
+  protected async getPublicCallStackItem(result: PublicExecutionResult, isExecutionRequest = false) {
+    return new PublicCallStackItem(
+      result.execution.contractAddress,
+      result.execution.functionData,
+      await this.getPublicCircuitPublicInputs(result),
+      isExecutionRequest,
+    );
+  }
+
+  protected async getPublicCallStackPreimages(result: PublicExecutionResult) {
+    const nested = result.nestedExecutions;
+    const preimages: PublicCallStackItem[] = await Promise.all(nested.map(n => this.getPublicCallStackItem(n)));
+    if (preimages.length > PUBLIC_CALL_STACK_LENGTH) {
+      throw new Error(`Public call stack size exceeded (max ${PUBLIC_CALL_STACK_LENGTH}, got ${preimages.length})`);
+    }
+
+    // Top of the stack is at the end of the array, so we padStart
+    return padArrayStart(preimages, PublicCallStackItem.empty(), PUBLIC_CALL_STACK_LENGTH);
+  }
+
+  protected getBytecodeHash(_result: PublicExecutionResult) {
+    // TODO: Determine how to calculate bytecode hash. Circuits just check it isn't zero for now.
+    // See https://github.com/AztecProtocol/aztec3-packages/issues/378
+    const bytecodeHash = new Fr(1n);
+    return Promise.resolve(bytecodeHash);
+  }
+
+  /**
+   * Calculates the PublicCircuitOutput for this execution result along with its proof,
+   * and assembles a PublicCallData object from it.
+   * @param result - The execution result.
+   * @param preimages - The preimages of the callstack items.
+   * @param isExecutionRequest - Whether the current callstack item should be considered a public fn execution request.
+   * @returns A corresponding PublicCallData object.
+   */
+  protected async getPublicCallData(
+    result: PublicExecutionResult,
+    preimages: Tuple<PublicCallStackItem, typeof PUBLIC_CALL_STACK_LENGTH>,
+    isExecutionRequest = false,
+  ) {
+    const bytecodeHash = await this.getBytecodeHash(result);
+    const callStackItem = await this.getPublicCallStackItem(result, isExecutionRequest);
+    const portalContractAddress = result.execution.callContext.portalContractAddress.toField();
+    const proof = await this.publicProver.getPublicCircuitProof(callStackItem.publicInputs);
+    return new PublicCallData(callStackItem, preimages, proof, portalContractAddress, bytecodeHash);
+  }
+}

package/src/sequencer/sequencer.test.ts

@@ -0,0 +1,158 @@
+import {
+  CombinedHistoricTreeRoots,
+  Fr,
+  GlobalVariables,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  makeEmptyProof,
+} from '@aztec/circuits.js';
+import { P2P, P2PClientState } from '@aztec/p2p';
+import { L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, Tx, TxHash } from '@aztec/types';
+import { MerkleTreeOperations, WorldStateRunningState, WorldStateSynchroniser } from '@aztec/world-state';
+import { MockProxy, mock } from 'jest-mock-extended';
+import times from 'lodash.times';
+import { BlockBuilder } from '../block_builder/index.js';
+import { L1Publisher, makeTx } from '../index.js';
+import { makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
+import { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
+import { Sequencer } from './sequencer.js';
+import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
+
+describe('sequencer', () => {
+  let publisher: MockProxy<L1Publisher>;
+  let globalVariableBuilder: MockProxy<GlobalVariableBuilder>;
+  let p2p: MockProxy<P2P>;
+  let worldState: MockProxy<WorldStateSynchroniser>;
+  let blockBuilder: MockProxy<BlockBuilder>;
+  let merkleTreeOps: MockProxy<MerkleTreeOperations>;
+  let publicProcessor: MockProxy<PublicProcessor>;
+  let l2BlockSource: MockProxy<L2BlockSource>;
+  let l1ToL2MessageSource: MockProxy<L1ToL2MessageSource>;
+  let publicProcessorFactory: MockProxy<PublicProcessorFactory>;
+
+  let lastBlockNumber: number;
+
+  let sequencer: TestSubject;
+
+  const chainId = Fr.ZERO;
+  const version = Fr.ZERO;
+
+  beforeEach(() => {
+    lastBlockNumber = 0;
+
+    publisher = mock<L1Publisher>();
+    globalVariableBuilder = mock<GlobalVariableBuilder>();
+    merkleTreeOps = mock<MerkleTreeOperations>();
+    blockBuilder = mock<BlockBuilder>();
+
+    p2p = mock<P2P>({
+      getStatus: () => Promise.resolve({ state: P2PClientState.IDLE, syncedToL2Block: lastBlockNumber }),
+    });
+
+    worldState = mock<WorldStateSynchroniser>({
+      getLatest: () => merkleTreeOps,
+      status: () => Promise.resolve({ state: WorldStateRunningState.IDLE, syncedToL2Block: lastBlockNumber }),
+    });
+
+    publicProcessor = mock<PublicProcessor>({
+      process: async txs => [await Promise.all(txs.map(tx => makeProcessedTx(tx))), []],
+      makeEmptyProcessedTx: () => makeEmptyProcessedTx(CombinedHistoricTreeRoots.empty(), chainId, version),
+    });
+
+    publicProcessorFactory = mock<PublicProcessorFactory>({
+      create: () => publicProcessor,
+    });
+
+    l2BlockSource = mock<L2BlockSource>({
+      getBlockHeight: () => Promise.resolve(lastBlockNumber),
+    });
+
+    l1ToL2MessageSource = mock<L1ToL2MessageSource>({
+      getPendingL1ToL2Messages: () => Promise.resolve(Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(Fr.ZERO)),
+    });
+
+    sequencer = new TestSubject(
+      publisher,
+      globalVariableBuilder,
+      p2p,
+      worldState,
+      blockBuilder,
+      l2BlockSource,
+      l1ToL2MessageSource,
+      publicProcessorFactory,
+      {
+        chainId: Number(chainId.value),
+        version: Number(version.value),
+      },
+    );
+  });
+
+  it('builds a block out of a single tx', async () => {
+    const tx = makeTx();
+    const block = L2Block.random(lastBlockNumber + 1);
+    const proof = makeEmptyProof();
+
+    p2p.getTxs.mockResolvedValueOnce([tx]);
+    blockBuilder.buildL2Block.mockResolvedValueOnce([block, proof]);
+    publisher.processL2Block.mockResolvedValueOnce(true);
+    globalVariableBuilder.buildGlobalVariables.mockResolvedValueOnce(
+      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
+    );
+
+    await sequencer.initialSync();
+    await sequencer.work();
+
+    const expectedTxHashes = [...(await Tx.getHashes([tx])), ...times(3, () => TxHash.ZERO)];
+
+    expect(blockBuilder.buildL2Block).toHaveBeenCalledWith(
+      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
+      expectedTxHashes.map(hash => expect.objectContaining({ hash })),
+      Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(new Fr(0n)),
+    );
+    expect(publisher.processL2Block).toHaveBeenCalledWith(block);
+  });
+
+  it('builds a block out of several txs rejecting double spends', async () => {
+    const txs = [makeTx(0x10000), makeTx(0x20000), makeTx(0x30000)];
+    const doubleSpendTx = txs[1];
+    const block = L2Block.random(lastBlockNumber + 1);
+    const proof = makeEmptyProof();
+
+    p2p.getTxs.mockResolvedValueOnce(txs);
+    blockBuilder.buildL2Block.mockResolvedValueOnce([block, proof]);
+    publisher.processL2Block.mockResolvedValueOnce(true);
+    globalVariableBuilder.buildGlobalVariables.mockResolvedValueOnce(
+      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
+    );
+
+    // We make a nullifier from tx1 a part of the nullifier tree, so it gets rejected as double spend
+    const doubleSpendNullifier = doubleSpendTx.data.end.newNullifiers[0].toBuffer();
+    merkleTreeOps.findLeafIndex.mockImplementation((treeId: MerkleTreeId, value: Buffer) => {
+      return Promise.resolve(
+        treeId === MerkleTreeId.NULLIFIER_TREE && value.equals(doubleSpendNullifier) ? 1n : undefined,
+      );
+    });
+
+    await sequencer.initialSync();
+    await sequencer.work();
+
+    const expectedTxHashes = [...(await Tx.getHashes([txs[0], txs[2]])), TxHash.ZERO, TxHash.ZERO];
+
+    expect(blockBuilder.buildL2Block).toHaveBeenCalledWith(
+      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
+      expectedTxHashes.map(hash => expect.objectContaining({ hash })),
+      Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(new Fr(0n)),
+    );
+    expect(publisher.processL2Block).toHaveBeenCalledWith(block);
+    expect(p2p.deleteTxs).toHaveBeenCalledWith([await doubleSpendTx.getTxHash()]);
+  });
+});
+
+class TestSubject extends Sequencer {
+  public work() {
+    return super.work();
+  }
+
+  public initialSync(): Promise<void> {
+    return super.initialSync();
+  }
+}