@aztec/stdlib 0.0.1-commit.b6e433891 → 0.0.1-commit.b8a057fa

package/src/avm/public_data_update_request.ts

@@ -1,106 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { inspect } from 'util';
-
-import type { AztecAddress } from '../aztec-address/index.js';
-import { computePublicDataTreeLeafSlot } from '../hash/hash.js';
-import type { ContractStorageUpdateRequest } from './contract_storage_update_request.js';
-
-// TO BE REMOVED.
-/**
- * Write operations on the public data tree including the previous value.
- */
-export class PublicDataUpdateRequest {
-  constructor(
-    /**
-     * Index of the leaf in the public data tree which is to be updated.
-     */
-    public readonly leafSlot: Fr,
-    /**
-     * New value of the leaf.
-     */
-    public readonly newValue: Fr,
-    /**
-     * Side effect counter tracking position of this event in tx execution.
-     */
-    public readonly sideEffectCounter: number,
-  ) {}
-
-  static from(args: {
-    /**
-     * Index of the leaf in the public data tree which is to be updated.
-     */
-    leafIndex: Fr;
-    /**
-     * New value of the leaf.
-     */
-    newValue: Fr;
-
-    /**
-     * Side effect counter tracking position of this event in tx execution.
-     */
-    sideEffectCounter: number;
-  }) {
-    return new PublicDataUpdateRequest(args.leafIndex, args.newValue, args.sideEffectCounter);
-  }
-
-  get counter() {
-    return this.sideEffectCounter;
-  }
-
-  get position() {
-    return this.leafSlot;
-  }
-
-  toBuffer() {
-    return serializeToBuffer(this.leafSlot, this.newValue, this.sideEffectCounter);
-  }
-
-  isEmpty() {
-    return this.leafSlot.isZero() && this.newValue.isZero();
-  }
-
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new PublicDataUpdateRequest(reader.readField(), reader.readField(), reader.readU32());
-  }
-
-  static isEmpty(x: PublicDataUpdateRequest) {
-    return x.isEmpty();
-  }
-
-  equals(other: PublicDataUpdateRequest) {
-    return this.leafSlot.equals(other.leafSlot) && this.newValue.equals(other.newValue);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new PublicDataUpdateRequest(Fr.fromBuffer(reader), Fr.fromBuffer(reader), reader.readNumber());
-  }
-
-  static async fromContractStorageUpdateRequest(
-    contractAddress: AztecAddress,
-    updateRequest: ContractStorageUpdateRequest,
-  ) {
-    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, updateRequest.storageSlot);
-
-    return new PublicDataUpdateRequest(leafSlot, updateRequest.newValue, updateRequest.counter);
-  }
-
-  static empty() {
-    return new PublicDataUpdateRequest(Fr.ZERO, Fr.ZERO, 0);
-  }
-
-  toFriendlyJSON() {
-    return `Leaf=${this.leafSlot.toFriendlyJSON()}: ${this.newValue.toFriendlyJSON()}, SideEffectCounter=${
-      this.sideEffectCounter
-    }`;
-  }
-
-  [inspect.custom]() {
-    return `PublicDataUpdateRequest { leafSlot: ${this.leafSlot.toFriendlyJSON()}, newValue: ${this.newValue.toFriendlyJSON()}, sideEffectCounter: ${
-      this.sideEffectCounter
-    } }`;
-  }
-}

package/src/avm/public_inner_call_request.ts

@@ -1,85 +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';
-
-import { inspect } from 'util';
-
-import { PublicCallStackItemCompressed } from './public_call_stack_item_compressed.js';
-
-// TO BE REMOVED
-/**
- * Represents a request to call a public function.
- */
-export class PublicInnerCallRequest {
-  constructor(
-    public item: PublicCallStackItemCompressed,
-    /**
-     * The counter for this call request.
-     */
-    public counter: number,
-  ) {}
-
-  getSize() {
-    return this.isEmpty() ? 0 : this.toBuffer().length;
-  }
-
-  /**
-   * Serialize this as a buffer.
-   * @returns The buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(this.item, this.counter);
-  }
-
-  /**
-   * Deserialize this from a buffer.
-   * @param buffer - The bufferable type from which to deserialize.
-   * @returns The deserialized instance of PublicInnerCallRequest.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new PublicInnerCallRequest(PublicCallStackItemCompressed.fromBuffer(reader), reader.readNumber());
-  }
-
-  /**
-   * Create PublicInnerCallRequest from a fields dictionary.
-   * @param fields - The dictionary.
-   * @returns A PublicInnerCallRequest object.
-   */
-  static from(fields: FieldsOf<PublicInnerCallRequest>): PublicInnerCallRequest {
-    return new PublicInnerCallRequest(...PublicInnerCallRequest.getFields(fields));
-  }
-
-  /**
-   * Serialize into a field array. Low-level utility.
-   * @param fields - Object with fields.
-   * @returns The array.
-   */
-  static getFields(fields: FieldsOf<PublicInnerCallRequest>) {
-    return [fields.item, fields.counter] as const;
-  }
-
-  toFields(): Fr[] {
-    return serializeToFields([this.item, this.counter]);
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): PublicInnerCallRequest {
-    const reader = FieldReader.asReader(fields);
-    return new PublicInnerCallRequest(PublicCallStackItemCompressed.fromFields(reader), reader.readU32());
-  }
-
-  static empty() {
-    return new PublicInnerCallRequest(PublicCallStackItemCompressed.empty(), 0);
-  }
-
-  isEmpty(): boolean {
-    return this.item.isEmpty() && this.counter == 0;
-  }
-
-  [inspect.custom]() {
-    return `PublicInnerCallRequest {
-      item: ${this.item.toFields()}
-      counter: ${this.counter}
-    }`;
-  }
-}

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/config/pipelining-config.ts

@@ -1,31 +0,0 @@
-import { type ConfigMappingsType, booleanConfigHelper, getConfigFromMappings } from '@aztec/foundation/config';
-
-import { z } from 'zod';
-
-import { zodFor } from '../schemas/index.js';
-
-export type PipelineConfig = {
-  /** Whether to enable build-ahead proposer pipelining. */
-  enableProposerPipelining: boolean;
-};
-
-/**
- * Pipelining config mappings for fields that need to be shared across packages.
- */
-export const pipelineConfigMappings: ConfigMappingsType<PipelineConfig> = {
-  enableProposerPipelining: {
-    env: 'SEQ_ENABLE_PROPOSER_PIPELINING',
-    description: 'Whether to enable build-ahead proposer pipelining.',
-    ...booleanConfigHelper(false),
-  },
-};
-
-export const PipelineConfigSchema = zodFor<PipelineConfig>()(
-  z.object({
-    enableProposerPipelining: z.boolean(),
-  }),
-);
-
-export function getPipelineConfigEnvVars(): PipelineConfig {
-  return getConfigFromMappings(pipelineConfigMappings);
-}

package/src/contract/deployment_info.ts

@@ -1,25 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-
-import type { CompleteAddress } from './complete_address.js';
-
-/**
- * Represents the data generated as part of contract deployment.
- */
-export type DeploymentInfo = {
-  /**
-   * The complete address of the deployed contract.
-   */
-  completeAddress: CompleteAddress;
-  /**
-   * The contract's constructor verification key hash.
-   */
-  constructorVkHash: Fr;
-  /**
-   * The contract's constructor hash.
-   */
-  constructorHash: Fr;
-  /**
-   * The root of the contract's function tree.
-   */
-  functionTreeRoot: Fr;
-};

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/epoch-prover.ts

@@ -1,72 +0,0 @@
-import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
-import type { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-
-import type { Proof } from '../proofs/proof.js';
-import type { CheckpointConstantData } from '../rollup/checkpoint_constant_data.js';
-import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
-import type { BlockHeader } from '../tx/block_header.js';
-import type { Tx } from '../tx/tx.js';
-import type { UInt64 } from '../types/index.js';
-import type { IBlockFactory } from './block-builder.js';
-
-/** Coordinates the proving of an entire epoch. */
-export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted' | 'startNewBlock'> {
-  /**
-   * Starts a new epoch. Must be the first method to be called.
-   * @param epochNumber - The epoch number.
-   * @param totalNumCheckpoints - The total number of checkpoints expected in the epoch (must be at least one).
-   * @param finalBlobBatchingChallenges - The final blob batching challenges for the epoch.
-   **/
-  startNewEpoch(
-    epochNumber: EpochNumber,
-    totalNumCheckpoints: number,
-    finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
-  ): void;
-
-  /**
-   * Starts a new checkpoint.
-   * @param checkpointIndex - The index of the checkpoint in the epoch.
-   * @param constants - The constants for this checkpoint.
-   * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this checkpoint.
-   * @param totalNumBlocks - The total number of blocks expected in the checkpoint (must be at least one).
-   * @param headerOfLastBlockInPreviousCheckpoint - The header of the last block in the previous checkpoint.
-   */
-  startNewCheckpoint(
-    checkpointIndex: number,
-    constants: CheckpointConstantData,
-    l1ToL2Messages: Fr[],
-    totalNumBlocks: number,
-    headerOfLastBlockInPreviousCheckpoint: BlockHeader,
-  ): Promise<void>;
-
-  /**
-   * Starts a new block.
-   * @param blockNumber - The block number.
-   * @param timestamp - The timestamp of the block.
-   * @param totalNumTxs - The total number of txs in the block.
-   */
-  startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number): Promise<void>;
-
-  /**
-   * Kickstarts chonk verifier circuits for the specified txs. These will be used during epoch proving.
-   * Note that if the chonk verifier circuits are not started this way, they will be started nonetheless after processing.
-   */
-  startChonkVerifierCircuits(txs: Tx[]): Promise<void>;
-
-  /** Returns the block. */
-  setBlockCompleted(blockNumber: BlockNumber, expectedBlockHeader?: BlockHeader): Promise<BlockHeader>;
-
-  /** Pads the epoch with empty block roots if needed and blocks until proven. Throws if proving has failed. */
-  finalizeEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof; batchedBlobInputs: BatchedBlob }>;
-
-  /** Cancels all proving jobs. */
-  cancel(): void;
-
-  /** Returns an identifier for the prover or zero if not set. */
-  getProverId(): EthAddress;
-
-  /** Called when no longer required, cleans up internal resources */
-  stop(): Promise<void>;
-}