@aztec/sequencer-client 0.6.7 → 0.7.2

package/Dockerfile

@@ -0,0 +1,21 @@
+FROM 278380418400.dkr.ecr.eu-west-2.amazonaws.com/yarn-project-base AS builder
+
+# (1) project
+COPY . .
+
+# (2) build
+WORKDIR /usr/src/yarn-project/sequencer-client
+RUN yarn build && yarn formatting
+
+# (3) test
+RUN yarn test
+
+# (4) Prune dev dependencies. See comment in base image.
+RUN yarn cache clean
+RUN yarn workspaces focus --production > /dev/null
+
+# (5) set up entry point
+FROM node:18-alpine
+COPY --from=builder /usr/src/yarn-project /usr/src/yarn-project
+WORKDIR /usr/src/yarn-project/sequencer-client
+ENTRYPOINT ["yarn", "test"]

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@aztec/sequencer-client",
-  "version": "0.6.7",
+  "version": "0.7.2",
   "exports": "./dest/index.js",
   "type": "module",
   "dependencies": {
-    "@aztec/acir-simulator": "0.6.7",
-    "@aztec/circuits.js": "0.6.7",
-    "@aztec/ethereum": "0.6.7",
-    "@aztec/foundation": "0.6.7",
-    "@aztec/l1-artifacts": "0.6.7",
-    "@aztec/merkle-tree": "0.6.7",
-    "@aztec/p2p": "0.6.7",
-    "@aztec/types": "0.6.7",
-    "@aztec/world-state": "0.6.7",
+    "@aztec/acir-simulator": "0.7.2",
+    "@aztec/circuits.js": "0.7.2",
+    "@aztec/ethereum": "0.7.2",
+    "@aztec/foundation": "0.7.2",
+    "@aztec/l1-artifacts": "0.7.2",
+    "@aztec/merkle-tree": "0.7.2",
+    "@aztec/p2p": "0.7.2",
+    "@aztec/types": "0.7.2",
+    "@aztec/world-state": "0.7.2",
     "lodash.chunk": "^4.2.0",
     "lodash.flatmap": "^4.5.0",
     "lodash.pick": "^4.4.0",

package/src/block_builder/solo_block_builder.test.ts

@@ -1,7 +1,6 @@
 import {
   AppendOnlyTreeSnapshot,
   BaseOrMergeRollupPublicInputs,
-  BaseRollupInputs,
   CircuitsWasm,
   Fr,
   GlobalVariables,
@@ -11,6 +10,7 @@ import {
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  NULLIFIER_SUBTREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   Proof,
   PublicDataUpdateRequest,
@@ -138,7 +138,7 @@ describe('sequencer/solo_block_builder', () => {
     await expectsDb.batchInsert(
       MerkleTreeId.NULLIFIER_TREE,
       flatMap(txs, tx => tx.data.end.newNullifiers.map(x => x.toBuffer())),
-      BaseRollupInputs.NULLIFIER_SUBTREE_HEIGHT,
+      NULLIFIER_SUBTREE_HEIGHT,
     );
     for (const write of txs.flatMap(tx => tx.data.end.publicDataUpdateRequests)) {
       await expectsDb.updateLeaf(MerkleTreeId.PUBLIC_DATA_TREE, write.newValue.toBuffer(), write.leafIndex.value);
@@ -157,7 +157,7 @@ describe('sequencer/solo_block_builder', () => {
       rootRollupOutput.endPrivateDataTreeSnapshot.root,
       rootRollupOutput.endNullifierTreeSnapshot.root,
       rootRollupOutput.endContractTreeSnapshot.root,
-      rootRollupOutput.endL1ToL2MessageTreeSnapshot.root,
+      rootRollupOutput.endL1ToL2MessagesTreeSnapshot.root,
       rootRollupOutput.endPublicDataTreeRoot,
     );
     await expectsDb.appendLeaves(MerkleTreeId.BLOCKS_TREE, [blockHash.toBuffer()]);
@@ -208,7 +208,7 @@ describe('sequencer/solo_block_builder', () => {
     rootRollupOutput.endPrivateDataTreeSnapshot = await getTreeSnapshot(MerkleTreeId.PRIVATE_DATA_TREE);
     rootRollupOutput.endPublicDataTreeRoot = (await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE)).root;
 
-    rootRollupOutput.endL1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE);
+    rootRollupOutput.endL1ToL2MessagesTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE);
 
     // Calculate block hash
     rootRollupOutput.globalVariables = globalVariables;
@@ -241,8 +241,8 @@ describe('sequencer/solo_block_builder', () => {
       endContractTreeSnapshot: rootRollupOutput.endContractTreeSnapshot,
       startPublicDataTreeRoot: rootRollupOutput.startPublicDataTreeRoot,
       endPublicDataTreeRoot: rootRollupOutput.endPublicDataTreeRoot,
-      startL1ToL2MessageTreeSnapshot: rootRollupOutput.startL1ToL2MessageTreeSnapshot,
-      endL1ToL2MessageTreeSnapshot: rootRollupOutput.endL1ToL2MessageTreeSnapshot,
+      startL1ToL2MessagesTreeSnapshot: rootRollupOutput.startL1ToL2MessagesTreeSnapshot,
+      endL1ToL2MessagesTreeSnapshot: rootRollupOutput.endL1ToL2MessagesTreeSnapshot,
       startHistoricBlocksTreeSnapshot: rootRollupOutput.startHistoricBlocksTreeSnapshot,
       endHistoricBlocksTreeSnapshot: rootRollupOutput.endHistoricBlocksTreeSnapshot,
       newCommitments,
@@ -384,7 +384,7 @@ describe('sequencer/solo_block_builder', () => {
 
       const [l2Block] = await builder.buildL2Block(globalVariables, txs, l1ToL2Messages);
       expect(l2Block.number).toEqual(blockNumber);
-    }, 20_000);
+    }, 40_000);
 
     // This test specifically tests nullifier values which previously caused e2e_private_token test to fail
     it('e2e_private_token edge case regression test on nullifier values', async () => {
@@ -411,7 +411,7 @@ describe('sequencer/solo_block_builder', () => {
       await builderDb.batchInsert(
         MerkleTreeId.NULLIFIER_TREE,
         updateVals.map(v => toBufferBE(v, 32)),
-        BaseRollupInputs.NULLIFIER_SUBTREE_HEIGHT,
+        NULLIFIER_SUBTREE_HEIGHT,
       );
 
       const [l2Block] = await builder.buildL2Block(globalVariables, txs, mockL1ToL2Messages);

package/src/block_builder/solo_block_builder.ts

@@ -2,16 +2,29 @@ import {
   AppendOnlyTreeSnapshot,
   BaseOrMergeRollupPublicInputs,
   BaseRollupInputs,
+  CONTRACT_SUBTREE_HEIGHT,
+  CONTRACT_SUBTREE_SIBLING_PATH_LENGTH,
   CircuitsWasm,
-  ConstantBaseRollupData,
+  ConstantRollupData,
   GlobalVariables,
   HISTORIC_BLOCKS_TREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
+  L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  MAX_NEW_NULLIFIERS_PER_BASE_ROLLUP,
+  MAX_PUBLIC_DATA_READS_PER_BASE_ROLLUP,
+  MAX_PUBLIC_DATA_READS_PER_TX,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_BASE_ROLLUP,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
   MergeRollupInputs,
+  NULLIFIER_SUBTREE_HEIGHT,
+  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NullifierLeafPreimage,
+  PRIVATE_DATA_SUBTREE_HEIGHT,
+  PRIVATE_DATA_SUBTREE_SIBLING_PATH_LENGTH,
+  PUBLIC_DATA_TREE_HEIGHT,
   PreviousKernelData,
   PreviousRollupData,
   Proof,
@@ -29,7 +42,7 @@ import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { assertLength } from '@aztec/foundation/serialize';
+import { Tuple, assertLength } from '@aztec/foundation/serialize';
 import { ContractData, L2Block, L2BlockL2Logs, MerkleTreeId, PublicDataWrite, TxL2Logs } from '@aztec/types';
 import { MerkleTreeOperations, computeGlobalVariablesHash } from '@aztec/world-state';
 
@@ -109,7 +122,7 @@ export class SoloBlockBuilder implements BlockBuilder {
       endNullifierTreeSnapshot,
       endContractTreeSnapshot,
       endPublicDataTreeRoot,
-      endL1ToL2MessageTreeSnapshot,
+      endL1ToL2MessagesTreeSnapshot,
       endHistoricBlocksTreeSnapshot,
     } = circuitsOutput;
 
@@ -149,8 +162,8 @@ export class SoloBlockBuilder implements BlockBuilder {
       endContractTreeSnapshot,
       startPublicDataTreeRoot: startPublicDataTreeSnapshot.root,
       endPublicDataTreeRoot,
-      startL1ToL2MessageTreeSnapshot,
-      endL1ToL2MessageTreeSnapshot,
+      startL1ToL2MessagesTreeSnapshot: startL1ToL2MessageTreeSnapshot,
+      endL1ToL2MessagesTreeSnapshot,
       startHistoricBlocksTreeSnapshot,
       endHistoricBlocksTreeSnapshot,
       newCommitments,
@@ -207,7 +220,7 @@ export class SoloBlockBuilder implements BlockBuilder {
     }
 
     // padArrayEnd throws if the array is already full. Otherwise it pads till we reach the required size
-    newL1ToL2Messages = padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    const newL1ToL2MessagesTuple = padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
 
     // Run the base rollup circuits for the txs
     const baseRollupOutputs: [BaseOrMergeRollupPublicInputs, Proof][] = [];
@@ -230,7 +243,7 @@ export class SoloBlockBuilder implements BlockBuilder {
 
     // Run the root rollup with the last two merge rollups (or base, if no merge layers)
     const [mergeOutputLeft, mergeOutputRight] = mergeRollupInputs;
-    return this.rootRollupCircuit(mergeOutputLeft, mergeOutputRight, newL1ToL2Messages);
+    return this.rootRollupCircuit(mergeOutputLeft, mergeOutputRight, newL1ToL2MessagesTuple);
   }
 
   protected async baseRollupCircuit(
@@ -276,7 +289,7 @@ export class SoloBlockBuilder implements BlockBuilder {
   protected async rootRollupCircuit(
     left: [BaseOrMergeRollupPublicInputs, Proof],
     right: [BaseOrMergeRollupPublicInputs, Proof],
-    newL1ToL2Messages: Fr[],
+    newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
   ): Promise<[RootRollupPublicInputs, Proof]> {
     this.debug(`Running root rollup circuit`);
     const rootInput = await this.getRootRollupInput(...left, ...right, newL1ToL2Messages);
@@ -351,7 +364,7 @@ export class SoloBlockBuilder implements BlockBuilder {
     await Promise.all([
       this.validateTrees(rootOutput),
       this.validateTree(rootOutput, MerkleTreeId.BLOCKS_TREE, 'HistoricBlocks'),
-      this.validateTree(rootOutput, MerkleTreeId.L1_TO_L2_MESSAGES_TREE, 'L1ToL2Message'),
+      this.validateTree(rootOutput, MerkleTreeId.L1_TO_L2_MESSAGES_TREE, 'L1ToL2Messages'),
     ]);
   }
 
@@ -359,7 +372,7 @@ export class SoloBlockBuilder implements BlockBuilder {
   protected async validateRootTree(
     rootOutput: RootRollupPublicInputs,
     treeId: MerkleTreeId,
-    name: 'Contract' | 'PrivateData' | 'L1ToL2Message',
+    name: 'Contract' | 'PrivateData' | 'L1ToL2Messages',
   ) {
     const localTree = await this.getTreeSnapshot(treeId);
     const simulatedTree = rootOutput[`endTreeOfHistoric${name}TreeRootsSnapshot`];
@@ -400,7 +413,7 @@ export class SoloBlockBuilder implements BlockBuilder {
   protected validateSimulatedTree(
     localTree: AppendOnlyTreeSnapshot,
     simulatedTree: AppendOnlyTreeSnapshot,
-    name: 'PrivateData' | 'Contract' | 'Nullifier' | 'L1ToL2Message' | 'HistoricBlocks',
+    name: 'PrivateData' | 'Contract' | 'Nullifier' | 'L1ToL2Messages' | 'HistoricBlocks',
     label?: string,
   ) {
     if (!simulatedTree.root.toBuffer().equals(localTree.root.toBuffer())) {
@@ -421,7 +434,7 @@ export class SoloBlockBuilder implements BlockBuilder {
     rollupProofLeft: Proof,
     rollupOutputRight: BaseOrMergeRollupPublicInputs,
     rollupProofRight: Proof,
-    newL1ToL2Messages: Fr[],
+    newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
   ) {
     const vk = this.getVerificationKey(rollupOutputLeft.rollupType);
     const previousRollupData: RootRollupInputs['previousRollupData'] = [
@@ -437,23 +450,36 @@ export class SoloBlockBuilder implements BlockBuilder {
       return path.toFieldArray();
     };
 
-    const newL1ToL2MessageTreeRootSiblingPath = await this.getSubtreeSiblingPath(
+    const newL1ToL2MessagesTreeRootSiblingPathArray = await this.getSubtreeSiblingPath(
       MerkleTreeId.L1_TO_L2_MESSAGES_TREE,
       L1_TO_L2_MSG_SUBTREE_HEIGHT,
     );
 
+    const newL1ToL2MessagesTreeRootSiblingPath = makeTuple(
+      L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+      i =>
+        i < newL1ToL2MessagesTreeRootSiblingPathArray.length ? newL1ToL2MessagesTreeRootSiblingPathArray[i] : Fr.ZERO,
+      0,
+    );
+
     // Get tree snapshots
-    const startL1ToL2MessageTreeSnapshot = await this.getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE);
+    const startL1ToL2MessagesTreeSnapshot = await this.getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE);
 
     // Get historic block tree roots
     const startHistoricBlocksTreeSnapshot = await this.getTreeSnapshot(MerkleTreeId.BLOCKS_TREE);
-    const newHistoricBlocksTreeSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.BLOCKS_TREE);
+    const newHistoricBlocksTreeSiblingPathArray = await getRootTreeSiblingPath(MerkleTreeId.BLOCKS_TREE);
+
+    const newHistoricBlocksTreeSiblingPath = makeTuple(
+      HISTORIC_BLOCKS_TREE_HEIGHT,
+      i => (i < newHistoricBlocksTreeSiblingPathArray.length ? newHistoricBlocksTreeSiblingPathArray[i] : Fr.ZERO),
+      0,
+    );
 
     return RootRollupInputs.from({
       previousRollupData,
       newL1ToL2Messages,
-      newL1ToL2MessageTreeRootSiblingPath,
-      startL1ToL2MessageTreeSnapshot,
+      newL1ToL2MessagesTreeRootSiblingPath,
+      startL1ToL2MessagesTreeSnapshot,
       startHistoricBlocksTreeSnapshot,
       newHistoricBlocksTreeSiblingPath,
     });
@@ -528,8 +554,8 @@ export class SoloBlockBuilder implements BlockBuilder {
     return this.getMembershipWitnessFor(blockHash, MerkleTreeId.BLOCKS_TREE, HISTORIC_BLOCKS_TREE_HEIGHT);
   }
 
-  protected async getConstantBaseRollupData(globalVariables: GlobalVariables): Promise<ConstantBaseRollupData> {
-    return ConstantBaseRollupData.from({
+  protected async getConstantRollupData(globalVariables: GlobalVariables): Promise<ConstantRollupData> {
+    return ConstantRollupData.from({
       baseRollupVkHash: DELETE_FR,
       mergeRollupVkHash: DELETE_FR,
       privateKernelVkTreeRoot: FUTURE_FR,
@@ -579,22 +605,38 @@ export class SoloBlockBuilder implements BlockBuilder {
   }
 
   protected async processPublicDataUpdateRequests(tx: ProcessedTx) {
-    const newPublicDataUpdateRequestsSiblingPaths: Fr[][] = [];
-    for (const publicDataUpdateRequest of tx.data.end.publicDataUpdateRequests) {
-      const index = publicDataUpdateRequest.leafIndex.value;
+    const newPublicDataUpdateRequestsSiblingPaths: Tuple<
+      Tuple<Fr, typeof PUBLIC_DATA_TREE_HEIGHT>,
+      typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+    > = makeTuple(MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, () => makeTuple(PUBLIC_DATA_TREE_HEIGHT, Fr.zero));
+    for (const i in tx.data.end.publicDataUpdateRequests) {
+      const index = tx.data.end.publicDataUpdateRequests[i].leafIndex.value;
+      await this.db.updateLeaf(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        tx.data.end.publicDataUpdateRequests[i].newValue.toBuffer(),
+        index,
+      );
       const path = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, index);
-      await this.db.updateLeaf(MerkleTreeId.PUBLIC_DATA_TREE, publicDataUpdateRequest.newValue.toBuffer(), index);
-      newPublicDataUpdateRequestsSiblingPaths.push(path.toFieldArray());
+      const array = path.toFieldArray();
+      newPublicDataUpdateRequestsSiblingPaths[i] = makeTuple(PUBLIC_DATA_TREE_HEIGHT, j =>
+        j < array.length ? array[j] : Fr.ZERO,
+      );
     }
     return newPublicDataUpdateRequestsSiblingPaths;
   }
 
   protected async getPublicDataReadsSiblingPaths(tx: ProcessedTx) {
-    const newPublicDataReadsSiblingPaths: Fr[][] = [];
-    for (const publicDataRead of tx.data.end.publicDataReads) {
-      const index = publicDataRead.leafIndex.value;
+    const newPublicDataReadsSiblingPaths: Tuple<
+      Tuple<Fr, typeof PUBLIC_DATA_TREE_HEIGHT>,
+      typeof MAX_PUBLIC_DATA_READS_PER_TX
+    > = makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => makeTuple(PUBLIC_DATA_TREE_HEIGHT, Fr.zero));
+    for (const i in tx.data.end.publicDataReads) {
+      const index = tx.data.end.publicDataReads[i].leafIndex.value;
       const path = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, index);
-      newPublicDataReadsSiblingPaths.push(path.toFieldArray());
+      const array = path.toFieldArray();
+      newPublicDataReadsSiblingPaths[i] = makeTuple(PUBLIC_DATA_TREE_HEIGHT, j =>
+        j < array.length ? array[j] : Fr.ZERO,
+      );
     }
     return newPublicDataReadsSiblingPaths;
   }
@@ -604,7 +646,7 @@ export class SoloBlockBuilder implements BlockBuilder {
     const wasm = await CircuitsWasm.get();
 
     // Get trees info before any changes hit
-    const constants = await this.getConstantBaseRollupData(globalVariables);
+    const constants = await this.getConstantRollupData(globalVariables);
     const startNullifierTreeSnapshot = await this.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE);
     const startContractTreeSnapshot = await this.getTreeSnapshot(MerkleTreeId.CONTRACT_TREE);
     const startPrivateDataTreeSnapshot = await this.getTreeSnapshot(MerkleTreeId.PRIVATE_DATA_TREE);
@@ -612,13 +654,22 @@ export class SoloBlockBuilder implements BlockBuilder {
     const startHistoricBlocksTreeSnapshot = await this.getTreeSnapshot(MerkleTreeId.BLOCKS_TREE);
 
     // Get the subtree sibling paths for the circuit
-    const newCommitmentsSubtreeSiblingPath = await this.getSubtreeSiblingPath(
+    const newCommitmentsSubtreeSiblingPathArray = await this.getSubtreeSiblingPath(
       MerkleTreeId.PRIVATE_DATA_TREE,
-      BaseRollupInputs.PRIVATE_DATA_SUBTREE_HEIGHT,
+      PRIVATE_DATA_SUBTREE_HEIGHT,
     );
-    const newContractsSubtreeSiblingPath = await this.getSubtreeSiblingPath(
+
+    const newCommitmentsSubtreeSiblingPath = makeTuple(PRIVATE_DATA_SUBTREE_SIBLING_PATH_LENGTH, i =>
+      i < newCommitmentsSubtreeSiblingPathArray.length ? newCommitmentsSubtreeSiblingPathArray[i] : Fr.ZERO,
+    );
+
+    const newContractsSubtreeSiblingPathArray = await this.getSubtreeSiblingPath(
       MerkleTreeId.CONTRACT_TREE,
-      BaseRollupInputs.CONTRACT_SUBTREE_HEIGHT,
+      CONTRACT_SUBTREE_HEIGHT,
+    );
+
+    const newContractsSubtreeSiblingPath = makeTuple(CONTRACT_SUBTREE_SIBLING_PATH_LENGTH, i =>
+      i < newContractsSubtreeSiblingPathArray.length ? newContractsSubtreeSiblingPathArray[i] : Fr.ZERO,
     );
 
     // Update the contract and private data trees with the new items being inserted to get the new roots
@@ -644,11 +695,17 @@ export class SoloBlockBuilder implements BlockBuilder {
     const rightPublicDataReadSiblingPaths = await this.getPublicDataReadsSiblingPaths(right);
     const rightPublicDataUpdateRequestsSiblingPaths = await this.processPublicDataUpdateRequests(right);
 
-    const newPublicDataReadsSiblingPaths = [...leftPublicDataReadSiblingPaths, ...rightPublicDataReadSiblingPaths];
-    const newPublicDataUpdateRequestsSiblingPaths = [
-      ...leftPublicDataUpdateRequestsSiblingPaths,
-      ...rightPublicDataUpdateRequestsSiblingPaths,
-    ];
+    const newPublicDataReadsSiblingPaths = makeTuple(MAX_PUBLIC_DATA_READS_PER_BASE_ROLLUP, i =>
+      i < MAX_PUBLIC_DATA_READS_PER_TX
+        ? leftPublicDataReadSiblingPaths[i]
+        : rightPublicDataReadSiblingPaths[i - MAX_PUBLIC_DATA_READS_PER_TX],
+    );
+
+    const newPublicDataUpdateRequestsSiblingPaths = makeTuple(MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_BASE_ROLLUP, i =>
+      i < MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+        ? leftPublicDataUpdateRequestsSiblingPaths[i]
+        : rightPublicDataUpdateRequestsSiblingPaths[i - MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX],
+    );
 
     // Update the nullifier tree, capturing the low nullifier info for each individual operation
     const newNullifiers = [...left.data.end.newNullifiers, ...right.data.end.newNullifiers];
@@ -656,7 +713,7 @@ export class SoloBlockBuilder implements BlockBuilder {
     const [nullifierWitnessLeaves, newNullifiersSubtreeSiblingPath] = await this.db.batchInsert(
       MerkleTreeId.NULLIFIER_TREE,
       newNullifiers.map(fr => fr.toBuffer()),
-      BaseRollupInputs.NULLIFIER_SUBTREE_HEIGHT,
+      NULLIFIER_SUBTREE_HEIGHT,
     );
     if (nullifierWitnessLeaves === undefined) {
       throw new Error(`Could not craft nullifier batch insertion proofs`);
@@ -668,6 +725,8 @@ export class SoloBlockBuilder implements BlockBuilder {
         MembershipWitness.fromBufferArray(l.index, assertLength(l.siblingPath.toBufferArray(), NULLIFIER_TREE_HEIGHT)),
       );
 
+    const newNullifiersSubtreeSiblingPathArray = newNullifiersSubtreeSiblingPath.toFieldArray();
+
     return BaseRollupInputs.from({
       constants,
       startNullifierTreeSnapshot,
@@ -677,14 +736,25 @@ export class SoloBlockBuilder implements BlockBuilder {
       startHistoricBlocksTreeSnapshot,
       newCommitmentsSubtreeSiblingPath,
       newContractsSubtreeSiblingPath,
-      newNullifiersSubtreeSiblingPath: newNullifiersSubtreeSiblingPath.toFieldArray(),
+      newNullifiersSubtreeSiblingPath: makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, i =>
+        i < newNullifiersSubtreeSiblingPathArray.length ? newNullifiersSubtreeSiblingPathArray[i] : Fr.ZERO,
+      ),
       newPublicDataUpdateRequestsSiblingPaths,
       newPublicDataReadsSiblingPaths,
-      lowNullifierLeafPreimages: nullifierWitnessLeaves.map(
-        ({ leafData }) =>
-          new NullifierLeafPreimage(new Fr(leafData.value), new Fr(leafData.nextValue), Number(leafData.nextIndex)),
+      lowNullifierLeafPreimages: makeTuple(MAX_NEW_NULLIFIERS_PER_BASE_ROLLUP, i =>
+        i < nullifierWitnessLeaves.length
+          ? new NullifierLeafPreimage(
+              new Fr(nullifierWitnessLeaves[i].leafData.value),
+              new Fr(nullifierWitnessLeaves[i].leafData.nextValue),
+              Number(nullifierWitnessLeaves[i].leafData.nextIndex),
+            )
+          : new NullifierLeafPreimage(Fr.ZERO, Fr.ZERO, 0),
+      ),
+      lowNullifierMembershipWitness: makeTuple(MAX_NEW_NULLIFIERS_PER_BASE_ROLLUP, i =>
+        i < lowNullifierMembershipWitnesses.length
+          ? lowNullifierMembershipWitnesses[i]
+          : this.makeEmptyMembershipWitness(NULLIFIER_TREE_HEIGHT),
       ),
-      lowNullifierMembershipWitness: lowNullifierMembershipWitnesses,
       kernelData: [this.getKernelDataFor(left), this.getKernelDataFor(right)],
       historicBlocksTreeRootMembershipWitnesses: [
         await this.getHistoricTreesMembershipWitnessFor(left),

package/src/block_builder/types.ts

@@ -5,7 +5,7 @@ import { AppendOnlyTreeSnapshot, BaseOrMergeRollupPublicInputs, RootRollupPublic
  */
 export type AllowedTreeNames<T extends BaseOrMergeRollupPublicInputs | RootRollupPublicInputs> =
   T extends RootRollupPublicInputs
-    ? 'PrivateData' | 'Contract' | 'Nullifier' | 'L1ToL2Message' | 'HistoricBlocks'
+    ? 'PrivateData' | 'Contract' | 'Nullifier' | 'L1ToL2Messages' | 'HistoricBlocks'
     : 'PrivateData' | 'Contract' | 'Nullifier';
 
 /**

package/src/publisher/viem-tx-sender.ts

@@ -1,7 +1,7 @@
 import { createEthereumChain } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { ContractDeploymentEmitterAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { ExtendedContractData } from '@aztec/types';
+import { BLOB_SIZE_IN_BYTES, ExtendedContractData } from '@aztec/types';
 
 import {
   GetContractReturnType,
@@ -141,6 +141,9 @@ export class ViemTxSender implements L1PublisherTxSender {
         `0x${extendedContractData.bytecode.toString('hex')}`,
       ] as const;
 
+      const codeSize = extendedContractData.bytecode.length;
+      this.log(`Bytecode is ${codeSize} bytes and require ${codeSize / BLOB_SIZE_IN_BYTES} blobs`);
+
       const gas = await this.contractDeploymentEmitterContract.estimateGas.emitContractDeployment(args, {
         account: this.account,
       });

package/src/sequencer/sequencer.ts

@@ -129,10 +129,11 @@ export class Sequencer {
         return;
       }
 
-      this.log(`Processing ${validTxs.length} txs...`);
+      const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
+
+      this.log.info(`Building block ${blockNumber} with ${validTxs.length} transactions...`);
       this.state = SequencerState.CREATING_BLOCK;
 
-      const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
       const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(blockNumber));
       const prevGlobalVariables = (await this.l2BlockSource.getL2Block(-1))?.globalVariables ?? GlobalVariables.empty();
 
@@ -146,7 +147,11 @@ export class Sequencer {
         await this.p2pClient.deleteTxs(await Tx.getHashes(failedTxData));
       }
 
-      if (processedTxs.length === 0) {
+      // Only accept processed transactions that are not double-spends
+      // public functions emitting nullifiers would pass earlier check but fail here
+      const processedValidTxs = await this.takeValidProcessedTxs(processedTxs);
+
+      if (processedValidTxs.length === 0) {
         this.log('No txs processed correctly to build block. Exiting');
         return;
       }
@@ -157,16 +162,16 @@ export class Sequencer {
       this.log('Successfully retrieved L1 to L2 messages from contract');
 
       // Build the new block by running the rollup circuits
-      this.log(`Assembling block with txs ${processedTxs.map(tx => tx.hash).join(', ')}`);
+      this.log(`Assembling block with txs ${processedValidTxs.map(tx => tx.hash).join(', ')}`);
 
       const emptyTx = await processor.makeEmptyProcessedTx();
-      const block = await this.buildBlock(processedTxs, l1ToL2Messages, emptyTx, newGlobalVariables);
+      const block = await this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables);
       this.log(`Assembled block ${block.number}`);
 
       await this.publishExtendedContractData(validTxs, block);
 
       await this.publishL2Block(block);
-      this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
+      this.log.info(`Submitted rollup block ${block.number} with ${processedValidTxs.length} transactions`);
     } catch (err) {
       this.log.error(err);
       this.log.error(`Rolling back world state DB`);
@@ -248,6 +253,13 @@ export class Sequencer {
     return validTxs;
   }
 
+  protected async takeValidProcessedTxs(txs: ProcessedTx[]) {
+    const isDoubleSpends = await Promise.all(txs.map(async tx => await this.isTxDoubleSpend(tx as unknown as Tx)));
+    const doubleSpends = txs.filter((tx, index) => isDoubleSpends[index]).map(tx => tx.hash);
+    await this.p2pClient.deleteTxs(doubleSpends);
+    return txs.filter((tx, index) => !isDoubleSpends[index]);
+  }
+
   /**
    * Returns whether the previous block sent has been mined, and all dependencies have caught up with it.
    * @returns Boolean indicating if our dependencies are synced to the latest block.

package/src/simulator/public_executor.ts

@@ -1,5 +1,4 @@
 import {
-  CommitmentDataOracleInputs,
   CommitmentsDB,
   MessageLoadOracleInputs,
   PublicContractsDB,
@@ -7,7 +6,6 @@ import {
   PublicStateDB,
 } from '@aztec/acir-simulator';
 import { AztecAddress, CircuitsWasm, EthAddress, Fr, FunctionSelector, HistoricBlockData } from '@aztec/circuits.js';
-import { siloCommitment } from '@aztec/circuits.js/abis';
 import { ContractDataSource, L1ToL2MessageSource, MerkleTreeId } from '@aztec/types';
 import { MerkleTreeOperations, computePublicDataTreeLeafIndex } from '@aztec/world-state';
 
@@ -100,19 +98,7 @@ export class WorldStateDB implements CommitmentsDB {
     };
   }
 
-  public async getCommitmentOracle(address: AztecAddress, innerCommitment: Fr): Promise<CommitmentDataOracleInputs> {
-    const siloedCommitment = siloCommitment(await CircuitsWasm.get(), address, innerCommitment);
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386): shoild be
-    // unique commitment that exists in tree (should be siloed and then made unique via
-    // nonce).  Once public kernel or base rollup circuit injects nonces, this can be updated
-    // to use uniqueSiloedCommitment.
-    const index = (await this.db.findLeafIndex(MerkleTreeId.PRIVATE_DATA_TREE, siloedCommitment.toBuffer()))!;
-    const siblingPath = await this.db.getSiblingPath(MerkleTreeId.PRIVATE_DATA_TREE, index);
-
-    return {
-      commitment: siloedCommitment,
-      siblingPath: siblingPath.toFieldArray(),
-      index,
-    };
+  public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
+    return await this.db.findLeafIndex(MerkleTreeId.PRIVATE_DATA_TREE, commitment.toBuffer());
   }
 }

package/src/simulator/rollup.ts

@@ -1,11 +1,14 @@
 import {
   BaseOrMergeRollupPublicInputs,
   BaseRollupInputs,
+  CircuitError,
   CircuitsWasm,
   MergeRollupInputs,
-  RollupWasmWrapper,
   RootRollupInputs,
   RootRollupPublicInputs,
+  baseRollupSim,
+  mergeRollupSim,
+  rootRollupSim,
 } from '@aztec/circuits.js';
 
 import { RollupSimulator } from './index.js';
@@ -14,10 +17,10 @@ import { RollupSimulator } from './index.js';
  * Implements the rollup circuit simulator using the wasm circuits implementation.
  */
 export class WasmRollupCircuitSimulator implements RollupSimulator {
-  private rollupWasmWrapper: RollupWasmWrapper;
+  private wasm: CircuitsWasm;
 
   constructor(wasm: CircuitsWasm) {
-    this.rollupWasmWrapper = new RollupWasmWrapper(wasm);
+    this.wasm = wasm;
   }
 
   /**
@@ -34,7 +37,12 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
-    return Promise.resolve(this.rollupWasmWrapper.simulateBaseRollup(input));
+    const result = baseRollupSim(this.wasm, input);
+    if (result instanceof CircuitError) {
+      throw new CircuitError(result.code, result.message);
+    }
+
+    return Promise.resolve(result);
   }
   /**
    * Simulates the merge rollup circuit from its inputs.
@@ -42,14 +50,25 @@ export class WasmRollupCircuitSimulator implements RollupSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
-    return Promise.resolve(this.rollupWasmWrapper.simulateMergeRollup(input));
+    const result = mergeRollupSim(this.wasm, input);
+    if (result instanceof CircuitError) {
+      throw new CircuitError(result.code, result.message);
+    }
+
+    return Promise.resolve(result);
   }
+
   /**
    * Simulates the root rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
   rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs> {
-    return Promise.resolve(this.rollupWasmWrapper.simulateRootRollup(input));
+    const result = rootRollupSim(this.wasm, input);
+    if (result instanceof CircuitError) {
+      throw new CircuitError(result.code, result.message);
+    }
+
+    return Promise.resolve(result);
   }
 }