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

package/src/aztec-address/index.ts

@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-import { Fr, Point, fromBuffer } from '@aztec/foundation/fields';
-import { type ZodFor, hexSchemaFor } from '@aztec/foundation/schemas';
+import { Fr, fromBuffer } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import { type ZodFor, bufferSchemaFor, hexSchemaFor } from '@aztec/foundation/schemas';
 import { type BufferReader, FieldReader, TypeRegistry } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
+import { z } from 'zod';
 
 /** Branding to ensure fields are not interchangeable types. */
 export interface AztecAddress {
@@ -71,6 +73,24 @@ export class AztecAddress {
     return new AztecAddress(hexToBuffer(buf));
   }
 
+  /**
+   * Creates an AztecAddress from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * Handles buffers, strings, or existing instances.
+   * @param obj - Plain object, buffer, string, or AztecAddress instance
+   * @returns An AztecAddress instance
+   */
+  static fromPlainObject(obj: any): AztecAddress {
+    if (obj instanceof AztecAddress) {
+      return obj;
+    }
+    if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
+      return new AztecAddress(obj);
+    }
+    return AztecAddress.fromString(obj);
+  }
+
   /**
    * @returns a random valid address (i.e. one that can be encrypted to).
    */
@@ -137,7 +157,12 @@ export class AztecAddress {
   }
 
   static get schema(): ZodFor<AztecAddress> {
-    return hexSchemaFor(AztecAddress, AztecAddress.isAddress);
+    return z.union([
+      // Serialization from hex string.
+      hexSchemaFor(AztecAddress, AztecAddress.isAddress),
+      // Serialization from buffer.
+      bufferSchemaFor(AztecAddress, buf => buf.length === 32),
+    ]);
   }
 }
 

package/src/block/attestation_info.ts

@@ -0,0 +1,69 @@
+import { recoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import { ConsensusPayload } from '../p2p/consensus_payload.js';
+import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
+import type { L2Block } from './l2_block.js';
+import type { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+/**
+ * Status indicating how the attestation address was determined
+ */
+export type AttestationStatus = 'recovered-from-signature' | 'provided-as-address' | 'invalid-signature' | 'empty';
+
+/**
+ * Information about an attestation extracted from a published block
+ */
+export type AttestationInfo =
+  | {
+      /** The validator's address, undefined if signature recovery failed or empty */
+      address?: undefined;
+      /** How the attestation address was determined */
+      status: Extract<AttestationStatus, 'invalid-signature' | 'empty'>;
+    }
+  | {
+      /** The validator's address */
+      address: EthAddress;
+      /** How the attestation address was determined */
+      status: Extract<AttestationStatus, 'provided-as-address' | 'recovered-from-signature'>;
+    };
+
+/**
+ * Extracts attestation information from a published L2 block.
+ * Returns info for each attestation, preserving array indices.
+ */
+export function getAttestationInfoFromPublishedL2Block(block: {
+  attestations: CommitteeAttestation[];
+  block: L2Block;
+}): AttestationInfo[] {
+  const payload = ConsensusPayload.fromBlock(block.block);
+  return getAttestationInfoFromPayload(payload, block.attestations);
+}
+
+export function getAttestationInfoFromPayload(
+  payload: ConsensusPayload,
+  attestations: CommitteeAttestation[],
+): AttestationInfo[] {
+  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+
+  return attestations.map(attestation => {
+    // If signature is empty, check if we have an address directly
+    if (attestation.signature.isEmpty()) {
+      if (attestation.address.isZero()) {
+        // No signature and no address - empty
+        return { status: 'empty' as const };
+      }
+      // Address provided without signature
+      return { address: attestation.address, status: 'provided-as-address' as const };
+    }
+
+    // Try to recover address from signature
+    try {
+      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature);
+      return { address: recoveredAddress, status: 'recovered-from-signature' as const };
+    } catch {
+      // Signature present but recovery failed
+      return { status: 'invalid-signature' as const };
+    }
+  });
+}

package/src/block/block_hash.ts

@@ -1,5 +1,5 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 
 import { schemas } from '../schemas/schemas.js';

package/src/block/block_parameter.ts

@@ -0,0 +1,8 @@
+import { BlockNumberSchema } from '@aztec/foundation/branded-types';
+
+import { z } from 'zod';
+
+export const BlockParameterSchema = z.union([BlockNumberSchema, z.literal('latest')]);
+
+/** Block parameter - either a specific BlockNumber or 'latest' */
+export type BlockParameter = z.infer<typeof BlockParameterSchema>;

package/src/block/body.ts

@@ -1,7 +1,6 @@
-import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
+import type { TxBlobData } from '@aztec/blob-lib/encoding';
 import { timesParallel } from '@aztec/foundation/collection';
-import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -10,13 +9,7 @@ import type { ZodFor } from '../schemas/index.js';
 import { TxEffect } from '../tx/tx_effect.js';
 
 export class Body {
-  constructor(public txEffects: TxEffect[]) {
-    txEffects.forEach(txEffect => {
-      if (txEffect.isEmpty()) {
-        throw new Error('Empty tx effect not allowed in Body');
-      }
-    });
-  }
+  constructor(public txEffects: TxEffect[]) {}
 
   equals(other: Body) {
     return (
@@ -53,32 +46,16 @@ export class Body {
   /**
    * Returns a flat packed array of fields of all tx effects - used for blobs.
    */
-  toBlobFields() {
-    let flattened: Fr[] = [];
-    this.txEffects.forEach((effect: TxEffect) => {
-      flattened = flattened.concat(effect.toBlobFields());
-    });
-    if (flattened.length > BLOBS_PER_BLOCK * FIELDS_PER_BLOB) {
-      throw new Error(
-        `Attempted to overfill block's blobs with ${flattened.length} elements. The maximum is ${
-          BLOBS_PER_BLOCK * FIELDS_PER_BLOB
-        }`,
-      );
-    }
-
-    return flattened;
+  toTxBlobData(): TxBlobData[] {
+    return this.txEffects.map(txEffect => txEffect.toTxBlobData());
   }
 
   /**
    * Decodes a block from blob fields.
    */
-  static fromBlobFields(fields: Fr[]) {
-    const txEffects: TxEffect[] = [];
-    const reader = new FieldReader(fields);
-    while (!reader.isFinished()) {
-      txEffects.push(TxEffect.fromBlobFields(reader));
-    }
-    return new this(txEffects);
+  static fromTxBlobData(txBlobData: TxBlobData[]): Body {
+    const txEffects = txBlobData.map(data => TxEffect.fromTxBlobData(data));
+    return new Body(txEffects);
   }
 
   [inspect.custom]() {
@@ -87,14 +64,16 @@ export class Body {
 }`;
   }
 
-  static async random(
+  static async random({
     txsPerBlock = 4,
-    numPublicCallsPerTx = 3,
-    numPublicLogsPerCall = 1,
-    maxEffects: number | undefined = undefined,
-  ) {
-    const txEffects = await timesParallel(txsPerBlock, () =>
-      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall, maxEffects),
+    makeTxOptions = () => ({}),
+    ...txEffectOptions
+  }: {
+    txsPerBlock?: number;
+    makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof TxEffect.random>[0]>;
+  } & Partial<Parameters<typeof TxEffect.random>[0]> = {}) {
+    const txEffects = await timesParallel(txsPerBlock, txIndex =>
+      TxEffect.random({ ...makeTxOptions(txIndex), ...txEffectOptions }),
     );
 
     return new Body(txEffects);

package/src/block/checkpointed_l2_block.ts

@@ -0,0 +1,120 @@
+// 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, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
+import { L2Block } from './l2_block.js';
+import { L2BlockNew } from './l2_block_new.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: L2BlockNew,
+    public l1: L1PublishedData,
+    public attestations: CommitteeAttestation[],
+  ) {}
+  static get schema() {
+    return z
+      .object({
+        checkpointNumber: CheckpointNumberSchema,
+        block: L2BlockNew.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(L2BlockNew);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    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.block,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}
+
+export class PublishedL2Block {
+  constructor(
+    public block: L2Block,
+    public l1: L1PublishedData,
+    public attestations: CommitteeAttestation[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        block: L2Block.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedL2Block.fromFields(obj));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedL2Block {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const block = reader.readObject(L2Block);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    return new PublishedL2Block(block, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
+  }
+
+  static fromFields(fields: FieldsOf<PublishedL2Block>) {
+    return new PublishedL2Block(fields.block, fields.l1, fields.attestations);
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.block,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+
+  public toPublishedCheckpoint() {
+    return new PublishedCheckpoint(this.block.toCheckpoint(), this.l1, this.attestations);
+  }
+
+  static fromPublishedCheckpoint(checkpoint: PublishedCheckpoint) {
+    return new PublishedL2Block(L2Block.fromCheckpoint(checkpoint.checkpoint), checkpoint.l1, checkpoint.attestations);
+  }
+}

package/src/block/in_block.ts

@@ -1,25 +1,35 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+
 import { type ZodTypeAny, z } from 'zod';
 
-import { schemas } from '../schemas/index.js';
 import { L2BlockHash } from './block_hash.js';
 import type { L2Block } from './l2_block.js';
 
-// Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
-export type InBlock<T> = {
-  l2BlockNumber: number;
+export type InBlock = {
+  l2BlockNumber: BlockNumber;
   l2BlockHash: L2BlockHash;
-  data: T;
 };
 
-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 {
-    data,
-    l2BlockNumber: Math.floor(Math.random() * 1000),
+    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000)),
     l2BlockHash: L2BlockHash.random(),
   };
 }
 
-export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T>> {
+export function randomDataInBlock<T>(data: T): DataInBlock<T> {
+  return {
+    ...randomInBlock(),
+    data,
+  };
+}
+
+export async function wrapDataInBlock<T>(data: T, block: L2Block): Promise<DataInBlock<T>> {
   return {
     data,
     l2BlockNumber: block.number,
@@ -27,10 +37,13 @@ export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T
   };
 }
 
-export function inBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
+export function inBlockSchema() {
   return z.object({
-    data: schema,
-    l2BlockNumber: schemas.Integer,
+    l2BlockNumber: BlockNumberSchema,
     l2BlockHash: L2BlockHash.schema,
   });
 }
+
+export function dataInBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
+  return inBlockSchema().extend({ data: schema });
+}

package/src/block/index.ts

@@ -1,9 +1,14 @@
 export * from './l2_block.js';
+export * from './l2_block_new.js';
+export * from './l2_block_header.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 './published_l2_block.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,23 +1,31 @@
-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 { Checkpoint } from '../checkpoint/checkpoint.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader } from '../tx/block_header.js';
+import type { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
-import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge.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(
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
     /** L2 block header. */
-    public header: BlockHeader,
+    public header: L2BlockHeader,
     /** L2 block body. */
     public body: Body,
     private blockHash: Fr | undefined = undefined,
@@ -27,7 +35,7 @@ export class L2Block {
     return z
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
-        header: BlockHeader.schema,
+        header: L2BlockHeader.schema,
         body: Body.schema,
       })
       .transform(({ archive, header, body }) => new L2Block(archive, header, body));
@@ -39,7 +47,7 @@ export class L2Block {
    */
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
-    const header = reader.readObject(BlockHeader);
+    const header = reader.readObject(L2BlockHeader);
     const archive = reader.readObject(AppendOnlyTreeSnapshot);
     const body = reader.readObject(Body);
 
@@ -81,7 +89,7 @@ export class L2Block {
    * @returns The L2 block.
    */
   static async random(
-    l2BlockNum: number,
+    l2BlockNum: BlockNumber,
     txsPerBlock = 4,
     numPublicCallsPerTx = 3,
     numPublicLogsPerCall = 1,
@@ -89,11 +97,11 @@ 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),
-      makeHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, inHash),
+      makeL2BlockHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, {}, inHash),
       body,
     );
   }
@@ -103,14 +111,14 @@ export class L2Block {
    * @returns The L2 block.
    */
   static empty(): L2Block {
-    return new L2Block(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty());
+    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();
   }
 
@@ -124,11 +132,100 @@ export class L2Block {
    */
   public async hash(): Promise<Fr> {
     if (this.blockHash === undefined) {
-      this.blockHash = await this.header.hash();
+      this.blockHash = await this.getBlockHeader().hash();
     }
     return this.blockHash;
   }
 
+  /**
+   * @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 getCheckpointHeader() {
+    return this.header.toCheckpointHeader();
+  }
+
+  // Temporary helper to get the actual block header.
+  public getBlockHeader(): BlockHeader {
+    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() {
+    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(),
+    };
+  }
+
   /**
    * Returns stats used for logging.
    * @returns Stats on tx count, number, and log size and count.
@@ -156,13 +253,15 @@ export class L2Block {
     };
   }
 
-  toBlockInfo(): BlockInfo {
+  toBlockInfo(): L2BlockInfo {
     return {
-      blockHash: this.blockHash?.toString(),
-      archive: this.archive.root.toString(),
+      blockHash: this.blockHash,
+      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,
     };
   }
 
@@ -170,11 +269,3 @@ export class L2Block {
     return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body);
   }
 }
-
-export type BlockInfo = {
-  blockHash?: string;
-  archive: string;
-  blockNumber: number;
-  slotNumber: number;
-  txCount: number;
-};