@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/avm/avm_accumulated_data.ts

@@ -1,15 +1,23 @@
 import {
+  AVM_ACCUMULATED_DATA_LENGTH,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, type Tuple, assertLength, serializeToBuffer } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  assertLength,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
@@ -92,6 +100,16 @@ export class AvmAccumulatedData {
     return serializeToBuffer(this.noteHashes, this.nullifiers, this.l2ToL1Msgs, this.publicLogs, this.publicDataWrites);
   }
 
+  static getFields(fields: FieldsOf<AvmAccumulatedData>) {
+    return [
+      fields.noteHashes,
+      fields.nullifiers,
+      fields.l2ToL1Msgs,
+      fields.publicLogs,
+      fields.publicDataWrites,
+    ] as const;
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     return new this(
@@ -103,6 +121,16 @@ export class AvmAccumulatedData {
     );
   }
 
+  toFields(): Fr[] {
+    const fields = serializeToFields(...AvmAccumulatedData.getFields(this));
+    if (fields.length !== AVM_ACCUMULATED_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for AvmAccumulatedData. Expected ${AVM_ACCUMULATED_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
   static fromString(str: string) {
     return this.fromBuffer(hexToBuffer(str));
   }
@@ -157,3 +185,96 @@ export class AvmAccumulatedData {
 }`;
   }
 }
+
+/**
+ * Represents the lengths of arrays in AVM accumulated data
+ */
+export class AvmAccumulatedDataArrayLengths {
+  constructor(
+    /**
+     * Number of note hashes
+     */
+    public noteHashes: number,
+    /**
+     * Number of nullifiers
+     */
+    public nullifiers: number,
+    /**
+     * Number of L2 to L1 messages
+     */
+    public l2ToL1Msgs: number,
+    /**
+     * Number of public logs
+     */
+    public publicLogs: number,
+    /**
+     * Number of public data writes
+     */
+    public publicDataWrites: number,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        noteHashes: z.number(),
+        nullifiers: z.number(),
+        l2ToL1Msgs: z.number(),
+        publicLogs: z.number(),
+        publicDataWrites: z.number(),
+      })
+      .transform(
+        ({ noteHashes, nullifiers, l2ToL1Msgs, publicLogs, publicDataWrites }) =>
+          new AvmAccumulatedDataArrayLengths(noteHashes, nullifiers, l2ToL1Msgs, publicLogs, publicDataWrites),
+      );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new AvmAccumulatedDataArrayLengths(
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.noteHashes, this.nullifiers, this.l2ToL1Msgs, this.publicLogs, this.publicDataWrites);
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new AvmAccumulatedDataArrayLengths(
+      Number(reader.readField()),
+      Number(reader.readField()),
+      Number(reader.readField()),
+      Number(reader.readField()),
+      Number(reader.readField()),
+    );
+  }
+
+  toFields(): Fr[] {
+    return [
+      new Fr(this.noteHashes),
+      new Fr(this.nullifiers),
+      new Fr(this.l2ToL1Msgs),
+      new Fr(this.publicLogs),
+      new Fr(this.publicDataWrites),
+    ];
+  }
+
+  static empty() {
+    return new AvmAccumulatedDataArrayLengths(0, 0, 0, 0, 0);
+  }
+
+  [inspect.custom]() {
+    return `AvmAccumulatedDataArrayLengths {
+  noteHashes: ${this.noteHashes},
+  nullifiers: ${this.nullifiers},
+  l2ToL1Msgs: ${this.l2ToL1Msgs},
+  publicLogs: ${this.publicLogs},
+  publicDataWrites: ${this.publicDataWrites},
+}`;
+  }
+}

package/src/avm/avm_circuit_public_inputs.ts

@@ -9,26 +9,30 @@ import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import { Gas, GasSettings } from '../gas/index.js';
+import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
 } from '../kernel/private_to_avm_accumulated_data.js';
-import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { PublicCallRequest, PublicCallRequestArrayLengths } from '../kernel/public_call_request.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { TreeSnapshots } from '../tx/tree_snapshots.js';
-import { AvmAccumulatedData } from './avm_accumulated_data.js';
+import { AvmAccumulatedData, AvmAccumulatedDataArrayLengths } from './avm_accumulated_data.js';
 import { serializeWithMessagePack } from './message_pack.js';
 
 // Note: the {from,to}{Buffer,Fields,String} methods are needed by AvmProofData and PublicBaseRollupInputs.
 // At some point it might be worth writing Zod schemas for all dependent types and get rid of that.
 export class AvmCircuitPublicInputs {
   constructor(
+    ///////////////////////////////////
+    // Inputs.
     public globalVariables: GlobalVariables,
     public startTreeSnapshots: TreeSnapshots,
     public startGasUsed: Gas,
     public gasSettings: GasSettings,
+    public effectiveGasFees: GasFees,
     public feePayer: AztecAddress,
+    public publicCallRequestArrayLengths: PublicCallRequestArrayLengths,
     public publicSetupCallRequests: Tuple<PublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
     public publicAppLogicCallRequests: Tuple<PublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
     public publicTeardownCallRequest: PublicCallRequest,
@@ -36,8 +40,11 @@ export class AvmCircuitPublicInputs {
     public previousRevertibleAccumulatedDataArrayLengths: PrivateToAvmAccumulatedDataArrayLengths,
     public previousNonRevertibleAccumulatedData: PrivateToAvmAccumulatedData,
     public previousRevertibleAccumulatedData: PrivateToAvmAccumulatedData,
+    ///////////////////////////////////
+    // Outputs.
     public endTreeSnapshots: TreeSnapshots,
     public endGasUsed: Gas,
+    public accumulatedDataArrayLengths: AvmAccumulatedDataArrayLengths,
     public accumulatedData: AvmAccumulatedData,
     public transactionFee: Fr,
     public reverted: boolean,
@@ -50,7 +57,9 @@ export class AvmCircuitPublicInputs {
         startTreeSnapshots: TreeSnapshots.schema,
         startGasUsed: Gas.schema,
         gasSettings: GasSettings.schema,
+        effectiveGasFees: GasFees.schema,
         feePayer: AztecAddress.schema,
+        publicCallRequestArrayLengths: PublicCallRequestArrayLengths.schema,
         publicSetupCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
         publicAppLogicCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
         publicTeardownCallRequest: PublicCallRequest.schema,
@@ -60,6 +69,7 @@ export class AvmCircuitPublicInputs {
         previousRevertibleAccumulatedData: PrivateToAvmAccumulatedData.schema,
         endTreeSnapshots: TreeSnapshots.schema,
         endGasUsed: Gas.schema,
+        accumulatedDataArrayLengths: AvmAccumulatedDataArrayLengths.schema,
         accumulatedData: AvmAccumulatedData.schema,
         transactionFee: schemas.Fr,
         reverted: z.boolean(),
@@ -70,7 +80,9 @@ export class AvmCircuitPublicInputs {
           startTreeSnapshots,
           startGasUsed,
           gasSettings,
+          effectiveGasFees,
           feePayer,
+          publicCallRequestArrayLengths,
           publicSetupCallRequests,
           publicAppLogicCallRequests,
           publicTeardownCallRequest,
@@ -80,6 +92,7 @@ export class AvmCircuitPublicInputs {
           previousRevertibleAccumulatedData,
           endTreeSnapshots,
           endGasUsed,
+          accumulatedDataArrayLengths,
           accumulatedData,
           transactionFee,
           reverted,
@@ -89,7 +102,9 @@ export class AvmCircuitPublicInputs {
             startTreeSnapshots,
             startGasUsed,
             gasSettings,
+            effectiveGasFees,
             feePayer,
+            publicCallRequestArrayLengths,
             assertLength(publicSetupCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
             assertLength(publicAppLogicCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
             publicTeardownCallRequest,
@@ -99,6 +114,7 @@ export class AvmCircuitPublicInputs {
             previousRevertibleAccumulatedData,
             endTreeSnapshots,
             endGasUsed,
+            accumulatedDataArrayLengths,
             accumulatedData,
             transactionFee,
             reverted,
@@ -113,7 +129,9 @@ export class AvmCircuitPublicInputs {
       reader.readObject(TreeSnapshots),
       reader.readObject(Gas),
       reader.readObject(GasSettings),
+      reader.readObject(GasFees),
       reader.readObject(AztecAddress),
+      reader.readObject(PublicCallRequestArrayLengths),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readObject(PublicCallRequest),
@@ -123,6 +141,7 @@ export class AvmCircuitPublicInputs {
       reader.readObject(PrivateToAvmAccumulatedData),
       reader.readObject(TreeSnapshots),
       reader.readObject(Gas),
+      reader.readObject(AvmAccumulatedDataArrayLengths),
       reader.readObject(AvmAccumulatedData),
       reader.readObject(Fr),
       reader.readBoolean(),
@@ -135,7 +154,9 @@ export class AvmCircuitPublicInputs {
       this.startTreeSnapshots,
       this.startGasUsed,
       this.gasSettings,
+      this.effectiveGasFees,
       this.feePayer,
+      this.publicCallRequestArrayLengths,
       this.publicSetupCallRequests,
       this.publicAppLogicCallRequests,
       this.publicTeardownCallRequest,
@@ -145,6 +166,7 @@ export class AvmCircuitPublicInputs {
       this.previousRevertibleAccumulatedData,
       this.endTreeSnapshots,
       this.endGasUsed,
+      this.accumulatedDataArrayLengths,
       this.accumulatedData,
       this.transactionFee,
       this.reverted,
@@ -166,7 +188,9 @@ export class AvmCircuitPublicInputs {
       TreeSnapshots.fromFields(reader),
       Gas.fromFields(reader),
       GasSettings.fromFields(reader),
+      GasFees.fromFields(reader),
       AztecAddress.fromFields(reader),
+      PublicCallRequestArrayLengths.fromFields(reader),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       PublicCallRequest.fromFields(reader),
@@ -176,19 +200,47 @@ export class AvmCircuitPublicInputs {
       PrivateToAvmAccumulatedData.fromFields(reader),
       TreeSnapshots.fromFields(reader),
       Gas.fromFields(reader),
+      AvmAccumulatedDataArrayLengths.fromFields(reader),
       AvmAccumulatedData.fromFields(reader),
       reader.readField(),
       reader.readBoolean(),
     );
   }
 
+  toFields() {
+    return [
+      ...this.globalVariables.toFields(),
+      ...this.startTreeSnapshots.toFields(),
+      ...this.startGasUsed.toFields(),
+      ...this.gasSettings.toFields(),
+      ...this.effectiveGasFees.toFields(),
+      this.feePayer,
+      ...this.publicCallRequestArrayLengths.toFields(),
+      ...this.publicSetupCallRequests.map(request => request.toFields()),
+      ...this.publicAppLogicCallRequests.map(request => request.toFields()),
+      ...this.publicTeardownCallRequest.toFields(),
+      ...this.previousNonRevertibleAccumulatedDataArrayLengths.toFields(),
+      ...this.previousRevertibleAccumulatedDataArrayLengths.toFields(),
+      ...this.previousNonRevertibleAccumulatedData.toFields(),
+      ...this.previousRevertibleAccumulatedData.toFields(),
+      ...this.endTreeSnapshots.toFields(),
+      ...this.endGasUsed.toFields(),
+      ...this.accumulatedDataArrayLengths.toFields(),
+      ...this.accumulatedData.toFields(),
+      this.transactionFee,
+      this.reverted,
+    ];
+  }
+
   static empty() {
     return new AvmCircuitPublicInputs(
       GlobalVariables.empty(),
       TreeSnapshots.empty(),
       Gas.empty(),
       GasSettings.empty(),
+      GasFees.empty(),
       AztecAddress.zero(),
+      PublicCallRequestArrayLengths.empty(),
       makeTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest.empty),
       makeTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest.empty),
       PublicCallRequest.empty(),
@@ -198,6 +250,7 @@ export class AvmCircuitPublicInputs {
       PrivateToAvmAccumulatedData.empty(),
       TreeSnapshots.empty(),
       Gas.empty(),
+      AvmAccumulatedDataArrayLengths.empty(),
       AvmAccumulatedData.empty(),
       Fr.zero(),
       false,
@@ -214,7 +267,9 @@ export class AvmCircuitPublicInputs {
       startTreeSnapshots: ${inspect(this.startTreeSnapshots)},
       startGasUsed: ${inspect(this.startGasUsed)},
       gasSettings: ${inspect(this.gasSettings)},
+      effectiveGasFees: ${inspect(this.effectiveGasFees)},
       feePayer: ${inspect(this.feePayer)},
+      publicCallRequestArrayLengths: ${inspect(this.publicCallRequestArrayLengths)},
       publicSetupCallRequests: [${this.publicSetupCallRequests
         .filter(x => !x.isEmpty())
         .map(h => inspect(h))
@@ -232,6 +287,7 @@ export class AvmCircuitPublicInputs {
       previousRevertibleAccumulatedData: ${inspect(this.previousRevertibleAccumulatedData)},
       endTreeSnapshots: ${inspect(this.endTreeSnapshots)},
       endGasUsed: ${inspect(this.endGasUsed)},
+      accumulatedDataArrayLengths: ${inspect(this.accumulatedDataArrayLengths)},
       accumulatedData: ${inspect(this.accumulatedData)},
       transactionFee: ${inspect(this.transactionFee)},
       reverted: ${this.reverted},

package/src/avm/message_pack.ts

@@ -1,3 +1,4 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fq, Fr, Point } from '@aztec/foundation/fields';
 
 import { strict as assert } from 'assert';
@@ -12,6 +13,7 @@ export function serializeWithMessagePack(obj: any): Buffer {
     // this makes it compatible with other MessagePack decoders
     useRecords: false,
     int64AsType: 'bigint',
+    largeBigIntToString: true,
   });
   return encoder.encode(obj);
 }
@@ -30,7 +32,7 @@ function setUpMessagePackExtensions() {
     Class: Fq,
     write: (fq: Fq) => fq.toBuffer(),
   });
-  // AztecAddress is a class that has a field in TS, but just a field in C++.
+  // AztecAddress is a class that has a field in TS, but is itself a field in C++.
   addExtension({
     Class: AztecAddress,
     write: (addr: AztecAddress) => addr.toField(),
@@ -44,5 +46,10 @@ function setUpMessagePackExtensions() {
       return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
     },
   });
+  // EthAddress is a class that has a buffer in TS, but is itself just a field in C++.
+  addExtension({
+    Class: EthAddress,
+    write: (addr: EthAddress) => addr.toField().toBuffer(),
+  });
   messagePackWasSetUp = true;
 }

package/src/avm/public_data_write.ts

@@ -1,6 +1,7 @@
+import { PUBLIC_DATA_WRITE_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -45,6 +46,25 @@ export class PublicDataWrite {
     return new PublicDataWrite(reader.readField(), reader.readField());
   }
 
+  toFields(): Fr[] {
+    const fields = serializeToFields(...PublicDataWrite.getFields(this));
+    if (fields.length !== PUBLIC_DATA_WRITE_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for PublicDataWrite. Expected ${PUBLIC_DATA_WRITE_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new PublicDataWrite(reader.readField(), reader.readField());
+  }
+
+  toBlobFields(): Fr[] {
+    return [this.leafSlot, this.value];
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PublicDataWrite(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
@@ -77,4 +97,8 @@ export class PublicDataWrite {
   isEmpty() {
     return this.leafSlot.isZero() && this.value.isZero();
   }
+
+  equals(other: PublicDataWrite): boolean {
+    return this.leafSlot.equals(other.leafSlot) && this.value.equals(other.value);
+  }
 }

package/src/avm/public_inner_call_request.ts

@@ -78,7 +78,7 @@ export class PublicInnerCallRequest {
 
   [inspect.custom]() {
     return `PublicInnerCallRequest {
-      item: ${this.item}
+      item: ${this.item.toFields()}
       counter: ${this.counter}
     }`;
   }

package/src/avm/revert_code.ts

@@ -13,10 +13,10 @@ export enum RevertCodeEnum {
 
 function isRevertCodeEnum(value: number): value is RevertCodeEnum {
   return (
-    value === RevertCodeEnum.OK ||
-    value === RevertCodeEnum.APP_LOGIC_REVERTED ||
-    value === RevertCodeEnum.TEARDOWN_REVERTED ||
-    value === RevertCodeEnum.BOTH_REVERTED
+    (value as RevertCodeEnum) === RevertCodeEnum.OK ||
+    (value as RevertCodeEnum) === RevertCodeEnum.APP_LOGIC_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.TEARDOWN_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.BOTH_REVERTED
   );
 }
 
@@ -46,7 +46,7 @@ export class RevertCode {
   }
 
   public getDescription() {
-    switch (this.code) {
+    switch (this.code as RevertCodeEnum) {
       case RevertCodeEnum.OK:
         return 'OK';
       case RevertCodeEnum.APP_LOGIC_REVERTED:

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/block_hash.ts

@@ -1,5 +1,6 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
 
 import { schemas } from '../schemas/schemas.js';
 
@@ -16,6 +17,19 @@ export class L2BlockHash extends Buffer32 {
     return new L2BlockHash(Fr.random().toBuffer());
   }
 
+  static override fromNumber(num: number): L2BlockHash {
+    return new L2BlockHash(super.fromNumber(num).toBuffer());
+  }
+
+  static override fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new L2BlockHash(reader.readBytes(L2BlockHash.SIZE));
+  }
+
+  static override fromString(str: string): Buffer32 {
+    return new L2BlockHash(super.fromString(str).toBuffer());
+  }
+
   static get schema() {
     return schemas.BufferHex.transform(value => new L2BlockHash(value));
   }

package/src/block/body.ts

@@ -1,7 +1,7 @@
 import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
 import { timesParallel } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -18,6 +18,12 @@ export class Body {
     });
   }
 
+  equals(other: Body) {
+    return (
+      this.txEffects.length === other.txEffects.length && this.txEffects.every((te, i) => te.equals(other.txEffects[i]))
+    );
+  }
+
   static get schema(): ZodFor<Body> {
     return z
       .object({
@@ -67,17 +73,11 @@ export class Body {
    * Decodes a block from blob fields.
    */
   static fromBlobFields(fields: Fr[]) {
-    const txEffectsFields: Fr[][] = [];
-    let checkedFields = 0;
-    while (checkedFields !== fields.length) {
-      if (!TxEffect.isFirstField(fields[checkedFields])) {
-        throw new Error('Invalid fields given to Body.fromBlobFields(): First field invalid.');
-      }
-      const len = TxEffect.decodeFirstField(fields[checkedFields]).length;
-      txEffectsFields.push(fields.slice(checkedFields, checkedFields + len));
-      checkedFields += len;
+    const txEffects: TxEffect[] = [];
+    const reader = new FieldReader(fields);
+    while (!reader.isFinished()) {
+      txEffects.push(TxEffect.fromBlobFields(reader));
     }
-    const txEffects = txEffectsFields.filter(effect => effect.length).map(effect => TxEffect.fromBlobFields(effect));
     return new this(txEffects);
   }
 
@@ -87,9 +87,14 @@ export class Body {
 }`;
   }
 
-  static async random(txsPerBlock = 4, numPublicCallsPerTx = 3, numPublicLogsPerCall = 1) {
+  static async random(
+    txsPerBlock = 4,
+    numPublicCallsPerTx = 3,
+    numPublicLogsPerCall = 1,
+    maxEffects: number | undefined = undefined,
+  ) {
     const txEffects = await timesParallel(txsPerBlock, () =>
-      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall),
+      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall, maxEffects),
     );
 
     return new Body(txEffects);

package/src/block/in_block.ts

@@ -1,13 +1,13 @@
-import { Fr } from '@aztec/foundation/fields';
-
 import { type ZodTypeAny, z } from 'zod';
 
 import { schemas } from '../schemas/index.js';
+import { L2BlockHash } from './block_hash.js';
 import type { L2Block } from './l2_block.js';
 
+// Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
 export type InBlock<T> = {
   l2BlockNumber: number;
-  l2BlockHash: string;
+  l2BlockHash: L2BlockHash;
   data: T;
 };
 
@@ -15,7 +15,7 @@ export function randomInBlock<T>(data: T): InBlock<T> {
   return {
     data,
     l2BlockNumber: Math.floor(Math.random() * 1000),
-    l2BlockHash: Fr.random().toString(),
+    l2BlockHash: L2BlockHash.random(),
   };
 }
 
@@ -23,7 +23,7 @@ export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T
   return {
     data,
     l2BlockNumber: block.number,
-    l2BlockHash: (await block.hash()).toString(),
+    l2BlockHash: L2BlockHash.fromField(await block.hash()),
   };
 }
 
@@ -31,6 +31,6 @@ export function inBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
   return z.object({
     data: schema,
     l2BlockNumber: schemas.Integer,
-    l2BlockHash: z.string(),
+    l2BlockHash: L2BlockHash.schema,
   });
 }

package/src/block/index.ts

@@ -1,8 +1,12 @@
 export * from './l2_block.js';
-export * from './l2_block_downloader/index.js';
-export * from './nullifier_with_block_source.js';
+export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';
 export * from './l2_block_number.js';
 export * from './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';