@aztec/stdlib 3.0.0-nightly.20251114 → 3.0.0-nightly.20251115

package/dest/tx/tx_effect.js

@@ -1,11 +1,10 @@
-import { decodeTxStartMarker, encodeTxStartMarker, isValidTxStartMarker } from '@aztec/blob-lib/encoding';
+import { decodeTxBlobData, encodeTxBlobData, getNumTxBlobFields } from '@aztec/blob-lib/encoding';
 import { MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX } from '@aztec/constants';
 import { makeTuple, makeTupleAsync } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import { computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 import { inspect } from 'util';
 import { z } from 'zod';
 import { PublicDataWrite } from '../avm/public_data_write.js';
@@ -13,6 +12,7 @@ import { RevertCode } from '../avm/revert_code.js';
 import { ContractClassLog } from '../logs/contract_class_log.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
+import { computeTxOutHash } from '../messaging/out_hash.js';
 import { TxHash } from './tx_hash.js';
 export class TxEffect {
     revertCode;
@@ -117,9 +117,6 @@ export class TxEffect {
     equals(other) {
         return this.revertCode.equals(other.revertCode) && this.txHash.equals(other.txHash) && this.transactionFee.equals(other.transactionFee) && this.noteHashes.length === other.noteHashes.length && this.noteHashes.every((h, i)=>h.equals(other.noteHashes[i])) && this.nullifiers.length === other.nullifiers.length && this.nullifiers.every((h, i)=>h.equals(other.nullifiers[i])) && this.l2ToL1Msgs.length === other.l2ToL1Msgs.length && this.l2ToL1Msgs.every((h, i)=>h.equals(other.l2ToL1Msgs[i])) && this.publicDataWrites.length === other.publicDataWrites.length && this.publicDataWrites.every((h, i)=>h.equals(other.publicDataWrites[i])) && this.privateLogs.length === other.privateLogs.length && this.privateLogs.every((h, i)=>h.equals(other.privateLogs[i])) && this.publicLogs.length === other.publicLogs.length && this.publicLogs.every((h, i)=>h.equals(other.publicLogs[i])) && this.contractClassLogs.length === other.contractClassLogs.length && this.contractClassLogs.every((h, i)=>h.equals(other.contractClassLogs[i]));
     }
-    /** Returns the size of this tx effect in bytes as serialized onto DA. */ getDASize() {
-        return this.toBlobFields().length * Fr.SIZE_IN_BYTES;
-    }
     /**
    * Deserializes the TxEffect object from a Buffer.
    * @param buffer - Buffer or BufferReader object to deserialize.
@@ -132,11 +129,7 @@ export class TxEffect {
    * Computes txOutHash of this tx effect.
    * @dev Follows new_sha in unbalanced_merkle_tree.nr
    */ txOutHash() {
-        const { l2ToL1Msgs } = this;
-        if (l2ToL1Msgs.length == 0) {
-            return Buffer.alloc(32);
-        }
-        return computeUnbalancedMerkleTreeRoot(l2ToL1Msgs.map((msg)=>msg.toBuffer()));
+        return computeTxOutHash(this.l2ToL1Msgs);
     }
     static async random(numPublicCallsPerTx = 3, numPublicLogsPerCall = 1, maxEffects = undefined) {
         return new TxEffect(RevertCode.random(), TxHash.random(), new Fr(Math.floor(Math.random() * 100_000)), makeTuple(maxEffects === undefined ? MAX_NOTE_HASHES_PER_TX : Math.min(maxEffects, MAX_NOTE_HASHES_PER_TX), Fr.random), makeTuple(maxEffects === undefined ? MAX_NULLIFIERS_PER_TX : Math.min(maxEffects, MAX_NULLIFIERS_PER_TX), Fr.random), makeTuple(maxEffects === undefined ? MAX_L2_TO_L1_MSGS_PER_TX : Math.min(maxEffects, MAX_L2_TO_L1_MSGS_PER_TX), Fr.random), makeTuple(maxEffects === undefined ? MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX : Math.min(maxEffects, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX), PublicDataWrite.random), makeTuple(MAX_PRIVATE_LOGS_PER_TX, ()=>PrivateLog.random()), await Promise.all(new Array(numPublicCallsPerTx * numPublicLogsPerCall).fill(null).map(()=>PublicLog.random())), await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.random));
@@ -147,63 +140,66 @@ export class TxEffect {
     /** Returns a hex representation of the TxEffect object. */ toString() {
         return bufferToHex(this.toBuffer());
     }
-    /**
-   * Returns a flat packed array of fields of all tx effects, to be appended to blobs.
-   * Must match the implementation in noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr
-   */ toBlobFields() {
-        const flattened = [];
-        // We reassign the first field at the end when we know the length of all effects to create the tx start marker.
-        flattened.push(Fr.ZERO);
-        flattened.push(this.txHash.hash);
-        flattened.push(this.transactionFee);
-        flattened.push(...this.noteHashes);
-        flattened.push(...this.nullifiers);
-        flattened.push(...this.l2ToL1Msgs);
-        flattened.push(...this.publicDataWrites.flatMap((w)=>w.toBlobFields()));
-        flattened.push(...this.privateLogs.flatMap((l)=>l.toBlobFields()));
-        const flattenedPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
-        flattened.push(...flattenedPublicLogs.toBlobFields());
-        flattened.push(...this.contractClassLogs.flatMap((l)=>l.toBlobFields()));
-        flattened[0] = encodeTxStartMarker({
+    getNumBlobFields() {
+        return this.getTxStartMarker().numBlobFields;
+    }
+    toBlobFields() {
+        return encodeTxBlobData(this.toTxBlobData());
+    }
+    static fromBlobFields(fields) {
+        return TxEffect.fromTxBlobData(decodeTxBlobData(fields));
+    }
+    getTxStartMarker() {
+        const flatPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
+        const partialTxStartMarker = {
             revertCode: this.revertCode.getCode(),
-            numBlobFields: flattened.length,
             numNoteHashes: this.noteHashes.length,
             numNullifiers: this.nullifiers.length,
             numL2ToL1Msgs: this.l2ToL1Msgs.length,
             numPublicDataWrites: this.publicDataWrites.length,
             numPrivateLogs: this.privateLogs.length,
-            publicLogsLength: flattenedPublicLogs.length,
+            privateLogsLength: this.privateLogs.reduce((acc, log)=>acc + log.emittedLength, 0),
+            publicLogsLength: flatPublicLogs.length,
             contractClassLogLength: this.contractClassLogs[0]?.emittedLength ?? 0
-        });
-        return flattened;
+        };
+        const numBlobFields = getNumTxBlobFields(partialTxStartMarker);
+        return {
+            ...partialTxStartMarker,
+            numBlobFields
+        };
+    }
+    /**
+   * Returns a flat packed array of fields of all tx effects, to be appended to blobs.
+   * Must match the implementation in noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr
+   */ toTxBlobData() {
+        return {
+            txStartMarker: this.getTxStartMarker(),
+            txHash: this.txHash.hash,
+            transactionFee: this.transactionFee,
+            noteHashes: this.noteHashes,
+            nullifiers: this.nullifiers,
+            l2ToL1Msgs: this.l2ToL1Msgs,
+            publicDataWrites: this.publicDataWrites.map((w)=>w.toBlobFields()),
+            privateLogs: this.privateLogs.map((l)=>l.toBlobFields()),
+            publicLogs: FlatPublicLogs.fromLogs(this.publicLogs).toBlobFields(),
+            contractClassLog: this.contractClassLogs.map((l)=>l.toBlobFields()).flat()
+        };
     }
     /**
    * Decodes a flat packed array of fields to TxEffect.
-   */ static fromBlobFields(fields) {
-        const reader = FieldReader.asReader(fields);
-        const totalFields = reader.remainingFields();
-        if (!totalFields) {
-            throw new Error('Cannot process empty blob fields.');
-        }
-        const txStartMarker = decodeTxStartMarker(reader.readField());
-        if (!isValidTxStartMarker(txStartMarker)) {
-            throw new Error('Invalid fields given to TxEffect.fromBlobFields(): invalid TxStartMarker');
-        }
-        const revertCode = RevertCode.fromField(new Fr(txStartMarker.revertCode));
-        const txHash = new TxHash(reader.readField());
-        const transactionFee = reader.readField();
-        const noteHashes = reader.readFieldArray(txStartMarker.numNoteHashes);
-        const nullifiers = reader.readFieldArray(txStartMarker.numNullifiers);
-        const l2ToL1Msgs = reader.readFieldArray(txStartMarker.numL2ToL1Msgs);
-        const publicDataWrites = Array.from({
-            length: txStartMarker.numPublicDataWrites
-        }, ()=>PublicDataWrite.fromBlobFields(reader));
-        const privateLogs = Array.from({
-            length: txStartMarker.numPrivateLogs
-        }, ()=>PrivateLog.fromBlobFields(reader));
-        const publicLogs = FlatPublicLogs.fromBlobFields(txStartMarker.publicLogsLength, reader).toLogs();
+   */ static fromTxBlobData(txBlobData) {
+        const txStartMarker = txBlobData.txStartMarker;
+        const revertCode = RevertCode.fromNumber(txStartMarker.revertCode);
+        const txHash = new TxHash(txBlobData.txHash);
+        const transactionFee = txBlobData.transactionFee;
+        const noteHashes = txBlobData.noteHashes;
+        const nullifiers = txBlobData.nullifiers;
+        const l2ToL1Msgs = txBlobData.l2ToL1Msgs;
+        const publicDataWrites = txBlobData.publicDataWrites.map((w)=>PublicDataWrite.fromBlobFields(w));
+        const privateLogs = txBlobData.privateLogs.map((l)=>PrivateLog.fromBlobFields(l.length, l));
+        const publicLogs = FlatPublicLogs.fromBlobFields(txStartMarker.publicLogsLength, txBlobData.publicLogs).toLogs();
         const contractClassLogs = txStartMarker.contractClassLogLength > 0 ? [
-            ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, reader)
+            ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, txBlobData.contractClassLog)
         ] : [];
         return TxEffect.from({
             revertCode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "3.0.0-nightly.20251114",
+  "version": "3.0.0-nightly.20251115",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -72,13 +72,13 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.892.0",
-    "@aztec/bb.js": "3.0.0-nightly.20251114",
-    "@aztec/blob-lib": "3.0.0-nightly.20251114",
-    "@aztec/constants": "3.0.0-nightly.20251114",
-    "@aztec/ethereum": "3.0.0-nightly.20251114",
-    "@aztec/foundation": "3.0.0-nightly.20251114",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20251114",
-    "@aztec/noir-noirc_abi": "3.0.0-nightly.20251114",
+    "@aztec/bb.js": "3.0.0-nightly.20251115",
+    "@aztec/blob-lib": "3.0.0-nightly.20251115",
+    "@aztec/constants": "3.0.0-nightly.20251115",
+    "@aztec/ethereum": "3.0.0-nightly.20251115",
+    "@aztec/foundation": "3.0.0-nightly.20251115",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20251115",
+    "@aztec/noir-noirc_abi": "3.0.0-nightly.20251115",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.12.0",
     "json-stringify-deterministic": "1.0.12",

package/src/avm/avm.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 
@@ -1056,7 +1057,7 @@ export class PublicTxResult {
     public gasUsed: GasUsed,
     public revertCode: RevertCode,
     public revertReason: SimulationError | undefined, // Revert reason, if any
-    // These are only guaranteed to be present in "client initiated simulation" mode.
+    // These are only guaranteed to be present if the simulator is configured to collect them.
     public processedPhases: ProcessedPhase[] | undefined,
     public logs: DebugLog[] | undefined,
     // For the proving request.
@@ -1121,17 +1122,52 @@ export class PublicTxResult {
   }
 }
 
-export type PublicTxSimulatorConfig = {
-  proverId: Fr;
-  doMerkleOperations: boolean;
-  skipFeeEnforcement: boolean;
-  clientInitiatedSimulation: boolean;
-  maxDebugLogMemoryReads: number;
-};
+export class PublicSimulatorConfig {
+  constructor(
+    public readonly proverId: Fr,
+    public readonly skipFeeEnforcement: boolean,
+    public readonly collectCallMetadata: boolean, // processedPhases.
+    public readonly collectHints: boolean, // hints.
+    public readonly collectDebugLogs: boolean, // logs.
+    public readonly maxDebugLogMemoryReads: number,
+    public readonly collectStatistics: boolean, // timings etc.
+  ) {}
+
+  static from(obj: Partial<PublicSimulatorConfig>): PublicSimulatorConfig {
+    return new PublicSimulatorConfig(
+      obj.proverId ?? Fr.ZERO,
+      obj.skipFeeEnforcement ?? false,
+      obj.collectCallMetadata ?? false,
+      obj.collectHints ?? false,
+      obj.collectDebugLogs ?? false,
+      obj.maxDebugLogMemoryReads ?? DEFAULT_MAX_DEBUG_LOG_MEMORY_READS,
+      obj.collectStatistics ?? false,
+    );
+  }
+
+  static empty() {
+    return PublicSimulatorConfig.from({});
+  }
+
+  static get schema() {
+    return z
+      .object({
+        proverId: Fr.schema,
+        skipFeeEnforcement: z.boolean(),
+        collectCallMetadata: z.boolean(),
+        collectHints: z.boolean(),
+        collectDebugLogs: z.boolean(),
+        maxDebugLogMemoryReads: z.number(),
+        collectStatistics: z.boolean(),
+      })
+      .transform(PublicSimulatorConfig.from);
+  }
+}
 
 export class AvmFastSimulationInputs {
   constructor(
     public readonly wsRevision: WorldStateRevision,
+    public readonly config: PublicSimulatorConfig,
     public tx: AvmTxHint,
     public globalVariables: GlobalVariables,
     public protocolContracts: ProtocolContracts,
@@ -1140,6 +1176,7 @@ export class AvmFastSimulationInputs {
   static empty() {
     return new AvmFastSimulationInputs(
       WorldStateRevision.empty(),
+      PublicSimulatorConfig.empty(),
       AvmTxHint.empty(),
       GlobalVariables.empty(),
       ProtocolContracts.empty(),
@@ -1150,13 +1187,14 @@ export class AvmFastSimulationInputs {
     return z
       .object({
         wsRevision: WorldStateRevision.schema,
+        config: PublicSimulatorConfig.schema,
         tx: AvmTxHint.schema,
         globalVariables: GlobalVariables.schema,
         protocolContracts: ProtocolContracts.schema,
       })
       .transform(
-        ({ wsRevision, tx, globalVariables, protocolContracts }) =>
-          new AvmFastSimulationInputs(wsRevision, tx, globalVariables, protocolContracts),
+        ({ wsRevision, config, tx, globalVariables, protocolContracts }) =>
+          new AvmFastSimulationInputs(wsRevision, config, tx, globalVariables, protocolContracts),
       );
   }
 

package/src/avm/public_data_write.ts

@@ -61,7 +61,7 @@ export class PublicDataWrite {
     return new PublicDataWrite(reader.readField(), reader.readField());
   }
 
-  toBlobFields(): Fr[] {
+  toBlobFields(): [Fr, Fr] {
     return [this.leafSlot, this.value];
   }
 

package/src/avm/revert_code.ts

@@ -115,11 +115,15 @@ export class RevertCode {
     return this.toBuffer().length;
   }
 
-  public static fromField(fr: Fr): RevertCode {
-    if (!isRevertCodeEnum(fr.toNumber())) {
-      throw new Error(`Invalid RevertCode: ${fr.toNumber()}`);
+  public static fromNumber(code: number): RevertCode {
+    if (!isRevertCodeEnum(code)) {
+      throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(fr.toNumber());
+    return new RevertCode(code);
+  }
+
+  public static fromField(field: Fr): RevertCode {
+    return RevertCode.fromNumber(field.toNumber());
   }
 
   public static fromFields(fields: Fr[] | FieldReader): RevertCode {
@@ -130,10 +134,7 @@ export class RevertCode {
   public static fromBuffer(buffer: Buffer | BufferReader): RevertCode {
     const reader = BufferReader.asReader(buffer);
     const code = reader.readBytes(RevertCode.PACKED_SIZE_IN_BYTES).readUInt8(0);
-    if (!isRevertCodeEnum(code)) {
-      throw new Error(`Invalid RevertCode: ${code}`);
-    }
-    return new RevertCode(code);
+    return RevertCode.fromNumber(code);
   }
 
   private static readonly NUM_OPTIONS = 4;

package/src/block/body.ts

@@ -1,7 +1,6 @@
-import { createBlockEndMarker, getNumTxsFromBlockEndMarker, isBlockEndMarker } from '@aztec/blob-lib/encoding';
+import type { TxBlobData } from '@aztec/blob-lib/encoding';
 import { timesParallel } from '@aztec/foundation/collection';
-import { 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';
@@ -9,14 +8,6 @@ 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[]) {}
 
@@ -55,32 +46,16 @@ export class Body {
   /**
    * Returns a flat packed array of fields of all tx effects - used for blobs.
    */
-  toBlobFields() {
-    return getBlockBlobFields(this.txEffects);
+  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.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);
+  static fromTxBlobData(txBlobData: TxBlobData[]): Body {
+    const txEffects = txBlobData.map(data => TxEffect.fromTxBlobData(data));
+    return new Body(txEffects);
   }
 
   [inspect.custom]() {

package/src/block/index.ts

@@ -1,4 +1,5 @@
 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';

package/src/block/l2_block.ts

@@ -1,10 +1,10 @@
+import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
 import { Fr } from '@aztec/foundation/fields';
 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 { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
@@ -14,6 +14,8 @@ import type { L2BlockInfo } from './l2_block_info.js';
 
 /**
  * The data that makes up the rollup proof, with encoder decoder functions.
+ *
+ * @deprecated Use `L2BlockNew` instead.
  */
 export class L2Block {
   constructor(
@@ -152,7 +154,36 @@ export class L2Block {
    * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
    */
   public getCheckpointBlobFields() {
-    return getCheckpointBlobFields([this.body.txEffects]);
+    const blockBlobData = this.toBlobFields(true);
+    return [new Fr(blockBlobData.length + 1)].concat(blockBlobData);
+  }
+
+  public toBlobFields(isFirstBlock: boolean): Fr[] {
+    const blockBlobData = this.toBlockBlobData(isFirstBlock);
+    return encodeBlockBlobData(blockBlobData);
+  }
+
+  public toBlockBlobData(isFirstBlock: boolean): BlockBlobData {
+    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(),
+    };
   }
 
   /**

package/src/block/l2_block_new.ts

@@ -0,0 +1,143 @@
+import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+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,
+    private blockHash: Fr | undefined = undefined,
+  ) {}
+
+  get number(): number {
+    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,
+      })
+      .transform(({ archive, header, body }) => new L2BlockNew(archive, header, body));
+  }
+
+  /**
+   * 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);
+
+    return new L2BlockNew(archive, header, body);
+  }
+
+  /**
+   * Serializes a block
+   * @returns A serialized L2 block as a Buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.header, this.archive, this.body);
+  }
+
+  /**
+   * 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(isFirstBlock: boolean): Fr[] {
+    const blockBlobData = this.toBlockBlobData(isFirstBlock);
+    return encodeBlockBlobData(blockBlobData);
+  }
+
+  public toBlockBlobData(isFirstBlock: boolean): BlockBlobData {
+    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.
+   */
+  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,
+    };
+  }
+
+  toBlockInfo(): L2BlockInfo {
+    return {
+      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,
+    };
+  }
+}

package/src/checkpoint/checkpoint.ts

@@ -0,0 +1,46 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { L2BlockNew } from '../block/l2_block_new.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+
+export class Checkpoint {
+  constructor(
+    /** Snapshot of archive tree after the checkpoint is added. */
+    public archive: AppendOnlyTreeSnapshot,
+    /** Header of the checkpoint. */
+    public header: CheckpointHeader,
+    /** L2 blocks in the checkpoint. */
+    public blocks: L2BlockNew[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        archive: AppendOnlyTreeSnapshot.schema,
+        header: CheckpointHeader.schema,
+        blocks: z.array(L2BlockNew.schema),
+      })
+      .transform(({ archive, header, blocks }) => new Checkpoint(archive, header, blocks));
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buf);
+    const archive = reader.readObject(AppendOnlyTreeSnapshot);
+    const header = reader.readObject(CheckpointHeader);
+    const blocks = reader.readVector(L2BlockNew);
+    return new Checkpoint(archive, header, blocks);
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks);
+  }
+
+  public toBlobFields() {
+    const blocksBlobFields = this.blocks.flatMap((block, i) => block.toBlobFields(i === 0));
+    return [new Fr(blocksBlobFields.length + 1)].concat(blocksBlobFields);
+  }
+}

package/src/checkpoint/index.ts

@@ -1 +1 @@
-export * from './checkpoint_body.js';
+export * from './checkpoint.js';

package/src/logs/private_log.ts

@@ -49,12 +49,11 @@ export class PrivateLog {
   }
 
   toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength)].concat(this.getEmittedFields());
+    return this.getEmittedFields();
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
+  static fromBlobFields(emittedLength: number, fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
     const emittedFields = reader.readFieldArray(emittedLength);
     return new PrivateLog(padArrayEnd(emittedFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), emittedLength);
   }