@aztec/stdlib 0.80.0 → 0.81.0

package/src/avm/avm.ts

@@ -12,25 +12,33 @@ import { AvmCircuitPublicInputs } from './avm_circuit_public_inputs.js';
 import { serializeWithMessagePack } from './message_pack.js';
 
 export class AvmEnqueuedCallHint {
-  constructor(public readonly contractAddress: AztecAddress, public readonly calldata: Fr[]) {}
+  constructor(
+    public readonly msgSender: AztecAddress,
+    public readonly contractAddress: AztecAddress,
+    public readonly calldata: Fr[],
+    public isStaticCall: boolean,
+  ) {}
 
   static get schema() {
     return z
       .object({
+        msgSender: AztecAddress.schema,
         contractAddress: AztecAddress.schema,
         calldata: schemas.Fr.array(),
+        isStaticCall: z.boolean(),
       })
-      .transform(({ contractAddress, calldata }) => new AvmEnqueuedCallHint(contractAddress, calldata));
+      .transform(
+        ({ msgSender, contractAddress, calldata, isStaticCall }) =>
+          new AvmEnqueuedCallHint(msgSender, contractAddress, calldata, isStaticCall),
+      );
   }
 }
 
 export class AvmContractClassHint {
   constructor(
     public readonly classId: Fr,
-    public readonly exists: boolean,
     public readonly artifactHash: Fr,
     public readonly privateFunctionsRoot: Fr,
-    public readonly publicBytecodeCommitment: Fr,
     public readonly packedBytecode: Buffer,
   ) {}
 
@@ -38,79 +46,70 @@ export class AvmContractClassHint {
     return z
       .object({
         classId: schemas.Fr,
-        exists: z.boolean(),
         artifactHash: schemas.Fr,
         privateFunctionsRoot: schemas.Fr,
-        publicBytecodeCommitment: schemas.Fr,
         packedBytecode: schemas.Buffer,
       })
       .transform(
-        ({ classId, exists, artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode }) =>
-          new AvmContractClassHint(
-            classId,
-            exists,
-            artifactHash,
-            privateFunctionsRoot,
-            publicBytecodeCommitment,
-            packedBytecode,
-          ),
+        ({ classId, artifactHash, privateFunctionsRoot, packedBytecode }) =>
+          new AvmContractClassHint(classId, artifactHash, privateFunctionsRoot, packedBytecode),
       );
   }
 }
 
+export class AvmBytecodeCommitmentHint {
+  constructor(public readonly classId: Fr, public readonly commitment: Fr) {}
+
+  static get schema() {
+    return z
+      .object({
+        classId: schemas.Fr,
+        commitment: schemas.Fr,
+      })
+      .transform(({ classId, commitment }) => new AvmBytecodeCommitmentHint(classId, commitment));
+  }
+}
+
 export class AvmContractInstanceHint {
   constructor(
     public readonly address: AztecAddress,
-    public readonly exists: boolean,
     public readonly salt: Fr,
     public readonly deployer: AztecAddress,
     public readonly currentContractClassId: Fr,
     public readonly originalContractClassId: Fr,
     public readonly initializationHash: Fr,
     public readonly publicKeys: PublicKeys,
-    // public readonly updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
-    public readonly updateMembershipHint: AvmPublicDataReadTreeHint,
-    public readonly updatePreimage: Fr[] = [],
   ) {}
 
   static get schema() {
     return z
       .object({
         address: AztecAddress.schema,
-        exists: z.boolean(),
         salt: schemas.Fr,
         deployer: AztecAddress.schema,
         currentContractClassId: schemas.Fr,
         originalContractClassId: schemas.Fr,
         initializationHash: schemas.Fr,
         publicKeys: PublicKeys.schema,
-        updateMembershipHint: AvmPublicDataReadTreeHint.schema,
-        updatePreimage: schemas.Fr.array(),
       })
       .transform(
         ({
           address,
-          exists,
           salt,
           deployer,
           currentContractClassId,
           originalContractClassId,
           initializationHash,
           publicKeys,
-          updateMembershipHint,
-          updatePreimage,
         }) =>
           new AvmContractInstanceHint(
             address,
-            exists,
             salt,
             deployer,
             currentContractClassId,
             originalContractClassId,
             initializationHash,
             publicKeys,
-            updateMembershipHint,
-            updatePreimage,
           ),
       );
   }
@@ -213,20 +212,21 @@ export class AvmPublicDataWriteTreeHint {
 
 export class AvmExecutionHints {
   constructor(
-    public readonly enqueuedCalls: AvmEnqueuedCallHint[],
-    public readonly contractInstances: AvmContractInstanceHint[],
-    public readonly contractClasses: AvmContractClassHint[],
-    public readonly publicDataReads: AvmPublicDataReadTreeHint[],
-    public readonly publicDataWrites: AvmPublicDataWriteTreeHint[],
-    public readonly nullifierReads: AvmNullifierReadTreeHint[],
-    public readonly nullifierWrites: AvmNullifierWriteTreeHint[],
-    public readonly noteHashReads: AvmAppendTreeHint[],
-    public readonly noteHashWrites: AvmAppendTreeHint[],
-    public readonly l1ToL2MessageReads: AvmAppendTreeHint[],
+    public readonly enqueuedCalls: AvmEnqueuedCallHint[] = [],
+    public readonly contractInstances: AvmContractInstanceHint[] = [],
+    public readonly contractClasses: AvmContractClassHint[] = [],
+    public readonly bytecodeCommitments: AvmBytecodeCommitmentHint[] = [],
+    public readonly publicDataReads: AvmPublicDataReadTreeHint[] = [],
+    public readonly publicDataWrites: AvmPublicDataWriteTreeHint[] = [],
+    public readonly nullifierReads: AvmNullifierReadTreeHint[] = [],
+    public readonly nullifierWrites: AvmNullifierWriteTreeHint[] = [],
+    public readonly noteHashReads: AvmAppendTreeHint[] = [],
+    public readonly noteHashWrites: AvmAppendTreeHint[] = [],
+    public readonly l1ToL2MessageReads: AvmAppendTreeHint[] = [],
   ) {}
 
   static empty() {
-    return new AvmExecutionHints([], [], [], [], [], [], [], [], [], []);
+    return new AvmExecutionHints();
   }
 
   static get schema() {
@@ -235,6 +235,7 @@ export class AvmExecutionHints {
         enqueuedCalls: AvmEnqueuedCallHint.schema.array(),
         contractInstances: AvmContractInstanceHint.schema.array(),
         contractClasses: AvmContractClassHint.schema.array(),
+        bytecodeCommitments: AvmBytecodeCommitmentHint.schema.array(),
         publicDataReads: AvmPublicDataReadTreeHint.schema.array(),
         publicDataWrites: AvmPublicDataWriteTreeHint.schema.array(),
         nullifierReads: AvmNullifierReadTreeHint.schema.array(),
@@ -248,6 +249,7 @@ export class AvmExecutionHints {
           enqueuedCalls,
           contractInstances,
           contractClasses,
+          bytecodeCommitments,
           publicDataReads,
           publicDataWrites,
           nullifierReads,
@@ -260,6 +262,7 @@ export class AvmExecutionHints {
             enqueuedCalls,
             contractInstances,
             contractClasses,
+            bytecodeCommitments,
             publicDataReads,
             publicDataWrites,
             nullifierReads,

package/src/avm/public_data_write.ts

@@ -77,4 +77,8 @@ export class PublicDataWrite {
   isEmpty() {
     return this.leafSlot.isZero() && this.value.isZero();
   }
+
+  equals(other: PublicDataWrite): boolean {
+    return this.leafSlot.equals(other.leafSlot) && this.value.equals(other.value);
+  }
 }

package/src/block/body.ts

@@ -18,6 +18,12 @@ export class Body {
     });
   }
 
+  equals(other: Body) {
+    return (
+      this.txEffects.length === other.txEffects.length && this.txEffects.every((te, i) => te.equals(other.txEffects[i]))
+    );
+  }
+
   static get schema(): ZodFor<Body> {
     return z
       .object({

package/src/block/index.ts

@@ -6,3 +6,4 @@ export * from './body.js';
 export * from './l2_block_number.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
+export * from './published_l2_block.js';

package/src/block/l2_block.ts

@@ -202,4 +202,8 @@ export class L2Block {
       ...logsStats,
     };
   }
+
+  equals(other: L2Block) {
+    return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body);
+  }
 }

package/src/block/l2_block_downloader/l2_block_stream.ts

@@ -2,8 +2,8 @@ import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 
-import type { L2Block } from '../l2_block.js';
 import type { L2BlockId, L2BlockSource, L2Tips } from '../l2_block_source.js';
+import type { PublishedL2Block } from '../published_l2_block.js';
 
 /** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
 export class L2BlockStream {
@@ -11,7 +11,7 @@ export class L2BlockStream {
   private isSyncing = false;
 
   constructor(
-    private l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'>,
+    private l2BlockSource: Pick<L2BlockSource, 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'>,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
@@ -84,12 +84,12 @@ export class L2BlockStream {
         const from = latestBlockNumber + 1;
         const limit = Math.min(this.opts.batchSize ?? 20, sourceTips.latest.number - from + 1);
         this.log.trace(`Requesting blocks from ${from} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getBlocks(from, limit, this.opts.proven);
+        const blocks = await this.l2BlockSource.getPublishedBlocks(from, limit, this.opts.proven);
         if (blocks.length === 0) {
           break;
         }
         await this.emitEvent({ type: 'blocks-added', blocks });
-        latestBlockNumber = blocks.at(-1)!.number;
+        latestBlockNumber = blocks.at(-1)!.block.number;
       }
 
       // Update the proven and finalized tips.
@@ -160,7 +160,7 @@ export type L2BlockStreamEvent =
   | {
       type: 'blocks-added';
       /** New blocks added to the chain. */
-      blocks: L2Block[];
+      blocks: PublishedL2Block[];
     }
   | {
       type: 'chain-pruned';

package/src/block/l2_block_source.ts

@@ -10,6 +10,7 @@ import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
 import type { InBlock } from './in_block.js';
 import type { L2Block } from './l2_block.js';
+import type { PublishedL2Block } from './published_l2_block.js';
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -62,6 +63,9 @@ export interface L2BlockSource {
    */
   getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
 
+  /** Equivalent to getBlocks but includes publish data. */
+  getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of a transaction which resulted in the returned tx effect.

package/src/block/published_l2_block.ts

@@ -0,0 +1,45 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { times } from '@aztec/foundation/collection';
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { schemas } from '@aztec/foundation/schemas';
+import { L2Block } from '@aztec/stdlib/block';
+
+import { z } from 'zod';
+
+export type L1PublishedData = {
+  blockNumber: bigint;
+  timestamp: bigint;
+  blockHash: string;
+};
+
+export type PublishedL2Block = {
+  block: L2Block;
+  l1: L1PublishedData;
+  signatures: Signature[];
+};
+
+export const PublishedL2BlockSchema = z.object({
+  block: L2Block.schema,
+  l1: z.object({
+    blockNumber: schemas.BigInt,
+    timestamp: schemas.BigInt,
+    blockHash: z.string(),
+  }),
+  signatures: z.array(Signature.schema),
+});
+
+export async function randomPublishedL2Block(l2BlockNumber: number): Promise<PublishedL2Block> {
+  const block = await L2Block.random(l2BlockNumber);
+  const l1 = {
+    blockNumber: BigInt(block.number),
+    timestamp: block.header.globalVariables.timestamp.toBigInt(),
+    blockHash: Buffer32.random().toString(),
+  };
+  // Create valid signatures
+  const signers = times(3, () => Secp256k1Signer.random());
+  const signatures = await Promise.all(
+    times(3, async i => signers[i].signMessage(Buffer32.fromField(await block.hash()))),
+  );
+  return { block, l1, signatures };
+}

package/src/contract/interfaces/contract_data_source.ts

@@ -2,18 +2,10 @@ import type { Fr } from '@aztec/foundation/fields';
 
 import { FunctionSelector } from '../../abi/index.js';
 import type { AztecAddress } from '../../aztec-address/index.js';
-import type { ContractClassPublic, PublicFunction } from './contract_class.js';
+import type { ContractClassPublic } from './contract_class.js';
 import type { ContractInstanceWithAddress } from './contract_instance.js';
 
 export interface ContractDataSource {
-  /**
-   * Returns a contract's encoded public function, given its function selector.
-   * @param address - The contract aztec address.
-   * @param selector - The function's selector.
-   * @returns The function's data.
-   */
-  getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined>;
-
   /**
    * Gets the number of the latest L2 block processed by the implementation.
    * @returns The number of the latest L2 block processed by the implementation.
@@ -37,8 +29,9 @@ export interface ContractDataSource {
   /**
    * Returns a publicly deployed contract instance given its address.
    * @param address - Address of the deployed contract.
+   * @param blockNumber - Block number at which to retrieve the contract instance. If not provided, the latest block should be used.
    */
-  getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+  getContract(address: AztecAddress, blockNumber?: number): Promise<ContractInstanceWithAddress | undefined>;
 
   /**
    * Returns the list of all class ids known.

package/src/database-version/version_manager.ts

@@ -148,7 +148,7 @@ export class DatabaseVersionManager<T> {
         }
       } else if (cmp !== 0) {
         this.log.info(
-          `Can't upgrade from version ${storedVersion.schemaVersion} to ${this.currentVersion}. Resetting database at ${this.dataDirectory}`,
+          `Can't upgrade from version ${storedVersion.schemaVersion} to ${this.currentVersion.schemaVersion}. Resetting database at ${this.dataDirectory}`,
         );
         needsReset = true;
       }

package/src/interfaces/archiver.ts

@@ -6,11 +6,11 @@ import { inBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
 import type { NullifierWithBlockSource } from '../block/nullifier_with_block_source.js';
+import { PublishedL2BlockSchema } from '../block/published_l2_block.js';
 import {
   ContractClassPublicSchema,
   type ContractDataSource,
   ContractInstanceWithAddressSchema,
-  PublicFunctionSchema,
 } from '../contract/index.js';
 import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
 import { LogFilterSchema } from '../logs/log_filter.js';
@@ -44,6 +44,10 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .function()
     .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
     .returns(z.array(L2Block.schema)),
+  getPublishedBlocks: z
+    .function()
+    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(PublishedL2BlockSchema)),
   getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
   getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
   getL2SlotNumber: z.function().args().returns(schemas.BigInt),
@@ -62,13 +66,12 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
   getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
-  getPublicFunction: z
-    .function()
-    .args(schemas.AztecAddress, schemas.FunctionSelector)
-    .returns(PublicFunctionSchema.optional()),
   getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
   getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
-  getContract: z.function().args(schemas.AztecAddress).returns(ContractInstanceWithAddressSchema.optional()),
+  getContract: z
+    .function()
+    .args(schemas.AztecAddress, optional(schemas.Integer))
+    .returns(ContractInstanceWithAddressSchema.optional()),
   getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
   registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
   getL1ToL2Messages: z.function().args(schemas.BigInt).returns(z.array(schemas.Fr)),

package/src/interfaces/aztec-node.ts

@@ -17,6 +17,7 @@ import { type InBlock, inBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockNumber, L2BlockNumberSchema } from '../block/l2_block_number.js';
 import { type L2BlockSource, type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
+import { PublishedL2BlockSchema } from '../block/published_l2_block.js';
 import {
   type ContractClassPublic,
   ContractClassPublicSchema,
@@ -63,7 +64,7 @@ import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_s
  */
 export interface AztecNode
   extends ProverCoordination,
-    Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'> {
+    Pick<L2BlockSource, 'getBlocks' | 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'> {
   /**
    * Returns the tips of the L2 chain.
    */
@@ -534,6 +535,8 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getBlocks: z.function().args(z.number(), z.number()).returns(z.array(L2Block.schema)),
 
+  getPublishedBlocks: z.function().args(z.number(), z.number()).returns(z.array(PublishedL2BlockSchema)),
+
   getCurrentBaseFees: z.function().returns(GasFees.schema),
 
   getNodeVersion: z.function().returns(z.string()),

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