@aztec/stdlib 0.0.0-test.0

package/src/block/l2_block_source.ts

@@ -0,0 +1,160 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import type { EventEmitter } from 'events';
+import { z } from 'zod';
+
+import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import type { BlockHeader } from '../tx/block_header.js';
+import type { TxEffect } from '../tx/tx_effect.js';
+import type { TxHash } from '../tx/tx_hash.js';
+import type { TxReceipt } from '../tx/tx_receipt.js';
+import type { InBlock } from './in_block.js';
+import type { L2Block } from './l2_block.js';
+
+/**
+ * Interface of classes allowing for the retrieval of L2 blocks.
+ */
+export interface L2BlockSource {
+  /**
+   * Method to fetch the rollup contract address at the base-layer.
+   * @returns The rollup address.
+   */
+  getRollupAddress(): Promise<EthAddress>;
+
+  /**
+   * Method to fetch the registry contract address at the base-layer.
+   * @returns The registry address.
+   */
+  getRegistryAddress(): Promise<EthAddress>;
+
+  /**
+   * Gets the number of the latest L2 block processed by the block source implementation.
+   * @returns The number of the latest L2 block processed by the block source implementation.
+   */
+  getBlockNumber(): Promise<number>;
+
+  /**
+   * Gets the number of the latest L2 block proven seen by the block source implementation.
+   * @returns The number of the latest L2 block proven seen by the block source implementation.
+   */
+  getProvenBlockNumber(): Promise<number>;
+
+  /**
+   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  getBlock(number: number): Promise<L2Block | undefined>;
+
+  /**
+   * Gets an l2 block header.
+   * @param number - The block number to return or 'latest' for the most recent one.
+   * @returns The requested L2 block header.
+   */
+  getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined>;
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The maximum number of blocks to return.
+   * @param proven - If true, only return blocks that have been proven.
+   * @returns The requested L2 blocks.
+   */
+  getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
+
+  /**
+   * Gets a tx effect.
+   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
+   * @returns The requested tx effect.
+   */
+  getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined>;
+
+  /**
+   * Gets a receipt of a settled tx.
+   * @param txHash - The hash of a tx we try to get the receipt for.
+   * @returns The requested tx receipt (or undefined if not found).
+   */
+  getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
+
+  /**
+   * Returns the current L2 slot number based on the current L1 timestamp.
+   */
+  getL2SlotNumber(): Promise<bigint>;
+
+  /**
+   * Returns the current L2 epoch number based on the current L1 timestamp.
+   */
+  getL2EpochNumber(): Promise<bigint>;
+
+  /**
+   * Returns all blocks for a given epoch.
+   * @dev Use this method only with recent epochs, since it walks the block list backwards.
+   * @param epochNumber - The epoch number to return blocks for.
+   */
+  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]>;
+
+  /**
+   * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
+   * @param epochNumber - The epoch number to check.
+   */
+  isEpochComplete(epochNumber: bigint): Promise<boolean>;
+
+  /**
+   * Returns the tips of the L2 chain.
+   */
+  getL2Tips(): Promise<L2Tips>;
+
+  /**
+   * Returns the rollup constants for the current chain.
+   */
+  getL1Constants(): Promise<L1RollupConstants>;
+}
+
+/**
+ * L2BlockSource that emits events upon pending / proven chain changes.
+ * see L2BlockSourceEvents for the events emitted.
+ */
+export interface L2BlockSourceEventEmitter extends L2BlockSource, EventEmitter {}
+
+/**
+ * Identifier for L2 block tags.
+ * - latest: Latest block pushed to L1.
+ * - proven: Proven block on L1.
+ * - finalized: Proven block on a finalized L1 block (not implemented, set to proven for now).
+ */
+export type L2BlockTag = 'latest' | 'proven' | 'finalized';
+
+/** Tips of the L2 chain. */
+export type L2Tips = Record<L2BlockTag, L2BlockId>;
+
+/** Identifies a block by number and hash. */
+export type L2BlockId = z.infer<typeof L2BlockIdSchema>;
+
+// TODO(palla/schemas): This package should know what is the block hash of the genesis block 0.
+const L2BlockIdSchema = z.union([
+  z.object({
+    number: z.literal(0),
+    hash: z.undefined(),
+  }),
+  z.object({
+    number: z.number(),
+    hash: z.string(),
+  }),
+]);
+
+export const L2TipsSchema = z.object({
+  latest: L2BlockIdSchema,
+  proven: L2BlockIdSchema,
+  finalized: L2BlockIdSchema,
+}) satisfies z.ZodType<L2Tips>;
+
+export enum L2BlockSourceEvents {
+  L2PruneDetected = 'l2PruneDetected',
+}
+
+export type L2BlockSourceEvent = {
+  type: 'l2PruneDetected';
+  blockNumber: bigint;
+  slotNumber: bigint;
+  epochNumber: bigint;
+};

package/src/block/nullifier_with_block_source.ts

@@ -0,0 +1,7 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+import type { InBlock } from './in_block.js';
+
+export interface NullifierWithBlockSource {
+  findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]>;
+}

package/src/config/config.ts

@@ -0,0 +1,42 @@
+import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+export { type AllowedElement, type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
+
+export const emptyChainConfig: ChainConfig = {
+  l1ChainId: 0,
+  l1Contracts: { rollupAddress: EthAddress.ZERO },
+  version: 0,
+};
+
+export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
+  l1ChainId: {
+    env: 'L1_CHAIN_ID',
+    parseEnv: (val: string) => +val,
+    defaultValue: 31337,
+    description: 'The chain ID of the ethereum host.',
+  },
+  version: {
+    env: 'VERSION',
+    description: 'The version of the rollup.',
+    ...numberConfigHelper(1),
+  },
+  l1Contracts: {
+    description: 'The deployed L1 contract addresses',
+    nested: l1ContractAddressesMapping,
+  },
+};
+
+/** Chain configuration. */
+export type ChainConfig = {
+  /** The chain id of the ethereum host. */
+  l1ChainId: number;
+  /** The version of the rollup. */
+  version: number;
+  /** The address to the L1 contracts. */
+  l1Contracts: {
+    /** The address to rollup */
+    rollupAddress: EthAddress;
+  };
+};

package/src/config/index.ts

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

package/src/contract/artifact_hash.ts

@@ -0,0 +1,115 @@
+import { sha256 } from '@aztec/foundation/crypto';
+import { Fr, reduceFn } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { numToUInt8 } from '@aztec/foundation/serialize';
+import { MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
+
+import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
+
+const VERSION = 1;
+
+// TODO(miranda): Artifact and artifact metadata hashes are currently the only SHAs not truncated by a byte.
+// They are never recalculated in the circuit or L1 contract, but they are input to circuits, so perhaps modding here is preferable?
+// TODO(@spalladino) Reducing sha256 to a field may have security implications. Validate this with crypto team.
+const sha256Fr = reduceFn(sha256, Fr);
+
+/**
+ * Returns the artifact hash of a given compiled contract artifact.
+ *
+ * ```
+ * private_functions_artifact_leaves = artifact.private_functions.map fn =>
+ *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
+ * private_functions_artifact_tree_root = merkleize(private_functions_artifact_leaves)
+ *
+ * unconstrained_functions_artifact_leaves = artifact.unconstrained_functions.map fn =>
+ *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
+ * unconstrained_functions_artifact_tree_root = merkleize(unconstrained_functions_artifact_leaves)
+ *
+ * version = 1
+ * artifact_hash = sha256(
+ *   version,
+ *   private_functions_artifact_tree_root,
+ *   unconstrained_functions_artifact_tree_root,
+ *   artifact_metadata,
+ * )
+ * ```
+ * @param artifact - Artifact to calculate the hash for.
+ */
+export async function computeArtifactHash(
+  artifact: ContractArtifact | { privateFunctionRoot: Fr; unconstrainedFunctionRoot: Fr; metadataHash: Fr },
+): Promise<Fr> {
+  if ('privateFunctionRoot' in artifact && 'unconstrainedFunctionRoot' in artifact && 'metadataHash' in artifact) {
+    const { privateFunctionRoot, unconstrainedFunctionRoot, metadataHash } = artifact;
+    const preimage = [privateFunctionRoot, unconstrainedFunctionRoot, metadataHash].map(x => x.toBuffer());
+    return sha256Fr(Buffer.concat([numToUInt8(VERSION), ...preimage]));
+  }
+
+  const preimage = await computeArtifactHashPreimage(artifact);
+  const artifactHash = computeArtifactHash(preimage);
+  getLogger().trace('Computed artifact hash', { artifactHash, ...preimage });
+  return artifactHash;
+}
+
+export async function computeArtifactHashPreimage(artifact: ContractArtifact) {
+  const privateFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.PRIVATE);
+  const unconstrainedFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.UNCONSTRAINED);
+  const metadataHash = computeArtifactMetadataHash(artifact);
+  return { privateFunctionRoot, unconstrainedFunctionRoot, metadataHash };
+}
+
+export function computeArtifactMetadataHash(artifact: ContractArtifact) {
+  return sha256Fr(Buffer.from(JSON.stringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
+}
+
+export async function computeArtifactFunctionTreeRoot(artifact: ContractArtifact, fnType: FunctionType) {
+  const tree = await computeArtifactFunctionTree(artifact, fnType);
+  return tree?.root ? Fr.fromBuffer(tree.root) : Fr.ZERO;
+}
+
+export async function computeArtifactFunctionTree(
+  artifact: ContractArtifact,
+  fnType: FunctionType,
+): Promise<MerkleTree | undefined> {
+  const leaves = await computeFunctionLeaves(artifact, fnType);
+  // TODO(@spalladino) Consider implementing a null-object for empty trees
+  if (leaves.length === 0) {
+    return undefined;
+  }
+  const height = Math.ceil(Math.log2(leaves.length));
+  const calculator = await MerkleTreeCalculator.create(height, Buffer.alloc(32), getArtifactMerkleTreeHasher());
+  return calculator.computeTree(leaves.map(x => x.toBuffer()));
+}
+
+async function computeFunctionLeaves(artifact: ContractArtifact, fnType: FunctionType) {
+  const selectors = await Promise.all(
+    artifact.functions
+      .filter(f => f.functionType === fnType)
+      .map(async f => ({ ...f, selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters) })),
+  );
+  selectors.sort((a, b) => a.selector.value - b.selector.value);
+  return await Promise.all(selectors.map(computeFunctionArtifactHash));
+}
+
+export async function computeFunctionArtifactHash(
+  fn:
+    | FunctionArtifact
+    | (Pick<FunctionArtifact, 'bytecode'> & { functionMetadataHash: Fr; selector: FunctionSelector }),
+) {
+  const selector = 'selector' in fn ? fn.selector : await FunctionSelector.fromNameAndParameters(fn);
+
+  const bytecodeHash = sha256Fr(fn.bytecode).toBuffer();
+  const metadataHash = 'functionMetadataHash' in fn ? fn.functionMetadataHash : computeFunctionMetadataHash(fn);
+  return sha256Fr(Buffer.concat([numToUInt8(VERSION), selector.toBuffer(), metadataHash.toBuffer(), bytecodeHash]));
+}
+
+export function computeFunctionMetadataHash(fn: FunctionArtifact) {
+  return sha256Fr(Buffer.from(JSON.stringify(fn.returnTypes), 'utf8'));
+}
+
+function getLogger() {
+  return createLogger('circuits:artifact_hash');
+}
+
+export function getArtifactMerkleTreeHasher() {
+  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer());
+}

package/src/contract/complete_address.ts

@@ -0,0 +1,155 @@
+import { Fr } from '@aztec/foundation/fields';
+import { hexSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex } from '@aztec/foundation/string';
+
+import { AztecAddress } from '../aztec-address/index.js';
+import { computeAddress, computePreaddress, deriveKeys } from '../keys/index.js';
+import { PublicKeys } from '../keys/public_keys.js';
+import { computePartialAddress } from './contract_address.js';
+import type { PartialAddress } from './partial_address.js';
+
+/**
+ * A complete address is a combination of an Aztec address, a public key and a partial address.
+ *
+ * @remarks We have introduced this type because it is common that these 3 values are used together. They are commonly
+ *          used together because it is the information needed to send user a note.
+ * @remarks See the link below for details about how address is computed:
+ *          https://github.com/AztecProtocol/aztec-packages/blob/master/docs/docs/concepts/foundation/accounts/keys.md#addresses-partial-addresses-and-public-keys
+ */
+export class CompleteAddress {
+  private constructor(
+    /** Contract address (typically of an account contract) */
+    public address: AztecAddress,
+    /** User public keys */
+    public publicKeys: PublicKeys,
+    /** Partial key corresponding to the public key to the address. */
+    public partialAddress: PartialAddress,
+  ) {}
+
+  static async create(
+    address: AztecAddress,
+    publicKeys: PublicKeys,
+    partialAddress: PartialAddress,
+  ): Promise<CompleteAddress> {
+    const completeAddress = new CompleteAddress(address, publicKeys, partialAddress);
+    await completeAddress.validate();
+    return completeAddress;
+  }
+
+  /** Size in bytes of an instance */
+  static readonly SIZE_IN_BYTES = 32 * 10;
+
+  static get schema() {
+    return hexSchemaFor(CompleteAddress);
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  static async random(): Promise<CompleteAddress> {
+    return await this.fromSecretKeyAndPartialAddress(Fr.random(), Fr.random());
+  }
+
+  static async fromSecretKeyAndPartialAddress(secretKey: Fr, partialAddress: Fr): Promise<CompleteAddress> {
+    const { publicKeys } = await deriveKeys(secretKey);
+    const address = await computeAddress(publicKeys, partialAddress);
+
+    return new CompleteAddress(address, publicKeys, partialAddress);
+  }
+
+  async getPreaddress() {
+    return computePreaddress(await this.publicKeys.hash(), this.partialAddress);
+  }
+
+  static async fromSecretKeyAndInstance(
+    secretKey: Fr,
+    instance: Parameters<typeof computePartialAddress>[0],
+  ): Promise<CompleteAddress> {
+    const partialAddress = await computePartialAddress(instance);
+    return CompleteAddress.fromSecretKeyAndPartialAddress(secretKey, partialAddress);
+  }
+
+  /** Throws if the address is not correctly derived from the public key and partial address.*/
+  public async validate() {
+    const expectedAddress = await computeAddress(this.publicKeys, this.partialAddress);
+
+    if (!expectedAddress.equals(this.address)) {
+      throw new Error(
+        `Address cannot be derived from public keys and partial address (received ${this.address.toString()}, derived ${expectedAddress.toString()})`,
+      );
+    }
+  }
+
+  /**
+   * Gets a readable string representation of the complete address.
+   * @returns A readable string representation of the complete address.
+   */
+  public toReadableString(): string {
+    return `Address: ${this.address.toString()}\nMaster Nullifier Public Key: ${this.publicKeys.masterNullifierPublicKey.toString()}\nMaster Incoming Viewing Public Key: ${this.publicKeys.masterIncomingViewingPublicKey.toString()}\nMaster Outgoing Viewing Public Key: ${this.publicKeys.masterOutgoingViewingPublicKey.toString()}\nMaster Tagging Public Key: ${this.publicKeys.masterTaggingPublicKey.toString()}\nPartial Address: ${this.partialAddress.toString()}\n`;
+  }
+
+  /**
+   * Determines if this CompleteAddress instance is equal to the given CompleteAddress instance.
+   * Equality is based on the content of their respective buffers.
+   *
+   * @param other - The CompleteAddress instance to compare against.
+   * @returns True if the buffers of both instances are equal, false otherwise.
+   */
+  equals(other: CompleteAddress): boolean {
+    return (
+      this.address.equals(other.address) &&
+      this.publicKeys.equals(other.publicKeys) &&
+      this.partialAddress.equals(other.partialAddress)
+    );
+  }
+
+  /**
+   * Converts the CompleteAddress instance into a Buffer.
+   * This method should be used when encoding the address for storage, transmission or serialization purposes.
+   *
+   * @returns A Buffer representation of the CompleteAddress instance.
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.address, this.publicKeys, this.partialAddress]);
+  }
+
+  /**
+   * Creates an CompleteAddress instance from a given buffer or BufferReader.
+   * If the input is a Buffer, it wraps it in a BufferReader before processing.
+   * Throws an error if the input length is not equal to the expected size.
+   *
+   * @param buffer - The input buffer or BufferReader containing the address data.
+   * @returns - A new CompleteAddress instance with the extracted address data.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): Promise<CompleteAddress> {
+    const reader = BufferReader.asReader(buffer);
+    const address = reader.readObject(AztecAddress);
+    const publicKeys = reader.readObject(PublicKeys);
+    const partialAddress = reader.readObject(Fr);
+    return CompleteAddress.create(address, publicKeys, partialAddress);
+  }
+
+  /**
+   * Create a CompleteAddress instance from a hex-encoded string.
+   * The input 'address' should be prefixed with '0x' or not, and have exactly 128 hex characters representing the x and y coordinates.
+   * Throws an error if the input length is invalid or coordinate values are out of range.
+   *
+   * @param address - The hex-encoded string representing the complete address.
+   * @returns A Point instance.
+   */
+  static fromString(address: string): Promise<CompleteAddress> {
+    return CompleteAddress.fromBuffer(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+  }
+
+  /**
+   * Convert the CompleteAddress to a hexadecimal string representation, with a "0x" prefix.
+   * The resulting string will have a length of 66 characters (including the prefix).
+   *
+   * @returns A hexadecimal string representation of the CompleteAddress.
+   */
+  toString(): string {
+    return bufferToHex(this.toBuffer());
+  }
+}

package/src/contract/contract_address.ts

@@ -0,0 +1,91 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+
+import { type FunctionAbi, FunctionSelector, encodeArguments } from '../abi/index.js';
+import type { AztecAddress } from '../aztec-address/index.js';
+import { computeVarArgsHash } from '../hash/hash.js';
+import { computeAddress } from '../keys/index.js';
+import type { ContractInstance } from './interfaces/contract_instance.js';
+
+// TODO(@spalladino): Review all generator indices in this file
+
+/**
+ * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * ```
+ * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
+ * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)
+ * address = ((poseidon2Hash([public_keys_hash, partial_address, GENERATOR__CONTRACT_ADDRESS_V1]) * G) + ivpk_m).x <- the x-coordinate of the address point
+ * ```
+ * @param instance - A contract instance for which to calculate the deployment address.
+ */
+export async function computeContractAddressFromInstance(
+  instance:
+    | ContractInstance
+    | ({ originalContractClassId: Fr; saltedInitializationHash: Fr } & Pick<ContractInstance, 'publicKeys'>),
+): Promise<AztecAddress> {
+  const partialAddress = await computePartialAddress(instance);
+  return computeAddress(instance.publicKeys, partialAddress);
+}
+
+/**
+ * Computes the partial address defined as the hash of the contract class id and salted initialization hash.
+ * @param instance - Contract instance for which to calculate the partial address.
+ */
+export async function computePartialAddress(
+  instance:
+    | Pick<ContractInstance, 'originalContractClassId' | 'initializationHash' | 'salt' | 'deployer'>
+    | { originalContractClassId: Fr; saltedInitializationHash: Fr },
+): Promise<Fr> {
+  const saltedInitializationHash =
+    'saltedInitializationHash' in instance
+      ? instance.saltedInitializationHash
+      : await computeSaltedInitializationHash(instance);
+
+  return poseidon2HashWithSeparator(
+    [instance.originalContractClassId, saltedInitializationHash],
+    GeneratorIndex.PARTIAL_ADDRESS,
+  );
+}
+
+/**
+ * Computes the salted initialization hash for an address, defined as the hash of the salt and initialization hash.
+ * @param instance - Contract instance for which to compute the salted initialization hash.
+ */
+export function computeSaltedInitializationHash(
+  instance: Pick<ContractInstance, 'initializationHash' | 'salt' | 'deployer'>,
+): Promise<Fr> {
+  return poseidon2HashWithSeparator(
+    [instance.salt, instance.initializationHash, instance.deployer],
+    GeneratorIndex.PARTIAL_ADDRESS,
+  );
+}
+
+/**
+ * Computes the initialization hash for an instance given its constructor function and arguments.
+ * @param initFn - Constructor function or empty if no initialization is expected.
+ * @param args - Unencoded arguments, will be encoded as fields according to the constructor function abi.
+ * @returns The hash, or zero if no initialization function is provided.
+ */
+export async function computeInitializationHash(initFn: FunctionAbi | undefined, args: any[]): Promise<Fr> {
+  if (!initFn) {
+    return Fr.ZERO;
+  }
+  const selector = await FunctionSelector.fromNameAndParameters(initFn.name, initFn.parameters);
+  const flatArgs = encodeArguments(initFn, args);
+  return computeInitializationHashFromEncodedArgs(selector, flatArgs);
+}
+
+/**
+ * Computes the initialization hash for an instance given its constructor function selector and encoded arguments.
+ * @param initFn - Constructor function selector.
+ * @param args - Encoded arguments.
+ * @returns The hash.
+ */
+export async function computeInitializationHashFromEncodedArgs(
+  initFn: FunctionSelector,
+  encodedArgs: Fr[],
+): Promise<Fr> {
+  const argsHash = await computeVarArgsHash(encodedArgs);
+  return poseidon2HashWithSeparator([initFn, argsHash], GeneratorIndex.CONSTRUCTOR);
+}

package/src/contract/contract_class.ts

@@ -0,0 +1,81 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+
+import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
+import { hashVK } from '../hash/hash.js';
+import { computeArtifactHash } from './artifact_hash.js';
+import { type ContractClassIdPreimage, computeContractClassIdWithPreimage } from './contract_class_id.js';
+import type { ContractClass, ContractClassWithId, PublicFunction } from './interfaces/index.js';
+
+/** Contract artifact including its artifact hash */
+type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
+
+const cmpFunctionArtifacts = <T extends { selector: FunctionSelector }>(a: T, b: T) =>
+  a.selector.toField().cmp(b.selector.toField());
+
+/** Creates a ContractClass from a contract compilation artifact. */
+export async function getContractClassFromArtifact(
+  artifact: ContractArtifact | ContractArtifactWithHash,
+): Promise<ContractClassWithId & ContractClassIdPreimage> {
+  const artifactHash = 'artifactHash' in artifact ? artifact.artifactHash : await computeArtifactHash(artifact);
+  const publicFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PUBLIC);
+  const artifactPublicFunctions: ContractClass['publicFunctions'] = await Promise.all(
+    publicFunctions.map(async f => ({
+      selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+      bytecode: f.bytecode,
+    })),
+  );
+
+  artifactPublicFunctions.sort(cmpFunctionArtifacts);
+
+  let packedBytecode = Buffer.alloc(0);
+  let dispatchFunction: PublicFunction | undefined = undefined;
+  if (artifactPublicFunctions.length > 0) {
+    dispatchFunction = artifactPublicFunctions.find(f =>
+      f.selector.equals(FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR))),
+    );
+    if (!dispatchFunction) {
+      throw new Error(
+        `A contract with public functions should define a public_dispatch(Field) function as its public entrypoint. Contract: ${artifact.name}`,
+      );
+    }
+    packedBytecode = dispatchFunction.bytecode;
+  }
+
+  const privateFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PRIVATE);
+  const privateArtifactFunctions: ContractClass['privateFunctions'] = await Promise.all(
+    privateFunctions.map(getContractClassPrivateFunctionFromArtifact),
+  );
+
+  privateArtifactFunctions.sort(cmpFunctionArtifacts);
+
+  const contractClass: ContractClass = {
+    version: 1,
+    artifactHash,
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
+    publicFunctions: dispatchFunction ? [dispatchFunction] : [],
+    packedBytecode,
+    privateFunctions: privateArtifactFunctions,
+  };
+  return { ...contractClass, ...(await computeContractClassIdWithPreimage(contractClass)) };
+}
+
+export async function getContractClassPrivateFunctionFromArtifact(
+  f: FunctionArtifact,
+): Promise<ContractClass['privateFunctions'][number]> {
+  return {
+    selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+    vkHash: await computeVerificationKeyHash(f),
+  };
+}
+
+/**
+ * For a given private function, computes the hash of its vk.
+ */
+export async function computeVerificationKeyHash(f: FunctionArtifact) {
+  if (!f.verificationKey) {
+    throw new Error(`Private function ${f.name} must have a verification key`);
+  }
+  return hashVK(await vkAsFieldsMegaHonk(Buffer.from(f.verificationKey, 'base64')));
+}