@aztec/sequencer-client 0.24.0 → 0.26.1

package/src/block_builder/solo_block_builder.ts

@@ -1,4 +1,4 @@
-import { ContractData, L2Block, L2BlockL2Logs, MerkleTreeId, PublicDataWrite, TxL2Logs } from '@aztec/circuit-types';
+import { Body, ContractData, L2Block, MerkleTreeId, PublicDataWrite, TxEffect, TxL2Logs } from '@aztec/circuit-types';
 import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
@@ -6,10 +6,13 @@ import {
   BaseRollupInputs,
   CONTRACT_SUBTREE_HEIGHT,
   CONTRACT_SUBTREE_SIBLING_PATH_LENGTH,
+  CombinedAccumulatedData,
   ConstantRollupData,
   GlobalVariables,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  MAX_NEW_CONTRACTS_PER_TX,
+  MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_PUBLIC_DATA_READS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
@@ -30,8 +33,9 @@ import {
   Proof,
   PublicDataTreeLeaf,
   PublicDataTreeLeafPreimage,
-  PublicKernelData,
   ROLLUP_VK_TREE_HEIGHT,
+  RollupKernelCircuitPublicInputs,
+  RollupKernelData,
   RollupTypes,
   RootRollupInputs,
   RootRollupPublicInputs,
@@ -42,8 +46,7 @@ import {
   VK_TREE_HEIGHT,
   VerificationKey,
 } from '@aztec/circuits.js';
-import { computeContractLeaf } from '@aztec/circuits.js/abis';
-import { makeTuple } from '@aztec/foundation/array';
+import { assertPermutation, makeTuple } from '@aztec/foundation/array';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
@@ -102,48 +105,44 @@ export class SoloBlockBuilder implements BlockBuilder {
     const [circuitsOutput, proof] = await this.runCircuits(globalVariables, txs, newL1ToL2Messages);
 
     // Collect all new nullifiers, commitments, and contracts from all txs in this block
-    const newNullifiers = txs.flatMap(tx => tx.data.end.newNullifiers);
-    const newCommitments = txs.flatMap(tx => tx.data.end.newCommitments);
-    const newContracts = txs.flatMap(tx => tx.data.end.newContracts).map(cd => computeContractLeaf(cd));
-    const newContractData = txs
-      .flatMap(tx => tx.data.end.newContracts)
-      .map(n => new ContractData(n.contractAddress, n.portalContractAddress));
-    const newPublicDataWrites = txs.flatMap(tx =>
-      tx.data.end.publicDataUpdateRequests.map(t => new PublicDataWrite(t.leafSlot, t.newValue)),
+    const txEffects: TxEffect[] = txs.map(
+      tx =>
+        new TxEffect(
+          tx.data.combinedData.newNoteHashes.map((c: SideEffect) => c.value) as Tuple<
+            Fr,
+            typeof MAX_NEW_NOTE_HASHES_PER_TX
+          >,
+          tx.data.combinedData.newNullifiers.map((n: SideEffectLinkedToNoteHash) => n.value) as Tuple<
+            Fr,
+            typeof MAX_NEW_NULLIFIERS_PER_TX
+          >,
+          tx.data.combinedData.newL2ToL1Msgs,
+          tx.data.combinedData.publicDataUpdateRequests.map(t => new PublicDataWrite(t.leafSlot, t.newValue)) as Tuple<
+            PublicDataWrite,
+            typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+          >,
+          tx.data.combinedData.newContracts.map(cd => cd.hash()) as Tuple<Fr, typeof MAX_NEW_CONTRACTS_PER_TX>,
+          tx.data.combinedData.newContracts.map(
+            cd => new ContractData(cd.contractAddress, cd.portalContractAddress),
+          ) as Tuple<ContractData, typeof MAX_NEW_CONTRACTS_PER_TX>,
+          tx.encryptedLogs || new TxL2Logs([]),
+          tx.unencryptedLogs || new TxL2Logs([]),
+        ),
     );
-    const newL2ToL1Msgs = txs.flatMap(tx => tx.data.end.newL2ToL1Msgs);
 
-    // Consolidate logs data from all txs
-    const encryptedLogsArr: TxL2Logs[] = [];
-    const unencryptedLogsArr: TxL2Logs[] = [];
-    for (const tx of txs) {
-      const encryptedLogs = tx.encryptedLogs || new TxL2Logs([]);
-      encryptedLogsArr.push(encryptedLogs);
-      const unencryptedLogs = tx.unencryptedLogs || new TxL2Logs([]);
-      unencryptedLogsArr.push(unencryptedLogs);
-    }
-    const newEncryptedLogs = new L2BlockL2Logs(encryptedLogsArr);
-    const newUnencryptedLogs = new L2BlockL2Logs(unencryptedLogsArr);
+    const blockBody = new Body(padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP), txEffects);
 
     const l2Block = L2Block.fromFields({
       archive: circuitsOutput.archive,
       header: circuitsOutput.header,
-      newCommitments: newCommitments.map((c: SideEffect) => c.value),
-      newNullifiers: newNullifiers.map((n: SideEffectLinkedToNoteHash) => n.value),
-      newL2ToL1Msgs,
-      newContracts,
-      newContractData,
-      newPublicDataWrites,
-      newL1ToL2Messages,
-      newEncryptedLogs,
-      newUnencryptedLogs,
+      body: blockBody,
     });
 
-    if (!l2Block.getCalldataHash().equals(circuitsOutput.header.bodyHash)) {
+    if (!l2Block.body.getCalldataHash().equals(circuitsOutput.header.contentCommitment.txsHash)) {
       throw new Error(
-        `Calldata hash mismatch, ${l2Block
+        `Calldata hash mismatch, ${l2Block.body
           .getCalldataHash()
-          .toString('hex')} == ${circuitsOutput.header.bodyHash.toString('hex')} `,
+          .toString('hex')} == ${circuitsOutput.header.contentCommitment.txsHash.toString('hex')} `,
       );
     }
 
@@ -418,9 +417,14 @@ export class SoloBlockBuilder implements BlockBuilder {
     );
   }
 
-  protected getKernelDataFor(tx: ProcessedTx) {
-    return new PublicKernelData(
-      tx.data,
+  protected getKernelDataFor(tx: ProcessedTx): RollupKernelData {
+    const inputs = new RollupKernelCircuitPublicInputs(
+      tx.data.aggregationObject,
+      CombinedAccumulatedData.recombine(tx.data.endNonRevertibleData, tx.data.end),
+      tx.data.constants,
+    );
+    return new RollupKernelData(
+      inputs,
       tx.proof,
 
       // VK for the kernel circuit
@@ -501,13 +505,14 @@ export class SoloBlockBuilder implements BlockBuilder {
   }
 
   protected async processPublicDataUpdateRequests(tx: ProcessedTx) {
+    const combinedPublicDataUpdateRequests = tx.data.combinedData.publicDataUpdateRequests.map(updateRequest => {
+      return new PublicDataTreeLeaf(updateRequest.leafSlot, updateRequest.newValue);
+    });
     const { lowLeavesWitnessData, newSubtreeSiblingPath, sortedNewLeaves, sortedNewLeavesIndexes } =
       await this.db.batchInsert(
         MerkleTreeId.PUBLIC_DATA_TREE,
+        combinedPublicDataUpdateRequests.map(x => x.toBuffer()),
         // TODO(#3675) remove oldValue from update requests
-        tx.data.end.publicDataUpdateRequests.map(updateRequest => {
-          return new PublicDataTreeLeaf(updateRequest.leafSlot, updateRequest.newValue).toBuffer();
-        }),
         PUBLIC_DATA_SUBTREE_HEIGHT,
       );
 
@@ -546,6 +551,12 @@ export class SoloBlockBuilder implements BlockBuilder {
       return lowLeavesWitnessData[i].leafPreimage as PublicDataTreeLeafPreimage;
     });
 
+    // validate that the sortedPublicDataWrites and sortedPublicDataWritesIndexes are in the correct order
+    // otherwise it will just fail in the circuit
+    assertPermutation(combinedPublicDataUpdateRequests, sortedPublicDataWrites, sortedPublicDataWritesIndexes, (a, b) =>
+      a.equals(b),
+    );
+
     return {
       lowPublicDataWritesPreimages,
       lowPublicDataWritesMembershipWitnesses,
@@ -563,8 +574,9 @@ export class SoloBlockBuilder implements BlockBuilder {
 
     const newPublicDataReadsPreimages: Tuple<PublicDataTreeLeafPreimage, typeof MAX_PUBLIC_DATA_READS_PER_TX> =
       makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => PublicDataTreeLeafPreimage.empty());
-    for (const i in tx.data.end.publicDataReads) {
-      const leafSlot = tx.data.end.publicDataReads[i].leafSlot.value;
+
+    for (const i in tx.data.combinedData.publicDataReads) {
+      const leafSlot = tx.data.combinedData.publicDataReads[i].leafSlot.value;
       const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
       if (!lowLeafResult) {
         throw new Error(`Public data tree should have one initial leaf`);
@@ -616,14 +628,15 @@ export class SoloBlockBuilder implements BlockBuilder {
 
     // Update the contract and note hash trees with the new items being inserted to get the new roots
     // that will be used by the next iteration of the base rollup circuit, skipping the empty ones
-    const newContracts = tx.data.end.newContracts.map(cd => computeContractLeaf(cd));
-    const newCommitments = tx.data.end.newCommitments.map(x => x.value.toBuffer());
+    const newContracts = tx.data.combinedData.newContracts.map(cd => cd.hash());
+    const newNoteHashes = tx.data.combinedData.newNoteHashes.map(x => x.value.toBuffer());
+
     await this.db.appendLeaves(
       MerkleTreeId.CONTRACT_TREE,
       newContracts.map(x => x.toBuffer()),
     );
 
-    await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, newCommitments);
+    await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, newNoteHashes);
 
     // The read witnesses for a given TX should be generated before the writes of the same TX are applied.
     // All reads that refer to writes in the same tx are transient and can be simplified out.
@@ -631,8 +644,6 @@ export class SoloBlockBuilder implements BlockBuilder {
     const txPublicDataUpdateRequestInfo = await this.processPublicDataUpdateRequests(tx);
 
     // Update the nullifier tree, capturing the low nullifier info for each individual operation
-    const newNullifiers = tx.data.end.newNullifiers;
-
     const {
       lowLeavesWitnessData: nullifierWitnessLeaves,
       newSubtreeSiblingPath: newNullifiersSubtreeSiblingPath,
@@ -640,7 +651,7 @@ export class SoloBlockBuilder implements BlockBuilder {
       sortedNewLeavesIndexes,
     } = await this.db.batchInsert(
       MerkleTreeId.NULLIFIER_TREE,
-      newNullifiers.map(sideEffectLinkedToNoteHash => sideEffectLinkedToNoteHash.value.toBuffer()),
+      tx.data.combinedData.newNullifiers.map(sideEffectLinkedToNoteHash => sideEffectLinkedToNoteHash.value.toBuffer()),
       NULLIFIER_SUBTREE_HEIGHT,
     );
     if (nullifierWitnessLeaves === undefined) {

package/src/global_variable_builder/viem-reader.ts

@@ -35,7 +35,7 @@ export class ViemReader implements L1GlobalReader {
     this.rollupContract = getContract({
       address: getAddress(l1Contracts.rollupAddress.toString()),
       abi: RollupAbi,
-      publicClient: this.publicClient,
+      client: this.publicClient,
     });
   }
 

package/src/publisher/l1-publisher.ts

@@ -105,8 +105,6 @@ export type L1ProcessArgs = {
   header: Buffer;
   /** A root of the archive tree after the L2 block is applied. */
   archive: Buffer;
-  /** Transactions hash. */
-  txsHash: Buffer;
   /** L2 block body. */
   body: Buffer;
   /** Root rollup proof of the L2 block. */
@@ -154,7 +152,7 @@ export class L1Publisher implements L2BlockReceiver {
       return false;
     }
 
-    const encodedBody = block.bodyToBuffer();
+    const encodedBody = block.body.toBuffer();
 
     // Publish block transaction effects
     while (!this.interrupted) {
@@ -193,7 +191,6 @@ export class L1Publisher implements L2BlockReceiver {
     const processTxArgs = {
       header: block.header.toBuffer(),
       archive: block.archive.root.toBuffer(),
-      txsHash: block.getCalldataHash(),
       body: encodedBody,
       proof: Buffer.alloc(0),
     };

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

@@ -1,4 +1,5 @@
-import { BLOB_SIZE_IN_BYTES, ExtendedContractData, L2Block } from '@aztec/circuit-types';
+import { ExtendedContractData, L2Block } from '@aztec/circuit-types';
+import { BLOB_SIZE_IN_BYTES } from '@aztec/circuits.js/constants';
 import { createEthereumChain } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AvailabilityOracleAbi, ContractDeploymentEmitterAbi, RollupAbi } from '@aztec/l1-artifacts';
@@ -33,17 +34,14 @@ import {
 export class ViemTxSender implements L1PublisherTxSender {
   private availabilityOracleContract: GetContractReturnType<
     typeof AvailabilityOracleAbi,
-    PublicClient<HttpTransport, chains.Chain>,
     WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
   >;
   private rollupContract: GetContractReturnType<
     typeof RollupAbi,
-    PublicClient<HttpTransport, chains.Chain>,
     WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
   >;
   private contractDeploymentEmitterContract: GetContractReturnType<
     typeof ContractDeploymentEmitterAbi,
-    PublicClient<HttpTransport, chains.Chain>,
     WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
   >;
 
@@ -69,20 +67,17 @@ export class ViemTxSender implements L1PublisherTxSender {
     this.availabilityOracleContract = getContract({
       address: getAddress(l1Contracts.availabilityOracleAddress.toString()),
       abi: AvailabilityOracleAbi,
-      publicClient: this.publicClient,
-      walletClient,
+      client: walletClient,
     });
     this.rollupContract = getContract({
       address: getAddress(l1Contracts.rollupAddress.toString()),
       abi: RollupAbi,
-      publicClient: this.publicClient,
-      walletClient,
+      client: walletClient,
     });
     this.contractDeploymentEmitterContract = getContract({
       address: getAddress(l1Contracts.contractDeploymentEmitterAddress.toString()),
       abi: ContractDeploymentEmitterAbi,
-      publicClient: this.publicClient,
-      walletClient,
+      client: walletClient,
     });
   }
 
@@ -92,7 +87,7 @@ export class ViemTxSender implements L1PublisherTxSender {
   }
 
   checkIfTxsAreAvailable(block: L2Block): Promise<boolean> {
-    const args = [`0x${block.getCalldataHash().toString('hex')}`] as const;
+    const args = [`0x${block.body.getCalldataHash().toString('hex')}`] as const;
     return this.availabilityOracleContract.read.isAvailable(args);
   }
 
@@ -160,7 +155,6 @@ export class ViemTxSender implements L1PublisherTxSender {
     const args = [
       `0x${encodedData.header.toString('hex')}`,
       `0x${encodedData.archive.toString('hex')}`,
-      `0x${encodedData.txsHash.toString('hex')}`,
       `0x${encodedData.body.toString('hex')}`,
       `0x${encodedData.proof.toString('hex')}`,
     ] as const;