@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/block/l2_block_code_to_purge.ts

@@ -1,26 +1,37 @@
+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';
 import { GasFees } from '../gas/gas_fees.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader } from '../tx/block_header.js';
 import { ContentCommitment } from '../tx/content_commitment.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { StateReference } from '../tx/state_reference.js';
+import { L2BlockHeader } from './l2_block_header.js';
 
-/**
- * Makes header.
- */
-export function makeHeader(seed = 0, blockNumber?: number, slotNumber?: number, inHash?: Fr): BlockHeader {
-  return new BlockHeader(
+export function makeL2BlockHeader(
+  seed = 0,
+  blockNumber?: number,
+  slotNumber?: number,
+  overrides: Partial<FieldsOf<L2BlockHeader>> = {},
+  inHash?: Fr,
+) {
+  return new L2BlockHeader(
     makeAppendOnlyTreeSnapshot(seed + 0x100),
-    makeContentCommitment(seed + 0x200, inHash),
-    makeStateReference(seed + 0x600),
-    makeGlobalVariables((seed += 0x700), blockNumber, slotNumber ?? blockNumber),
+    overrides?.contentCommitment ?? makeContentCommitment(seed + 0x200, inHash),
+    overrides?.state ?? makeStateReference(seed + 0x600),
+    makeGlobalVariables((seed += 0x700), {
+      ...(blockNumber ? { blockNumber: BlockNumber(blockNumber) } : {}),
+      ...(slotNumber ? { slotNumber: SlotNumber(slotNumber) } : {}),
+    }),
+    new Fr(seed + 0x300),
     new Fr(seed + 0x800),
     new Fr(seed + 0x900),
+    new Fr(seed + 0xa00),
   );
 }
 
@@ -62,26 +73,16 @@ function makePartialStateReference(seed = 0): PartialStateReference {
   );
 }
 
-/**
- * Makes global variables.
- * @param seed - The seed to use for generating the global variables.
- * @param blockNumber - The block number to use for generating the global variables.
- * If blockNumber is undefined, it will be set to seed + 2.
- * @returns Global variables.
- */
-export function makeGlobalVariables(
-  seed = 1,
-  blockNumber: number | undefined = undefined,
-  slotNumber: number | undefined = undefined,
-): GlobalVariables {
-  return new GlobalVariables(
-    new Fr(seed),
-    new Fr(seed + 1),
-    blockNumber ?? seed + 2,
-    new Fr(slotNumber ?? seed + 3),
-    BigInt(seed + 4),
-    EthAddress.fromField(new Fr(seed + 5)),
-    AztecAddress.fromField(new Fr(seed + 6)),
-    new GasFees(seed + 7, seed + 8),
-  );
+function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
+  return GlobalVariables.from({
+    chainId: new Fr(seed),
+    version: new Fr(seed + 1),
+    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)),
+    gasFees: new GasFees(seed + 7, seed + 8),
+    ...compact(overrides),
+  });
 }

package/src/block/l2_block_header.ts

@@ -0,0 +1,246 @@
+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';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from '../tx/index.js';
+
+/**
+ * TO BE DELETED
+ *
+ * A header of an L2 block combining the block header and the checkpoint header.
+ * This is a temporary workaround to avoid changing too many things before building in chunks is properly implemented.
+ * This works for now because we only have one block per checkpoint.
+ *
+ * @deprecated Use BlockHeader or CheckpointHeader instead.
+ */
+export class L2BlockHeader {
+  constructor(
+    /** Snapshot of archive before the block is applied. */
+    public lastArchive: AppendOnlyTreeSnapshot,
+    /** Hash of the body of an L2 block. */
+    public contentCommitment: ContentCommitment,
+    /** State reference. */
+    public state: StateReference,
+    /** Global variables of an L2 block. */
+    public globalVariables: GlobalVariables,
+    /** Total fees in the block, computed by the root rollup circuit */
+    public totalFees: Fr,
+    /** Total mana used in the block, computed by the root rollup circuit */
+    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> {
+    return z
+      .object({
+        lastArchive: AppendOnlyTreeSnapshot.schema,
+        contentCommitment: ContentCommitment.schema,
+        state: StateReference.schema,
+        globalVariables: GlobalVariables.schema,
+        totalFees: schemas.Fr,
+        totalManaUsed: schemas.Fr,
+        spongeBlobHash: schemas.Fr,
+        blockHeadersHash: schemas.Fr,
+      })
+      .transform(L2BlockHeader.from);
+  }
+
+  static getFields(fields: FieldsOf<L2BlockHeader>) {
+    return [
+      fields.lastArchive,
+      fields.contentCommitment,
+      fields.state,
+      fields.globalVariables,
+      fields.totalFees,
+      fields.totalManaUsed,
+      fields.spongeBlobHash,
+      fields.blockHeadersHash,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<L2BlockHeader>) {
+    return new L2BlockHeader(...L2BlockHeader.getFields(fields));
+  }
+
+  getSlot(): SlotNumber {
+    return this.globalVariables.slotNumber;
+  }
+
+  getBlockNumber() {
+    return this.globalVariables.blockNumber;
+  }
+
+  getSize() {
+    return (
+      this.lastArchive.getSize() +
+      this.contentCommitment.getSize() +
+      this.state.getSize() +
+      this.globalVariables.getSize() +
+      this.totalFees.size +
+      this.totalManaUsed.size +
+      this.spongeBlobHash.size +
+      this.blockHeadersHash.size
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...L2BlockHeader.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...L2BlockHeader.getFields(this));
+  }
+
+  clone() {
+    return L2BlockHeader.fromBuffer(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    return new L2BlockHeader(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(ContentCommitment),
+      reader.readObject(StateReference),
+      reader.readObject(GlobalVariables),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+
+    return new L2BlockHeader(
+      AppendOnlyTreeSnapshot.fromFields(reader),
+      ContentCommitment.fromFields(reader),
+      StateReference.fromFields(reader),
+      GlobalVariables.fromFields(reader),
+      reader.readField(),
+      reader.readField(),
+      reader.readField(),
+      reader.readField(),
+    );
+  }
+
+  static empty(fields: Partial<FieldsOf<L2BlockHeader>> = {}) {
+    return L2BlockHeader.from({
+      lastArchive: AppendOnlyTreeSnapshot.empty(),
+      contentCommitment: ContentCommitment.empty(),
+      state: StateReference.empty(),
+      globalVariables: GlobalVariables.empty(),
+      totalFees: Fr.ZERO,
+      totalManaUsed: Fr.ZERO,
+      spongeBlobHash: Fr.ZERO,
+      blockHeadersHash: Fr.ZERO,
+      ...fields,
+    });
+  }
+
+  isEmpty(): boolean {
+    return (
+      this.lastArchive.isEmpty() &&
+      this.contentCommitment.isEmpty() &&
+      this.state.isEmpty() &&
+      this.globalVariables.isEmpty() &&
+      this.totalFees.isZero() &&
+      this.totalManaUsed.isZero() &&
+      this.spongeBlobHash.isZero() &&
+      this.blockHeadersHash.isZero()
+    );
+  }
+
+  /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return L2BlockHeader.fromBuffer(hexToBuffer(str));
+  }
+
+  toCheckpointHeader() {
+    return new CheckpointHeader(
+      this.lastArchive.root,
+      this.blockHeadersHash,
+      this.contentCommitment,
+      this.globalVariables.slotNumber,
+      this.globalVariables.timestamp,
+      this.globalVariables.coinbase,
+      this.globalVariables.feeRecipient,
+      this.globalVariables.gasFees,
+      this.totalManaUsed,
+    );
+  }
+
+  toBlockHeader() {
+    return new BlockHeader(
+      this.lastArchive,
+      this.state,
+      this.spongeBlobHash,
+      this.globalVariables,
+      this.totalFees,
+      this.totalManaUsed,
+    );
+  }
+
+  toInspect() {
+    return {
+      lastArchive: this.lastArchive.root.toString(),
+      contentCommitment: this.contentCommitment.toInspect(),
+      state: this.state.toInspect(),
+      globalVariables: this.globalVariables.toInspect(),
+      totalFees: this.totalFees.toBigInt(),
+      totalManaUsed: this.totalManaUsed.toBigInt(),
+      spongeBlobHash: this.spongeBlobHash.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `L2BlockHeader {
+  lastArchive: ${inspect(this.lastArchive)},
+  contentCommitment.blobsHash: ${inspect(this.contentCommitment.blobsHash)},
+  contentCommitment.inHash: ${inspect(this.contentCommitment.inHash)},
+  contentCommitment.outHash: ${inspect(this.contentCommitment.outHash)},
+  state.l1ToL2MessageTree: ${inspect(this.state.l1ToL2MessageTree)},
+  state.noteHashTree: ${inspect(this.state.partial.noteHashTree)},
+  state.nullifierTree: ${inspect(this.state.partial.nullifierTree)},
+  state.publicDataTree: ${inspect(this.state.partial.publicDataTree)},
+  globalVariables: ${inspect(this.globalVariables)},
+  totalFees: ${this.totalFees},
+  totalManaUsed: ${this.totalManaUsed},
+  spongeBlobHash: ${this.spongeBlobHash},
+  blockHeadersHash: ${this.blockHeadersHash},
+}`;
+  }
+
+  public equals(other: this): boolean {
+    return (
+      this.contentCommitment.equals(other.contentCommitment) &&
+      this.state.equals(other.state) &&
+      this.globalVariables.equals(other.globalVariables) &&
+      this.totalFees.equals(other.totalFees) &&
+      this.totalManaUsed.equals(other.totalManaUsed) &&
+      this.lastArchive.equals(other.lastArchive) &&
+      this.spongeBlobHash.equals(other.spongeBlobHash) &&
+      this.blockHeadersHash.equals(other.blockHeadersHash)
+    );
+  }
+}

package/src/block/l2_block_info.ts

@@ -0,0 +1,64 @@
+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';
+
+import { z } from 'zod';
+
+export type L2BlockInfo = {
+  blockHash?: Fr;
+  archive: Fr;
+  lastArchive: Fr;
+  blockNumber: BlockNumber;
+  slotNumber: SlotNumber;
+  txCount: number;
+  timestamp: bigint;
+};
+
+export function randomBlockInfo(blockNumber?: BlockNumber | number): L2BlockInfo {
+  return {
+    blockHash: Fr.random(),
+    archive: Fr.random(),
+    lastArchive: Fr.random(),
+    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)),
+  };
+}
+
+export const BlockInfoSchema = z.object({
+  blockHash: schemas.Fr.optional(),
+  archive: schemas.Fr,
+  lastArchive: schemas.Fr,
+  blockNumber: BlockNumberSchema,
+  slotNumber: SlotNumberSchema,
+  txCount: z.number(),
+  timestamp: schemas.BigInt,
+});
+
+export function serializeBlockInfo(blockInfo: L2BlockInfo): Buffer {
+  return serializeToBuffer(
+    blockInfo.blockHash ?? Fr.ZERO,
+    blockInfo.archive,
+    blockInfo.lastArchive,
+    blockInfo.blockNumber,
+    blockInfo.slotNumber,
+    blockInfo.txCount,
+    blockInfo.timestamp,
+  );
+}
+
+export function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo {
+  const reader = BufferReader.asReader(buffer);
+  const blockHash = reader.readObject(Fr);
+  return {
+    blockHash: blockHash.equals(Fr.ZERO) ? undefined : blockHash,
+    archive: reader.readObject(Fr),
+    lastArchive: reader.readObject(Fr),
+    blockNumber: BlockNumber(reader.readNumber()),
+    slotNumber: SlotNumber(reader.readNumber()),
+    txCount: reader.readNumber(),
+    timestamp: reader.readBigInt(),
+  };
+}

package/src/block/l2_block_new.ts

@@ -0,0 +1,207 @@
+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,
+  ) {}
+
+  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 hash(): Promise<Fr> {
+    return this.header.hash();
+  }
+
+  /**
+   * Checks if this block equals another block.
+   * @param other - The other block to compare with.
+   * @returns True if both blocks are equal.
+   */
+  public equals(other: this): boolean {
+    return (
+      this.archive.equals(other.archive) &&
+      this.header.equals(other.header) &&
+      this.body.equals(other.body) &&
+      this.checkpointNumber === other.checkpointNumber &&
+      this.indexWithinCheckpoint === other.indexWithinCheckpoint
+    );
+  }
+
+  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 {
+      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,
+    };
+  }
+}