@aztec/stdlib 0.87.7 → 1.0.0-nightly.20250605

package/src/rollup/root_rollup.ts

@@ -7,7 +7,6 @@ import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { FeeRecipient } from './block_root_or_block_merge_public_inputs.js';
 import { PreviousRollupBlockData } from './previous_rollup_block_data.js';
 
@@ -100,13 +99,10 @@ export class RootRollupInputs {
  */
 export class RootRollupPublicInputs {
   constructor(
-    /** Snapshot of archive tree before/after this rollup been processed */
-    public previousArchive: AppendOnlyTreeSnapshot,
-    public endArchive: AppendOnlyTreeSnapshot,
-    // This is a u64 in nr, but GlobalVariables contains this as a u64 and is mapped to ts as a field, so I'm doing the same here
-    public endTimestamp: Fr,
-    public endBlockNumber: Fr,
-    public outHash: Fr,
+    /** Root of the archive tree before this rollup is processed */
+    public previousArchiveRoot: Fr,
+    /** Root of the archive tree after this rollup is processed */
+    public endArchiveRoot: Fr,
     public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
     public chainId: Fr,
@@ -119,11 +115,8 @@ export class RootRollupPublicInputs {
 
   static getFields(fields: FieldsOf<RootRollupPublicInputs>) {
     return [
-      fields.previousArchive,
-      fields.endArchive,
-      fields.endTimestamp,
-      fields.endBlockNumber,
-      fields.outHash,
+      fields.previousArchiveRoot,
+      fields.endArchiveRoot,
       fields.proposedBlockHeaderHashes,
       fields.fees,
       fields.chainId,
@@ -155,9 +148,6 @@ export class RootRollupPublicInputs {
   public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new RootRollupPublicInputs(
-      reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(AppendOnlyTreeSnapshot),
-      Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
@@ -192,9 +182,6 @@ export class RootRollupPublicInputs {
   /** Creates a random instance. */
   static random() {
     return new RootRollupPublicInputs(
-      AppendOnlyTreeSnapshot.random(),
-      AppendOnlyTreeSnapshot.random(),
-      Fr.random(),
       Fr.random(),
       Fr.random(),
       makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),

package/src/tests/factories.ts

@@ -1,7 +1,7 @@
 import { makeBlockBlobPublicInputs, makeSpongeBlob } from '@aztec/blob-lib/testing';
 import {
   ARCHIVE_HEIGHT,
-  AVM_PROOF_LENGTH_IN_FIELDS,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   AZTEC_MAX_EPOCH_DURATION,
   BLOBS_PER_BLOCK,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
@@ -55,6 +55,7 @@ import { ContractStorageRead } from '../avm/contract_storage_read.js';
 import { ContractStorageUpdateRequest } from '../avm/contract_storage_update_request.js';
 import {
   AvmAccumulatedData,
+  AvmAccumulatedDataArrayLengths,
   AvmAppendLeavesHint,
   AvmBytecodeCommitmentHint,
   AvmCircuitInputs,
@@ -75,6 +76,7 @@ import {
   AvmSequentialInsertHintPublicDataTree,
   AvmTxHint,
   RevertCode,
+  clampGasSettingsForAVM,
 } from '../avm/index.js';
 import { PublicDataHint } from '../avm/public_data_hint.js';
 import { PublicDataRead } from '../avm/public_data_read.js';
@@ -115,7 +117,11 @@ import { PrivateCallRequest } from '../kernel/private_call_request.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import { PrivateLogData } from '../kernel/private_log_data.js';
 import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
-import { CountedPublicCallRequest, PublicCallRequest } from '../kernel/public_call_request.js';
+import {
+  CountedPublicCallRequest,
+  PublicCallRequest,
+  PublicCallRequestArrayLengths,
+} from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
 import { ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
@@ -168,8 +174,8 @@ import { TxConstantData } from '../tx/tx_constant_data.js';
 import { TxContext } from '../tx/tx_context.js';
 import { TxRequest } from '../tx/tx_request.js';
 import { RollupTypes, Vector } from '../types/index.js';
+import { VkData } from '../vks/index.js';
 import { VerificationKey, VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
-import { VkWitnessData } from '../vks/vk_witness_data.js';
 import { mockTx } from './mocks.js';
 
 /**
@@ -368,6 +374,10 @@ function makeAvmAccumulatedData(seed = 1) {
   );
 }
 
+function makeAvmAccumulatedDataArrayLengths(seed = 1) {
+  return new AvmAccumulatedDataArrayLengths(seed, seed + 1, seed + 2, seed + 3, seed + 4);
+}
+
 export function makeGas(seed = 1) {
   return new Gas(seed, seed + 1);
 }
@@ -452,7 +462,9 @@ function makeAvmCircuitPublicInputs(seed = 1) {
     makeTreeSnapshots(seed + 0x10),
     makeGas(seed + 0x20),
     makeGasSettings(),
+    makeGasFees(seed + 0x30),
     makeAztecAddress(seed + 0x40),
+    makePublicCallRequestArrayLengths(seed + 0x40),
     makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x100),
     makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x200),
     makePublicCallRequest(seed + 0x300),
@@ -462,6 +474,7 @@ function makeAvmCircuitPublicInputs(seed = 1) {
     makePrivateToAvmAccumulatedData(seed + 0x600),
     makeTreeSnapshots(seed + 0x700),
     makeGas(seed + 0x750),
+    makeAvmAccumulatedDataArrayLengths(seed + 0x800),
     makeAvmAccumulatedData(seed + 0x800),
     fr(seed + 0x900),
     false,
@@ -533,6 +546,10 @@ export function makePublicCallRequest(seed = 1) {
   return new PublicCallRequest(makeAztecAddress(seed), makeAztecAddress(seed + 1), false, fr(seed + 0x3));
 }
 
+export function makePublicCallRequestArrayLengths(seed = 1) {
+  return new PublicCallRequestArrayLengths(seed, seed + 1, seed % 2 === 0);
+}
+
 function makeCountedPublicCallRequest(seed = 1) {
   return new CountedPublicCallRequest(makePublicCallRequest(seed), seed + 0x100);
 }
@@ -742,8 +759,7 @@ export function makePreviousRollupData(
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
       seed + 0x50,
     ),
-    VerificationKeyAsFields.makeFakeHonk(),
-    makeMembershipWitness(VK_TREE_HEIGHT, seed + 0x120),
+    makeVkData(seed + 0x100),
   );
 }
 
@@ -763,8 +779,7 @@ export function makePreviousRollupBlockData(
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
       seed + 0x50,
     ),
-    VerificationKeyAsFields.makeFakeHonk(),
-    makeMembershipWitness(VK_TREE_HEIGHT, seed + 0x120),
+    makeVkData(seed + 0x100),
   );
 }
 
@@ -881,13 +896,10 @@ export function makeRootParityInputs(seed = 0): RootParityInputs {
  */
 export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
   return new RootRollupPublicInputs(
-    makeAppendOnlyTreeSnapshot(seed + 0x100),
-    makeAppendOnlyTreeSnapshot(seed + 0x200),
-    fr(seed + 0x300),
-    fr(seed + 0x400),
-    fr(seed + 0x500),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x650),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x600),
+    fr(seed + 0x100),
+    fr(seed + 0x200),
+    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
+    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
     fr(seed + 0x700),
     fr(seed + 0x701),
     fr(seed + 0x702),
@@ -1070,15 +1082,15 @@ export function makePrivateBaseStateDiffHints(seed = 1): PrivateBaseStateDiffHin
   );
 }
 
-function makeVkWitnessData(seed = 1) {
-  return new VkWitnessData(VerificationKeyData.makeFakeHonk(), seed, makeTuple(VK_TREE_HEIGHT, fr, seed + 0x100));
+function makeVkData(seed = 1) {
+  return new VkData(VerificationKeyData.makeFakeHonk(), seed, makeTuple(VK_TREE_HEIGHT, fr, seed + 0x100));
 }
 
 function makePrivateTubeData(seed = 1, kernelPublicInputs?: PrivateToRollupKernelCircuitPublicInputs) {
   return new PrivateTubeData(
     kernelPublicInputs ?? makePrivateToRollupKernelCircuitPublicInputs(seed, true),
     makeRecursiveProof<typeof TUBE_PROOF_LENGTH>(TUBE_PROOF_LENGTH, seed + 0x100),
-    makeVkWitnessData(seed + 0x200),
+    makeVkData(seed + 0x200),
   );
 }
 
@@ -1095,11 +1107,7 @@ function makePrivateBaseRollupHints(seed = 1) {
 
   const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
 
-  const contractClassLogsPreimages = makeTuple(
-    MAX_CONTRACT_CLASS_LOGS_PER_TX,
-    makeContractClassLogFields,
-    seed + 0x800,
-  );
+  const contractClassLogsFields = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLogFields, seed + 0x800);
 
   const constants = makeConstantRollupData(0x100);
 
@@ -1111,7 +1119,7 @@ function makePrivateBaseRollupHints(seed = 1) {
     stateDiffHints,
     feePayerFeeJuiceBalanceReadHint,
     archiveRootMembershipWitness,
-    contractClassLogsPreimages,
+    contractClassLogsFields,
     constants,
   });
 }
@@ -1121,18 +1129,14 @@ function makePublicBaseRollupHints(seed = 1) {
 
   const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
 
-  const contractClassLogsPreimages = makeTuple(
-    MAX_CONTRACT_CLASS_LOGS_PER_TX,
-    makeContractClassLogFields,
-    seed + 0x800,
-  );
+  const contractClassLogsFields = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLogFields, seed + 0x800);
 
   const constants = makeConstantRollupData(0x100);
 
   return PublicBaseRollupHints.from({
     startSpongeBlob,
     archiveRootMembershipWitness,
-    contractClassLogsPreimages,
+    contractClassLogsFields,
     constants,
   });
 }
@@ -1151,15 +1155,15 @@ function makePublicTubeData(seed = 1) {
   return new PublicTubeData(
     makePrivateToPublicKernelCircuitPublicInputs(seed),
     makeRecursiveProof<typeof TUBE_PROOF_LENGTH>(TUBE_PROOF_LENGTH, seed + 0x100),
-    makeVkWitnessData(seed + 0x200),
+    makeVkData(seed + 0x200),
   );
 }
 
 function makeAvmProofData(seed = 1) {
   return new AvmProofData(
     makeAvmCircuitPublicInputs(seed),
-    makeRecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>(AVM_PROOF_LENGTH_IN_FIELDS, seed + 0x100),
-    makeVkWitnessData(seed + 0x200),
+    makeRecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, seed + 0x100),
+    makeVkData(seed + 0x200),
   );
 }
 
@@ -1486,17 +1490,22 @@ export function makeAvmTxHint(seed = 0): AvmTxHint {
   return new AvmTxHint(
     `txhash-${seed}`,
     makeGlobalVariables(seed),
+    makeGasSettings(),
+    makeGasFees(seed + 0x1000),
     {
       noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
       nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x2000),
+      l2ToL1Messages: makeArray((seed % 20) + 4, i => makeScopedL2ToL1Message(i), seed + 0x3000),
     },
     {
       noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x3000),
       nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x4000),
+      l2ToL1Messages: makeArray((seed % 20) + 4, i => makeScopedL2ToL1Message(i), seed + 0x5000),
     },
     makeArray((seed % 20) + 4, i => makeAvmEnqueuedCallHint(i), seed + 0x5000), // setupEnqueuedCalls
     makeArray((seed % 20) + 4, i => makeAvmEnqueuedCallHint(i), seed + 0x6000), // appLogicEnqueuedCalls
     makeAvmEnqueuedCallHint(seed + 0x7000), // teardownEnqueuedCall
+    makeGas(seed + 0x8000), // gasUsedByPrivate
   );
 }
 
@@ -1647,27 +1656,55 @@ export async function makeBloatedProcessedTx({
 
   if (privateOnly) {
     const data = makePrivateToRollupAccumulatedData(seed + 0x1000);
+    clearContractClassLogs(data);
 
     const transactionFee = tx.data.gasUsed.computeFee(globalVariables.gasFees);
     feePaymentPublicDataWrite ??= new PublicDataWrite(Fr.random(), Fr.random());
 
-    clearLogs(data);
-
     tx.data.forRollup!.end = data;
 
     return makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables);
   } else {
-    const nonRevertibleData = tx.data.forPublic!.nonRevertibleAccumulatedData;
-    const revertibleData = makePrivateToPublicAccumulatedData(seed + 0x1000);
+    const dataFromPrivate = tx.data.forPublic!;
 
-    revertibleData.nullifiers[MAX_NULLIFIERS_PER_TX - 1] = Fr.ZERO; // Leave one space for the tx hash nullifier in nonRevertibleAccumulatedData.
+    const nonRevertibleData = dataFromPrivate.nonRevertibleAccumulatedData;
 
-    clearLogs(revertibleData);
-
-    tx.data.forPublic!.revertibleAccumulatedData = revertibleData;
+    // Create revertible data.
+    const revertibleData = makePrivateToPublicAccumulatedData(seed + 0x1000);
+    clearContractClassLogs(revertibleData);
+    revertibleData.nullifiers[MAX_NULLIFIERS_PER_TX - 1] = Fr.ZERO; // Leave one space for the tx hash nullifier in nonRevertibleAccumulatedData.
+    dataFromPrivate.revertibleAccumulatedData = revertibleData;
 
+    // Create avm output.
     const avmOutput = AvmCircuitPublicInputs.empty();
+    // Assign data from private.
     avmOutput.globalVariables = globalVariables;
+    avmOutput.startGasUsed = tx.data.gasUsed;
+    avmOutput.gasSettings = gasSettings;
+    avmOutput.feePayer = feePayer;
+    avmOutput.publicCallRequestArrayLengths = new PublicCallRequestArrayLengths(
+      tx.data.numberOfNonRevertiblePublicCallRequests(),
+      tx.data.numberOfRevertiblePublicCallRequests(),
+      tx.data.hasTeardownPublicCallRequest(),
+    );
+    avmOutput.publicSetupCallRequests = dataFromPrivate.nonRevertibleAccumulatedData.publicCallRequests;
+    avmOutput.publicAppLogicCallRequests = dataFromPrivate.revertibleAccumulatedData.publicCallRequests;
+    avmOutput.publicTeardownCallRequest = dataFromPrivate.publicTeardownCallRequest;
+    avmOutput.previousNonRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
+      dataFromPrivate.nonRevertibleAccumulatedData.noteHashes,
+      dataFromPrivate.nonRevertibleAccumulatedData.nullifiers,
+      dataFromPrivate.nonRevertibleAccumulatedData.l2ToL1Msgs,
+    );
+    avmOutput.previousNonRevertibleAccumulatedDataArrayLengths =
+      avmOutput.previousNonRevertibleAccumulatedData.getArrayLengths();
+    avmOutput.previousRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
+      dataFromPrivate.revertibleAccumulatedData.noteHashes,
+      dataFromPrivate.revertibleAccumulatedData.nullifiers,
+      dataFromPrivate.revertibleAccumulatedData.l2ToL1Msgs,
+    );
+    avmOutput.previousRevertibleAccumulatedDataArrayLengths =
+      avmOutput.previousRevertibleAccumulatedData.getArrayLengths();
+    // Assign final data emitted from avm.
     avmOutput.accumulatedData.noteHashes = revertibleData.noteHashes;
     avmOutput.accumulatedData.nullifiers = mergeAccumulatedData(
       nonRevertibleData.nullifiers,
@@ -1680,8 +1717,10 @@ export async function makeBloatedProcessedTx({
       i => new PublicDataWrite(new Fr(i), new Fr(i + 10)),
       seed + 0x2000,
     );
+    avmOutput.gasSettings = clampGasSettingsForAVM(gasSettings, tx.data.gasUsed);
 
     const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
+
     const gasUsed = {
       totalGas: Gas.empty(),
       teardownGas: Gas.empty(),
@@ -1702,8 +1741,8 @@ export async function makeBloatedProcessedTx({
   }
 }
 
-// Remove all logs as it's ugly to mock them at the moment and we are going to change it to have the preimages be part of the public inputs soon.
-function clearLogs(data: { publicLogs?: PublicLog[]; contractClassLogsHashes: ScopedLogHash[] }) {
-  data.publicLogs?.forEach((_, i) => (data.publicLogs![i] = PublicLog.empty()));
+// Remove all contract class log hashes from the data as they are not required for the current tests.
+// If they are needed one day, change this to create the random fields first and update the data with real hashes of those fields.
+function clearContractClassLogs(data: { contractClassLogsHashes: ScopedLogHash[] }) {
   data.contractClassLogsHashes.forEach((_, i) => (data.contractClassLogsHashes[i] = ScopedLogHash.empty()));
 }

package/src/tests/mocks.ts

@@ -6,6 +6,7 @@ import { Fr } from '@aztec/foundation/fields';
 
 import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import { CommitteeAttestation } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
 import type { PublishedL2Block } from '../block/published_l2_block.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
@@ -299,7 +300,7 @@ export async function randomPublishedL2Block(
   };
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
-  const attestations = await Promise.all(
+  const atts = await Promise.all(
     signers.map(signer =>
       makeBlockAttestation({
         signer,
@@ -310,6 +311,8 @@ export async function randomPublishedL2Block(
       }),
     ),
   );
-  const signatures = attestations.map(attestation => attestation.signature);
-  return { block, l1, signatures };
+  const attestations = atts.map(
+    (attestation, i) => new CommitteeAttestation(signers[i].address, attestation.signature),
+  );
+  return { block, l1, attestations };
 }

package/src/tx/processed_tx.ts

@@ -99,7 +99,7 @@ export async function makeProcessedTxFromPrivateOnlyTx(
     [feePaymentPublicDataWrite],
     data.end.privateLogs.filter(l => !l.isEmpty()),
     [],
-    await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true),
+    tx.getContractClassLogs(),
   );
 
   const gasUsed = {
@@ -147,10 +147,9 @@ export async function makeProcessedTxFromTxWithPublicCalls(
     ...(revertCode.isOK() ? tx.data.forPublic!.revertibleAccumulatedData.privateLogs : []),
   ].filter(l => !l.isEmpty());
 
-  const contractClassLogs = [
-    ...(await tx.getSplitContractClassLogs(false, true)),
-    ...(revertCode.isOK() ? await tx.getSplitContractClassLogs(true, true) : []),
-  ].filter(l => !l.isEmpty());
+  const contractClassLogs = revertCode.isOK()
+    ? tx.getContractClassLogs()
+    : tx.getSplitContractClassLogs(false /* revertible */);
 
   const txEffect = new TxEffect(
     revertCode,

package/src/tx/tx.ts

@@ -11,7 +11,6 @@ import type { GasSettings } from '../gas/gas_settings.js';
 import type { GetPublicLogsResponse } from '../interfaces/get_logs_response.js';
 import type { L2LogsSource } from '../interfaces/l2_logs_source.js';
 import type { PublicCallRequest } from '../kernel/index.js';
-import type { ScopedLogHash } from '../kernel/log_hash.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
 import { Gossipable } from '../p2p/gossipable.js';
@@ -42,9 +41,11 @@ export class Tx extends Gossipable {
      */
     public readonly clientIvcProof: ClientIvcProof,
     /**
-     * Contract class logs generated by the tx.
+     * Contract class log fields emitted from the tx.
+     * Their order should match the order of the log hashes returned from `this.data.getNonEmptyContractClassLogsHashes`.
+     * It's checked in data_validator.ts
      */
-    public contractClassLogs: ContractClassLogFields[],
+    public contractClassLogFields: ContractClassLogFields[],
     /**
      * An array of calldata for the enqueued public function calls and the teardown function call.
      */
@@ -120,7 +121,7 @@ export class Tx extends Gossipable {
     return serializeToBuffer([
       this.data,
       this.clientIvcProof,
-      serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
+      serializeArrayOfBufferableToVector(this.contractClassLogFields, 1),
       serializeArrayOfBufferableToVector(this.publicFunctionCalldata, 1),
     ]);
   }
@@ -130,14 +131,14 @@ export class Tx extends Gossipable {
       .object({
         data: PrivateKernelTailCircuitPublicInputs.schema,
         clientIvcProof: ClientIvcProof.schema,
-        contractClassLogs: z.array(ContractClassLogFields.schema),
+        contractClassLogFields: z.array(ContractClassLogFields.schema),
         publicFunctionCalldata: z.array(HashedValues.schema),
       })
       .transform(Tx.from);
   }
 
   static from(fields: FieldsOf<Tx>) {
-    return new Tx(fields.data, fields.clientIvcProof, fields.contractClassLogs, fields.publicFunctionCalldata);
+    return new Tx(fields.data, fields.clientIvcProof, fields.contractClassLogFields, fields.publicFunctionCalldata);
   }
 
   /**
@@ -149,43 +150,32 @@ export class Tx extends Gossipable {
     return logsSource.getPublicLogs({ txHash: await this.getTxHash() });
   }
 
+  getContractClassLogs(): ContractClassLog[] {
+    const logHashes = this.data.getNonEmptyContractClassLogsHashes();
+    return logHashes.map((logHash, i) =>
+      ContractClassLog.from({
+        contractAddress: logHash.contractAddress,
+        fields: this.contractClassLogFields[i],
+        emittedLength: logHash.logHash.length,
+      }),
+    );
+  }
+
   /**
    * Gets either revertible or non revertible contract class logs emitted by this tx.
    * @param revertible - true for revertible only logs, false for non reverible only logs.
    * @returns The requested logs.
    */
-  async getSplitContractClassLogs(revertible: boolean, silo: boolean = false): Promise<ContractClassLog[]> {
-    // Should only be called on txs with public calls
+  getSplitContractClassLogs(revertible: boolean): ContractClassLog[] {
     if (!this.data.forPublic) {
-      return [];
+      throw new Error('`getSplitContractClassLogs` should only be called on txs with public calls');
     }
-    const contractClassLogsHashes = revertible
-      ? this.data.forPublic.revertibleAccumulatedData.contractClassLogsHashes.filter(h => !h.isEmpty())
-      : this.data.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes.filter(h => !h.isEmpty());
-    return await this.filterContractClassLogs(contractClassLogsHashes, silo);
-  }
 
-  /**
-   * Filters contract class logs emitted by this tx.
-   * @param logHashes - logs to keep represented by their hashes.
-   * @param silo - whether to silo the logs before returning them.
-   * @returns The requested logs.
-   */
-  async filterContractClassLogs(logHashes: ScopedLogHash[], silo: boolean = false): Promise<ContractClassLog[]> {
-    const contractClassLogs = [];
-    for (const fields of this.contractClassLogs) {
-      const hashedLog = await fields.hash();
-      const logHash = logHashes.find(hash => hash.value.equals(hashedLog));
-      if (logHash) {
-        const log = ContractClassLog.from({
-          contractAddress: logHash.contractAddress,
-          fields,
-          emittedLength: logHash.logHash.length,
-        });
-        contractClassLogs.push(silo ? await log.silo() : log);
-      }
-    }
-    return contractClassLogs;
+    const contractClassLogs = this.getContractClassLogs();
+    const numNonRevertible = this.data.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes.filter(
+      h => !h.isEmpty(),
+    ).length;
+    return revertible ? contractClassLogs.slice(numNonRevertible) : contractClassLogs.slice(0, numNonRevertible);
   }
 
   /**
@@ -246,7 +236,7 @@ export class Tx extends Gossipable {
     return (
       this.data.getSize() +
       this.clientIvcProof.clientIvcProofBuffer.length +
-      arraySerializedSizeOfNonEmpty(this.contractClassLogs) +
+      arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
       this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
     );
   }
@@ -290,9 +280,9 @@ export class Tx extends Gossipable {
   static clone(tx: Tx): Tx {
     const publicInputs = PrivateKernelTailCircuitPublicInputs.fromBuffer(tx.data.toBuffer());
     const clientIvcProof = ClientIvcProof.fromBuffer(tx.clientIvcProof.toBuffer());
-    const contractClassLogs = tx.contractClassLogs.map(p => p.clone());
+    const contractClassLogFields = tx.contractClassLogFields.map(p => p.clone());
     const publicFunctionCalldata = tx.publicFunctionCalldata.map(cd => HashedValues.fromBuffer(cd.toBuffer()));
-    const clonedTx = new Tx(publicInputs, clientIvcProof, contractClassLogs, publicFunctionCalldata);
+    const clonedTx = new Tx(publicInputs, clientIvcProof, contractClassLogFields, publicFunctionCalldata);
     if (tx.txHash) {
       clonedTx.setTxHash(TxHash.fromBuffer(tx.txHash.toBuffer()));
     }
@@ -314,22 +304,6 @@ export class Tx extends Gossipable {
     );
   }
 
-  /**
-   * Filters out logs from functions that are not present in the provided kernel output.
-   *
-   * The purpose of this is to remove logs that got dropped due to a revert,
-   * in which case, we only have the kernel's hashes to go on, as opposed to
-   * this grouping by function maintained in this class.
-   *
-   * The logic therefore is to drop all FunctionLogs if any constituent hash
-   * does not appear in the provided hashes: it is impossible for part of a
-   * function to revert.
-   */
-  // TODO: don't modify the tx object directly. The preimages should match the log hashes. When did the log hashes change?
-  public async filterRevertedLogs() {
-    this.contractClassLogs = (await this.getSplitContractClassLogs(false)).map(log => log.fields);
-  }
-
   #combinePublicCallRequestWithCallData(request: PublicCallRequest) {
     const calldataMap = this.getCalldataMap();
     // Assume empty calldata if nothing is given for the hash.

package/src/tx/tx_effect.ts

@@ -232,15 +232,33 @@ export class TxEffect {
     return thisLayer[0];
   }
 
-  static async random(numPublicCallsPerTx = 3, numPublicLogsPerCall = 1): Promise<TxEffect> {
+  static async random(
+    numPublicCallsPerTx = 3,
+    numPublicLogsPerCall = 1,
+    maxEffects: number | undefined = undefined,
+  ): Promise<TxEffect> {
     return new TxEffect(
       RevertCode.random(),
       TxHash.random(),
       new Fr(Math.floor(Math.random() * 100_000)),
-      makeTuple(MAX_NOTE_HASHES_PER_TX, Fr.random),
-      makeTuple(MAX_NULLIFIERS_PER_TX, Fr.random),
-      makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, Fr.random),
-      makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite.random),
+      makeTuple(
+        maxEffects === undefined ? MAX_NOTE_HASHES_PER_TX : Math.min(maxEffects, MAX_NOTE_HASHES_PER_TX),
+        Fr.random,
+      ),
+      makeTuple(
+        maxEffects === undefined ? MAX_NULLIFIERS_PER_TX : Math.min(maxEffects, MAX_NULLIFIERS_PER_TX),
+        Fr.random,
+      ),
+      makeTuple(
+        maxEffects === undefined ? MAX_L2_TO_L1_MSGS_PER_TX : Math.min(maxEffects, MAX_L2_TO_L1_MSGS_PER_TX),
+        Fr.random,
+      ),
+      makeTuple(
+        maxEffects === undefined
+          ? MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+          : Math.min(maxEffects, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX),
+        PublicDataWrite.random,
+      ),
       makeTuple(MAX_PRIVATE_LOGS_PER_TX, () => PrivateLog.random()),
       await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, async () => await PublicLog.random()),
       await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.random),

package/src/tx/tx_hash.ts

@@ -29,6 +29,10 @@ export class TxHash {
     return new TxHash(new Fr(value));
   }
 
+  static fromField(value: Fr) {
+    return new TxHash(value);
+  }
+
   public toBuffer() {
     return this.hash.toBuffer();
   }

package/src/validators/types.ts

@@ -35,3 +35,5 @@ export type ValidatorsStats = {
   initialSlot?: bigint;
   slotWindow: number;
 };
+
+export type ValidatorsEpochPerformance = Record<`0x${string}`, { missed: number; total: number }>;

package/src/vks/index.ts

@@ -1,2 +1,2 @@
 export * from './verification_key.js';
-export * from './vk_witness_data.js';
+export * from './vk_data.js';