@aztec/stdlib 0.0.1-commit.85d7d01 → 0.0.1-commit.8655d4a

package/src/block/checkpointed_l2_block.ts

@@ -1,70 +0,0 @@
-// Ignoring import issue to fix portable inferred type issue in zod schema
-import { CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { z } from 'zod';
-
-import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
-import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
-import { L2Block } from './l2_block.js';
-import { CommitteeAttestation } from './proposal/committee_attestation.js';
-
-/**
- * Encapsulates an L2 Block along with the checkpoint data associated with it.
- */
-export class CheckpointedL2Block {
-  constructor(
-    public checkpointNumber: CheckpointNumber,
-    public block: L2Block,
-    public l1: L1PublishedData,
-    public attestations: CommitteeAttestation[],
-  ) {}
-  static get schema() {
-    return z
-      .object({
-        checkpointNumber: CheckpointNumberSchema,
-        block: L2Block.schema,
-        l1: L1PublishedData.schema,
-        attestations: z.array(CommitteeAttestation.schema),
-      })
-      .transform(obj => CheckpointedL2Block.fromFields(obj));
-  }
-
-  static fromBuffer(bufferOrReader: Buffer | BufferReader): CheckpointedL2Block {
-    const reader = BufferReader.asReader(bufferOrReader);
-    const checkpointNumber = reader.readNumber();
-    const block = reader.readObject(L2Block);
-    const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
-    const l1Timestamp = reader.readBigInt();
-    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
-    return new CheckpointedL2Block(
-      CheckpointNumber(checkpointNumber),
-      block,
-      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
-      attestations,
-    );
-  }
-
-  static fromFields(fields: FieldsOf<CheckpointedL2Block>) {
-    return new CheckpointedL2Block(
-      CheckpointNumber(fields.checkpointNumber),
-      fields.block,
-      fields.l1,
-      fields.attestations,
-    );
-  }
-
-  public toBuffer(): Buffer {
-    return serializeToBuffer(
-      this.checkpointNumber,
-      this.block,
-      this.l1.blockNumber,
-      this.l1.blockHash,
-      this.l1.timestamp,
-      this.attestations.length,
-      this.attestations,
-    );
-  }
-}

package/src/contract/private_function_membership_proof.ts

@@ -1,167 +0,0 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
-import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
-
-import { type ContractArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
-import {
-  computeArtifactFunctionTree,
-  computeArtifactHash,
-  computeArtifactHashPreimage,
-  computeFunctionArtifactHash,
-  computeFunctionMetadataHash,
-  getArtifactMerkleTreeHasher,
-} from './artifact_hash.js';
-import { getContractClassPrivateFunctionFromArtifact } from './contract_class.js';
-import type {
-  ContractClassPublic,
-  ExecutablePrivateFunctionWithMembershipProof,
-  PrivateFunctionMembershipProof,
-} from './interfaces/index.js';
-import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './private_function.js';
-
-/**
- * Creates a membership proof for a private function in a contract class, to be verified via `isValidPrivateFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */
-export async function createPrivateFunctionMembershipProof(
-  selector: FunctionSelector,
-  artifact: ContractArtifact,
-): Promise<PrivateFunctionMembershipProof> {
-  const log = createLogger('circuits:function_membership_proof');
-
-  // Locate private function definition and artifact
-  const privateFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.PRIVATE);
-  const privateFunctionsFromArtifact = await Promise.all(
-    privateFunctions.map(getContractClassPrivateFunctionFromArtifact),
-  );
-  const privateFunction = privateFunctionsFromArtifact.find(fn => fn.selector.equals(selector));
-  const privateFunctionsAndSelectors = await Promise.all(
-    privateFunctions.map(async fn => ({
-      fn,
-      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
-    })),
-  );
-  const privateFunctionArtifact = privateFunctionsAndSelectors.find(fnAndSelector =>
-    selector.equals(fnAndSelector.selector),
-  )?.fn;
-  if (!privateFunction || !privateFunctionArtifact) {
-    throw new Error(`Private function with selector ${selector.toString()} not found`);
-  }
-
-  // Compute preimage for the artifact hash
-  const { utilityFunctionRoot: utilityFunctionsTreeRoot, metadataHash: artifactMetadataHash } =
-    await computeArtifactHashPreimage(artifact);
-
-  // We need two sibling paths because private function information is split across two trees:
-  // The "private function tree" captures the selectors and verification keys, and is used in the kernel circuit for verifying the proof generated by the app circuit.
-  const functionLeaf = await computePrivateFunctionLeaf(privateFunction);
-  const functionsTree = await computePrivateFunctionsTree(privateFunctionsFromArtifact);
-  const functionsTreeLeafIndex = functionsTree.getIndex(functionLeaf);
-  const functionsTreeSiblingPath = functionsTree.getSiblingPath(functionsTreeLeafIndex).map(Fr.fromBuffer);
-
-  // And the "artifact tree" captures function bytecode and metadata, and is used by the pxe to check that its executing the code it's supposed to be executing, but it never goes into circuits.
-  const functionMetadataHash = computeFunctionMetadataHash(privateFunctionArtifact);
-  const functionArtifactHash = await computeFunctionArtifactHash({ ...privateFunctionArtifact, functionMetadataHash });
-  const artifactTree = (await computeArtifactFunctionTree(artifact, FunctionType.PRIVATE))!;
-  const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
-  const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
-
-  log.debug(`Computed proof for private function with selector ${selector.toString()}`, {
-    functionArtifactHash,
-    functionMetadataHash,
-    functionLeaf: '0x' + functionLeaf.toString('hex'),
-    artifactMetadataHash,
-    privateFunctionsTreeRoot: '0x' + functionsTree.root.toString('hex'),
-    utilityFunctionsTreeRoot,
-    artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    privateFunctionTreeSiblingPath: functionsTreeSiblingPath.map(fr => fr.toString()).join(','),
-  });
-
-  return {
-    artifactTreeSiblingPath,
-    artifactTreeLeafIndex,
-    artifactMetadataHash,
-    functionMetadataHash,
-    utilityFunctionsTreeRoot,
-    privateFunctionTreeSiblingPath: functionsTreeSiblingPath,
-    privateFunctionTreeLeafIndex: functionsTreeLeafIndex,
-  };
-}
-
-/**
- * Verifies that a private function with a membership proof as emitted by the ClassRegistry contract is valid,
- * as defined in the protocol specs at contract-deployment/classes:
- *
- * ```
- * // Load contract class from local db
- * contract_class = db.get_contract_class(contract_class_id)
- *
- * // Compute function leaf and assert it belongs to the private functions tree
- * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__PRIVATE_FUNCTION_LEAF)
- * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
- * assert computed_private_function_tree_root == contract_class.private_functions_root
- *
- * // Compute artifact leaf and assert it belongs to the artifact
- * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_private_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path)
- * computed_artifact_hash = sha256(computed_artifact_private_function_tree_root, utility_functions_artifact_tree_root, artifact_metadata_hash)
- * assert computed_artifact_hash == contract_class.artifact_hash
- * ```
- * @param fn - Function to check membership proof for.
- * @param contractClass - In which contract class the function is expected to be.
- */
-export async function isValidPrivateFunctionMembershipProof(
-  fn: ExecutablePrivateFunctionWithMembershipProof,
-  contractClass: Pick<ContractClassPublic, 'privateFunctionsRoot' | 'artifactHash'>,
-) {
-  const log = createLogger('circuits:function_membership_proof');
-
-  // Check private function tree membership
-  const functionLeaf = await computePrivateFunctionLeaf(fn);
-  const rootBuffer = await computeRootFromSiblingPath(
-    functionLeaf,
-    fn.privateFunctionTreeSiblingPath.map(fr => fr.toBuffer()),
-    fn.privateFunctionTreeLeafIndex,
-    async (left, right) => (await poseidon2Hash([left, right])).toBuffer(),
-  );
-  const computedPrivateFunctionTreeRoot = Fr.fromBuffer(rootBuffer);
-  if (!contractClass.privateFunctionsRoot.equals(computedPrivateFunctionTreeRoot)) {
-    log.debug(`Private function tree root mismatch`, {
-      expectedPrivateFunctionTreeRoot: contractClass.privateFunctionsRoot,
-      computedPrivateFunctionTreeRoot: computedPrivateFunctionTreeRoot,
-      computedFunctionLeaf: '0x' + functionLeaf.toString('hex'),
-    });
-    return false;
-  }
-
-  // Check artifact hash
-  const functionArtifactHash = await computeFunctionArtifactHash(fn);
-  const computedArtifactPrivateFunctionTreeRootBuffer = await computeRootFromSiblingPath(
-    functionArtifactHash.toBuffer(),
-    fn.artifactTreeSiblingPath.map(fr => fr.toBuffer()),
-    fn.artifactTreeLeafIndex,
-    getArtifactMerkleTreeHasher(),
-  );
-  const computedArtifactPrivateFunctionTreeRoot = Fr.fromBuffer(computedArtifactPrivateFunctionTreeRootBuffer);
-  const computedArtifactHash = await computeArtifactHash({
-    privateFunctionRoot: computedArtifactPrivateFunctionTreeRoot,
-    utilityFunctionRoot: fn.utilityFunctionsTreeRoot,
-    metadataHash: fn.artifactMetadataHash,
-  });
-  if (!contractClass.artifactHash.equals(computedArtifactHash)) {
-    log.debug(`Artifact hash mismatch`, {
-      expected: contractClass.artifactHash,
-      computedArtifactHash,
-      computedFunctionArtifactHash: functionArtifactHash,
-      computedArtifactPrivateFunctionTreeRoot,
-      utilityFunctionRoot: fn.utilityFunctionsTreeRoot,
-      metadataHash: fn.artifactMetadataHash,
-      artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    });
-    return false;
-  }
-
-  return true;
-}

package/src/contract/utility_function_membership_proof.ts

@@ -1,118 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
-import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
-
-import { type ContractArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
-import {
-  computeArtifactFunctionTree,
-  computeArtifactHash,
-  computeArtifactHashPreimage,
-  computeFunctionArtifactHash,
-  computeFunctionMetadataHash,
-  getArtifactMerkleTreeHasher,
-} from './artifact_hash.js';
-import type {
-  ContractClassPublic,
-  UtilityFunctionMembershipProof,
-  UtilityFunctionWithMembershipProof,
-} from './interfaces/index.js';
-
-/**
- * Creates a membership proof for a utility  function in a contract class, to be verified via `isValidUtilityFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */
-export async function createUtilityFunctionMembershipProof(
-  selector: FunctionSelector,
-  artifact: ContractArtifact,
-): Promise<UtilityFunctionMembershipProof> {
-  const log = createLogger('circuits:function_membership_proof');
-
-  // Locate function artifact
-  const utilityFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UTILITY);
-  const utilityFunctionsAndSelectors = await Promise.all(
-    utilityFunctions.map(async fn => ({ fn, selector: await FunctionSelector.fromNameAndParameters(fn) })),
-  );
-  const fn = utilityFunctionsAndSelectors.find(fnAndSelector => selector.equals(fnAndSelector.selector))?.fn;
-  if (!fn) {
-    throw new Error(`Utility function with selector ${selector.toString()} not found`);
-  }
-  // Compute preimage for the artifact hash
-  const { privateFunctionRoot: privateFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } =
-    await computeArtifactHashPreimage(artifact);
-
-  // Compute the sibling path for the "artifact tree"
-  const functionMetadataHash = computeFunctionMetadataHash(fn);
-  const functionArtifactHash = await computeFunctionArtifactHash({ ...fn, functionMetadataHash });
-  const artifactTree = (await computeArtifactFunctionTree(artifact, FunctionType.UTILITY))!;
-  const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
-  const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
-
-  log.debug(`Computed proof for utility function with selector ${selector.toString()}`, {
-    functionArtifactHash,
-    functionMetadataHash,
-    artifactMetadataHash,
-    artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    privateFunctionsArtifactTreeRoot,
-  });
-
-  return {
-    artifactTreeSiblingPath,
-    artifactTreeLeafIndex,
-    artifactMetadataHash,
-    functionMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-  };
-}
-
-/**
- * Verifies that a utility  function with a membership proof as emitted by the ClassRegistry contract is valid,
- * as defined in the protocol specs at contract-deployment/classes:
- *
- * ```
- * // Load contract class from local db
- * contract_class = db.get_contract_class(contract_class_id)
- *
- * // Compute artifact leaf and assert it belongs to the artifact
- * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_utility_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path, artifact_function_tree_leaf_index)
- * computed_artifact_hash = sha256(private_functions_artifact_tree_root, computed_artifact_utility_function_tree_root, artifact_metadata_hash)
- * assert computed_artifact_hash == contract_class.artifact_hash
- * ```
- * @param fn - Function to check membership proof for.
- * @param contractClass - In which contract class the function is expected to be.
- */
-export async function isValidUtilityFunctionMembershipProof(
-  fn: UtilityFunctionWithMembershipProof,
-  contractClass: Pick<ContractClassPublic, 'artifactHash'>,
-) {
-  const log = createLogger('circuits:function_membership_proof');
-
-  const functionArtifactHash = await computeFunctionArtifactHash(fn);
-  const computedArtifactFunctionTreeRootBuffer = await computeRootFromSiblingPath(
-    functionArtifactHash.toBuffer(),
-    fn.artifactTreeSiblingPath.map(fr => fr.toBuffer()),
-    fn.artifactTreeLeafIndex,
-    getArtifactMerkleTreeHasher(),
-  );
-  const computedArtifactFunctionTreeRoot = Fr.fromBuffer(computedArtifactFunctionTreeRootBuffer);
-  const computedArtifactHash = await computeArtifactHash({
-    privateFunctionRoot: fn.privateFunctionsArtifactTreeRoot,
-    utilityFunctionRoot: computedArtifactFunctionTreeRoot,
-    metadataHash: fn.artifactMetadataHash,
-  });
-  if (!contractClass.artifactHash.equals(computedArtifactHash)) {
-    log.debug(`Artifact hash mismatch`, {
-      expected: contractClass.artifactHash,
-      computedArtifactHash,
-      computedFunctionArtifactHash: functionArtifactHash,
-      computedArtifactFunctionTreeRoot,
-      privateFunctionsArtifactTreeRoot: fn.privateFunctionsArtifactTreeRoot,
-      metadataHash: fn.artifactMetadataHash,
-      artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    });
-    return false;
-  }
-
-  return true;
-}

package/src/interfaces/get_logs_response.ts

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-
-import { ExtendedContractClassLog } from '../logs/extended_contract_class_log.js';
-import { ExtendedPublicLog } from '../logs/extended_public_log.js';
-import { zodFor } from '../schemas/index.js';
-
-/** Response for the getContractClassLogs archiver call. */
-export type GetContractClassLogsResponse = {
-  /** An array of ExtendedContractClassLog elements. */
-  logs: ExtendedContractClassLog[];
-  /** Indicates if a limit has been reached. */
-  maxLogsHit: boolean;
-};
-
-export const GetContractClassLogsResponseSchema = zodFor<GetContractClassLogsResponse>()(
-  z.object({
-    logs: z.array(ExtendedContractClassLog.schema),
-    maxLogsHit: z.boolean(),
-  }),
-);
-
-/** Response for the getPublicLogs archiver call. */
-export type GetPublicLogsResponse = {
-  /** An array of ExtendedPublicLog elements. */
-  logs: ExtendedPublicLog[];
-  /** Indicates if a limit has been reached. */
-  maxLogsHit: boolean;
-};
-
-export const GetPublicLogsResponseSchema = zodFor<GetPublicLogsResponse>()(
-  z.object({
-    logs: z.array(ExtendedPublicLog.schema),
-    maxLogsHit: z.boolean(),
-  }),
-);

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