@aztec/stdlib 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/interfaces/prover-coordination.ts

@@ -1,17 +0,0 @@
-import { Tx } from '../tx/tx.js';
-import { TxHash } from '../tx/tx_hash.js';
-import type { P2PClient } from './p2p.js';
-
-/** Provides basic operations for ProverNodes to interact with other nodes in the network. */
-export interface ProverCoordination {
-  /**
-   * Returns a set of transactions given their hashes if available.
-   * @param txHashes - The hashes of the transactions, used as an ID.
-   * @returns The transactions found, no necessarily in the same order as the hashes.
-   */
-  getTxsByHash(txHashes: TxHash[]): Promise<Tx[]>;
-
-  gatherTxs(txHashes: TxHash[]): Promise<void>;
-
-  getP2PClient(): P2PClient | undefined;
-}

package/src/kernel/hints/tree_leaf_read_request.ts

@@ -1,35 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-export class TreeLeafReadRequest {
-  constructor(
-    public value: Fr,
-    public leafIndex: Fr,
-  ) {}
-
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.value, this.leafIndex);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new TreeLeafReadRequest(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
-  }
-
-  toFields(): Fr[] {
-    return [this.value, this.leafIndex];
-  }
-
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new TreeLeafReadRequest(reader.readField(), reader.readField());
-  }
-
-  isEmpty() {
-    return this.value.isZero() && this.leafIndex.isZero();
-  }
-
-  static empty() {
-    return new TreeLeafReadRequest(Fr.zero(), Fr.zero());
-  }
-}

package/src/kernel/private_kernel_tail_circuit_private_inputs.ts

@@ -1,58 +0,0 @@
-import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import type { UInt64 } from '../types/shared.js';
-import { PaddedSideEffectAmounts } from './padded_side_effects.js';
-import { PrivateKernelData } from './private_kernel_data.js';
-
-/**
- * Input to the private kernel circuit - tail call.
- */
-export class PrivateKernelTailCircuitPrivateInputs {
-  constructor(
-    /**
-     * The previous kernel data
-     */
-    public previousKernel: PrivateKernelData,
-    /**
-     * The number of the padded side effects.
-     */
-    public paddedSideEffectAmounts: PaddedSideEffectAmounts,
-    /**
-     * The timestamp by which the transaction must be included in a block.
-     */
-    public expirationTimestampUpperBound: UInt64,
-  ) {}
-
-  isForPublic() {
-    return (
-      this.previousKernel.publicInputs.end.publicCallRequests.claimedLength > 0 ||
-      !this.previousKernel.publicInputs.publicTeardownCallRequest.isEmpty()
-    );
-  }
-
-  /**
-   * Serialize this as a buffer.
-   * @returns The buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(
-      this.previousKernel,
-      this.paddedSideEffectAmounts,
-      bigintToUInt64BE(this.expirationTimestampUpperBound),
-    );
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelTailCircuitPrivateInputs {
-    const reader = BufferReader.asReader(buffer);
-    return new PrivateKernelTailCircuitPrivateInputs(
-      reader.readObject(PrivateKernelData),
-      reader.readObject(PaddedSideEffectAmounts),
-      reader.readUInt64(),
-    );
-  }
-}

package/src/kernel/utils/optional_number.ts

@@ -1,50 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-export class OptionalNumber {
-  constructor(
-    /**
-     * Whether a value was set.
-     */
-    public isSome: boolean,
-    /**
-     * The actual number, if isSome is true.
-     */
-    public value: number,
-  ) {}
-
-  getSize() {
-    return this.toBuffer().length;
-  }
-
-  static getFields(fields: FieldsOf<OptionalNumber>) {
-    return [fields.isSome, fields.value] as const;
-  }
-
-  toBuffer() {
-    return serializeToBuffer(...OptionalNumber.getFields(this));
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): OptionalNumber {
-    const reader = BufferReader.asReader(buffer);
-    return new OptionalNumber(reader.readBoolean(), reader.readNumber());
-  }
-
-  toFields(): Fr[] {
-    return serializeToFields(...OptionalNumber.getFields(this));
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): OptionalNumber {
-    const reader = FieldReader.asReader(fields);
-    return new OptionalNumber(reader.readBoolean(), reader.readU32());
-  }
-
-  isEmpty(): boolean {
-    return !this.isSome && !this.value;
-  }
-
-  static empty() {
-    return new OptionalNumber(false, 0);
-  }
-}

package/src/l1-contracts/slash_factory.ts

@@ -1,180 +0,0 @@
-import type { L1TxRequest } from '@aztec/ethereum/l1-tx-utils';
-import type { ViemClient } from '@aztec/ethereum/types';
-import { tryExtractEvent } from '@aztec/ethereum/utils';
-import { maxBigint } from '@aztec/foundation/bigint';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-import { SlashFactoryAbi } from '@aztec/l1-artifacts/SlashFactoryAbi';
-
-import { type GetContractReturnType, type Hex, type Log, encodeFunctionData, getContract } from 'viem';
-
-import type { L1RollupConstants } from '../epoch-helpers/index.js';
-import {
-  OffenseToBigInt,
-  type SlashPayload,
-  type ValidatorSlash,
-  type ValidatorSlashOffense,
-  bigIntToOffense,
-} from '../slashing/index.js';
-
-export class SlashFactoryContract {
-  private readonly logger = createLogger('contracts:slash_factory');
-  private readonly contract: GetContractReturnType<typeof SlashFactoryAbi, ViemClient>;
-
-  constructor(
-    public readonly client: ViemClient,
-    address: Hex | EthAddress,
-  ) {
-    this.contract = getContract({
-      address: typeof address === 'string' ? address : address.toString(),
-      abi: SlashFactoryAbi,
-      client,
-    });
-  }
-
-  public get address() {
-    return EthAddress.fromString(this.contract.address);
-  }
-
-  public buildCreatePayloadRequest(slashes: ValidatorSlash[]): L1TxRequest {
-    const sorted = this.sortSlashes(slashes);
-
-    return {
-      to: this.contract.address,
-      abi: SlashFactoryAbi,
-      data: encodeFunctionData({
-        abi: SlashFactoryAbi,
-        functionName: 'createSlashPayload',
-        args: [
-          sorted.map(d => d.validator.toString()),
-          sorted.map(d => d.amount),
-          sorted.map(d => d.offenses.map(packValidatorSlashOffense)),
-        ],
-      }),
-    };
-  }
-
-  /** Tries to extract a SlashPayloadCreated event from the given logs. */
-  public tryExtractSlashPayloadCreatedEvent(logs: Log[]) {
-    return tryExtractEvent(logs, this.address.toString(), SlashFactoryAbi, 'SlashPayloadCreated');
-  }
-
-  public async getSlashPayloadCreatedEvents(): Promise<SlashPayload[]> {
-    const events = await this.contract.getEvents.SlashPayloadCreated();
-    return Promise.all(
-      events.map(async event => {
-        const { validators, amounts, offenses } = event.args;
-        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
-          validator: EthAddress.fromString(validator),
-          amount: amounts![i],
-          offenses: offenses![i].map(unpackValidatorSlashOffense),
-        }));
-
-        const block = await this.client.getBlock({ blockNumber: event.blockNumber, includeTransactions: false });
-        return { address: EthAddress.fromString(event.args.payloadAddress!), slashes, timestamp: block.timestamp };
-      }),
-    );
-  }
-
-  /**
-   * Searches for a slash payload in the events emitted by the contract.
-   * This method cannot query for historical payload events, it queries for payloads that have not yet expired.
-   * @param payloadAddress The address of the payload to search for.
-   * @param constants The L1 rollup constants needed for time calculations.
-   */
-  public async getSlashPayloadFromEvents(
-    payloadAddress: EthAddress,
-    settings: {
-      logsBatchSize?: number;
-      slashingRoundSize: number;
-      slashingPayloadLifetimeInRounds: number;
-    } & Pick<L1RollupConstants, 'slotDuration' | 'ethereumSlotDuration'>,
-  ): Promise<Omit<SlashPayload, 'votes'> | undefined> {
-    // We query for the log where the payload was emitted walking backwards until we go past payload expiration time
-    // Note that all log queries require a block range, and RPC providers cap the max range (eg quicknode is 10k blocks).
-    const { slashingRoundSize, slashingPayloadLifetimeInRounds, slotDuration, ethereumSlotDuration } = settings;
-    const currentBlockNumber = await this.client.getBlockNumber({ cacheTime: 0 });
-
-    // Why the +1 below? Just for good measure. Better err on the safe side.
-    const earliestBlockNumber = maxBigint(
-      0n,
-      currentBlockNumber -
-        ((BigInt(slashingPayloadLifetimeInRounds) + 1n) * BigInt(slashingRoundSize) * BigInt(slotDuration)) /
-          BigInt(ethereumSlotDuration),
-    );
-
-    this.logger.trace(
-      `Starting search for slash payload ${payloadAddress} from block ${currentBlockNumber} with earliest block ${earliestBlockNumber}`,
-    );
-    const batchSize = BigInt(settings.logsBatchSize ?? 10000);
-    let toBlock = currentBlockNumber;
-
-    do {
-      const fromBlock = maxBigint(earliestBlockNumber, toBlock - batchSize);
-      this.logger.trace(`Searching for slash payload ${payloadAddress} in blocks ${fromBlock} to ${toBlock}`);
-      const logs = await this.contract.getEvents.SlashPayloadCreated(
-        { payloadAddress: payloadAddress.toString() },
-        { fromBlock, toBlock, strict: true },
-      );
-
-      // We found the payload, return it
-      if (logs.length > 0) {
-        const log = logs[0];
-        const { validators, amounts, offenses } = log.args;
-
-        // Convert the data to our internal types
-        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
-          validator: EthAddress.fromString(validator),
-          amount: amounts![i],
-          offenses: offenses![i].map(unpackValidatorSlashOffense),
-        }));
-
-        // Get the timestamp from the block
-        const block = await this.client.getBlock({ blockNumber: log.blockNumber, includeTransactions: false });
-
-        return { address: payloadAddress, slashes, timestamp: block.timestamp };
-      }
-
-      // If not found, we go back one batch
-      toBlock -= batchSize;
-    } while (toBlock > earliestBlockNumber);
-
-    return undefined;
-  }
-
-  public async getAddressAndIsDeployed(
-    slashes: ValidatorSlash[],
-  ): Promise<{ address: EthAddress; salt: Hex; isDeployed: boolean }> {
-    const sortedSlashes = this.sortSlashes(slashes);
-    const [address, salt, isDeployed] = await this.contract.read.getAddressAndIsDeployed([
-      sortedSlashes.map(s => s.validator.toString()),
-      sortedSlashes.map(s => s.amount),
-      sortedSlashes.map(s => s.offenses.map(packValidatorSlashOffense)),
-    ]);
-    return { address: EthAddress.fromString(address), salt, isDeployed };
-  }
-
-  private sortSlashes(slashes: ValidatorSlash[]): ValidatorSlash[] {
-    const offenseSorter = (a: ValidatorSlashOffense, b: ValidatorSlashOffense) => {
-      return a.epochOrSlot === b.epochOrSlot ? a.offenseType - b.offenseType : Number(a.epochOrSlot - b.epochOrSlot);
-    };
-    return [...slashes]
-      .map(slash => ({ ...slash, offenses: [...slash.offenses].sort(offenseSorter) }))
-      .sort((a, b) => a.validator.toString().localeCompare(b.validator.toString()));
-  }
-}
-
-export function packValidatorSlashOffense(offense: ValidatorSlashOffense): bigint {
-  const offenseId = OffenseToBigInt[offense.offenseType];
-  if (offenseId > (1 << 8) - 1) {
-    throw new Error(`Offense type ${offense.offenseType} cannot be packed into 8 bits`);
-  }
-  return (offenseId << 120n) + offense.epochOrSlot;
-}
-
-export function unpackValidatorSlashOffense(packed: bigint): ValidatorSlashOffense {
-  const offenseId = (packed >> 120n) & 0xffn;
-  const epochOrSlot = packed & ((1n << 120n) - 1n);
-  const offenseType = bigIntToOffense(offenseId);
-  return { epochOrSlot, offenseType };
-}

package/src/logs/extended_contract_class_log.ts

@@ -1,87 +0,0 @@
-import type { ZodFor } from '@aztec/foundation/schemas';
-import { BufferReader } from '@aztec/foundation/serialize';
-import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import isEqual from 'lodash.isequal';
-import { z } from 'zod';
-
-import { ContractClassLog } from './contract_class_log.js';
-import { LogId } from './log_id.js';
-
-/**
- * Represents an individual contract class log entry extended with info about the block and tx it was emitted in.
- */
-export class ExtendedContractClassLog {
-  constructor(
-    /** Globally unique id of the log. */
-    public readonly id: LogId,
-    /** The data contents of the log. */
-    public readonly log: ContractClassLog,
-  ) {}
-
-  static async random() {
-    return new ExtendedContractClassLog(LogId.random(), await ContractClassLog.random());
-  }
-
-  static get schema(): ZodFor<ExtendedContractClassLog> {
-    return z
-      .object({
-        id: LogId.schema,
-        log: ContractClassLog.schema,
-      })
-      .transform(ExtendedContractClassLog.from);
-  }
-
-  static from(fields: FieldsOf<ExtendedContractClassLog>) {
-    return new ExtendedContractClassLog(fields.id, fields.log);
-  }
-
-  /**
-   * Serializes log to a buffer.
-   * @returns A buffer containing the serialized log.
-   */
-  public toBuffer(): Buffer {
-    return Buffer.concat([this.id.toBuffer(), this.log.toBuffer()]);
-  }
-
-  /**
-   * Serializes log to a string.
-   * @returns A string containing the serialized log.
-   */
-  public toString(): string {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * Checks if two ExtendedContractClassLog objects are equal.
-   * @param other - Another ExtendedContractClassLog object to compare with.
-   * @returns True if the two objects are equal, false otherwise.
-   */
-  public equals(other: ExtendedContractClassLog): boolean {
-    return isEqual(this, other);
-  }
-
-  /**
-   * Deserializes log from a buffer.
-   * @param buffer - The buffer or buffer reader containing the log.
-   * @returns Deserialized instance of `Log`.
-   */
-  public static fromBuffer(buffer: Buffer | BufferReader): ExtendedContractClassLog {
-    const reader = BufferReader.asReader(buffer);
-
-    const logId = LogId.fromBuffer(reader);
-    const log = ContractClassLog.fromBuffer(reader);
-
-    return new ExtendedContractClassLog(logId, log);
-  }
-
-  /**
-   * Deserializes `ExtendedContractClassLog` object from a hex string representation.
-   * @param data - A hex string representation of the log.
-   * @returns An `ExtendedContractClassLog` object.
-   */
-  public static fromString(data: string): ExtendedContractClassLog {
-    return ExtendedContractClassLog.fromBuffer(hexToBuffer(data));
-  }
-}

package/src/logs/extended_directional_app_tagging_secret.ts

@@ -1,98 +0,0 @@
-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 {
-  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. Returns undefined if `externalAddress` is an invalid address.
-   *
-   * @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 | undefined> {
-    const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
-    if (!taggingSecretPoint) {
-      return undefined;
-    }
-
-    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, or undefined if `externalAddress` is an
-// invalid address.
-async function computeSharedTaggingSecret(
-  localAddress: CompleteAddress,
-  localIvsk: Fq,
-  externalAddress: AztecAddress,
-): Promise<Point | undefined> {
-  // Given A (local complete address) -> B (external address) and h == preaddress
-  // Compute shared secret as S = (h_A + local_ivsk_A) * Addr_Point_B
-
-  const knownPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
-
-  // An invalid address has no corresponding address point
-  if (!(await externalAddress.isValid())) {
-    return undefined;
-  }
-
-  const externalAddressPoint = await externalAddress.toAddressPoint();
-
-  // 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/extended_public_log.ts

@@ -1,94 +0,0 @@
-import { BufferReader } from '@aztec/foundation/serialize';
-import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import isEqual from 'lodash.isequal';
-import { z } from 'zod';
-
-import { LogId } from './log_id.js';
-import { PublicLog } from './public_log.js';
-
-/**
- * Represents an individual public log entry extended with info about the block and tx it was emitted in.
- */
-export class ExtendedPublicLog {
-  constructor(
-    /** Globally unique id of the log. */
-    public readonly id: LogId,
-    /** The data contents of the log. */
-    public readonly log: PublicLog,
-  ) {}
-
-  static async random() {
-    return new ExtendedPublicLog(LogId.random(), await PublicLog.random());
-  }
-
-  static get schema() {
-    return z
-      .object({
-        id: LogId.schema,
-        log: PublicLog.schema,
-      })
-      .transform(ExtendedPublicLog.from);
-  }
-
-  static from(fields: FieldsOf<ExtendedPublicLog>) {
-    return new ExtendedPublicLog(fields.id, fields.log);
-  }
-
-  /**
-   * Serializes log to a buffer.
-   * @returns A buffer containing the serialized log.
-   */
-  public toBuffer(): Buffer {
-    return Buffer.concat([this.id.toBuffer(), this.log.toBuffer()]);
-  }
-
-  /**
-   * Serializes log to a string.
-   * @returns A string containing the serialized log.
-   */
-  public toString(): string {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * Serializes log to a human readable string.
-   * @returns A human readable representation of the log.
-   */
-  public toHumanReadable(): string {
-    return `${this.id.toHumanReadable()}, ${this.log.toHumanReadable()}`;
-  }
-
-  /**
-   * Checks if two ExtendedPublicLog objects are equal.
-   * @param other - Another ExtendedPublicLog object to compare with.
-   * @returns True if the two objects are equal, false otherwise.
-   */
-  public equals(other: ExtendedPublicLog): boolean {
-    return isEqual(this, other);
-  }
-
-  /**
-   * Deserializes log from a buffer.
-   * @param buffer - The buffer or buffer reader containing the log.
-   * @returns Deserialized instance of `Log`.
-   */
-  public static fromBuffer(buffer: Buffer | BufferReader): ExtendedPublicLog {
-    const reader = BufferReader.asReader(buffer);
-
-    const logId = LogId.fromBuffer(reader);
-    const log = PublicLog.fromBuffer(reader);
-
-    return new ExtendedPublicLog(logId, log);
-  }
-
-  /**
-   * Deserializes `ExtendedPublicLog` object from a hex string representation.
-   * @param data - A hex string representation of the log.
-   * @returns An `ExtendedPublicLog` object.
-   */
-  public static fromString(data: string): ExtendedPublicLog {
-    return ExtendedPublicLog.fromBuffer(hexToBuffer(data));
-  }
-}

package/src/logs/log_filter.ts

@@ -1,36 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-
-import { z } from 'zod';
-
-import type { AztecAddress } from '../aztec-address/index.js';
-import { type ZodFor, schemas } from '../schemas/index.js';
-import { TxHash } from '../tx/tx_hash.js';
-import { LogId } from './log_id.js';
-
-/**
- * Log filter used to fetch L2 logs.
- * @remarks This filter is applied as an intersection of all it's params.
- */
-export type LogFilter = {
-  /** Hash of a transaction from which to fetch the logs. */
-  txHash?: TxHash;
-  /** The block number from which to start fetching logs (inclusive). */
-  fromBlock?: number;
-  /** The block number until which to fetch logs (not inclusive). */
-  toBlock?: number;
-  /** Log id after which to start fetching logs. */
-  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({
-  txHash: TxHash.schema.optional(),
-  fromBlock: schemas.Integer.optional(),
-  toBlock: schemas.Integer.optional(),
-  afterLog: LogId.schema.optional(),
-  contractAddress: schemas.AztecAddress.optional(),
-  tag: schemas.Fr.optional(),
-});