@aztec/stdlib 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/src/block/published_l2_block.ts

@@ -1,65 +0,0 @@
-// Ignoring import issue to fix portable inferred type issue in zod schema
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { z } from 'zod';
-
-import { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
-import { L2Block } from './l2_block.js';
-import { CommitteeAttestation } from './proposal/committee_attestation.js';
-
-/**
- * @deprecated `PublishedCheckpoint` is what will be retrieved from L1.
- * L2 blocks do not need to link to L1PublishedData directly.
- * TODO: Create another type (AttestedL2Block?) for an L2 block and its attestations.
- */
-export class PublishedL2Block {
-  constructor(
-    public block: L2Block,
-    public l1: L1PublishedData,
-    public attestations: CommitteeAttestation[],
-  ) {}
-
-  static get schema() {
-    return z
-      .object({
-        block: L2Block.schema,
-        l1: L1PublishedData.schema,
-        attestations: z.array(CommitteeAttestation.schema),
-      })
-      .transform(obj => PublishedL2Block.fromFields(obj));
-  }
-
-  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedL2Block {
-    const reader = BufferReader.asReader(bufferOrReader);
-    const block = reader.readObject(L2Block);
-    const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
-    const l1Timestamp = reader.readBigInt();
-    const attestations = reader.readVector(CommitteeAttestation);
-    return new PublishedL2Block(block, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
-  }
-
-  static fromFields(fields: FieldsOf<PublishedL2Block>) {
-    return new PublishedL2Block(fields.block, fields.l1, fields.attestations);
-  }
-
-  public toBuffer(): Buffer {
-    return serializeToBuffer(
-      this.block,
-      this.l1.blockNumber,
-      this.l1.blockHash,
-      this.l1.timestamp,
-      this.attestations.length,
-      this.attestations,
-    );
-  }
-
-  public toPublishedCheckpoint() {
-    return new PublishedCheckpoint(this.block.toCheckpoint(), this.l1, this.attestations);
-  }
-
-  static fromPublishedCheckpoint(checkpoint: PublishedCheckpoint) {
-    return new PublishedL2Block(L2Block.fromCheckpoint(checkpoint.checkpoint), checkpoint.l1, checkpoint.attestations);
-  }
-}

package/src/contract/contract_class_metadata.ts

@@ -1,8 +0,0 @@
-import type { ContractArtifact } from '../abi/abi.js';
-import type { ContractClassWithId } from './interfaces/contract_class.js';
-
-export interface ContractClassMetadata {
-  contractClass?: ContractClassWithId | undefined;
-  isContractClassPubliclyRegistered: boolean;
-  artifact?: ContractArtifact | undefined;
-}

package/src/contract/contract_metadata.ts

@@ -1,7 +0,0 @@
-import type { ContractInstanceWithAddress } from './interfaces/contract_instance.js';
-
-export interface ContractMetadata {
-  contractInstance?: ContractInstanceWithAddress | undefined;
-  isContractInitialized: boolean;
-  isContractPublished: boolean;
-}

package/src/contract/private_function_membership_proof.ts

@@ -1,167 +0,0 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-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__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/fields';
-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/database-version/index.ts

@@ -1 +0,0 @@
-export * from './version_manager.js';

package/src/kernel/hints/key_validation_request_and_generator.ts

@@ -1,52 +0,0 @@
-import { KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { KeyValidationRequest } from './key_validation_request.js';
-
-/**
- * Request for validating keys used in the app and a generator.
- */
-export class KeyValidationRequestAndGenerator {
-  constructor(
-    /** The key validation request. */
-    public readonly request: KeyValidationRequest,
-    /**
-     * The generator index which can be used along with sk_m to derive the sk_app stored in the request.
-     * Note: This generator constrains that a correct key type gets validated in the kernel.
-     */
-    public readonly skAppGenerator: Fr,
-  ) {}
-
-  toBuffer() {
-    return serializeToBuffer(this.request, this.skAppGenerator);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new KeyValidationRequestAndGenerator(reader.readObject(KeyValidationRequest), Fr.fromBuffer(reader));
-  }
-
-  toFields(): Fr[] {
-    const fields = [...this.request.toFields(), this.skAppGenerator];
-    if (fields.length !== KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH) {
-      throw new Error(
-        `Invalid number of fields for KeyValidationRequestAndGenerator. Expected ${KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH}, got ${fields.length}`,
-      );
-    }
-    return fields;
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): KeyValidationRequestAndGenerator {
-    const reader = FieldReader.asReader(fields);
-    return new KeyValidationRequestAndGenerator(KeyValidationRequest.fromFields(reader), reader.readField());
-  }
-
-  isEmpty() {
-    return this.request.isEmpty() && this.skAppGenerator.isZero();
-  }
-
-  static empty() {
-    return new KeyValidationRequestAndGenerator(KeyValidationRequest.empty(), Fr.ZERO);
-  }
-}

package/src/l1-contracts/slash_factory.ts

@@ -1,177 +0,0 @@
-import { type L1TxRequest, type ViemClient, tryExtractEvent } from '@aztec/ethereum';
-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,
-      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/log_with_tx_data.ts

@@ -1,46 +0,0 @@
-import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { TxHash } from '@aztec/stdlib/tx';
-
-// This is used as a response for PXE's custom getPublicLogByTag oracle.
-export class PublicLogWithTxData {
-  constructor(
-    public logPayload: Fr[],
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-  ) {}
-}
-
-// This is used as a response for PXE's custom getPrivateLogByTag oracle.
-export class PrivateLogWithTxData {
-  constructor(
-    public logPayload: Fr[],
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-  ) {}
-
-  toNoirSerialization(): (Fr | Fr[])[] {
-    return [
-      ...toBoundedVecSerialization(this.logPayload, PRIVATE_LOG_CIPHERTEXT_LEN),
-      this.txHash.hash,
-      ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
-      this.firstNullifierInTx,
-    ];
-  }
-
-  static noirSerializationOfEmpty(): (Fr | Fr[])[] {
-    return new PrivateLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
-  }
-}
-
-function toBoundedVecSerialization(array: Fr[], maxLength: number) {
-  if (array.length > maxLength) {
-    throw new Error(
-      `An array of length ${array.length} cannot be converted to a BoundedVec of max length ${maxLength}`,
-    );
-  }
-
-  return [array.concat(Array(maxLength - array.length).fill(new Fr(0))), new Fr(array.length)];
-}