@aztec/stdlib 0.80.0 → 0.82.0

package/src/p2p/consensus_payload.ts

@@ -7,6 +7,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
+import type { L2Block } from '../block/l2_block.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/tx_hash.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
@@ -73,6 +74,14 @@ export class ConsensusPayload implements Signable {
     return new ConsensusPayload(fields.header, fields.archive, fields.txHashes);
   }
 
+  static fromBlock(block: L2Block): ConsensusPayload {
+    return new ConsensusPayload(
+      block.header,
+      block.archive.root,
+      block.body.txEffects.map(tx => tx.txHash),
+    );
+  }
+
   static empty(): ConsensusPayload {
     return new ConsensusPayload(BlockHeader.empty(), Fr.ZERO, []);
   }

package/src/proofs/client_ivc_proof.ts

@@ -3,7 +3,6 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 const CLIENT_IVC_PROOF_LENGTH = 172052;
-const CLIENT_IVC_VK_LENGTH = 2730;
 
 /**
  * TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370) refactor this to
@@ -15,7 +14,6 @@ export class ClientIvcProof {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370): Need to precompute private kernel tail VK so we can verify this immediately in the tx pool
     // which parts of these are needed to quickly verify that we have a correct IVC proof
     public clientIvcProofBuffer: Buffer,
-    public clientIvcVkBuffer: Buffer,
   ) {}
 
   public isEmpty() {
@@ -23,18 +21,15 @@ export class ClientIvcProof {
   }
 
   static empty() {
-    return new ClientIvcProof(Buffer.from(''), Buffer.from(''));
+    return new ClientIvcProof(Buffer.from(''));
   }
 
   static fake(fill = Math.floor(Math.random() * 255)) {
-    return new ClientIvcProof(Buffer.alloc(1, fill), Buffer.alloc(1, fill));
+    return new ClientIvcProof(Buffer.alloc(1, fill));
   }
 
   static random() {
-    return new ClientIvcProof(
-      Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)),
-      Buffer.from(randomBytes(CLIENT_IVC_VK_LENGTH)),
-    );
+    return new ClientIvcProof(Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)));
   }
 
   static get schema() {
@@ -47,15 +42,10 @@ export class ClientIvcProof {
 
   static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProof {
     const reader = BufferReader.asReader(buffer);
-    return new ClientIvcProof(reader.readBuffer(), reader.readBuffer());
+    return new ClientIvcProof(reader.readBuffer());
   }
 
   public toBuffer() {
-    return serializeToBuffer(
-      this.clientIvcProofBuffer.length,
-      this.clientIvcProofBuffer,
-      this.clientIvcVkBuffer.length,
-      this.clientIvcVkBuffer,
-    );
+    return serializeToBuffer(this.clientIvcProofBuffer.length, this.clientIvcProofBuffer);
   }
 }

package/src/proofs/proof.ts

@@ -18,9 +18,6 @@ export class Proof {
   // Honk proofs start with a 4 byte length prefix
   // the proof metadata starts immediately after
   private readonly metadataOffset = 4;
-  // the metadata is 3 Frs long
-  // the public inputs are after it
-  private readonly publicInputsOffset = 100;
 
   constructor(
     /**
@@ -65,15 +62,12 @@ export class Proof {
   }
 
   public withoutPublicInputs(): Buffer {
-    return Buffer.concat([
-      this.buffer.subarray(this.metadataOffset, this.publicInputsOffset),
-      this.buffer.subarray(this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
-    ]);
+    return Buffer.concat([this.buffer.subarray(this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs)]);
   }
 
   public extractPublicInputs(): Fr[] {
     const reader = BufferReader.asReader(
-      this.buffer.subarray(this.publicInputsOffset, this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
+      this.buffer.subarray(this.metadataOffset, this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
     );
     return reader.readArray(this.numPublicInputs, Fr);
   }

package/src/rollup/tube_inputs.ts

@@ -5,15 +5,19 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 
+/**
+ * Inputs for the tube circuit, which turns a client IVC proof folding stack into an ultrahonk proof.
+ * 'usePublicTailVk' signifies if we should prove this with the public or private kernel tail client IVC VKs.
+ */
 export class TubeInputs {
-  constructor(public clientIVCData: ClientIvcProof) {}
+  constructor(public usePublicTailVk: boolean, public clientIVCData: ClientIvcProof) {}
 
   static from(fields: FieldsOf<TubeInputs>): TubeInputs {
     return new TubeInputs(...TubeInputs.getFields(fields));
   }
 
   static getFields(fields: FieldsOf<TubeInputs>) {
-    return [fields.clientIVCData] as const;
+    return [fields.usePublicTailVk, fields.clientIVCData] as const;
   }
 
   /**
@@ -39,7 +43,7 @@ export class TubeInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): TubeInputs {
     const reader = BufferReader.asReader(buffer);
-    return new TubeInputs(reader.readObject(ClientIvcProof));
+    return new TubeInputs(reader.readBoolean(), reader.readObject(ClientIvcProof));
   }
 
   isEmpty(): boolean {
@@ -55,7 +59,7 @@ export class TubeInputs {
   }
 
   static empty() {
-    return new TubeInputs(ClientIvcProof.empty());
+    return new TubeInputs(false, ClientIvcProof.empty());
   }
 
   /** Returns a hex representation for JSON serialization. */

package/src/tests/factories.ts

@@ -56,6 +56,7 @@ import { ContractStorageUpdateRequest } from '../avm/contract_storage_update_req
 import {
   AvmAccumulatedData,
   AvmAppendTreeHint,
+  AvmBytecodeCommitmentHint,
   AvmCircuitInputs,
   AvmCircuitPublicInputs,
   AvmContractClassHint,
@@ -1337,7 +1338,6 @@ export function makeAvmStorageUpdateTreeHints(seed = 0): AvmPublicDataWriteTreeH
 export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
   return new AvmContractInstanceHint(
     new AztecAddress(new Fr(seed)),
-    true /* exists */,
     new Fr(seed + 0x2),
     new AztecAddress(new Fr(seed + 0x3)),
     new Fr(seed + 0x4),
@@ -1349,8 +1349,6 @@ export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
       new Point(new Fr(seed + 0x11), new Fr(seed + 0x12), false),
       new Point(new Fr(seed + 0x13), new Fr(seed + 0x14), false),
     ),
-    makeAvmPublicDataReadTreeHints(seed + 0x2000),
-    makeArray(4, i => new Fr(i), seed + 0x3000),
   );
 }
 
@@ -1358,22 +1356,23 @@ export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
  * @param seed - The seed to use for generating the state reference.
  * @returns AvmContractClassHint.
  */
-export async function makeAvmContractClassHint(seed = 0): Promise<AvmContractClassHint> {
+export function makeAvmContractClassHint(seed = 0): AvmContractClassHint {
   const bytecode = makeBytes(32, seed + 0x5);
-  return new AvmContractClassHint(
-    new Fr(seed),
-    true /* exists */,
-    new Fr(seed + 0x2),
-    new Fr(seed + 0x3),
-    await computePublicBytecodeCommitment(bytecode),
-    bytecode,
-  );
+  return new AvmContractClassHint(new Fr(seed), new Fr(seed + 0x2), new Fr(seed + 0x3), bytecode);
+}
+
+export async function makeAvmBytecodeCommitmentHint(seed = 0): Promise<AvmBytecodeCommitmentHint> {
+  const classId = new Fr(seed + 2);
+  const bytecode = makeBytes(32, seed + 0x5);
+  return new AvmBytecodeCommitmentHint(classId, await computePublicBytecodeCommitment(bytecode));
 }
 
 export function makeAvmEnqueuedCallHint(seed = 0): AvmEnqueuedCallHint {
   return new AvmEnqueuedCallHint(
     new AztecAddress(new Fr(seed)),
+    new AztecAddress(new Fr(seed + 2)),
     makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
+    /*isStaticCall=*/ false,
   );
 }
 
@@ -1392,8 +1391,9 @@ export async function makeAvmExecutionHints(
 
   const fields = {
     enqueuedCalls: makeArray(baseLength, makeAvmEnqueuedCallHint, seed + 0x4100),
-    contractInstances: makeArray(baseLength + 5, makeAvmContractInstanceHint, seed + 0x4700),
-    contractClasses: await makeArrayAsync(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
+    contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
+    contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
+    bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
     publicDataReads: makeArray(baseLength + 7, makeAvmStorageReadTreeHints, seed + 0x4900),
     publicDataWrites: makeArray(baseLength + 8, makeAvmStorageUpdateTreeHints, seed + 0x4a00),
     nullifierReads: makeArray(baseLength + 9, makeAvmNullifierReadTreeHints, seed + 0x4b00),
@@ -1408,6 +1408,7 @@ export async function makeAvmExecutionHints(
     fields.enqueuedCalls,
     fields.contractInstances,
     fields.contractClasses,
+    fields.bytecodeCommitments,
     fields.publicDataReads,
     fields.publicDataWrites,
     fields.nullifierReads,

package/src/tests/mocks.ts

@@ -4,7 +4,6 @@ import { Secp256k1Signer, randomBytes } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 
 import type { ContractArtifact } from '../abi/abi.js';
-import { NoteSelector } from '../abi/note_selector.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
@@ -46,37 +45,33 @@ export const randomTxHash = (): TxHash => TxHash.random();
 
 export const randomExtendedNote = async ({
   note = Note.random(),
-  owner = undefined,
+  recipient = undefined,
   contractAddress = undefined,
   txHash = randomTxHash(),
   storageSlot = Fr.random(),
-  noteTypeId = NoteSelector.random(),
 }: Partial<ExtendedNote> = {}) => {
   return new ExtendedNote(
     note,
-    owner ?? (await AztecAddress.random()),
+    recipient ?? (await AztecAddress.random()),
     contractAddress ?? (await AztecAddress.random()),
     storageSlot,
-    noteTypeId,
     txHash,
   );
 };
 
 export const randomUniqueNote = async ({
   note = Note.random(),
-  owner = undefined,
+  recipient = undefined,
   contractAddress = undefined,
   txHash = randomTxHash(),
   storageSlot = Fr.random(),
-  noteTypeId = NoteSelector.random(),
   nonce = Fr.random(),
 }: Partial<UniqueNote> = {}) => {
   return new UniqueNote(
     note,
-    owner ?? (await AztecAddress.random()),
+    recipient ?? (await AztecAddress.random()),
     contractAddress ?? (await AztecAddress.random()),
     storageSlot,
-    noteTypeId,
     txHash,
     nonce,
   );

package/src/trees/nullifier_membership_witness.ts

@@ -56,4 +56,16 @@ export class NullifierMembershipWitness {
   public toFields(): Fr[] {
     return [new Fr(this.index), ...this.leafPreimage.toFields(), ...this.siblingPath.toFields()];
   }
+
+  /**
+   * Returns a representation of the nullifier membership witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      ...(this.leafPreimage.toFields().map(fr => fr.toString()) as string[]),
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
 }

package/src/trees/public_data_witness.ts

@@ -58,6 +58,21 @@ export class PublicDataWitness {
     ];
   }
 
+  /**
+   * Returns a representation of the public data witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      new Fr(this.leafPreimage.slot).toString() as string,
+      new Fr(this.leafPreimage.value).toString() as string,
+      new Fr(this.leafPreimage.nextSlot).toString() as string,
+      new Fr(this.leafPreimage.nextIndex).toString() as string,
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
+
   toBuffer(): Buffer {
     return serializeToBuffer([this.index, this.leafPreimage, this.siblingPath]);
   }

package/src/tx/capsule.ts

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

package/src/tx/index.ts

@@ -16,6 +16,8 @@ export * from './tx_hash.js';
 export * from './tx_receipt.js';
 export * from './tx.js';
 export * from './processed_tx.js';
+export * from './proven_tx.js';
+export * from './profiled_tx.js';
 export * from './simulated_tx.js';
 export * from './tx_effect.js';
 export * from './public_simulation_output.js';

package/src/tx/private_execution_result.ts

@@ -115,6 +115,13 @@ export class PrivateExecutionResult {
   static async random(nested = 1): Promise<PrivateExecutionResult> {
     return new PrivateExecutionResult(await PrivateCallExecutionResult.random(nested), Fr.random());
   }
+
+  /**
+   * The block number that this execution was simulated with.
+   */
+  getSimulationBlockNumber(): number {
+    return this.entrypoint.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
+  }
 }
 
 /**

package/src/tx/profiled_tx.ts

@@ -0,0 +1,27 @@
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
+
+export class TxProfileResult {
+  constructor(public executionSteps: PrivateExecutionStep[]) {}
+
+  static get schema(): ZodFor<TxProfileResult> {
+    return z
+      .object({
+        executionSteps: z.array(PrivateExecutionStepSchema),
+      })
+      .transform(({ executionSteps }) => new TxProfileResult(executionSteps));
+  }
+
+  static random(): TxProfileResult {
+    return new TxProfileResult([
+      {
+        functionName: 'random',
+        bytecode: Buffer.from('random'),
+        witness: new Map([[1, 'random']]),
+      },
+    ]);
+  }
+}

package/src/tx/proven_tx.ts

@@ -0,0 +1,58 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import {
+  PrivateExecutionResult,
+  collectEnqueuedPublicFunctionCalls,
+  collectPublicTeardownFunctionCall,
+  collectSortedContractClassLogs,
+} from './private_execution_result.js';
+import { Tx } from './tx.js';
+
+export class TxProvingResult {
+  constructor(
+    public privateExecutionResult: PrivateExecutionResult,
+    public publicInputs: PrivateKernelTailCircuitPublicInputs,
+    public clientIvcProof: ClientIvcProof,
+  ) {}
+
+  toTx(): Tx {
+    const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
+    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
+    const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
+
+    const tx = new Tx(
+      this.publicInputs,
+      this.clientIvcProof,
+      contractClassLogs,
+      enqueuedPublicFunctions,
+      teardownPublicFunction,
+    );
+    return tx;
+  }
+
+  static get schema() {
+    return z
+      .object({
+        privateExecutionResult: PrivateExecutionResult.schema,
+        publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+        clientIvcProof: ClientIvcProof.schema,
+      })
+      .transform(TxProvingResult.from);
+  }
+
+  static from(fields: FieldsOf<TxProvingResult>) {
+    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+  }
+
+  static async random() {
+    return new TxProvingResult(
+      await PrivateExecutionResult.random(),
+      PrivateKernelTailCircuitPublicInputs.empty(),
+      ClientIvcProof.empty(),
+    );
+  }
+}

package/src/tx/simulated_tx.ts

@@ -5,10 +5,6 @@ import { z } from 'zod';
 
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
-import {
-  type PrivateKernelProverProfileResult,
-  PrivateKernelProverProfileResultSchema,
-} from '../kernel/private_kernel_prover_profile_result.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 import {
@@ -47,15 +43,12 @@ export class PrivateSimulationResult {
   }
 }
 
-export class TxSimulationResult extends PrivateSimulationResult {
+export class TxSimulationResult {
   constructor(
-    privateExecutionResult: PrivateExecutionResult,
-    publicInputs: PrivateKernelTailCircuitPublicInputs,
+    public privateExecutionResult: PrivateExecutionResult,
+    public publicInputs: PrivateKernelTailCircuitPublicInputs,
     public publicOutput?: PublicSimulationOutput,
-    public profileResult?: PrivateKernelProverProfileResult,
-  ) {
-    super(privateExecutionResult, publicInputs);
-  }
+  ) {}
 
   get gasUsed(): GasUsed {
     return (
@@ -74,34 +67,22 @@ export class TxSimulationResult extends PrivateSimulationResult {
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
         publicOutput: PublicSimulationOutput.schema.optional(),
-        profileResult: PrivateKernelProverProfileResultSchema.optional(),
       })
       .transform(TxSimulationResult.from);
   }
 
   static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed'>) {
-    return new TxSimulationResult(
-      fields.privateExecutionResult,
-      fields.publicInputs,
-      fields.publicOutput,
-      fields.profileResult,
-    );
-  }
-
-  getPublicReturnValues() {
-    return this.publicOutput ? this.publicOutput.publicReturnValues : [];
+    return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput);
   }
 
   static fromPrivateSimulationResultAndPublicOutput(
     privateSimulationResult: PrivateSimulationResult,
     publicOutput?: PublicSimulationOutput,
-    profileResult?: PrivateKernelProverProfileResult,
   ) {
     return new TxSimulationResult(
       privateSimulationResult.privateExecutionResult,
       privateSimulationResult.publicInputs,
       publicOutput,
-      profileResult,
     );
   }
 
@@ -112,50 +93,17 @@ export class TxSimulationResult extends PrivateSimulationResult {
       await PublicSimulationOutput.random(),
     );
   }
-}
-
-export class TxProvingResult {
-  constructor(
-    public privateExecutionResult: PrivateExecutionResult,
-    public publicInputs: PrivateKernelTailCircuitPublicInputs,
-    public clientIvcProof: ClientIvcProof,
-  ) {}
 
-  toTx(): Tx {
-    const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
-    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
-    const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
-
-    const tx = new Tx(
-      this.publicInputs,
-      this.clientIvcProof,
-      contractClassLogs,
-      enqueuedPublicFunctions,
-      teardownPublicFunction,
-    );
-    return tx;
-  }
-
-  static get schema() {
-    return z
-      .object({
-        privateExecutionResult: PrivateExecutionResult.schema,
-        publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
-      })
-      .transform(TxProvingResult.from);
+  getPrivateReturnValues() {
+    return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).getPrivateReturnValues();
   }
 
-  static from(fields: FieldsOf<TxProvingResult>) {
-    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+  toSimulatedTx(): Tx {
+    return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).toSimulatedTx();
   }
 
-  static async random() {
-    return new TxProvingResult(
-      await PrivateExecutionResult.random(),
-      PrivateKernelTailCircuitPublicInputs.empty(),
-      ClientIvcProof.empty(),
-    );
+  getPublicReturnValues() {
+    return this.publicOutput ? this.publicOutput.publicReturnValues : [];
   }
 }
 

package/src/tx/tx_effect.ts

@@ -158,6 +158,28 @@ export class TxEffect {
     ]);
   }
 
+  equals(other: TxEffect): boolean {
+    return (
+      this.revertCode.equals(other.revertCode) &&
+      this.txHash.equals(other.txHash) &&
+      this.transactionFee.equals(other.transactionFee) &&
+      this.noteHashes.length === other.noteHashes.length &&
+      this.noteHashes.every((h, i) => h.equals(other.noteHashes[i])) &&
+      this.nullifiers.length === other.nullifiers.length &&
+      this.nullifiers.every((h, i) => h.equals(other.nullifiers[i])) &&
+      this.l2ToL1Msgs.length === other.l2ToL1Msgs.length &&
+      this.l2ToL1Msgs.every((h, i) => h.equals(other.l2ToL1Msgs[i])) &&
+      this.publicDataWrites.length === other.publicDataWrites.length &&
+      this.publicDataWrites.every((h, i) => h.equals(other.publicDataWrites[i])) &&
+      this.privateLogs.length === other.privateLogs.length &&
+      this.privateLogs.every((h, i) => h.equals(other.privateLogs[i])) &&
+      this.publicLogs.length === other.publicLogs.length &&
+      this.publicLogs.every((h, i) => h.equals(other.publicLogs[i])) &&
+      this.contractClassLogs.length === other.contractClassLogs.length &&
+      this.contractClassLogs.every((h, i) => h.equals(other.contractClassLogs[i]))
+    );
+  }
+
   /** Returns the size of this tx effect in bytes as serialized onto DA. */
   getDASize() {
     return this.toBlobFields().length * Fr.SIZE_IN_BYTES;
@@ -223,7 +245,7 @@ export class TxEffect {
       makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, Fr.random),
       makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, () => new PublicDataWrite(Fr.random(), Fr.random())),
       makeTuple(MAX_PRIVATE_LOGS_PER_TX, () => new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random))),
-      await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, PublicLog.random),
+      await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, async () => await PublicLog.random()),
       await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.random),
     );
   }

package/src/tx/tx_receipt.ts

@@ -1,9 +1,7 @@
-import type { Fr } from '@aztec/foundation/fields';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
 import { L2BlockHash } from '../block/block_hash.js';
 import { type ZodFor, schemas } from '../schemas/schemas.js';
@@ -41,8 +39,6 @@ export class TxReceipt {
     public blockHash?: L2BlockHash,
     /** The block number in which the transaction was included. */
     public blockNumber?: number,
-    /** Information useful for testing/debugging, set when test flag is set to true in `waitOpts`. */
-    public debugInfo?: DebugInfo,
   ) {}
 
   static empty() {
@@ -58,7 +54,6 @@ export class TxReceipt {
         blockHash: L2BlockHash.schema.optional(),
         blockNumber: z.number().int().nonnegative().optional(),
         transactionFee: schemas.BigInt.optional(),
-        debugInfo: DebugInfoSchema.optional(),
       })
       .transform(TxReceipt.from);
   }
@@ -71,7 +66,6 @@ export class TxReceipt {
       fields.transactionFee,
       fields.blockHash,
       fields.blockNumber,
-      fields.debugInfo,
     );
   }
 
@@ -89,33 +83,3 @@ export class TxReceipt {
     }
   }
 }
-
-/**
- * Information useful for debugging/testing purposes included in the receipt when the debug flag is set to true
- * in `WaitOpts`.
- */
-interface DebugInfo {
-  /**
-   * New note hashes created by the transaction.
-   */
-  noteHashes: Fr[];
-  /**
-   * New nullifiers created by the transaction.
-   */
-  nullifiers: Fr[];
-  /**
-   * New public data writes created by the transaction.
-   */
-  publicDataWrites: PublicDataWrite[];
-  /**
-   * New L2 to L1 messages created by the transaction.
-   */
-  l2ToL1Msgs: Fr[];
-}
-
-const DebugInfoSchema = z.object({
-  noteHashes: z.array(schemas.Fr),
-  nullifiers: z.array(schemas.Fr),
-  publicDataWrites: z.array(PublicDataWrite.schema),
-  l2ToL1Msgs: z.array(schemas.Fr),
-});

package/dest/block/nullifier_with_block_source.d.ts

@@ -1,6 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { InBlock } from './in_block.js';
-export interface NullifierWithBlockSource {
-    findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]>;
-}
-//# sourceMappingURL=nullifier_with_block_source.d.ts.map