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

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';
 
@@ -666,9 +667,9 @@ export class AvmRevertCheckpointHint {
   }
 }
 
-export class AvmContractDBCreateCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
-export class AvmContractDBCommitCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
-export class AvmContractDBRevertCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
+export class AvmContractDbCreateCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
+export class AvmContractDbCommitCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
+export class AvmContractDbRevertCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
 
 ////////////////////////////////////////////////////////////////////////////
 // Hints (other)
@@ -858,9 +859,9 @@ export class AvmExecutionHints {
     public readonly contractClasses: AvmContractClassHint[] = [],
     public readonly bytecodeCommitments: AvmBytecodeCommitmentHint[] = [],
     public readonly debugFunctionNames: AvmDebugFunctionNameHint[] = [],
-    public readonly contractDBCreateCheckpointHints: AvmContractDBCreateCheckpointHint[] = [],
-    public readonly contractDBCommitCheckpointHints: AvmContractDBCommitCheckpointHint[] = [],
-    public readonly contractDBRevertCheckpointHints: AvmContractDBRevertCheckpointHint[] = [],
+    public readonly contractDbCreateCheckpointHints: AvmContractDbCreateCheckpointHint[] = [],
+    public readonly contractDbCommitCheckpointHints: AvmContractDbCommitCheckpointHint[] = [],
+    public readonly contractDbRevertCheckpointHints: AvmContractDbRevertCheckpointHint[] = [],
     // Merkle DB hints.
     public startingTreeRoots: TreeSnapshots = TreeSnapshots.empty(),
     public readonly getSiblingPathHints: AvmGetSiblingPathHint[] = [],
@@ -895,9 +896,9 @@ export class AvmExecutionHints {
       obj.contractClasses?.map((c: any) => AvmContractClassHint.fromPlainObject(c)) || [],
       obj.bytecodeCommitments?.map((b: any) => AvmBytecodeCommitmentHint.fromPlainObject(b)) || [],
       obj.debugFunctionNames?.map((d: any) => AvmDebugFunctionNameHint.fromPlainObject(d)) || [],
-      obj.contractDBCreateCheckpointHints?.map((h: any) => AvmContractDBCreateCheckpointHint.fromPlainObject(h)) || [],
-      obj.contractDBCommitCheckpointHints?.map((h: any) => AvmContractDBCommitCheckpointHint.fromPlainObject(h)) || [],
-      obj.contractDBRevertCheckpointHints?.map((h: any) => AvmContractDBRevertCheckpointHint.fromPlainObject(h)) || [],
+      obj.contractDbCreateCheckpointHints?.map((h: any) => AvmContractDbCreateCheckpointHint.fromPlainObject(h)) || [],
+      obj.contractDbCommitCheckpointHints?.map((h: any) => AvmContractDbCommitCheckpointHint.fromPlainObject(h)) || [],
+      obj.contractDbRevertCheckpointHints?.map((h: any) => AvmContractDbRevertCheckpointHint.fromPlainObject(h)) || [],
       obj.startingTreeRoots ? TreeSnapshots.fromPlainObject(obj.startingTreeRoots) : TreeSnapshots.empty(),
       obj.getSiblingPathHints?.map((h: any) => AvmGetSiblingPathHint.fromPlainObject(h)) || [],
       obj.getPreviousValueIndexHints?.map((h: any) => AvmGetPreviousValueIndexHint.fromPlainObject(h)) || [],
@@ -934,9 +935,9 @@ export class AvmExecutionHints {
         contractClasses: AvmContractClassHint.schema.array(),
         bytecodeCommitments: AvmBytecodeCommitmentHint.schema.array(),
         debugFunctionNames: AvmDebugFunctionNameHint.schema.array(),
-        contractDBCreateCheckpointHints: AvmContractDBCreateCheckpointHint.schema.array(),
-        contractDBCommitCheckpointHints: AvmContractDBCommitCheckpointHint.schema.array(),
-        contractDBRevertCheckpointHints: AvmContractDBRevertCheckpointHint.schema.array(),
+        contractDbCreateCheckpointHints: AvmContractDbCreateCheckpointHint.schema.array(),
+        contractDbCommitCheckpointHints: AvmContractDbCommitCheckpointHint.schema.array(),
+        contractDbRevertCheckpointHints: AvmContractDbRevertCheckpointHint.schema.array(),
         startingTreeRoots: TreeSnapshots.schema,
         getSiblingPathHints: AvmGetSiblingPathHint.schema.array(),
         getPreviousValueIndexHints: AvmGetPreviousValueIndexHint.schema.array(),
@@ -959,9 +960,9 @@ export class AvmExecutionHints {
           contractClasses,
           bytecodeCommitments,
           debugFunctionNames,
-          contractDBCreateCheckpointHints,
-          contractDBCommitCheckpointHints,
-          contractDBRevertCheckpointHints,
+          contractDbCreateCheckpointHints,
+          contractDbCommitCheckpointHints,
+          contractDbRevertCheckpointHints,
           startingTreeRoots,
           getSiblingPathHints,
           getPreviousValueIndexHints,
@@ -983,9 +984,9 @@ export class AvmExecutionHints {
             contractClasses,
             bytecodeCommitments,
             debugFunctionNames,
-            contractDBCreateCheckpointHints,
-            contractDBCommitCheckpointHints,
-            contractDBRevertCheckpointHints,
+            contractDbCreateCheckpointHints,
+            contractDbCommitCheckpointHints,
+            contractDbRevertCheckpointHints,
             startingTreeRoots,
             getSiblingPathHints,
             getPreviousValueIndexHints,
@@ -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);
   }

package/src/messaging/in_hash.ts

@@ -0,0 +1,15 @@
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { MerkleTreeCalculator } from '@aztec/foundation/trees';
+
+/** Computes the inHash for a block's ContentCommitment given its l1 to l2 messages. */
+export async function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr[]): Promise<Fr> {
+  const l1ToL2Messages = padArrayEnd<Fr, number>(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  const hasher = (left: Buffer, right: Buffer) =>
+    Promise.resolve(sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>);
+  const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+  const parityCalculator = await MerkleTreeCalculator.create(parityHeight, Fr.ZERO.toBuffer(), hasher);
+  return new Fr(await parityCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer())));
+}

package/src/messaging/index.ts

@@ -1,3 +1,4 @@
+export * from './in_hash.js';
 export * from './inbox_leaf.js';
 export * from './l1_to_l2_message.js';
 export * from './l1_to_l2_message_source.js';
@@ -5,3 +6,4 @@ export * from './l1_actor.js';
 export * from './l2_actor.js';
 export * from './l2_to_l1_message.js';
 export * from './l2_to_l1_membership.js';
+export * from './out_hash.js';

package/src/messaging/out_hash.ts

@@ -0,0 +1,36 @@
+import { Fr } from '@aztec/foundation/fields';
+import { UnbalancedMerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
+
+export function computeTxOutHash(messages: Fr[]): Fr {
+  if (!messages.length) {
+    return Fr.ZERO;
+  }
+  // Tx out hash is the root of the unbalanced merkle tree of all the messages.
+  // Zero hashes (which should not happen) are not compressed.
+  return Fr.fromBuffer(computeUnbalancedMerkleTreeRoot(messages.map(msg => msg.toBuffer())));
+}
+
+export function computeBlockOutHash(messagesPerBlock: Fr[][]): Fr {
+  const txOutHashes = messagesPerBlock.map(messages => computeTxOutHash(messages));
+  return aggregateOutHashes(txOutHashes);
+}
+
+export function computeCheckpointOutHash(messagesForAllTxs: Fr[][][]): Fr {
+  const blockOutHashes = messagesForAllTxs.map(block => computeBlockOutHash(block));
+  return aggregateOutHashes(blockOutHashes);
+}
+
+// The root of this tree should match the `out_hash` calculated in the circuits. Zero hashes are compressed to reduce
+// cost if the non-zero leaves result in a shorter path.
+function aggregateOutHashes(outHashes: Fr[]): Fr {
+  if (!outHashes.length) {
+    return Fr.ZERO;
+  }
+
+  const valueToCompress = Buffer.alloc(32);
+  const tree = UnbalancedMerkleTreeCalculator.create(
+    outHashes.map(hash => hash.toBuffer()),
+    valueToCompress,
+  );
+  return Fr.fromBuffer(tree.getRoot());
+}

package/src/rollup/checkpoint_constant_data.ts

@@ -3,6 +3,8 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { inspect } from 'util';
+
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/gas_fees.js';
 
@@ -81,4 +83,22 @@ export class CheckpointConstantData {
       reader.readObject(GasFees),
     );
   }
+
+  toInspect() {
+    return {
+      chainId: this.chainId.toNumber(),
+      version: this.version.toNumber(),
+      vkTreeRoot: this.vkTreeRoot.toString(),
+      protocolContractsHash: this.protocolContractsHash.toString(),
+      proverId: this.proverId.toString(),
+      slotNumber: this.slotNumber.toNumber(),
+      coinbase: this.coinbase.toString(),
+      feeRecipient: this.feeRecipient.toString(),
+      gasFees: this.gasFees.toInspect(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `CheckpointConstantData ${inspect(this.toInspect())}`;
+  }
 }