@aztec/stdlib 0.79.0 → 0.81.0

package/src/logs/contract_class_log.ts

@@ -28,6 +28,14 @@ export class ContractClassLog {
     return [this.contractAddress.toField(), ...this.fields];
   }
 
+  equals(other: ContractClassLog) {
+    return (
+      this.contractAddress.equals(other.contractAddress) &&
+      this.fields.length === other.fields.length &&
+      this.fields.every((f, i) => f.equals(other.fields[i]))
+    );
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'

package/src/logs/l1_payload/index.ts

@@ -1,2 +1,2 @@
 export * from './encrypted_log_payload.js';
-export * from './l1_note_payload.js';
+export * from './shared_secret_derivation.js';

package/src/logs/private_log.ts

@@ -1,4 +1,4 @@
-import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
@@ -38,8 +38,8 @@ export class PrivateLog {
     return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr));
   }
 
-  static random() {
-    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random));
+  static random(tag = Fr.random()) {
+    return PrivateLog.fromFields([tag, ...Array.from({ length: PRIVATE_LOG_SIZE_IN_FIELDS - 1 }, () => Fr.random())]);
   }
 
   getEmittedLength() {
@@ -54,6 +54,12 @@ export class PrivateLog {
   }
 
   static get schema() {
+    if (PUBLIC_LOG_DATA_SIZE_IN_FIELDS + 1 == PRIVATE_LOG_SIZE_IN_FIELDS) {
+      throw new Error(
+        'Constants got updated and schema for PublicLog matches that of PrivateLog. This needs to be updated now as Zod is no longer able to differentiate the 2 in TxScopedL2Log.',
+      );
+    }
+
     return z
       .object({
         fields: z.array(schemas.Fr),
@@ -61,6 +67,10 @@ export class PrivateLog {
       .transform(({ fields }) => PrivateLog.fromFields(fields));
   }
 
+  equals(other: PrivateLog) {
+    return this.fields.every((field, i) => field.equals(other.fields[i]));
+  }
+
   [inspect.custom](): string {
     return `PrivateLog {
       fields: [${this.fields.map(x => inspect(x)).join(', ')}],

package/src/logs/public_log.ts

@@ -1,4 +1,8 @@
-import { PUBLIC_LOG_DATA_SIZE_IN_FIELDS, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import {
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+  PUBLIC_LOG_SIZE_IN_FIELDS,
+} from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
@@ -78,6 +82,12 @@ export class PublicLog {
   }
 
   static get schema(): ZodFor<PublicLog> {
+    if (PUBLIC_LOG_DATA_SIZE_IN_FIELDS + 1 == PRIVATE_LOG_SIZE_IN_FIELDS) {
+      throw new Error(
+        'Constants got updated and schema for PrivateLog matches that of PublicLog. This needs to be updated now as Zod is no longer able to differentiate the 2 in TxScopedL2Log.',
+      );
+    }
+
     return z
       .object({
         contractAddress: AztecAddress.schema,

package/src/logs/tx_scoped_l2_log.ts

@@ -1,10 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { schemas } from '../schemas/schemas.js';
 import { TxHash } from '../tx/tx_hash.js';
+import { PrivateLog } from './private_log.js';
+import { PublicLog } from './public_log.js';
 
 export class TxScopedL2Log {
   constructor(
@@ -22,53 +22,55 @@ export class TxScopedL2Log {
      */
     public blockNumber: number,
     /*
-     * Indicates if the log comes from the public logs stream (partial note)
+     * The log data as either a PrivateLog or PublicLog
      */
-    public isFromPublic: boolean,
-    /*
-     * The log data
-     */
-    public logData: Buffer,
+    public log: PrivateLog | PublicLog,
   ) {}
 
+  get isFromPublic() {
+    return this.log instanceof PublicLog;
+  }
+
   static get schema() {
     return z
       .object({
         txHash: TxHash.schema,
         dataStartIndexForTx: z.number(),
         blockNumber: z.number(),
-        isFromPublic: z.boolean(),
-        logData: schemas.Buffer,
+        log: z.union([PrivateLog.schema, PublicLog.schema]),
       })
       .transform(
-        ({ txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData }) =>
-          new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData),
+        ({ txHash, dataStartIndexForTx, blockNumber, log }) =>
+          new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, log),
       );
   }
 
   toBuffer() {
+    const isFromPublic = this.log instanceof PublicLog;
     return Buffer.concat([
       this.txHash.toBuffer(),
       numToUInt32BE(this.dataStartIndexForTx),
       numToUInt32BE(this.blockNumber),
-      boolToBuffer(this.isFromPublic),
-      this.logData,
+      boolToBuffer(isFromPublic),
+      this.log.toBuffer(),
     ]);
   }
 
   static fromBuffer(buffer: Buffer) {
     const reader = BufferReader.asReader(buffer);
-    return new TxScopedL2Log(
-      reader.readObject(TxHash),
-      reader.readNumber(),
-      reader.readNumber(),
-      reader.readBoolean(),
-      reader.readToEnd(),
-    );
+    const txHash = reader.readObject(TxHash);
+    const dataStartIndexForTx = reader.readNumber();
+    const blockNumber = reader.readNumber();
+    const isFromPublic = reader.readBoolean();
+    const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
+
+    return new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, log);
   }
 
-  static random() {
-    return new TxScopedL2Log(TxHash.random(), 1, 1, false, Fr.random().toBuffer());
+  static async random() {
+    const isFromPublic = Math.random() < 0.5;
+    const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
+    return new TxScopedL2Log(TxHash.random(), 1, 1, log);
   }
 
   equals(other: TxScopedL2Log) {
@@ -76,8 +78,9 @@ export class TxScopedL2Log {
       this.txHash.equals(other.txHash) &&
       this.dataStartIndexForTx === other.dataStartIndexForTx &&
       this.blockNumber === other.blockNumber &&
-      this.isFromPublic === other.isFromPublic &&
-      this.logData.equals(other.logData)
+      ((this.log instanceof PublicLog && other.log instanceof PublicLog) ||
+        (this.log instanceof PrivateLog && other.log instanceof PrivateLog)) &&
+      this.log.equals(other.log as any)
     );
   }
 }

package/src/note/extended_note.ts

@@ -4,7 +4,6 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
-import { NoteSelector } from '../abi/note_selector.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { type ZodFor, schemas } from '../schemas/index.js';
 import { TxHash } from '../tx/tx_hash.js';
@@ -17,54 +16,43 @@ export class ExtendedNote {
   constructor(
     /** The note as emitted from the Noir contract. */
     public note: Note,
-    /** The owner whose public key was used to encrypt the note. */
-    public owner: AztecAddress,
+    /** The address whose public key was used to encrypt the note. */
+    public recipient: AztecAddress,
     /** The contract address this note is created in. */
     public contractAddress: AztecAddress,
     /** The specific storage location of the note on the contract. */
     public storageSlot: Fr,
-    /** The type identifier of the note on the contract. */
-    public noteTypeId: NoteSelector,
     /** The hash of the tx the note was created in. */
     public txHash: TxHash,
   ) {}
 
   toBuffer(): Buffer {
-    return serializeToBuffer([
-      this.note,
-      this.owner,
-      this.contractAddress,
-      this.storageSlot,
-      this.noteTypeId,
-      this.txHash,
-    ]);
+    return serializeToBuffer([this.note, this.recipient, this.contractAddress, this.storageSlot, this.txHash]);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
 
     const note = reader.readObject(Note);
-    const owner = reader.readObject(AztecAddress);
+    const recipient = reader.readObject(AztecAddress);
     const contractAddress = reader.readObject(AztecAddress);
     const storageSlot = reader.readObject(Fr);
-    const noteTypeId = reader.readObject(NoteSelector);
     const txHash = reader.readObject(TxHash);
 
-    return new this(note, owner, contractAddress, storageSlot, noteTypeId, txHash);
+    return new this(note, recipient, contractAddress, storageSlot, txHash);
   }
 
   static get schema(): ZodFor<ExtendedNote> {
     return z
       .object({
         note: Note.schema,
-        owner: schemas.AztecAddress,
+        recipient: schemas.AztecAddress,
         contractAddress: schemas.AztecAddress,
         storageSlot: schemas.Fr,
-        noteTypeId: schemas.NoteSelector,
         txHash: TxHash.schema,
       })
-      .transform(({ note, owner, contractAddress, storageSlot, noteTypeId, txHash }) => {
-        return new ExtendedNote(note, owner, contractAddress, storageSlot, noteTypeId, txHash);
+      .transform(({ note, recipient, contractAddress, storageSlot, txHash }) => {
+        return new ExtendedNote(note, recipient, contractAddress, storageSlot, txHash);
       });
   }
 
@@ -82,7 +70,6 @@ export class ExtendedNote {
       await AztecAddress.random(),
       await AztecAddress.random(),
       Fr.random(),
-      NoteSelector.random(),
       TxHash.random(),
     );
   }
@@ -92,45 +79,41 @@ export class UniqueNote extends ExtendedNote {
   constructor(
     /** The note as emitted from the Noir contract. */
     note: Note,
-    /** The owner whose public key was used to encrypt the note. */
-    owner: AztecAddress,
+    /** The recipient whose public key was used to encrypt the note. */
+    recipient: AztecAddress,
     /** The contract address this note is created in. */
     contractAddress: AztecAddress,
     /** The specific storage location of the note on the contract. */
     storageSlot: Fr,
-    /** The type identifier of the note on the contract. */
-    noteTypeId: NoteSelector,
     /** The hash of the tx the note was created in. */
     txHash: TxHash,
     /** The nonce of the note. */
     public nonce: Fr,
   ) {
-    super(note, owner, contractAddress, storageSlot, noteTypeId, txHash);
+    super(note, recipient, contractAddress, storageSlot, txHash);
   }
 
   static override get schema() {
     return z
       .object({
         note: Note.schema,
-        owner: schemas.AztecAddress,
+        recipient: schemas.AztecAddress,
         contractAddress: schemas.AztecAddress,
         storageSlot: schemas.Fr,
-        noteTypeId: schemas.NoteSelector,
         txHash: TxHash.schema,
         nonce: schemas.Fr,
       })
-      .transform(({ note, owner, contractAddress, storageSlot, noteTypeId, txHash, nonce }) => {
-        return new UniqueNote(note, owner, contractAddress, storageSlot, noteTypeId, txHash, nonce);
+      .transform(({ note, recipient, contractAddress, storageSlot, txHash, nonce }) => {
+        return new UniqueNote(note, recipient, contractAddress, storageSlot, txHash, nonce);
       });
   }
 
   override toBuffer(): Buffer {
     return serializeToBuffer([
       this.note,
-      this.owner,
+      this.recipient,
       this.contractAddress,
       this.storageSlot,
-      this.noteTypeId,
       this.txHash,
       this.nonce,
     ]);
@@ -142,7 +125,6 @@ export class UniqueNote extends ExtendedNote {
       await AztecAddress.random(),
       await AztecAddress.random(),
       Fr.random(),
-      NoteSelector.random(),
       TxHash.random(),
       Fr.random(),
     );
@@ -152,14 +134,13 @@ export class UniqueNote extends ExtendedNote {
     const reader = BufferReader.asReader(buffer);
 
     const note = reader.readObject(Note);
-    const owner = reader.readObject(AztecAddress);
+    const recipient = reader.readObject(AztecAddress);
     const contractAddress = reader.readObject(AztecAddress);
     const storageSlot = reader.readObject(Fr);
-    const noteTypeId = reader.readObject(NoteSelector);
     const txHash = reader.readObject(TxHash);
     const nonce = reader.readObject(Fr);
 
-    return new this(note, owner, contractAddress, storageSlot, noteTypeId, txHash, nonce);
+    return new this(note, recipient, contractAddress, storageSlot, txHash, nonce);
   }
 
   static override fromString(str: string) {

package/src/note/notes_filter.ts

@@ -18,8 +18,8 @@ export type NotesFilter = {
   contractAddress?: AztecAddress;
   /** The specific storage location of the note on the contract. */
   storageSlot?: Fr;
-  /** The owner of the note (whose public key was used to encrypt the note). */
-  owner?: AztecAddress;
+  /** The recipient of the note (whose public key was used to encrypt the note). */
+  recipient?: AztecAddress;
   /** The status of the note. Defaults to 'ACTIVE'. */
   status?: NoteStatus;
   /** The siloed nullifier for the note. */
@@ -32,7 +32,7 @@ export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
   txHash: TxHash.schema.optional(),
   contractAddress: schemas.AztecAddress.optional(),
   storageSlot: schemas.Fr.optional(),
-  owner: schemas.AztecAddress.optional(),
+  recipient: schemas.AztecAddress.optional(),
   status: z.nativeEnum(NoteStatus).optional(),
   siloedNullifier: schemas.Fr.optional(),
   scopes: z.array(schemas.AztecAddress).optional(),

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/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/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,
   );
@@ -228,6 +223,7 @@ export const mockSimulatedTx = async (seed = 1) => {
 export const randomContractArtifact = (): ContractArtifact => ({
   name: randomBytes(4).toString('hex'),
   functions: [],
+  nonDispatchPublicFunctions: [],
   outputs: {
     structs: {},
     globals: {},

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/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),
     );
   }