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

package/src/tx/tx_effect.ts

@@ -1,22 +1,13 @@
+import { decodeTxStartMarker, encodeTxStartMarker, isValidTxStartMarker } from '@aztec/blob-lib/encoding';
 import {
-  CONTRACT_CLASS_LOGS_PREFIX,
-  L2_L1_MSGS_PREFIX,
   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,
-  NOTES_PREFIX,
-  NULLIFIERS_PREFIX,
-  PRIVATE_LOGS_PREFIX,
-  PUBLIC_DATA_UPDATE_REQUESTS_PREFIX,
-  PUBLIC_LOGS_PREFIX,
-  REVERT_CODE_PREFIX,
-  TX_FEE_PREFIX,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple, makeTupleAsync } from '@aztec/foundation/array';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import {
@@ -35,16 +26,9 @@ import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
 import { ContractClassLog } from '../logs/contract_class_log.js';
 import { PrivateLog } from '../logs/private_log.js';
-import { PublicLog } from '../logs/public_log.js';
+import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
 import { TxHash } from './tx_hash.js';
 
-// This will appear as 0x74785f7374617274 in logs
-export const TX_START_PREFIX = 8392562855083340404n;
-// These are helper constants to decode tx effects from blob encoded fields
-export const TX_START_PREFIX_BYTES_LENGTH = TX_START_PREFIX.toString(16).length / 2;
-// 7 bytes for: | 0 | txlen[0] | txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revertCode |
-export const TX_EFFECT_PREFIX_BYTE_LENGTH = TX_START_PREFIX_BYTES_LENGTH + 7;
-
 export class TxEffect {
   constructor(
     /**
@@ -149,7 +133,7 @@ export class TxEffect {
       serializeArrayOfBufferableToVector(this.l2ToL1Msgs, 1),
       serializeArrayOfBufferableToVector(this.publicDataWrites, 1),
       serializeArrayOfBufferableToVector(this.privateLogs, 1),
-      serializeArrayOfBufferableToVector(this.publicLogs, 1),
+      serializeArrayOfBufferableToVector(this.publicLogs, 4),
       serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
     ]);
   }
@@ -198,7 +182,7 @@ export class TxEffect {
       reader.readVectorUint8Prefix(Fr),
       reader.readVectorUint8Prefix(PublicDataWrite),
       reader.readVectorUint8Prefix(PrivateLog),
-      reader.readVectorUint8Prefix(PublicLog),
+      reader.readVector(PublicLog),
       reader.readVectorUint8Prefix(ContractClassLog),
     );
   }
@@ -244,7 +228,7 @@ export class TxEffect {
         PublicDataWrite.random,
       ),
       makeTuple(MAX_PRIVATE_LOGS_PER_TX, () => PrivateLog.random()),
-      await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, async () => await PublicLog.random()),
+      await Promise.all(new Array(numPublicCallsPerTx * numPublicLogsPerCall).fill(null).map(() => PublicLog.random())),
       await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.random),
     );
   }
@@ -253,223 +237,90 @@ export class TxEffect {
     return new TxEffect(RevertCode.OK, TxHash.zero(), Fr.ZERO, [], [], [], [], [], [], []);
   }
 
-  isEmpty(): boolean {
-    return this.nullifiers.length === 0;
-  }
-
   /** Returns a hex representation of the TxEffect object. */
   toString() {
     return bufferToHex(this.toBuffer());
   }
 
   /**
-   * Returns the prefix as used in a blob.
-   * Used to prefix a 'block' of tx effects with its type and length.
-   */
-  private toPrefix(type: number, length: number): Fr {
-    const buf = Buffer.alloc(4);
-    buf.writeUint8(type);
-    buf.writeUInt16BE(length, 2);
-    return new Fr(buf);
-  }
-
-  /**
-   * Decodes the prefix as used in a blob to tx effect type and length.
-   */
-  static fromPrefix(prefix: Fr) {
-    const buf = prefix.toBuffer().subarray(-4);
-    return { type: buf[0], length: new Fr(buf.subarray(-2)).toNumber() };
-  }
-
-  /**
-   * Encodes the first field of a tx effect as used in a blob:
-   * TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
-   */
-  private encodeFirstField(length: number, revertCode: RevertCode) {
-    const lengthBuf = Buffer.alloc(2);
-    lengthBuf.writeUInt16BE(length, 0);
-    return new Fr(
-      Buffer.concat([
-        toBufferBE(TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH),
-        Buffer.alloc(1),
-        lengthBuf,
-        Buffer.alloc(1),
-        Buffer.from([REVERT_CODE_PREFIX]),
-        Buffer.alloc(1),
-        revertCode.toBuffer(),
-      ]),
-    );
-  }
-
-  /**
-   * Decodes the first field of a tx effect as used in a blob:
-   * TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
-   * Assumes that isFirstField has been called already.
-   */
-  static decodeFirstField(field: Fr) {
-    const buf = field.toBuffer().subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-    return {
-      length: new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber(),
-      revertCode: buf[buf.length - 1],
-    };
-  }
-
-  /**
-   * Determines whether a field is the first field of a tx effect
-   */
-  static isFirstField(field: Fr) {
-    const buf = field.toBuffer();
-    if (
-      !buf
-        .subarray(0, field.size - TX_EFFECT_PREFIX_BYTE_LENGTH)
-        .equals(Buffer.alloc(field.size - TX_EFFECT_PREFIX_BYTE_LENGTH))
-    ) {
-      return false;
-    }
-    const sliced = buf.subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-    if (
-      // Checking we start with the correct prefix...
-      !new Fr(sliced.subarray(0, TX_START_PREFIX_BYTES_LENGTH)).equals(new Fr(TX_START_PREFIX)) ||
-      // ...and include the revert code prefix..
-      sliced[sliced.length - 3] !== REVERT_CODE_PREFIX ||
-      // ...and the following revert code is valid.
-      sliced[sliced.length - 1] > 4
-    ) {
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Returns a flat packed array of prefixed fields of all tx effects, used for blobs.
+   * 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(): Fr[] {
-    if (this.isEmpty()) {
-      return [];
-    }
     const flattened: Fr[] = [];
-    // We reassign the first field when we know the length of all effects - see below
+
+    // 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);
-    // TODO: how long should tx fee be? For now, not using toPrefix()
-    flattened.push(
-      new Fr(
-        Buffer.concat([Buffer.from([TX_FEE_PREFIX]), Buffer.alloc(1), this.transactionFee.toBuffer().subarray(3)]),
-      ),
-    );
-    if (this.noteHashes.length) {
-      flattened.push(this.toPrefix(NOTES_PREFIX, this.noteHashes.length));
-      flattened.push(...this.noteHashes);
-    }
-    if (this.nullifiers.length) {
-      flattened.push(this.toPrefix(NULLIFIERS_PREFIX, this.nullifiers.length));
-      flattened.push(...this.nullifiers);
-    }
-    if (this.l2ToL1Msgs.length) {
-      flattened.push(this.toPrefix(L2_L1_MSGS_PREFIX, this.l2ToL1Msgs.length));
-      flattened.push(...this.l2ToL1Msgs);
-    }
-    if (this.publicDataWrites.length) {
-      flattened.push(this.toPrefix(PUBLIC_DATA_UPDATE_REQUESTS_PREFIX, this.publicDataWrites.length));
-      flattened.push(...this.publicDataWrites.flatMap(w => w.toBlobFields()));
-    }
-    if (this.privateLogs.length) {
-      flattened.push(this.toPrefix(PRIVATE_LOGS_PREFIX, this.privateLogs.length));
-      flattened.push(...this.privateLogs.flatMap(l => l.toBlobFields()));
-    }
-    if (this.publicLogs.length) {
-      flattened.push(this.toPrefix(PUBLIC_LOGS_PREFIX, this.publicLogs.length));
-      flattened.push(...this.publicLogs.flatMap(l => l.toBlobFields()));
-    }
-    if (this.contractClassLogs.length) {
-      flattened.push(this.toPrefix(CONTRACT_CLASS_LOGS_PREFIX, this.contractClassLogs.length));
-      flattened.push(...this.contractClassLogs.flatMap(l => l.toBlobFields()));
-    }
+    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({
+      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,
+      contractClassLogLength: this.contractClassLogs[0]?.emittedLength ?? 0,
+    });
 
-    // The first value appended to each list of fields representing a tx effect is:
-    // TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
-    // Tx start and len are to aid decomposing/ identifying when we reach a new tx effect
-    // The remaining bytes are used for revert code, since that only requires 3 bytes
-    flattened[0] = this.encodeFirstField(flattened.length, this.revertCode);
     return flattened;
   }
 
   /**
-   * Decodes a flat packed array of prefixed fields to TxEffect
+   * Decodes a flat packed array of fields to TxEffect.
    */
   static fromBlobFields(fields: Fr[] | FieldReader) {
-    const ensureEmpty = <T>(arr: Array<T>) => {
-      if (arr.length) {
-        throw new Error('Invalid fields given to TxEffect.fromBlobFields(): Attempted to assign property twice.');
-      }
-    };
-
-    const effect = this.empty();
     const reader = FieldReader.asReader(fields);
     const totalFields = reader.remainingFields();
     if (!totalFields) {
-      return effect;
+      throw new Error('Cannot process empty blob fields.');
     }
 
-    const firstField = reader.readField();
-    if (!this.isFirstField(firstField)) {
-      throw new Error('Invalid fields given to TxEffect.fromBlobFields(): First field invalid.');
+    const txStartMarker = decodeTxStartMarker(reader.readField());
+    if (!isValidTxStartMarker(txStartMarker)) {
+      throw new Error('Invalid fields given to TxEffect.fromBlobFields(): invalid TxStartMarker');
     }
 
-    const { length: fieldsToProcess, revertCode } = this.decodeFirstField(firstField);
-    effect.revertCode = RevertCode.fromField(new Fr(revertCode));
-
-    effect.txHash = new TxHash(reader.readField());
-    // TODO: how long should tx fee be? For now, not using fromPrefix()
-    const prefixedFee = reader.readField();
-    // NB: Fr.fromBuffer hangs here if you provide a buffer less than 32 in len
-    // todo: try new Fr(prefixedFee.toBuffer().subarray(3))
-    effect.transactionFee = Fr.fromBuffer(Buffer.concat([Buffer.alloc(3), prefixedFee.toBuffer().subarray(3)]));
-
-    let fieldsProcessed = totalFields - reader.remainingFields();
-    while (fieldsProcessed < fieldsToProcess) {
-      const { type, length } = this.fromPrefix(reader.readField());
-      switch (type) {
-        case NOTES_PREFIX:
-          ensureEmpty(effect.noteHashes);
-          effect.noteHashes = reader.readFieldArray(length);
-          break;
-        case NULLIFIERS_PREFIX:
-          ensureEmpty(effect.nullifiers);
-          effect.nullifiers = reader.readFieldArray(length);
-          break;
-        case L2_L1_MSGS_PREFIX:
-          ensureEmpty(effect.l2ToL1Msgs);
-          effect.l2ToL1Msgs = reader.readFieldArray(length);
-          break;
-        case PUBLIC_DATA_UPDATE_REQUESTS_PREFIX: {
-          ensureEmpty(effect.publicDataWrites);
-          effect.publicDataWrites = Array.from({ length }, () => PublicDataWrite.fromBlobFields(reader));
-          break;
-        }
-        case PRIVATE_LOGS_PREFIX: {
-          ensureEmpty(effect.privateLogs);
-          effect.privateLogs = Array.from({ length }, () => PrivateLog.fromBlobFields(reader));
-          break;
-        }
-        case PUBLIC_LOGS_PREFIX: {
-          ensureEmpty(effect.publicLogs);
-          effect.publicLogs = Array.from({ length }, () => PublicLog.fromBlobFields(reader));
-          break;
-        }
-        case CONTRACT_CLASS_LOGS_PREFIX: {
-          ensureEmpty(effect.contractClassLogs);
-          effect.contractClassLogs = Array.from({ length }, () => ContractClassLog.fromBlobFields(reader));
-          break;
-        }
-        case REVERT_CODE_PREFIX:
-        default:
-          throw new Error(`Too many fields to decode given to TxEffect.fromBlobFields()`);
-      }
-      fieldsProcessed = totalFields - reader.remainingFields();
-    }
-    return effect;
+    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();
+    const contractClassLogs =
+      txStartMarker.contractClassLogLength > 0
+        ? [ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, reader)]
+        : [];
+
+    return TxEffect.from({
+      revertCode,
+      txHash,
+      transactionFee,
+      noteHashes,
+      nullifiers,
+      l2ToL1Msgs,
+      publicDataWrites,
+      privateLogs,
+      publicLogs,
+      contractClassLogs,
+    });
   }
 
   static from(fields: FieldsOf<TxEffect>) {
@@ -514,7 +365,7 @@ export class TxEffect {
       l2ToL1Msgs: [${this.l2ToL1Msgs.map(h => h.toString()).join(', ')}],
       publicDataWrites: [${this.publicDataWrites.map(h => h.toString()).join(', ')}],
       privateLogs: [${this.privateLogs.map(l => l.fields.map(f => f.toString()).join(',')).join(', ')}],
-      publicLogs: [${this.publicLogs.map(l => l.fields.map(f => f.toString()).join(',')).join(', ')}],
+      publicLogs: ${inspect(this.publicLogs)},
       contractClassLogs: [${this.contractClassLogs
         .map(l =>
           l

package/src/tx/validator/error_texts.ts

@@ -16,7 +16,7 @@ export const TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP = 'Invalid expiration timesta
 export const TX_ERROR_INCORRECT_L1_CHAIN_ID = 'Incorrect L1 chain id';
 export const TX_ERROR_INCORRECT_ROLLUP_VERSION = 'Incorrect rollup version';
 export const TX_ERROR_INCORRECT_VK_TREE_ROOT = 'Incorrect verification keys tree root';
-export const TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT = 'Incorrect protocol contracts tree root';
+export const TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH = 'Incorrect protocol contracts hash';
 
 // Proof
 export const TX_ERROR_INVALID_PROOF = 'Invalid proof';

package/src/update-checker/update-checker.ts

@@ -43,7 +43,7 @@ export class UpdateChecker extends EventEmitter<EventMap> {
     private rollupVersion: bigint,
     private fetch: typeof globalThis.fetch,
     private getLatestRollupVersion: () => Promise<bigint>,
-    private checkIntervalMs = 60_000, // every minute
+    private checkIntervalMs = 10 * 60_000, // every 10 mins
     private log = createLogger('foundation:update-check'),
   ) {
     super();

package/src/validators/schemas.ts

@@ -4,6 +4,7 @@ import { z } from 'zod';
 
 import type {
   SingleValidatorStats,
+  ValidatorMissedStats,
   ValidatorStats,
   ValidatorStatusHistory,
   ValidatorStatusInSlot,
@@ -35,19 +36,20 @@ const ValidatorTimeStatSchema = z.object({
   date: z.string(),
 });
 
-const ValidatorFilteredHistorySchema = z.object({
+const ValidatorMissedStatsSchema = z.object({
   currentStreak: schemas.Integer,
   rate: z.number().optional(),
   count: schemas.Integer,
-});
+  total: schemas.Integer,
+}) satisfies ZodFor<ValidatorMissedStats>;
 
 export const ValidatorStatsSchema = z.object({
   address: schemas.EthAddress,
   lastProposal: ValidatorTimeStatSchema.optional(),
   lastAttestation: ValidatorTimeStatSchema.optional(),
   totalSlots: schemas.Integer,
-  missedProposals: ValidatorFilteredHistorySchema,
-  missedAttestations: ValidatorFilteredHistorySchema,
+  missedProposals: ValidatorMissedStatsSchema,
+  missedAttestations: ValidatorMissedStatsSchema,
   history: ValidatorStatusHistorySchema,
 }) satisfies ZodFor<ValidatorStats>;
 

package/src/validators/types.ts

@@ -11,21 +11,20 @@ export type ValidatorStatusInSlot =
 
 export type ValidatorStatusHistory = { slot: bigint; status: ValidatorStatusInSlot }[];
 
+export type ValidatorMissedStats = {
+  currentStreak: number;
+  rate?: number;
+  count: number;
+  total: number;
+};
+
 export type ValidatorStats = {
   address: EthAddress;
   lastProposal?: { timestamp: bigint; slot: bigint; date: string };
   lastAttestation?: { timestamp: bigint; slot: bigint; date: string };
   totalSlots: number;
-  missedProposals: {
-    currentStreak: number;
-    rate?: number;
-    count: number;
-  };
-  missedAttestations: {
-    currentStreak: number;
-    rate?: number;
-    count: number;
-  };
+  missedProposals: ValidatorMissedStats;
+  missedAttestations: ValidatorMissedStats;
   history: ValidatorStatusHistory;
 };
 

package/src/versioning/versioning.ts

@@ -14,21 +14,21 @@ export type ComponentsVersions = {
   // such as the keystore, we need to change it so we can handle updates.
   l1RollupAddress: EthAddress;
   rollupVersion: number;
-  l2ProtocolContractsTreeRoot: string;
+  l2ProtocolContractsHash: string;
   l2CircuitsVkTreeRoot: string;
 };
 
 /** Returns components versions from chain config. */
 export function getComponentsVersionsFromConfig(
   config: ChainConfig,
-  l2ProtocolContractsTreeRoot: string | Fr,
+  l2ProtocolContractsHash: string | Fr,
   l2CircuitsVkTreeRoot: string | Fr,
 ): ComponentsVersions {
   return {
     l1ChainId: config.l1ChainId,
     l1RollupAddress: config.l1Contracts?.rollupAddress, // This should not be undefined, but sometimes the config lies to us and it is...
     rollupVersion: config.rollupVersion,
-    l2ProtocolContractsTreeRoot: l2ProtocolContractsTreeRoot.toString(),
+    l2ProtocolContractsHash: l2ProtocolContractsHash.toString(),
     l2CircuitsVkTreeRoot: l2CircuitsVkTreeRoot.toString(),
   };
 }
@@ -37,7 +37,7 @@ export function getComponentsVersionsFromConfig(
 export function compressComponentVersions(versions: ComponentsVersions): string {
   if (
     versions.l1RollupAddress === undefined ||
-    versions.l2ProtocolContractsTreeRoot === undefined ||
+    versions.l2ProtocolContractsHash === undefined ||
     versions.l2CircuitsVkTreeRoot === undefined
   ) {
     throw new Error(`Component versions are not set: ${jsonStringify(versions)}`);
@@ -48,7 +48,7 @@ export function compressComponentVersions(versions: ComponentsVersions): string
     versions.l1ChainId,
     versions.l1RollupAddress.toString().slice(2, 10),
     versions.rollupVersion,
-    versions.l2ProtocolContractsTreeRoot.toString().slice(2, 10),
+    versions.l2ProtocolContractsHash.toString().slice(2, 10),
     versions.l2CircuitsVkTreeRoot.toString().slice(2, 10),
   ].join('-');
 }
@@ -62,7 +62,7 @@ export class ComponentsVersionsError extends Error {
 
 /** Checks if the compressed string matches against the expected versions. Throws on mismatch. */
 export function checkCompressedComponentVersion(compressed: string, expected: ComponentsVersions) {
-  const [versionVersion, l1ChainId, l1RollupAddress, rollupVersion, l2ProtocolContractsTreeRoot, l2CircuitsVkTreeRoot] =
+  const [versionVersion, l1ChainId, l1RollupAddress, rollupVersion, l2ProtocolContractsHash, l2CircuitsVkTreeRoot] =
     compressed.split('-');
   if (versionVersion !== '00') {
     throw new ComponentsVersionsError('version', '00', versionVersion);
@@ -76,11 +76,11 @@ export function checkCompressedComponentVersion(compressed: string, expected: Co
   if (rollupVersion !== expected.rollupVersion.toString()) {
     throw new ComponentsVersionsError('L2 chain version', expected.rollupVersion.toString(), rollupVersion);
   }
-  if (l2ProtocolContractsTreeRoot !== expected.l2ProtocolContractsTreeRoot.toString().slice(2, 10)) {
+  if (l2ProtocolContractsHash !== expected.l2ProtocolContractsHash.toString().slice(2, 10)) {
     throw new ComponentsVersionsError(
       `L2 protocol contracts vk tree root`,
-      expected.l2ProtocolContractsTreeRoot.toString(),
-      l2ProtocolContractsTreeRoot,
+      expected.l2ProtocolContractsHash.toString(),
+      l2ProtocolContractsHash,
     );
   }
   if (l2CircuitsVkTreeRoot !== expected.l2CircuitsVkTreeRoot.toString().slice(2, 10)) {
@@ -99,7 +99,7 @@ export function validatePartialComponentVersionsMatch(
 ) {
   for (const key of [
     'l1RollupAddress',
-    'l2ProtocolContractsTreeRoot',
+    'l2ProtocolContractsHash',
     'l2CircuitsVkTreeRoot',
     'l1ChainId',
     'rollupVersion',
@@ -117,11 +117,16 @@ export function validatePartialComponentVersionsMatch(
 /** Returns a Koa middleware that injects the versioning info as headers. */
 export function getVersioningMiddleware(versions: Partial<ComponentsVersions>) {
   return async (ctx: Koa.Context, next: () => Promise<void>) => {
-    await next();
-    for (const key in versions) {
-      const value = versions[key as keyof ComponentsVersions];
-      if (value !== undefined) {
-        ctx.set(`x-aztec-${key}`, value.toString());
+    try {
+      await next();
+    } finally {
+      // Always add version headers, even if there was an error
+      // This allows the client to detect version mismatches before processing other errors
+      for (const key in versions) {
+        const value = versions[key as keyof ComponentsVersions];
+        if (value !== undefined) {
+          ctx.set(`x-aztec-${key}`, value.toString());
+        }
       }
     }
   };

package/src/world-state/index.ts

@@ -0,0 +1 @@
+export * from './world_state_revision.js';

package/src/world-state/world_state_revision.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export class WorldStateRevision {
+  constructor(
+    public readonly forkId: number,
+    public readonly blockNumber: number,
+    public readonly includeUncommitted: boolean,
+  ) {}
+
+  static empty() {
+    return new WorldStateRevision(0, 0, false);
+  }
+
+  static get schema() {
+    return z.object({
+      forkId: z.number(),
+      blockNumber: z.number(),
+      includeUncommitted: z.boolean(),
+    });
+  }
+}