@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/trees/database_public_state_source.ts

@@ -0,0 +1,30 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { computePublicDataTreeLeafSlot } from '../hash/hash.js';
+import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operations.js';
+import type { PublicStateSource } from '../interfaces/public_state_source.js';
+import { MerkleTreeId } from './merkle_tree_id.js';
+import type { PublicDataTreeLeafPreimage } from './public_data_leaf.js';
+
+export type { PublicStateSource };
+
+export class DatabasePublicStateSource implements PublicStateSource {
+  constructor(private db: MerkleTreeReadOperations) {}
+
+  async storageRead(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
+    const leafSlot = (await computePublicDataTreeLeafSlot(contractAddress, slot)).toBigInt();
+
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+      return Fr.ZERO;
+    }
+
+    const preimage = (await this.db.getLeafPreimage(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      lowLeafResult.index,
+    )) as PublicDataTreeLeafPreimage;
+
+    return preimage.leaf.value;
+  }
+}

package/src/trees/index.ts

@@ -1,8 +1,8 @@
 export * from './nullifier_leaf.js';
-export * from './protocol_contract_leaf.js';
 export * from './public_data_leaf.js';
 export * from './append_only_tree_snapshot.js';
 export * from './merkle_tree_id.js';
 export * from './nullifier_membership_witness.js';
 export * from './public_data_witness.js';
 export * from '../interfaces/merkle_tree_operations.js';
+export * from './database_public_state_source.js';

package/src/trees/merkle_tree_id.ts

@@ -40,3 +40,15 @@ export type TreeHeights = typeof TREE_HEIGHTS;
 export function getTreeHeight<TID extends MerkleTreeId>(treeId: TID): TreeHeights[TID] {
   return TREE_HEIGHTS[treeId];
 }
+
+const TREE_NAMES = {
+  [MerkleTreeId.NULLIFIER_TREE]: 'NULLIFIER_TREE' as const,
+  [MerkleTreeId.NOTE_HASH_TREE]: 'NOTE_HASH_TREE' as const,
+  [MerkleTreeId.PUBLIC_DATA_TREE]: 'PUBLIC_DATA_TREE' as const,
+  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: 'L1_TO_L2_MESSAGE_TREE' as const,
+  [MerkleTreeId.ARCHIVE]: 'ARCHIVE' as const,
+} as const;
+
+export function getTreeName<TID extends MerkleTreeId>(treeId: TID): (typeof TREE_NAMES)[TID] {
+  return TREE_NAMES[treeId];
+}

package/src/trees/nullifier_leaf.ts

@@ -15,11 +15,11 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
     /**
      * Leaf value inside the indexed tree's linked list.
      */
-    public nullifier: Fr,
+    public leaf: NullifierLeaf,
     /**
-     * Next value inside the indexed tree's linked list.
+     * Next nullifier inside the indexed tree's linked list.
      */
-    public nextNullifier: Fr,
+    public nextKey: Fr,
     /**
      * Index of the next leaf in the indexed tree's linked list.
      */
@@ -29,21 +29,41 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   static get schema() {
     return z
       .object({
-        nullifier: schemas.Fr,
-        nextNullifier: schemas.Fr,
+        leaf: NullifierLeaf.schema,
+        nextKey: schemas.Fr,
         nextIndex: schemas.BigInt,
       })
-      .transform(
-        ({ nullifier, nextNullifier, nextIndex }) => new NullifierLeafPreimage(nullifier, nextNullifier, nextIndex),
-      );
+      .transform(({ leaf, nextKey, nextIndex }) => new NullifierLeafPreimage(leaf, nextKey, nextIndex));
+  }
+
+  /**
+   * Creates a NullifierLeafPreimage 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).
+   * @param obj - Plain object containing NullifierLeafPreimage fields
+   * @returns A NullifierLeafPreimage instance
+   */
+  static fromPlainObject(obj: any): NullifierLeafPreimage {
+    if (obj instanceof NullifierLeafPreimage) {
+      return obj;
+    }
+    return new NullifierLeafPreimage(
+      NullifierLeaf.fromPlainObject(obj.leaf),
+      Fr.fromPlainObject(obj.nextKey),
+      typeof obj.nextIndex === 'bigint' ? obj.nextIndex : BigInt(obj.nextIndex),
+    );
+  }
+
+  static get leafSchema() {
+    return NullifierLeaf.schema;
   }
 
   getKey(): bigint {
-    return this.nullifier.toBigInt();
+    return this.leaf.getKey();
   }
 
   getNextKey(): bigint {
-    return this.nextNullifier.toBigInt();
+    return this.nextKey.toBigInt();
   }
 
   getNextIndex(): bigint {
@@ -51,7 +71,7 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   asLeaf(): NullifierLeaf {
-    return new NullifierLeaf(this.nullifier);
+    return this.leaf;
   }
 
   toBuffer(): Buffer {
@@ -60,8 +80,8 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
 
   toHashInputs(): Buffer[] {
     return [
-      Buffer.from(this.nullifier.toBuffer()),
-      Buffer.from(this.nextNullifier.toBuffer()),
+      ...this.leaf.toHashInputs(),
+      Buffer.from(this.nextKey.toBuffer()),
       Buffer.from(toBufferBE(this.nextIndex, 32)),
     ];
   }
@@ -71,28 +91,32 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   clone(): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(this.nullifier, this.nextNullifier, this.nextIndex);
+    return new NullifierLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
   }
 
   static random() {
-    return new NullifierLeafPreimage(Fr.random(), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
+    return new NullifierLeafPreimage(NullifierLeaf.random(), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
   }
 
   static empty(): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(Fr.ZERO, Fr.ZERO, 0n);
+    return new NullifierLeafPreimage(NullifierLeaf.empty(), Fr.zero(), 0n);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): NullifierLeafPreimage {
     const reader = BufferReader.asReader(buffer);
-    return new NullifierLeafPreimage(reader.readObject(Fr), reader.readObject(Fr), toBigIntBE(reader.readBytes(32)));
+    return new NullifierLeafPreimage(
+      NullifierLeaf.fromBuffer(reader),
+      reader.readObject(Fr),
+      toBigIntBE(reader.readBytes(32)),
+    );
   }
 
   static fromLeaf(leaf: NullifierLeaf, nextKey: bigint, nextIndex: bigint): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(leaf.nullifier, new Fr(nextKey), nextIndex);
+    return new NullifierLeafPreimage(leaf, new Fr(nextKey), nextIndex);
   }
 
   static clone(preimage: NullifierLeafPreimage): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(preimage.nullifier, preimage.nextNullifier, preimage.nextIndex);
+    return preimage.clone();
   }
 }
 
@@ -115,6 +139,22 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     return this.nullifier.toBuffer();
   }
 
+  clone(): NullifierLeaf {
+    return new NullifierLeaf(new Fr(this.nullifier));
+  }
+
+  toHashInputs(): Buffer[] {
+    return [Buffer.from(this.nullifier.toBuffer())];
+  }
+
+  static empty(): NullifierLeaf {
+    return new NullifierLeaf(Fr.ZERO);
+  }
+
+  static random(): NullifierLeaf {
+    return new NullifierLeaf(Fr.random());
+  }
+
   isEmpty(): boolean {
     return this.nullifier.isZero();
   }
@@ -127,7 +167,26 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     return new NullifierLeaf(new Fr(key));
   }
 
-  static fromBuffer(buf: Buffer): NullifierLeaf {
-    return new NullifierLeaf(Fr.fromBuffer(buf));
+  static fromBuffer(buf: Buffer | BufferReader): NullifierLeaf {
+    const reader = BufferReader.asReader(buf);
+    return new NullifierLeaf(reader.readObject(Fr));
+  }
+
+  static get schema() {
+    return z.object({ nullifier: schemas.Fr }).transform(({ nullifier }) => new NullifierLeaf(nullifier));
+  }
+
+  /**
+   * Creates a NullifierLeaf 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).
+   * @param obj - Plain object containing NullifierLeaf fields
+   * @returns A NullifierLeaf instance
+   */
+  static fromPlainObject(obj: any): NullifierLeaf {
+    if (obj instanceof NullifierLeaf) {
+      return obj;
+    }
+    return new NullifierLeaf(Fr.fromPlainObject(obj.nullifier));
   }
 }

package/src/trees/nullifier_membership_witness.ts

@@ -1,6 +1,6 @@
 import { NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { SiblingPath } from '@aztec/foundation/trees';
+import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
 
@@ -49,6 +49,10 @@ export class NullifierMembershipWitness {
     );
   }
 
+  public withoutPreimage(): MembershipWitness<typeof NULLIFIER_TREE_HEIGHT> {
+    return new MembershipWitness(NULLIFIER_TREE_HEIGHT, this.index, this.siblingPath.toTuple());
+  }
+
   /**
    * Returns a field array representation of a nullifier witness.
    * @returns A field array representation of a nullifier witness.
@@ -56,4 +60,16 @@ export class NullifierMembershipWitness {
   public toFields(): Fr[] {
     return [new Fr(this.index), ...this.leafPreimage.toFields(), ...this.siblingPath.toFields()];
   }
+
+  /**
+   * Returns a representation of the nullifier membership witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      ...(this.leafPreimage.toFields().map(fr => fr.toString()) as string[]),
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
 }

package/src/trees/public_data_leaf.ts

@@ -13,17 +13,13 @@ import { z } from 'zod';
 export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   constructor(
     /**
-     * The slot of the leaf
+     * The leaf (slot, value).
      */
-    public slot: Fr,
-    /**
-     * The value of the leaf
-     */
-    public value: Fr,
+    public leaf: PublicDataTreeLeaf,
     /**
-     * Next value inside the indexed tree's linked list.
+     * Next key (slot) inside the indexed tree's linked list.
      */
-    public nextSlot: Fr,
+    public nextKey: Fr,
     /**
      * Index of the next leaf in the indexed tree's linked list.
      */
@@ -33,22 +29,41 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   static get schema() {
     return z
       .object({
-        slot: schemas.Fr,
-        value: schemas.Fr,
-        nextSlot: schemas.Fr,
+        leaf: PublicDataTreeLeaf.schema,
+        nextKey: schemas.Fr,
         nextIndex: schemas.BigInt,
       })
-      .transform(
-        ({ slot, value, nextSlot, nextIndex }) => new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex),
-      );
+      .transform(({ leaf, nextKey, nextIndex }) => new PublicDataTreeLeafPreimage(leaf, nextKey, nextIndex));
+  }
+
+  /**
+   * Creates a PublicDataTreeLeafPreimage 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).
+   * @param obj - Plain object containing PublicDataTreeLeafPreimage fields
+   * @returns A PublicDataTreeLeafPreimage instance
+   */
+  static fromPlainObject(obj: any): PublicDataTreeLeafPreimage {
+    if (obj instanceof PublicDataTreeLeafPreimage) {
+      return obj;
+    }
+    return new PublicDataTreeLeafPreimage(
+      PublicDataTreeLeaf.fromPlainObject(obj.leaf),
+      Fr.fromPlainObject(obj.nextKey),
+      typeof obj.nextIndex === 'bigint' ? obj.nextIndex : BigInt(obj.nextIndex),
+    );
+  }
+
+  static get leafSchema() {
+    return PublicDataTreeLeaf.schema;
   }
 
   getKey(): bigint {
-    return this.slot.toBigInt();
+    return this.leaf.getKey();
   }
 
   getNextKey(): bigint {
-    return this.nextSlot.toBigInt();
+    return this.nextKey.toBigInt();
   }
 
   getNextIndex(): bigint {
@@ -56,7 +71,7 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   asLeaf(): PublicDataTreeLeaf {
-    return new PublicDataTreeLeaf(this.slot, this.value);
+    return this.leaf;
   }
 
   toBuffer(): Buffer {
@@ -65,45 +80,42 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
 
   toHashInputs(): Buffer[] {
     return [
-      Buffer.from(this.slot.toBuffer()),
-      Buffer.from(this.value.toBuffer()),
+      ...this.leaf.toHashInputs(),
       Buffer.from(toBufferBE(this.nextIndex, 32)),
-      Buffer.from(this.nextSlot.toBuffer()),
+      Buffer.from(this.nextKey.toBuffer()),
     ];
   }
 
   clone(): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(this.slot, this.value, this.nextSlot, this.nextIndex);
+    return new PublicDataTreeLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
   }
 
   static random() {
     return new PublicDataTreeLeafPreimage(
-      Fr.random(),
-      Fr.random(),
+      PublicDataTreeLeaf.buildDummy(BigInt(Math.floor(Math.random() * 1000))),
       Fr.random(),
       BigInt(Math.floor(Math.random() * 1000)),
     );
   }
 
   static empty(): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(Fr.ZERO, Fr.ZERO, Fr.ZERO, 0n);
+    return new PublicDataTreeLeafPreimage(PublicDataTreeLeaf.empty(), Fr.ZERO, 0n);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PublicDataTreeLeafPreimage {
     const reader = BufferReader.asReader(buffer);
-    const slot = Fr.fromBuffer(reader);
-    const value = Fr.fromBuffer(reader);
+    const value = PublicDataTreeLeaf.fromBuffer(reader);
     const nextIndex = toBigIntBE(reader.readBytes(32));
     const nextSlot = Fr.fromBuffer(reader);
-    return new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex);
+    return new PublicDataTreeLeafPreimage(value, nextSlot, nextIndex);
   }
 
   static fromLeaf(leaf: PublicDataTreeLeaf, nextKey: bigint, nextIndex: bigint): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(leaf.slot, leaf.value, new Fr(nextKey), nextIndex);
+    return new PublicDataTreeLeafPreimage(leaf, new Fr(nextKey), nextIndex);
   }
 
   static clone(preimage: PublicDataTreeLeafPreimage): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(preimage.slot, preimage.value, preimage.nextSlot, preimage.nextIndex);
+    return preimage.clone();
   }
 }
 
@@ -130,6 +142,14 @@ export class PublicDataTreeLeaf implements IndexedTreeLeaf {
     return serializeToBuffer([this.slot, this.value]);
   }
 
+  clone(): PublicDataTreeLeaf {
+    return new PublicDataTreeLeaf(this.slot, this.value);
+  }
+
+  toHashInputs(): Buffer[] {
+    return [this.slot.toBuffer(), this.value.toBuffer()];
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PublicDataTreeLeaf(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
@@ -161,4 +181,27 @@ export class PublicDataTreeLeaf implements IndexedTreeLeaf {
   static empty(): PublicDataTreeLeaf {
     return new PublicDataTreeLeaf(Fr.ZERO, Fr.ZERO);
   }
+
+  static get schema() {
+    return z
+      .object({
+        slot: schemas.Fr,
+        value: schemas.Fr,
+      })
+      .transform(({ slot, value }) => new PublicDataTreeLeaf(slot, value));
+  }
+
+  /**
+   * Creates a PublicDataTreeLeaf 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).
+   * @param obj - Plain object containing PublicDataTreeLeaf fields
+   * @returns A PublicDataTreeLeaf instance
+   */
+  static fromPlainObject(obj: any): PublicDataTreeLeaf {
+    if (obj instanceof PublicDataTreeLeaf) {
+      return obj;
+    }
+    return new PublicDataTreeLeaf(Fr.fromPlainObject(obj.slot), Fr.fromPlainObject(obj.value));
+  }
 }

package/src/trees/public_data_witness.ts

@@ -3,7 +3,7 @@ import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import { SiblingPath } from '@aztec/foundation/trees';
+import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
 
@@ -50,14 +50,29 @@ export class PublicDataWitness {
   public toFields(): Fr[] {
     return [
       new Fr(this.index),
-      new Fr(this.leafPreimage.slot),
-      new Fr(this.leafPreimage.value),
+      new Fr(this.leafPreimage.leaf.slot),
+      new Fr(this.leafPreimage.leaf.value),
       new Fr(this.leafPreimage.nextIndex),
-      new Fr(this.leafPreimage.nextSlot),
+      new Fr(this.leafPreimage.nextKey),
       ...this.siblingPath.toFields(),
     ];
   }
 
+  /**
+   * Returns a representation of the public data witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      new Fr(this.leafPreimage.leaf.slot).toString() as string,
+      new Fr(this.leafPreimage.leaf.value).toString() as string,
+      new Fr(this.leafPreimage.nextKey).toString() as string,
+      new Fr(this.leafPreimage.nextIndex).toString() as string,
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
+
   toBuffer(): Buffer {
     return serializeToBuffer([this.index, this.leafPreimage, this.siblingPath]);
   }
@@ -77,6 +92,10 @@ export class PublicDataWitness {
     );
   }
 
+  public withoutPreimage(): MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT> {
+    return new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, this.index, this.siblingPath.toTuple());
+  }
+
   /**
    * Deserializes an PublicDataWitness object from a buffer.
    * @param buf - Buffer or BufferReader to deserialize.

package/src/tx/block_header.ts

@@ -1,5 +1,6 @@
 import { BLOCK_HEADER_LENGTH, GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { poseidon2HashWithSeparator, randomInt } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
@@ -10,7 +11,6 @@ import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { ContentCommitment } from './content_commitment.js';
 import { GlobalVariables } from './global_variables.js';
 import { StateReference } from './state_reference.js';
 
@@ -19,10 +19,13 @@ export class BlockHeader {
   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,
+    /**
+     * Hash of the sponge blob after the tx effects of this block has been applied.
+     * May contain tx effects from the previous blocks in the same checkpoint.
+     */
+    public spongeBlobHash: Fr,
     /** Global variables of an L2 block. */
     public globalVariables: GlobalVariables,
     /** Total fees in the block, computed by the root rollup circuit */
@@ -35,8 +38,8 @@ export class BlockHeader {
     return z
       .object({
         lastArchive: AppendOnlyTreeSnapshot.schema,
-        contentCommitment: ContentCommitment.schema,
         state: StateReference.schema,
+        spongeBlobHash: schemas.Fr,
         globalVariables: GlobalVariables.schema,
         totalFees: schemas.Fr,
         totalManaUsed: schemas.Fr,
@@ -45,11 +48,10 @@ export class BlockHeader {
   }
 
   static getFields(fields: FieldsOf<BlockHeader>) {
-    // Note: The order here must match the order in the HeaderLib solidity library.
     return [
       fields.lastArchive,
-      fields.contentCommitment,
       fields.state,
+      fields.spongeBlobHash,
       fields.globalVariables,
       fields.totalFees,
       fields.totalManaUsed,
@@ -60,15 +62,19 @@ export class BlockHeader {
     return new BlockHeader(...BlockHeader.getFields(fields));
   }
 
-  getSlot() {
-    return this.globalVariables.slotNumber.toBigInt();
+  getSlot(): SlotNumber {
+    return this.globalVariables.slotNumber;
+  }
+
+  getBlockNumber() {
+    return this.globalVariables.blockNumber;
   }
 
   getSize() {
     return (
       this.lastArchive.getSize() +
-      this.contentCommitment.getSize() +
       this.state.getSize() +
+      this.spongeBlobHash.size +
       this.globalVariables.getSize() +
       this.totalFees.size +
       this.totalManaUsed.size
@@ -96,8 +102,8 @@ export class BlockHeader {
 
     return new BlockHeader(
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(ContentCommitment),
       reader.readObject(StateReference),
+      reader.readObject(Fr),
       reader.readObject(GlobalVariables),
       reader.readObject(Fr),
       reader.readObject(Fr),
@@ -109,8 +115,8 @@ export class BlockHeader {
 
     return new BlockHeader(
       AppendOnlyTreeSnapshot.fromFields(reader),
-      ContentCommitment.fromFields(reader),
       StateReference.fromFields(reader),
+      reader.readField(),
       GlobalVariables.fromFields(reader),
       reader.readField(),
       reader.readField(),
@@ -119,9 +125,9 @@ export class BlockHeader {
 
   static empty(fields: Partial<FieldsOf<BlockHeader>> = {}): BlockHeader {
     return BlockHeader.from({
-      lastArchive: AppendOnlyTreeSnapshot.zero(),
-      contentCommitment: ContentCommitment.empty(),
+      lastArchive: AppendOnlyTreeSnapshot.empty(),
       state: StateReference.empty(),
+      spongeBlobHash: Fr.ZERO,
       globalVariables: GlobalVariables.empty(),
       totalFees: Fr.ZERO,
       totalManaUsed: Fr.ZERO,
@@ -131,9 +137,9 @@ export class BlockHeader {
 
   isEmpty(): boolean {
     return (
-      this.lastArchive.isZero() &&
-      this.contentCommitment.isEmpty() &&
+      this.lastArchive.isEmpty() &&
       this.state.isEmpty() &&
+      this.spongeBlobHash.isZero() &&
       this.globalVariables.isEmpty() &&
       this.totalFees.isZero() &&
       this.totalManaUsed.isZero()
@@ -156,11 +162,23 @@ export class BlockHeader {
     return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
   }
 
+  static random(overrides: Partial<FieldsOf<BlockHeader>> & Partial<FieldsOf<GlobalVariables>> = {}): BlockHeader {
+    return BlockHeader.from({
+      lastArchive: AppendOnlyTreeSnapshot.random(),
+      state: StateReference.random(),
+      spongeBlobHash: Fr.random(),
+      globalVariables: GlobalVariables.random(overrides),
+      totalFees: new Fr(randomInt(100_000)),
+      totalManaUsed: new Fr(randomInt(100_000_000)),
+      ...overrides,
+    });
+  }
+
   toInspect() {
     return {
       lastArchive: this.lastArchive.root.toString(),
-      contentCommitment: this.contentCommitment.toInspect(),
       state: this.state.toInspect(),
+      spongeBlobHash: this.spongeBlobHash.toBigInt(),
       globalVariables: this.globalVariables.toInspect(),
       totalFees: this.totalFees.toBigInt(),
       totalManaUsed: this.totalManaUsed.toBigInt(),
@@ -170,14 +188,11 @@ export class BlockHeader {
   [inspect.custom]() {
     return `Header {
   lastArchive: ${inspect(this.lastArchive)},
-  contentCommitment.numTxs: ${this.contentCommitment.numTxs.toNumber()},
-  contentCommitment.blobsHash: ${this.contentCommitment.blobsHash.toString('hex')},
-  contentCommitment.inHash: ${this.contentCommitment.inHash.toString('hex')},
-  contentCommitment.outHash: ${this.contentCommitment.outHash.toString('hex')},
   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)},
+  spongeBlobHash: ${this.spongeBlobHash},
   globalVariables: ${inspect(this.globalVariables)},
   totalFees: ${this.totalFees},
   totalManaUsed: ${this.totalManaUsed},
@@ -186,12 +201,12 @@ export class BlockHeader {
 
   public equals(other: this): boolean {
     return (
-      this.contentCommitment.equals(other.contentCommitment) &&
+      this.lastArchive.equals(other.lastArchive) &&
       this.state.equals(other.state) &&
+      this.spongeBlobHash.equals(other.spongeBlobHash) &&
       this.globalVariables.equals(other.globalVariables) &&
       this.totalFees.equals(other.totalFees) &&
-      this.totalManaUsed.equals(other.totalManaUsed) &&
-      this.lastArchive.equals(other.lastArchive)
+      this.totalManaUsed.equals(other.totalManaUsed)
     );
   }
 }

package/src/tx/capsule.ts

@@ -8,6 +8,8 @@ import { Vector } from '../types/shared.js';
 
 /**
  * Read-only data that is passed to the contract through an oracle during a transaction execution.
+ * TODO(#12425): Check whether this is always used to represent a transient capsule and if so, rename to
+ * TransientCapsule.
  */
 export class Capsule {
   constructor(