@aztec/stdlib 3.0.0-devnet.2 → 3.0.0-devnet.2-patch.1

package/src/block/l2_block.ts

@@ -1,19 +1,24 @@
-import { Fr } from '@aztec/foundation/fields';
+import { type BlockBlobData, encodeBlockBlobData, encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
-import { getCheckpointBlobFields } from '../checkpoint/checkpoint_body.js';
+import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
 import { makeAppendOnlyTreeSnapshot, makeL2BlockHeader } from './l2_block_code_to_purge.js';
 import { L2BlockHeader } from './l2_block_header.js';
 import type { L2BlockInfo } from './l2_block_info.js';
+import { L2BlockNew } from './l2_block_new.js';
 
 /**
  * The data that makes up the rollup proof, with encoder decoder functions.
+ *
+ * @deprecated Use `L2BlockNew` instead.
  */
 export class L2Block {
   constructor(
@@ -84,7 +89,7 @@ export class L2Block {
    * @returns The L2 block.
    */
   static async random(
-    l2BlockNum: number,
+    l2BlockNum: BlockNumber,
     txsPerBlock = 4,
     numPublicCallsPerTx = 3,
     numPublicLogsPerCall = 1,
@@ -92,7 +97,7 @@ export class L2Block {
     slotNumber: number | undefined = undefined,
     maxEffects: number | undefined = undefined,
   ): Promise<L2Block> {
-    const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects);
+    const body = await Body.random({ txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects });
 
     return new L2Block(
       makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
@@ -109,11 +114,11 @@ export class L2Block {
     return new L2Block(AppendOnlyTreeSnapshot.empty(), L2BlockHeader.empty(), Body.empty());
   }
 
-  get number(): number {
+  get number(): BlockNumber {
     return this.header.getBlockNumber();
   }
 
-  get slot(): bigint {
+  get slot(): SlotNumber {
     return this.header.getSlot();
   }
 
@@ -146,13 +151,79 @@ export class L2Block {
     return this.header.toBlockHeader();
   }
 
+  public toL2Block() {
+    return new L2BlockNew(
+      this.archive,
+      this.getBlockHeader(),
+      this.body,
+      CheckpointNumber.fromBlockNumber(this.number),
+      0, // indexWithinCheckpoint
+    );
+  }
+
+  public toCheckpoint() {
+    return new Checkpoint(
+      this.archive,
+      this.getCheckpointHeader(),
+      [this.toL2Block()],
+      CheckpointNumber.fromBlockNumber(this.number),
+    );
+  }
+
+  static fromCheckpoint(checkpoint: Checkpoint) {
+    const checkpointHeader = checkpoint.header;
+    const block = checkpoint.blocks.at(-1)!;
+    const header = new L2BlockHeader(
+      new AppendOnlyTreeSnapshot(checkpointHeader.lastArchiveRoot, block.number),
+      checkpointHeader.contentCommitment,
+      block.header.state,
+      block.header.globalVariables,
+      block.header.totalFees,
+      checkpointHeader.totalManaUsed,
+      block.header.spongeBlobHash,
+      checkpointHeader.blockHeadersHash,
+    );
+    return new L2Block(checkpoint.archive, header, block.body);
+  }
+
   /**
    * @deprecated
    * This only works when there's one block per checkpoint.
    * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
    */
   public getCheckpointBlobFields() {
-    return getCheckpointBlobFields([this.body.txEffects]);
+    const blockBlobData = this.toBlockBlobData();
+    return encodeCheckpointBlobDataFromBlocks([blockBlobData]);
+  }
+
+  public toBlobFields(): Fr[] {
+    const blockBlobData = this.toBlockBlobData();
+    return encodeBlockBlobData(blockBlobData);
+  }
+
+  public toBlockBlobData(): BlockBlobData {
+    // There's only one L2Block per checkpoint, so it's always the first block in the checkpoint.
+    const isFirstBlock = true;
+    return {
+      blockEndMarker: {
+        numTxs: this.body.txEffects.length,
+        timestamp: this.header.globalVariables.timestamp,
+        blockNumber: this.number,
+      },
+      blockEndStateField: {
+        l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
+        noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
+        nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
+        publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
+        totalManaUsed: this.header.totalManaUsed.toBigInt(),
+      },
+      lastArchiveRoot: this.header.lastArchive.root,
+      noteHashRoot: this.header.state.partial.noteHashTree.root,
+      nullifierRoot: this.header.state.partial.nullifierTree.root,
+      publicDataRoot: this.header.state.partial.publicDataTree.root,
+      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
+      txs: this.body.toTxBlobData(),
+    };
   }
 
   /**
@@ -188,7 +259,7 @@ export class L2Block {
       archive: this.archive.root,
       lastArchive: this.header.lastArchive.root,
       blockNumber: this.number,
-      slotNumber: Number(this.header.getSlot()),
+      slotNumber: this.header.getSlot(),
       txCount: this.body.txEffects.length,
       timestamp: this.header.globalVariables.timestamp,
     };

package/src/block/l2_block_code_to_purge.ts

@@ -1,6 +1,7 @@
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { compact } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AztecAddress } from '../aztec-address/index.js';
@@ -24,9 +25,10 @@ export function makeL2BlockHeader(
     overrides?.contentCommitment ?? makeContentCommitment(seed + 0x200, inHash),
     overrides?.state ?? makeStateReference(seed + 0x600),
     makeGlobalVariables((seed += 0x700), {
-      ...(blockNumber ? { blockNumber } : {}),
-      ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
+      ...(blockNumber ? { blockNumber: BlockNumber(blockNumber) } : {}),
+      ...(slotNumber ? { slotNumber: SlotNumber(slotNumber) } : {}),
     }),
+    new Fr(seed + 0x300),
     new Fr(seed + 0x800),
     new Fr(seed + 0x900),
     new Fr(seed + 0xa00),
@@ -75,8 +77,8 @@ function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<GlobalVariabl
   return GlobalVariables.from({
     chainId: new Fr(seed),
     version: new Fr(seed + 1),
-    blockNumber: seed + 2,
-    slotNumber: new Fr(seed + 3),
+    blockNumber: BlockNumber(seed + 2),
+    slotNumber: SlotNumber(seed + 3),
     timestamp: BigInt(seed + 4),
     coinbase: EthAddress.fromField(new Fr(seed + 5)),
     feeRecipient: AztecAddress.fromField(new Fr(seed + 6)),

package/src/block/l2_block_header.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -36,6 +37,8 @@ export class L2BlockHeader {
     public totalManaUsed: Fr,
     /** Hash of the sponge blob of the block. */
     public spongeBlobHash: Fr,
+    /** Hash of the block headers in the checkpoint. */
+    public blockHeadersHash: Fr,
   ) {}
 
   static get schema(): ZodFor<L2BlockHeader> {
@@ -48,6 +51,7 @@ export class L2BlockHeader {
         totalFees: schemas.Fr,
         totalManaUsed: schemas.Fr,
         spongeBlobHash: schemas.Fr,
+        blockHeadersHash: schemas.Fr,
       })
       .transform(L2BlockHeader.from);
   }
@@ -61,6 +65,7 @@ export class L2BlockHeader {
       fields.totalFees,
       fields.totalManaUsed,
       fields.spongeBlobHash,
+      fields.blockHeadersHash,
     ] as const;
   }
 
@@ -68,8 +73,8 @@ export class L2BlockHeader {
     return new L2BlockHeader(...L2BlockHeader.getFields(fields));
   }
 
-  getSlot() {
-    return this.globalVariables.slotNumber.toBigInt();
+  getSlot(): SlotNumber {
+    return this.globalVariables.slotNumber;
   }
 
   getBlockNumber() {
@@ -84,7 +89,8 @@ export class L2BlockHeader {
       this.globalVariables.getSize() +
       this.totalFees.size +
       this.totalManaUsed.size +
-      this.spongeBlobHash.size
+      this.spongeBlobHash.size +
+      this.blockHeadersHash.size
     );
   }
 
@@ -111,6 +117,7 @@ export class L2BlockHeader {
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readObject(Fr),
+      reader.readObject(Fr),
     );
   }
 
@@ -125,6 +132,7 @@ export class L2BlockHeader {
       reader.readField(),
       reader.readField(),
       reader.readField(),
+      reader.readField(),
     );
   }
 
@@ -137,6 +145,7 @@ export class L2BlockHeader {
       totalFees: Fr.ZERO,
       totalManaUsed: Fr.ZERO,
       spongeBlobHash: Fr.ZERO,
+      blockHeadersHash: Fr.ZERO,
       ...fields,
     });
   }
@@ -149,7 +158,8 @@ export class L2BlockHeader {
       this.globalVariables.isEmpty() &&
       this.totalFees.isZero() &&
       this.totalManaUsed.isZero() &&
-      this.spongeBlobHash.isZero()
+      this.spongeBlobHash.isZero() &&
+      this.blockHeadersHash.isZero()
     );
   }
 
@@ -168,6 +178,7 @@ export class L2BlockHeader {
   toCheckpointHeader() {
     return new CheckpointHeader(
       this.lastArchive.root,
+      this.blockHeadersHash,
       this.contentCommitment,
       this.globalVariables.slotNumber,
       this.globalVariables.timestamp,
@@ -198,6 +209,7 @@ export class L2BlockHeader {
       totalFees: this.totalFees.toBigInt(),
       totalManaUsed: this.totalManaUsed.toBigInt(),
       spongeBlobHash: this.spongeBlobHash.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
     };
   }
 
@@ -215,6 +227,7 @@ export class L2BlockHeader {
   totalFees: ${this.totalFees},
   totalManaUsed: ${this.totalManaUsed},
   spongeBlobHash: ${this.spongeBlobHash},
+  blockHeadersHash: ${this.blockHeadersHash},
 }`;
   }
 
@@ -226,7 +239,8 @@ export class L2BlockHeader {
       this.totalFees.equals(other.totalFees) &&
       this.totalManaUsed.equals(other.totalManaUsed) &&
       this.lastArchive.equals(other.lastArchive) &&
-      this.spongeBlobHash.equals(other.spongeBlobHash)
+      this.spongeBlobHash.equals(other.spongeBlobHash) &&
+      this.blockHeadersHash.equals(other.blockHeadersHash)
     );
   }
 }

package/src/block/l2_block_info.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, BlockNumberSchema, SlotNumber, SlotNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -8,19 +9,19 @@ export type L2BlockInfo = {
   blockHash?: Fr;
   archive: Fr;
   lastArchive: Fr;
-  blockNumber: number;
-  slotNumber: number;
+  blockNumber: BlockNumber;
+  slotNumber: SlotNumber;
   txCount: number;
   timestamp: bigint;
 };
 
-export function randomBlockInfo(blockNumber?: number): L2BlockInfo {
+export function randomBlockInfo(blockNumber?: BlockNumber | number): L2BlockInfo {
   return {
     blockHash: Fr.random(),
     archive: Fr.random(),
     lastArchive: Fr.random(),
-    blockNumber: blockNumber ?? Math.floor(Math.random() * 100000) + 1,
-    slotNumber: Math.floor(Math.random() * 100000) + 1,
+    blockNumber: BlockNumber(blockNumber ?? Math.floor(Math.random() * 100000) + 1),
+    slotNumber: SlotNumber(Math.floor(Math.random() * 100000) + 1),
     txCount: Math.floor(Math.random() * 100),
     timestamp: BigInt(Math.floor(Date.now() / 1000)),
   };
@@ -30,8 +31,8 @@ export const BlockInfoSchema = z.object({
   blockHash: schemas.Fr.optional(),
   archive: schemas.Fr,
   lastArchive: schemas.Fr,
-  blockNumber: z.number(),
-  slotNumber: z.number(),
+  blockNumber: BlockNumberSchema,
+  slotNumber: SlotNumberSchema,
   txCount: z.number(),
   timestamp: schemas.BigInt,
 });
@@ -55,8 +56,8 @@ export function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo
     blockHash: blockHash.equals(Fr.ZERO) ? undefined : blockHash,
     archive: reader.readObject(Fr),
     lastArchive: reader.readObject(Fr),
-    blockNumber: reader.readNumber(),
-    slotNumber: reader.readNumber(),
+    blockNumber: BlockNumber(reader.readNumber()),
+    slotNumber: SlotNumber(reader.readNumber()),
     txCount: reader.readNumber(),
     timestamp: reader.readBigInt(),
   };

package/src/block/l2_block_new.ts

@@ -0,0 +1,197 @@
+import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import type { PrivateLog } from '../logs/private_log.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { Body } from './body.js';
+import type { L2BlockInfo } from './l2_block_info.js';
+
+/**
+ * An L2 block with a header and a body.
+ * TODO: Delete the existing `L2Block` class and rename this to `L2Block`.
+ */
+export class L2BlockNew {
+  constructor(
+    /** Snapshot of archive tree after the block is applied. */
+    public archive: AppendOnlyTreeSnapshot,
+    /** Header of the block. */
+    public header: BlockHeader,
+    /** L2 block body. */
+    public body: Body,
+    /** Number of the checkpoint that the block belongs to. */
+    public checkpointNumber: CheckpointNumber,
+    /** Index of the block within the checkpoint. */
+    public indexWithinCheckpoint: number,
+    private blockHash: Fr | undefined = undefined,
+  ) {}
+
+  get number(): BlockNumber {
+    return this.header.globalVariables.blockNumber;
+  }
+
+  get timestamp(): bigint {
+    return this.header.globalVariables.timestamp;
+  }
+
+  static get schema() {
+    return z
+      .object({
+        archive: AppendOnlyTreeSnapshot.schema,
+        header: BlockHeader.schema,
+        body: Body.schema,
+        checkpointNumber: CheckpointNumberSchema,
+        indexWithinCheckpoint: z.number(),
+      })
+      .transform(
+        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
+          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+      );
+  }
+
+  /**
+   * Deserializes a block from a buffer
+   * @returns A deserialized L2 block.
+   */
+  static fromBuffer(buf: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buf);
+    const header = reader.readObject(BlockHeader);
+    const archive = reader.readObject(AppendOnlyTreeSnapshot);
+    const body = reader.readObject(Body);
+    const checkpointNumber = CheckpointNumber(reader.readNumber());
+    const indexWithinCheckpoint = reader.readNumber();
+
+    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+  }
+
+  /**
+   * Serializes a block
+   * @returns A serialized L2 block as a Buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
+  }
+
+  /**
+   * Returns the block's hash (hash of block header).
+   * @returns The block's hash.
+   */
+  public async hash(): Promise<Fr> {
+    if (this.blockHash === undefined) {
+      this.blockHash = await this.header.hash();
+    }
+    return this.blockHash;
+  }
+
+  public toBlobFields(): Fr[] {
+    const blockBlobData = this.toBlockBlobData();
+    return encodeBlockBlobData(blockBlobData);
+  }
+
+  public toBlockBlobData(): BlockBlobData {
+    const isFirstBlock = this.indexWithinCheckpoint === 0;
+    return {
+      blockEndMarker: {
+        numTxs: this.body.txEffects.length,
+        timestamp: this.header.globalVariables.timestamp,
+        blockNumber: this.number,
+      },
+      blockEndStateField: {
+        l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
+        noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
+        nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
+        publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
+        totalManaUsed: this.header.totalManaUsed.toBigInt(),
+      },
+      lastArchiveRoot: this.header.lastArchive.root,
+      noteHashRoot: this.header.state.partial.noteHashTree.root,
+      nullifierRoot: this.header.state.partial.nullifierTree.root,
+      publicDataRoot: this.header.state.partial.publicDataTree.root,
+      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
+      txs: this.body.toTxBlobData(),
+    };
+  }
+
+  static empty() {
+    return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty(), CheckpointNumber(0), 0);
+  }
+
+  /**
+   * Creates an L2 block containing random data.
+   * @param l2BlockNum - The number of the L2 block.
+   * @param txsPerBlock - The number of transactions to include in the block.
+   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
+   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
+   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
+   * @returns The L2 block.
+   */
+  static async random(
+    blockNumber: BlockNumber,
+    {
+      checkpointNumber = CheckpointNumber(Number(blockNumber)),
+      indexWithinCheckpoint = 0,
+      txsPerBlock = 1,
+      txOptions = {},
+      makeTxOptions,
+      ...blockHeaderOverrides
+    }: {
+      checkpointNumber?: CheckpointNumber;
+      indexWithinCheckpoint?: number;
+      txsPerBlock?: number;
+      txOptions?: Partial<Parameters<typeof Body.random>[0]>;
+      makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
+    } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
+  ): Promise<L2BlockNew> {
+    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
+    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
+    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
+    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+  }
+
+  /**
+   * Returns stats used for logging.
+   * @returns Stats on tx count, number, and log size and count.
+   */
+  getStats() {
+    const logsStats = {
+      privateLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.privateLogs.length, 0),
+      publicLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.publicLogs.length, 0),
+      contractClassLogCount: this.body.txEffects.reduce(
+        (logCount, txEffect) => logCount + txEffect.contractClassLogs.length,
+        0,
+      ),
+      contractClassLogSize: this.body.txEffects.reduce(
+        (totalLogSize, txEffect) =>
+          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
+        0,
+      ),
+    };
+
+    return {
+      txCount: this.body.txEffects.length,
+      blockNumber: this.number,
+      blockTimestamp: Number(this.header.globalVariables.timestamp),
+      ...logsStats,
+    };
+  }
+
+  getPrivateLogs(): PrivateLog[] {
+    return this.body.txEffects.map(txEffect => txEffect.privateLogs).flat();
+  }
+
+  toBlockInfo(): L2BlockInfo {
+    return {
+      blockHash: this.blockHash,
+      archive: this.archive.root,
+      lastArchive: this.header.lastArchive.root,
+      blockNumber: this.number,
+      slotNumber: this.header.getSlot(),
+      txCount: this.body.txEffects.length,
+      timestamp: this.header.globalVariables.timestamp,
+    };
+  }
+}