@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/block/checkpointed_l2_block.ts

@@ -0,0 +1,70 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+/**
+ * Encapsulates an L2 Block along with the checkpoint data associated with it.
+ */
+export class CheckpointedL2Block {
+  constructor(
+    public checkpointNumber: CheckpointNumber,
+    public block: L2Block,
+    public l1: L1PublishedData,
+    public attestations: CommitteeAttestation[],
+  ) {}
+  static get schema() {
+    return z
+      .object({
+        checkpointNumber: CheckpointNumberSchema,
+        block: L2Block.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => CheckpointedL2Block.fromFields(obj));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): CheckpointedL2Block {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpointNumber = reader.readNumber();
+    const block = reader.readObject(L2Block);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
+    return new CheckpointedL2Block(
+      CheckpointNumber(checkpointNumber),
+      block,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  static fromFields(fields: FieldsOf<CheckpointedL2Block>) {
+    return new CheckpointedL2Block(
+      CheckpointNumber(fields.checkpointNumber),
+      fields.block,
+      fields.l1,
+      fields.attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.checkpointNumber,
+      this.block,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/block/in_block.ts

@@ -1,36 +1,49 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
 
 import { type ZodTypeAny, z } from 'zod';
 
-import { schemas } from '../schemas/index.js';
+import { BlockHash } from './block_hash.js';
 import type { L2Block } from './l2_block.js';
 
-export type InBlock<T> = {
-  l2BlockNumber: number;
-  l2BlockHash: string;
-  data: T;
+export type InBlock = {
+  l2BlockNumber: BlockNumber;
+  l2BlockHash: BlockHash;
 };
 
-export function randomInBlock<T>(data: T): InBlock<T> {
+// Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
+export type DataInBlock<T> = {
+  data: T;
+} & InBlock;
+
+export function randomInBlock(): InBlock {
   return {
+    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000) + 1),
+    l2BlockHash: BlockHash.random(),
+  };
+}
+
+export function randomDataInBlock<T>(data: T): DataInBlock<T> {
+  return {
+    ...randomInBlock(),
     data,
-    l2BlockNumber: Math.floor(Math.random() * 1000),
-    l2BlockHash: Fr.random().toString(),
   };
 }
 
-export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T>> {
+export async function wrapDataInBlock<T>(data: T, block: L2Block): Promise<DataInBlock<T>> {
   return {
     data,
     l2BlockNumber: block.number,
-    l2BlockHash: (await block.hash()).toString(),
+    l2BlockHash: await block.hash(),
   };
 }
 
-export function inBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
+export function inBlockSchema() {
   return z.object({
-    data: schema,
-    l2BlockNumber: schemas.Integer,
-    l2BlockHash: z.string(),
+    l2BlockNumber: BlockNumberSchema,
+    l2BlockHash: BlockHash.schema,
   });
 }
+
+export function dataInBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
+  return inBlockSchema().extend({ data: schema });
+}

package/src/block/index.ts

@@ -1,8 +1,13 @@
+export * from './block_data.js';
 export * from './l2_block.js';
-export * from './l2_block_downloader/index.js';
-export * from './nullifier_with_block_source.js';
+export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';
-export * from './l2_block_number.js';
+export * from './block_parameter.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
+export * from './checkpointed_l2_block.js';
+export * from './proposal/index.js';
+export * from './validate_block_result.js';
+export * from './l2_block_info.js';
+export * from './attestation_info.js';

package/src/block/l2_block.ts

@@ -1,36 +1,67 @@
-import { sha256, sha256ToField } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { DA_GAS_PER_FIELD } from '@aztec/constants';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  IndexWithinCheckpoint,
+  IndexWithinCheckpointSchema,
+  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 type { PrivateLog } from '../logs/private_log.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
+import type { BlockHash } from './block_hash.js';
 import { Body } from './body.js';
-import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge.js';
+import type { L2BlockInfo } from './l2_block_info.js';
 
 /**
- * The data that makes up the rollup proof, with encoder decoder functions.
+ * An L2 block with a header and a body.
  */
 export class L2Block {
   constructor(
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
-    /** L2 block header. */
+    /** 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: IndexWithinCheckpoint,
   ) {}
 
+  get number(): BlockNumber {
+    return this.header.globalVariables.blockNumber;
+  }
+
+  get slot(): SlotNumber {
+    return this.header.globalVariables.slotNumber;
+  }
+
+  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: IndexWithinCheckpointSchema,
       })
-      .transform(({ archive, header, body }) => new L2Block(archive, header, body));
+      .transform(
+        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
+          new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+      );
   }
 
   /**
@@ -42,8 +73,10 @@ export class L2Block {
     const header = reader.readObject(BlockHeader);
     const archive = reader.readObject(AppendOnlyTreeSnapshot);
     const body = reader.readObject(Body);
+    const checkpointNumber = CheckpointNumber(reader.readNumber());
+    const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
 
-    return new L2Block(archive, header, body);
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -51,24 +84,69 @@ export class L2Block {
    * @returns A serialized L2 block as a Buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.header, this.archive, this.body);
+    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
   }
 
   /**
-   * Deserializes L2 block from a buffer.
-   * @param str - A serialized L2 block.
-   * @returns Deserialized L2 block.
+   * Returns the block's hash (hash of block header).
+   * @returns The block's hash.
    */
-  static fromString(str: string): L2Block {
-    return L2Block.fromBuffer(hexToBuffer(str));
+  public hash(): Promise<BlockHash> {
+    return this.header.hash();
   }
 
   /**
-   * Serializes a block to a string.
-   * @returns A serialized L2 block as a string.
+   * Checks if this block equals another block.
+   * @param other - The other block to compare with.
+   * @returns True if both blocks are equal.
    */
-  toString(): string {
-    return bufferToHex(this.toBuffer());
+  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(header?: BlockHeader) {
+    return new L2Block(
+      AppendOnlyTreeSnapshot.empty(),
+      header ?? BlockHeader.empty(),
+      Body.empty(),
+      CheckpointNumber(0),
+      IndexWithinCheckpoint(0),
+    );
   }
 
   /**
@@ -81,99 +159,26 @@ export class L2Block {
    * @returns The L2 block.
    */
   static async random(
-    l2BlockNum: number,
-    txsPerBlock = 4,
-    numPublicCallsPerTx = 3,
-    numPublicLogsPerCall = 1,
-    inHash: Buffer | undefined = undefined,
-    slotNumber: number | undefined = undefined,
+    blockNumber: BlockNumber,
+    {
+      checkpointNumber = CheckpointNumber(Number(blockNumber)),
+      indexWithinCheckpoint = IndexWithinCheckpoint(0),
+      txsPerBlock = 1,
+      txOptions = {},
+      makeTxOptions,
+      ...blockHeaderOverrides
+    }: {
+      checkpointNumber?: CheckpointNumber;
+      indexWithinCheckpoint?: IndexWithinCheckpoint;
+      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<L2Block> {
-    const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall);
-
-    return new L2Block(
-      makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
-      makeHeader(0, txsPerBlock, l2BlockNum, slotNumber ?? l2BlockNum, inHash),
-      body,
-    );
-  }
-
-  /**
-   * Creates an L2 block containing empty data.
-   * @returns The L2 block.
-   */
-  static empty(): L2Block {
-    return new L2Block(AppendOnlyTreeSnapshot.zero(), BlockHeader.empty(), Body.empty());
-  }
-
-  get number(): number {
-    return Number(this.header.globalVariables.blockNumber.toBigInt());
-  }
-
-  /**
-   * Returns the block's hash (hash of block header).
-   * @returns The block's hash.
-   */
-  public hash(): Promise<Fr> {
-    return this.header.hash();
-  }
-
-  /**
-   * Computes the public inputs hash for the L2 block.
-   * The same output as the hash of RootRollupPublicInputs.
-   * TODO(Miranda): Check where/if this is used (v diff now with epochs and blobs)
-   * @returns The public input hash for the L2 block as a field element.
-   */
-  // TODO(#4844)
-  getPublicInputsHash(): Fr {
-    const preimage = [
-      this.header.globalVariables,
-      AppendOnlyTreeSnapshot.zero(), // this.startNoteHashTreeSnapshot / commitments,
-      AppendOnlyTreeSnapshot.zero(), // this.startNullifierTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startPublicDataTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startL1ToL2MessageTreeSnapshot,
-      this.header.lastArchive,
-      this.header.state.partial.noteHashTree,
-      this.header.state.partial.nullifierTree,
-      this.header.state.partial.publicDataTree,
-      this.header.state.l1ToL2MessageTree,
-      this.archive,
-    ];
-
-    return sha256ToField(preimage);
-  }
-
-  /**
-   * Computes the start state hash (should equal contract data before block).
-   * @returns The start state hash for the L2 block.
-   */
-  // TODO(#4844)
-  getStartStateHash() {
-    const inputValue = serializeToBuffer(
-      new Fr(Number(this.header.globalVariables.blockNumber.toBigInt()) - 1),
-      AppendOnlyTreeSnapshot.zero(), // this.startNoteHashTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startNullifierTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startPublicDataTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startL1ToL2MessageTreeSnapshot,
-      this.header.lastArchive,
-    );
-    return sha256(inputValue);
-  }
-
-  /**
-   * Computes the end state hash (should equal contract data after block).
-   * @returns The end state hash for the L2 block.
-   */
-  // TODO(#4844)
-  getEndStateHash() {
-    const inputValue = serializeToBuffer(
-      this.header.globalVariables.blockNumber,
-      this.header.state.partial.noteHashTree,
-      this.header.state.partial.nullifierTree,
-      this.header.state.partial.publicDataTree,
-      this.header.state.l1ToL2MessageTree,
-      this.archive,
-    );
-    return sha256(inputValue);
+    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
+    const header = BlockHeader.random({ ...blockHeaderOverrides, blockNumber });
+    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -190,7 +195,7 @@ export class L2Block {
       ),
       contractClassLogSize: this.body.txEffects.reduce(
         (totalLogSize, txEffect) =>
-          totalLogSize + txEffect.contractClassLogs.reduce((logSize, log) => logSize + log.getEmittedLength(), 0),
+          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
         0,
       ),
     };
@@ -198,8 +203,34 @@ export class L2Block {
     return {
       txCount: this.body.txEffects.length,
       blockNumber: this.number,
-      blockTimestamp: this.header.globalVariables.timestamp.toNumber(),
+      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,
+    };
+  }
+
+  /**
+   * Compute how much DA gas this block uses.
+   *
+   * @remarks This assumes DA gas is computed solely based on the number of blob fields in transactions.
+   * This may change in the future, but we cannot access the actual DA gas used in a block since it's not exposed
+   * in the L2BlockHeader, so we have to rely on recomputing it.
+   */
+  computeDAGasUsed(): number {
+    return this.body.txEffects.reduce((total, txEffect) => total + txEffect.getNumBlobFields(), 0) * DA_GAS_PER_FIELD;
+  }
 }

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(),
+  };
+}