@aztec/sequencer-client 0.7.0 → 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.7.0",
+  "version": "0.7.2",
   "exports": "./dest/index.js",
   "type": "module",
   "dependencies": {
-    "@aztec/acir-simulator": "0.7.0",
-    "@aztec/circuits.js": "0.7.0",
-    "@aztec/ethereum": "0.7.0",
-    "@aztec/foundation": "0.7.0",
-    "@aztec/l1-artifacts": "0.7.0",
-    "@aztec/merkle-tree": "0.7.0",
-    "@aztec/p2p": "0.7.0",
-    "@aztec/types": "0.7.0",
-    "@aztec/world-state": "0.7.0",
+    "@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);
@@ -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,17 +2,29 @@ import {
   AppendOnlyTreeSnapshot,
   BaseOrMergeRollupPublicInputs,
   BaseRollupInputs,
+  CONTRACT_SUBTREE_HEIGHT,
+  CONTRACT_SUBTREE_SIBLING_PATH_LENGTH,
   CircuitsWasm,
   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,
@@ -593,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;
   }
@@ -626,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
@@ -658,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];
@@ -670,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`);
@@ -682,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,
@@ -691,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/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

@@ -147,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;
       }
@@ -158,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`);
@@ -249,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

@@ -4,9 +4,9 @@ import {
   CircuitError,
   CircuitsWasm,
   MergeRollupInputs,
-  RollupWasmWrapper,
   RootRollupInputs,
   RootRollupPublicInputs,
+  baseRollupSim,
   mergeRollupSim,
   rootRollupSim,
 } from '@aztec/circuits.js';
@@ -17,11 +17,9 @@ 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;
   }
 
@@ -39,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.