@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/tx/protocol_contracts.ts

@@ -0,0 +1,70 @@
+import { GeneratorIndex, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  assertLength,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+export class ProtocolContracts {
+  constructor(public derivedAddresses: Tuple<AztecAddress, typeof MAX_PROTOCOL_CONTRACTS>) {}
+
+  static from(fields: FieldsOf<ProtocolContracts>) {
+    return new ProtocolContracts(...ProtocolContracts.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<ProtocolContracts>) {
+    return [fields.derivedAddresses] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): ProtocolContracts {
+    const reader = FieldReader.asReader(fields);
+    return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...ProtocolContracts.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ProtocolContracts {
+    const reader = BufferReader.asReader(buffer);
+    return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...ProtocolContracts.getFields(this));
+  }
+
+  static empty() {
+    return new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, () => AztecAddress.zero()));
+  }
+
+  getSize() {
+    return arraySerializedSizeOfNonEmpty(this.derivedAddresses);
+  }
+
+  hash() {
+    return poseidon2HashWithSeparator(this.derivedAddresses, GeneratorIndex.PROTOCOL_CONTRACTS);
+  }
+
+  static get schema() {
+    return z
+      .object({
+        derivedAddresses: AztecAddress.schema.array().min(MAX_PROTOCOL_CONTRACTS).max(MAX_PROTOCOL_CONTRACTS),
+      })
+      .transform(
+        ({ derivedAddresses }) => new ProtocolContracts(assertLength(derivedAddresses, MAX_PROTOCOL_CONTRACTS)),
+      );
+  }
+}

package/src/tx/state_reference.ts

@@ -78,6 +78,10 @@ export class StateReference {
     return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
   }
 
+  static random(): StateReference {
+    return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
+  }
+
   toViem(): ViemStateReference {
     return {
       l1ToL2MessageTree: this.l1ToL2MessageTree.toViem(),
@@ -133,6 +137,6 @@ export class StateReference {
   }
 
   public equals(other: this): boolean {
-    return this.l1ToL2MessageTree.root.equals(other.l1ToL2MessageTree.root) && this.partial.equals(other.partial);
+    return this.l1ToL2MessageTree.equals(other.l1ToL2MessageTree) && this.partial.equals(other.partial);
   }
 }

package/src/tx/tx.ts

@@ -38,7 +38,6 @@ export class Tx extends Gossipable {
     public readonly data: PrivateKernelTailCircuitPublicInputs,
     /**
      * Proof from the private kernel circuit.
-     * TODO(#7368): This client IVC object currently contains various VKs that will eventually be more like static data.
      */
     public readonly clientIvcProof: ClientIvcProof,
     /**
@@ -162,6 +161,16 @@ export class Tx extends Gossipable {
     );
   }
 
+  /**
+   * Validates that the tx hash matches the computed hash from the tx data.
+   * This should be called when deserializing a tx from an untrusted source.
+   * @returns true if the hash is valid, false otherwise
+   */
+  async validateTxHash(): Promise<boolean> {
+    const expectedHash = await Tx.computeTxHash(this);
+    return this.txHash.equals(expectedHash);
+  }
+
   /**
    * Gets public logs emitted by this tx.
    * @param logsSource - An instance of `L2LogsSource` which can be used to obtain the logs.
@@ -207,16 +216,6 @@ export class Tx extends Gossipable {
     return this.txHash;
   }
 
-  /**
-   * Allows setting the hash of the Tx.
-   * Use this when you want to skip computing it from the original data.
-   * Don't set a Tx hash received from an untrusted source.
-   * @param hash - The hash to set.
-   */
-  setTxHash(_hash: TxHash) {
-    return this;
-  }
-
   getCalldataMap(): Map<string, Fr[]> {
     if (!this.calldataMap) {
       const calldataMap = new Map();
@@ -238,7 +237,7 @@ export class Tx extends Gossipable {
       classPublishedCount: this.data.getNonEmptyContractClassLogsHashes().length,
       contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
 
-      proofSize: this.clientIvcProof.clientIvcProofBuffer.length,
+      proofSize: this.clientIvcProof.fields.length,
       size: this.toBuffer().length,
 
       feePaymentMethod:
@@ -250,7 +249,7 @@ export class Tx extends Gossipable {
   getSize() {
     return (
       this.data.getSize() +
-      this.clientIvcProof.clientIvcProofBuffer.length +
+      this.clientIvcProof.fields.length * Fr.SIZE_IN_BYTES +
       arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
       this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
     );

package/src/tx/tx_constant_data.ts

@@ -7,29 +7,16 @@ import { BlockHeader } from './block_header.js';
 import { TxContext } from './tx_context.js';
 
 /**
- * Data that is constant/not modified by neither of the kernels.
+ * Version of `PrivateTxConstantData` exposed by the tail circuits
+ * It compresses the protocol contracts list to a hash to minimize the number of public inputs.
+ * Refer to `PrivateTxConstantData` for more details.
  */
 export class TxConstantData {
   constructor(
-    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
-    public historicalHeader: BlockHeader,
-    /**
-     * Context of the transaction.
-     *
-     * Note: `chainId` and `version` in txContext are not redundant to the values in
-     * self.historical_header.global_variables because they can be different in case of a protocol upgrade. In such
-     * a situation we could be using header from a block before the upgrade took place but be using the updated
-     * protocol to execute and prove the transaction.
-     */
+    public anchorBlockHeader: BlockHeader,
     public txContext: TxContext,
-    /**
-     * Root of the vk tree for the protocol circuits.
-     */
     public vkTreeRoot: Fr,
-    /**
-     * Root of the tree for the protocol contracts.
-     */
-    public protocolContractTreeRoot: Fr,
+    public protocolContractsHash: Fr,
   ) {}
 
   static from(fields: FieldsOf<TxConstantData>) {
@@ -37,7 +24,7 @@ export class TxConstantData {
   }
 
   static getFields(fields: FieldsOf<TxConstantData>) {
-    return [fields.historicalHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContractTreeRoot] as const;
+    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContractsHash] as const;
   }
 
   static fromFields(fields: Fr[] | FieldReader): TxConstantData {
@@ -80,10 +67,10 @@ export class TxConstantData {
 
   getSize() {
     return (
-      this.historicalHeader.getSize() +
+      this.anchorBlockHeader.getSize() +
       this.txContext.getSize() +
       this.vkTreeRoot.size +
-      this.protocolContractTreeRoot.size
+      this.protocolContractsHash.size
     );
   }
 

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;
 };