@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/logs/contract_class_log.ts

@@ -1,40 +1,85 @@
-import { CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { CONTRACT_CLASS_LOG_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
-export class ContractClassLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_SIZE_IN_FIELDS;
-  // Keeps original first field pre-siloing. Only set by silo().
-  public unsiloedFirstField?: Fr | undefined;
-
+export class ContractClassLogFields {
   // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-  // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS>
-  constructor(public contractAddress: AztecAddress, public fields: Fr[]) {
-    if (fields.length !== CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS) {
+  // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_SIZE_IN_FIELDS>
+  constructor(public fields: Fr[]) {
+    if (fields.length !== CONTRACT_CLASS_LOG_SIZE_IN_FIELDS) {
       throw new Error(
-        `Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS}, got ${fields.length}`,
+        `Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_SIZE_IN_FIELDS}, got ${fields.length}`,
       );
     }
   }
 
+  static get schema() {
+    return z
+      .object({
+        fields: z.array(schemas.Fr).refine(arr => arr.length === CONTRACT_CLASS_LOG_SIZE_IN_FIELDS),
+      })
+      .transform(({ fields }) => new ContractClassLogFields(fields));
+  }
+
+  /**
+   * Creates a ContractClassLogFields from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ContractClassLogFields fields
+   * @returns A ContractClassLogFields instance
+   */
+  static fromPlainObject(obj: any): ContractClassLogFields {
+    if (obj instanceof ContractClassLogFields) {
+      return obj;
+    }
+    return new ContractClassLogFields(obj.fields.map((f: any) => Fr.fromPlainObject(f)));
+  }
+
   toFields(): Fr[] {
-    return [this.contractAddress.toField(), ...this.fields];
+    return this.fields;
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // return new ContractClassLog(reader.readFieldArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS));
-    return new ContractClassLog(
-      reader.readObject(AztecAddress),
-      Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () => reader.readField()),
+    // reader.readFieldArray(CONTRACT_CLASS_LOG_LENGTH);
+    return new ContractClassLogFields(
+      Array.from({ length: CONTRACT_CLASS_LOG_SIZE_IN_FIELDS }, () => reader.readField()),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.fields);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr)
+    return new ContractClassLogFields(
+      Array.from({ length: CONTRACT_CLASS_LOG_SIZE_IN_FIELDS }, () => reader.readObject(Fr)),
+    );
+  }
+
+  equals(other: ContractClassLogFields) {
+    return this.fields.every((f, i) => f.equals(other.fields[i]));
+  }
+
+  getEmittedFields(emittedLength: number) {
+    return this.fields.slice(0, emittedLength);
+  }
+
+  static fromEmittedFields(emittedFields: Fr[]) {
+    return new ContractClassLogFields(
+      emittedFields.concat(Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - emittedFields.length).fill(Fr.ZERO)),
     );
   }
 
@@ -43,89 +88,146 @@ export class ContractClassLog {
   }
 
   static empty() {
-    return new ContractClassLog(AztecAddress.ZERO, new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS).fill(Fr.ZERO));
+    return new ContractClassLogFields(Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS).fill(Fr.ZERO));
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer([this.contractAddress, this.fields]);
+  static random(emittedLength = CONTRACT_CLASS_LOG_SIZE_IN_FIELDS) {
+    return new ContractClassLogFields(
+      Array.from({ length: emittedLength }, () => Fr.random()).concat(
+        Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - emittedLength).fill(Fr.ZERO),
+      ),
+    );
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr);
-    const address = reader.readObject(AztecAddress);
-    const fields = Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () =>
-      reader.remainingBytes() == 0 ? Fr.ZERO : Fr.fromBuffer(reader),
-    );
-    return new ContractClassLog(address, fields);
+  async hash() {
+    return await poseidon2Hash(this.fields);
   }
 
   clone() {
-    return ContractClassLog.fromBuffer(this.toBuffer());
+    return ContractClassLogFields.fromBuffer(this.toBuffer());
   }
+}
 
-  static async random() {
-    // NB: Using half the maximum number of fields per log because max fields keeps overfilling blobs in tests.
-    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, Fr.random);
-    const fields = Array.from({ length: Math.ceil(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.random());
-    return new ContractClassLog(
-      await AztecAddress.random(),
-      fields.concat(Array.from({ length: Math.floor(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.ZERO)),
+export class ContractClassLog {
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_LENGTH;
+
+  constructor(
+    public contractAddress: AztecAddress,
+    public fields: ContractClassLogFields,
+    public emittedLength: number,
+  ) {}
+
+  static from(fields: FieldsOf<ContractClassLog>) {
+    return new ContractClassLog(fields.contractAddress, fields.fields, fields.emittedLength);
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields([this.contractAddress, this.fields, this.emittedLength]);
+  }
+
+  equals(other: ContractClassLog) {
+    return (
+      this.contractAddress.equals(other.contractAddress) &&
+      this.fields.equals(other.fields) &&
+      this.emittedLength === other.emittedLength
     );
   }
 
-  getEmittedLength() {
-    // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
-    // Does not include address or length prefix.
-    // Note: Unlike public logs, address is not included here because it is not included in the log itself.
-    return this.getEmittedFields().length;
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ContractClassLog(
+      reader.readObject(AztecAddress),
+      reader.readObject(ContractClassLogFields),
+      reader.readU32(),
+    );
   }
 
   getEmittedFields() {
-    const lastNonZeroIndex = this.fields.findLastIndex(f => !f.isZero());
-    return this.fields.slice(0, lastNonZeroIndex + 1);
+    return this.fields.getEmittedFields(this.emittedLength);
   }
 
-  setUnsiloedFirstField(field: Fr) {
-    this.unsiloedFirstField = field;
+  toBlobFields(): Fr[] {
+    return [this.contractAddress.toField()].concat(this.getEmittedFields());
   }
 
-  toUnsiloed() {
-    if (this.unsiloedFirstField) {
-      return new ContractClassLog(this.contractAddress, [this.unsiloedFirstField].concat(this.fields.slice(1)));
-    } else {
-      return this;
-    }
+  static fromBlobFields(emittedLength: number, fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const contractAddress = reader.readObject(AztecAddress);
+    const emittedFields = reader.readFieldArray(emittedLength);
+    return new ContractClassLog(
+      contractAddress,
+      ContractClassLogFields.fromEmittedFields(emittedFields),
+      emittedLength,
+    );
   }
 
-  async silo() {
-    const innerLog = this.clone();
-    if (innerLog.contractAddress.isZero()) {
-      return innerLog;
-    }
-    innerLog.setUnsiloedFirstField(innerLog.fields[0]);
-    innerLog.fields[0] = await poseidon2Hash([innerLog.contractAddress, innerLog.fields[0]]);
-    return innerLog;
+  isEmpty() {
+    return this.contractAddress.isZero() && this.fields.isEmpty() && this.emittedLength === 0;
+  }
+
+  static empty() {
+    return new ContractClassLog(AztecAddress.ZERO, ContractClassLogFields.empty(), 0);
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.contractAddress, this.fields, this.emittedLength]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    const address = reader.readObject(AztecAddress);
+    const fields = ContractClassLogFields.fromBuffer(reader);
+    const emittedLength = reader.readNumber();
+    return new ContractClassLog(address, fields, emittedLength);
+  }
+
+  static async random() {
+    // NB: Using half the maximum number of fields per log because max fields keeps overfilling blobs in tests.
+    const emittedLength = Math.ceil(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS / 2);
+    return new ContractClassLog(
+      await AztecAddress.random(),
+      ContractClassLogFields.random(emittedLength),
+      emittedLength,
+    );
   }
 
   async hash() {
-    return await poseidon2Hash(this.fields);
+    return await this.fields.hash();
   }
 
   static get schema() {
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        fields: z.array(schemas.Fr),
+        fields: ContractClassLogFields.schema,
+        emittedLength: z.number(),
       })
-      .transform(({ contractAddress, fields }) => ContractClassLog.fromFields([contractAddress.toField(), ...fields]));
+      .transform(ContractClassLog.from);
+  }
+
+  /**
+   * Creates a ContractClassLog from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ContractClassLog fields
+   * @returns A ContractClassLog instance
+   */
+  static fromPlainObject(obj: any): ContractClassLog {
+    if (obj instanceof ContractClassLog) {
+      return obj;
+    }
+    return new ContractClassLog(
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      ContractClassLogFields.fromPlainObject(obj.fields),
+      obj.emittedLength,
+    );
   }
 
   [inspect.custom](): string {
     return `ContractClassLog {
-      fields: [${this.fields.map((x: Fr) => inspect(x)).join(', ')}],
+      contractAddress: ${this.contractAddress.toString()},
+      emittedLength: ${this.emittedLength},
+      fields: [${this.fields.fields.map((x: Fr) => inspect(x)).join(', ')}],
     }`;
   }
 }

package/src/logs/debug_log.ts

@@ -0,0 +1,51 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type LogLevel, LogLevels } from '@aztec/foundation/log';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+/*
+ * Represents a debug log emitted by public bytecode.
+ */
+export class DebugLog {
+  constructor(
+    public contractAddress: AztecAddress,
+    public level: LogLevel,
+    public message: string,
+    public fields: Fr[],
+  ) {}
+
+  static get schema(): ZodFor<DebugLog> {
+    return z
+      .object({
+        contractAddress: AztecAddress.schema,
+        level: z.enum(LogLevels),
+        message: z.string(),
+        fields: z.array(schemas.Fr),
+      })
+      .transform(
+        ({ contractAddress, level, message, fields }) => new DebugLog(contractAddress, level, message, fields),
+      );
+  }
+
+  /**
+   * Creates a DebugLog from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing DebugLog fields
+   * @returns A DebugLog instance
+   */
+  static fromPlainObject(obj: any): DebugLog {
+    if (obj instanceof DebugLog) {
+      return obj;
+    }
+    return new DebugLog(
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      obj.level,
+      obj.message,
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
+    );
+  }
+}

package/src/logs/debug_log_store.ts

@@ -0,0 +1,54 @@
+import type { TxReceipt } from '../tx/tx_receipt.js';
+import type { DebugLog } from './debug_log.js';
+
+/**
+ * Store for debug logs emitted by public functions during transaction execution.
+ *
+ * Uses the Null Object pattern: production code uses NullDebugLogStore (no-op), while test mode uses
+ * InMemoryDebugLogStore (stores and serves logs).
+ */
+export interface DebugLogStore {
+  /** Store debug logs for a processed transaction. */
+  storeLogs(txHash: string, logs: DebugLog[]): void;
+  /** Decorate a TxReceipt with any stored debug logs for the given tx. */
+  decorateReceiptWithLogs(txHash: string, receipt: TxReceipt): void;
+  /** Whether debug log collection is enabled. */
+  readonly isEnabled: boolean;
+}
+
+/** No-op implementation for production mode. */
+export class NullDebugLogStore implements DebugLogStore {
+  storeLogs(_txHash: string, _logs: DebugLog[]): void {
+    return;
+  }
+  decorateReceiptWithLogs(_txHash: string, _receipt: TxReceipt): void {
+    return;
+  }
+  get isEnabled(): boolean {
+    return false;
+  }
+}
+
+/** In-memory implementation for test mode that stores and serves debug logs. */
+export class InMemoryDebugLogStore implements DebugLogStore {
+  private map = new Map<string, DebugLog[]>();
+
+  storeLogs(txHash: string, logs: DebugLog[]): void {
+    if (logs.length > 0) {
+      this.map.set(txHash, logs);
+    }
+  }
+
+  decorateReceiptWithLogs(txHash: string, receipt: TxReceipt): void {
+    if (receipt.isMined()) {
+      const debugLogs = this.map.get(txHash);
+      if (debugLogs) {
+        receipt.debugLogs = debugLogs;
+      }
+    }
+  }
+
+  get isEnabled(): boolean {
+    return true;
+  }
+}

package/src/logs/extended_directional_app_tagging_secret.ts

@@ -0,0 +1,87 @@
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { type Fq, Fr } from '@aztec/foundation/curves/bn254';
+import type { Point } from '@aztec/foundation/curves/grumpkin';
+
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+import type { CompleteAddress } from '../contract/complete_address.js';
+import { computeAddressSecret, computePreaddress } from '../keys/derivation.js';
+
+/**
+ * Extended directional application tagging secret used for log tagging.
+ *
+ * "Extended" because it bundles the directional app tagging secret with the app (contract) address. This bundling was
+ * done because where this type is used we commonly need access to both the secret and the address.
+ *
+ * "Directional" because the derived secret is bound to the recipient address: A→B differs from B→A even with the same
+ * participants and app.
+ *
+ * Note: It's a bit unfortunate that this type resides in `stdlib` as the rest of the tagging functionality resides in
+ * `pxe/src/tagging`. We need to use this type in `PreTag` that in turn is used by other types in stdlib hence there
+ * doesn't seem to be a good way around this.
+ */
+export class ExtendedDirectionalAppTaggingSecret {
+  private constructor(
+    public readonly secret: Fr,
+    public readonly app: AztecAddress,
+  ) {}
+
+  /**
+   * Derives shared tagging secret and from that, the app address and recipient derives the directional app tagging
+   * secret.
+   *
+   * @param localAddress - The complete address of entity A in the shared tagging secret derivation scheme
+   * @param localIvsk - The incoming viewing secret key of entity A
+   * @param externalAddress - The address of entity B in the shared tagging secret derivation scheme
+   * @param app - Contract address to silo the secret to
+   * @param recipient - Recipient of the log. Defines the "direction of the secret".
+   * @returns The secret that can be used along with an index to compute a tag to be included in a log.
+   */
+  static async compute(
+    localAddress: CompleteAddress,
+    localIvsk: Fq,
+    externalAddress: AztecAddress,
+    app: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<ExtendedDirectionalAppTaggingSecret> {
+    const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
+    const appTaggingSecret = await poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
+    const directionalAppTaggingSecret = await poseidon2Hash([appTaggingSecret, recipient]);
+
+    return new ExtendedDirectionalAppTaggingSecret(directionalAppTaggingSecret, app);
+  }
+
+  toString(): string {
+    return `${this.secret.toString()}:${this.app.toString()}`;
+  }
+
+  static fromString(str: string): ExtendedDirectionalAppTaggingSecret {
+    const [secretStr, appStr] = str.split(':');
+    return new ExtendedDirectionalAppTaggingSecret(Fr.fromString(secretStr), AztecAddress.fromString(appStr));
+  }
+}
+
+// Returns shared tagging secret computed with Diffie-Hellman key exchange.
+async function computeSharedTaggingSecret(
+  localAddress: CompleteAddress,
+  localIvsk: Fq,
+  externalAddress: AztecAddress,
+): Promise<Point> {
+  const knownPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
+  // TODO: #8970 - Computation of address point from x coordinate might fail
+  const externalAddressPoint = await externalAddress.toAddressPoint();
+  // Given A (local complete address) -> B (external address) and h == preaddress
+  // Compute shared secret as S = (h_A + local_ivsk_A) * Addr_Point_B
+
+  // Beware! h_a + local_ivsk_a (also known as the address secret) can lead to an address point with a negative
+  // y-coordinate, since there's two possible candidates computeAddressSecret takes care of selecting the one that
+  // leads to a positive y-coordinate, which is the only valid address point
+  return Grumpkin.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, localIvsk));
+}
+
+export const ExtendedDirectionalAppTaggingSecretSchema = z.object({
+  secret: Fr.schema,
+  app: AztecAddress.schema,
+});

package/src/logs/index.ts

@@ -1,11 +1,18 @@
-export * from './log_with_tx_data.js';
-export * from './indexed_tagging_secret.js';
+export * from './extended_directional_app_tagging_secret.js';
+export * from './pre_tag.js';
+export * from './tagging_index_range.js';
 export * from './contract_class_log.js';
 export * from './public_log.js';
 export * from './private_log.js';
+export * from './pending_tagged_log.js';
 export * from './log_id.js';
 export * from './log_filter.js';
 export * from './extended_public_log.js';
 export * from './extended_contract_class_log.js';
-export * from './l1_payload/index.js';
+export * from './shared_secret_derivation.js';
 export * from './tx_scoped_l2_log.js';
+export * from './message_context.js';
+export * from './debug_log.js';
+export * from './debug_log_store.js';
+export * from './tag.js';
+export * from './siloed_tag.js';

package/src/logs/log_filter.ts

@@ -1,3 +1,5 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
 import { z } from 'zod';
 
 import type { AztecAddress } from '../aztec-address/index.js';
@@ -20,6 +22,8 @@ export type LogFilter = {
   afterLog?: LogId;
   /** The contract address to filter logs by. */
   contractAddress?: AztecAddress;
+  /** The tag (first field of the log) to filter logs by. */
+  tag?: Fr;
 };
 
 export const LogFilterSchema: ZodFor<LogFilter> = z.object({
@@ -28,4 +32,5 @@ export const LogFilterSchema: ZodFor<LogFilter> = z.object({
   toBlock: schemas.Integer.optional(),
   afterLog: LogId.schema.optional(),
   contractAddress: schemas.AztecAddress.optional(),
+  tag: schemas.Fr.optional(),
 });

package/src/logs/log_id.ts

@@ -1,22 +1,24 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
+import { BlockHash } from '../block/block_hash.js';
 import { schemas } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
 
 /** A globally unique log id. */
 export class LogId {
-  /**
-   * Parses a log id from a string.
-   * @param blockNumber - The block number.
-   * @param txIndex - The transaction index.
-   * @param logIndex - The log index.
-   */
   constructor(
     /** The block number the log was emitted in. */
-    public readonly blockNumber: number,
+    public readonly blockNumber: BlockNumber,
+    /** The hash of the block the log was emitted in. */
+    public readonly blockHash: BlockHash,
+    /** The hash of the transaction the log was emitted in. */
+    public readonly txHash: TxHash,
     /** The index of a tx in a block the log was emitted in. */
     public readonly txIndex: number,
     /** The index of a log the tx was emitted in. */
@@ -35,7 +37,9 @@ export class LogId {
 
   static random() {
     return new LogId(
-      Math.floor(Math.random() * 1000) + 1,
+      BlockNumber(Math.floor(Math.random() * 1000) + 1),
+      BlockHash.random(),
+      TxHash.random(),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -44,11 +48,16 @@ export class LogId {
   static get schema() {
     return z
       .object({
-        blockNumber: schemas.Integer,
+        blockNumber: BlockNumberSchema,
+        blockHash: BlockHash.schema,
+        txHash: TxHash.schema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
-      .transform(({ blockNumber, txIndex, logIndex }) => new LogId(blockNumber, txIndex, logIndex));
+      .transform(
+        ({ blockNumber, blockHash, txHash, txIndex, logIndex }) =>
+          new LogId(blockNumber, blockHash, txHash, txIndex, logIndex),
+      );
   }
 
   /**
@@ -58,6 +67,8 @@ export class LogId {
   public toBuffer(): Buffer {
     return Buffer.concat([
       toBufferBE(BigInt(this.blockNumber), 4),
+      this.blockHash.toBuffer(),
+      this.txHash.toBuffer(),
       toBufferBE(BigInt(this.txIndex), 4),
       toBufferBE(BigInt(this.logIndex), 4),
     ]);
@@ -71,11 +82,13 @@ export class LogId {
   static fromBuffer(buffer: Buffer | BufferReader): LogId {
     const reader = BufferReader.asReader(buffer);
 
-    const blockNumber = reader.readNumber();
+    const blockNumber = BlockNumber(reader.readNumber());
+    const blockHash = new BlockHash(reader.readObject(Fr));
+    const txHash = reader.readObject(TxHash);
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
-    return new LogId(blockNumber, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -83,7 +96,7 @@ export class LogId {
    * @returns A string representation of the log id.
    */
   public toString(): string {
-    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}`;
+    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}-${this.txHash.toString()}`;
   }
 
   /**
@@ -92,12 +105,14 @@ export class LogId {
    * @returns A log id.
    */
   static fromString(data: string): LogId {
-    const [rawBlockNumber, rawTxIndex, rawLogIndex] = data.split('-');
-    const blockNumber = Number(rawBlockNumber);
+    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash, rawTxHash] = data.split('-');
+    const blockNumber = BlockNumber(Number(rawBlockNumber));
+    const blockHash = BlockHash.fromString(rawBlockHash);
+    const txHash = TxHash.fromString(rawTxHash);
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 
-    return new LogId(blockNumber, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -105,6 +120,6 @@ export class LogId {
    * @returns A human readable representation of the log id.
    */
   public toHumanReadable(): string {
-    return `logId: (blockNumber: ${this.blockNumber}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
+    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txHash: ${this.txHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
   }
 }