@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/block/attestation_info.ts

@@ -0,0 +1,62 @@
+import { recoverAddress } from '@aztec/foundation/crypto';
+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);
+  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+
+  return block.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/body.ts

@@ -1,6 +1,6 @@
-import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
+import { createBlockEndMarker, getNumTxsFromBlockEndMarker, isBlockEndMarker } from '@aztec/blob-lib/encoding';
 import { timesParallel } from '@aztec/foundation/collection';
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
@@ -9,14 +9,16 @@ import { z } from 'zod';
 import type { ZodFor } from '../schemas/index.js';
 import { TxEffect } from '../tx/tx_effect.js';
 
+export { createBlockEndMarker };
+
+export function getBlockBlobFields(txEffects: TxEffect[]) {
+  const blobFields = txEffects.flatMap(txEffect => txEffect.toBlobFields());
+  blobFields.push(createBlockEndMarker(txEffects.length));
+  return blobFields;
+}
+
 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 (
@@ -54,19 +56,7 @@ 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;
+    return getBlockBlobFields(this.txEffects);
   }
 
   /**
@@ -74,10 +64,22 @@ export class Body {
    */
   static fromBlobFields(fields: Fr[]) {
     const txEffects: TxEffect[] = [];
-    const reader = new FieldReader(fields);
+    const reader = new FieldReader(fields.slice(0, -1));
     while (!reader.isFinished()) {
       txEffects.push(TxEffect.fromBlobFields(reader));
     }
+
+    // If the fields are from a proven block, or are constructed by calling `toBlobFields`, the following errors should never throw.
+
+    if (!isBlockEndMarker(fields[fields.length - 1])) {
+      throw new Error('Block end marker not found');
+    }
+
+    const numTxs = getNumTxsFromBlockEndMarker(fields[fields.length - 1]);
+    if (numTxs !== txEffects.length) {
+      throw new Error(`Expected ${numTxs} txs, but got ${txEffects.length}`);
+    }
+
     return new this(txEffects);
   }
 

package/src/block/index.ts

@@ -1,4 +1,5 @@
 export * from './l2_block.js';
+export * from './l2_block_header.js';
 export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';
@@ -7,3 +8,6 @@ export * from './l2_block_source.js';
 export * from './block_hash.js';
 export * from './published_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

@@ -4,10 +4,13 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
+import { getCheckpointBlobFields } from '../checkpoint/checkpoint_body.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';
 
 /**
  * The data that makes up the rollup proof, with encoder decoder functions.
@@ -17,7 +20,7 @@ export class L2Block {
     /** 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 +30,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 +42,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);
 
@@ -93,7 +96,7 @@ export class L2Block {
 
     return new L2Block(
       makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
-      makeHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, inHash),
+      makeL2BlockHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, {}, inHash),
       body,
     );
   }
@@ -103,7 +106,7 @@ 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 {
@@ -124,11 +127,34 @@ 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();
+  }
+
+  /**
+   * @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]);
+  }
+
   /**
    * Returns stats used for logging.
    * @returns Stats on tx count, number, and log size and count.
@@ -156,13 +182,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()),
       txCount: this.body.txEffects.length,
+      timestamp: this.header.globalVariables.timestamp,
     };
   }
 
@@ -170,11 +198,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;
-};

package/src/block/l2_block_code_to_purge.ts

@@ -1,26 +1,35 @@
+import { compact } from '@aztec/foundation/collection';
 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 } : {}),
+      ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
+    }),
     new Fr(seed + 0x800),
     new Fr(seed + 0x900),
+    new Fr(seed + 0xa00),
   );
 }
 
@@ -62,26 +71,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: seed + 2,
+    slotNumber: new Fr(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,232 @@
+import { Fr } from '@aztec/foundation/fields';
+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,
+  ) {}
+
+  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,
+      })
+      .transform(L2BlockHeader.from);
+  }
+
+  static getFields(fields: FieldsOf<L2BlockHeader>) {
+    return [
+      fields.lastArchive,
+      fields.contentCommitment,
+      fields.state,
+      fields.globalVariables,
+      fields.totalFees,
+      fields.totalManaUsed,
+      fields.spongeBlobHash,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<L2BlockHeader>) {
+    return new L2BlockHeader(...L2BlockHeader.getFields(fields));
+  }
+
+  getSlot() {
+    return this.globalVariables.slotNumber.toBigInt();
+  }
+
+  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
+    );
+  }
+
+  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),
+    );
+  }
+
+  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(),
+    );
+  }
+
+  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,
+      ...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()
+    );
+  }
+
+  /**
+   * 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.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(),
+    };
+  }
+
+  [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},
+}`;
+  }
+
+  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)
+    );
+  }
+}

package/src/block/l2_block_info.ts

@@ -0,0 +1,63 @@
+import { Fr } from '@aztec/foundation/fields';
+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: number;
+  slotNumber: number;
+  txCount: number;
+  timestamp: bigint;
+};
+
+export function randomBlockInfo(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,
+    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: z.number(),
+  slotNumber: z.number(),
+  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: reader.readNumber(),
+    slotNumber: reader.readNumber(),
+    txCount: reader.readNumber(),
+    timestamp: reader.readBigInt(),
+  };
+}