@aztec/stdlib 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/abi/abi.ts

@@ -224,13 +224,20 @@ export const FunctionDebugMetadataSchema = z.object({
     acir_locations: z.record(z.number()),
     brillig_locations: z.record(z.record(z.number())),
   }),
-  files: z.record(
-    z.object({
-      source: z.string(),
-      path: z.string(),
-      function_locations: z.array(z.object({ start: z.number(), name: z.string() })),
-    }),
-  ),
+  // `function_locations` is required in the static `DebugFileMap` type (noir-types compat), but legacy v4-next
+  // artifacts were compiled before this field existed — see {@link fillMissingFunctionLocations} for the full
+  // rationale. The preprocessor injects `[]` for missing entries so parsing succeeds; the cast restores the
+  // output type since `z.preprocess` widens the schema's input type to `unknown`.
+  files: z.preprocess(
+    fillMissingFunctionLocations,
+    z.record(
+      z.object({
+        source: z.string(),
+        path: z.string(),
+        function_locations: z.array(z.object({ start: z.number(), name: z.string() })),
+      }),
+    ),
+  ) as z.ZodType<DebugFileMap>,
 }) satisfies z.ZodType<FunctionDebugMetadata>;
 
 /** The artifact entry of a function. */
@@ -332,6 +339,45 @@ export type DebugFileMap = Record<
   }
 >;
 
+/**
+ * Preprocessor for {@link FunctionDebugMetadataSchema} / {@link ContractArtifactSchema} that injects an empty
+ * `function_locations` array on any file map entry missing it. Invoked via `z.preprocess(...)` before the strict
+ * object schema runs, so legacy inputs do not fail validation.
+ *
+ * Why this exists on v4-next (and not on `next` / v5):
+ *
+ *   - The Noir submodule on `next` was bumped past nightly-2026-03-19, which added `function_locations` to the
+ *     debug file map in the Noir `@aztec/noir-types` package and to every freshly-compiled artifact's `file_map`
+ *     entries. The matching stdlib change (making `DebugFileMap.function_locations` required) was done in one
+ *     go on `next`, so there `function_locations` is always present both at compile time and at runtime.
+ *
+ *   - On v4-next we had to cherry-pick the Noir bump (chore: Update Noir to nightly-2026-04-10 (#22393)) without
+ *     re-running the full noir-projects compilation pipeline, so the on-disk contract and protocol-circuit
+ *     artifacts (e.g. `yarn-project/protocol-contracts/artifacts/AuthRegistry.json`) still carry the pre-update
+ *     `file_map` shape with only `source` + `path`. Separately, `ivc-integration` compares our `DebugFileMap`
+ *     against the Noir-types `DebugFileMap`, which *does* require `function_locations`, so we cannot simply make
+ *     our own field optional — that would break the structural compatibility check.
+ *
+ *   - To satisfy both constraints at once we keep `function_locations` required in the static TypeScript type
+ *     (so `ivc-integration` keeps compiling) but relax the runtime input shape via this preprocessor (so legacy
+ *     artifacts keep parsing). Once all v4-next artifacts get regenerated with the new Noir compiler, this
+ *     helper — and both `z.preprocess(...)` wrappers — can be removed.
+ */
+function fillMissingFunctionLocations(val: unknown): unknown {
+  if (val && typeof val === 'object') {
+    for (const entry of Object.values(val as Record<string, unknown>)) {
+      if (
+        entry &&
+        typeof entry === 'object' &&
+        (entry as { function_locations?: unknown }).function_locations === undefined
+      ) {
+        (entry as { function_locations: FunctionLocation[] }).function_locations = [];
+      }
+    }
+  }
+  return val;
+}
+
 /** Type representing a field layout in the storage of a contract. */
 export type FieldLayout = {
   /** Slot in which the field is stored. */
@@ -383,13 +429,20 @@ export const ContractArtifactSchema = zodFor<ContractArtifact>()(
       globals: z.record(z.array(AbiValueSchema)),
     }),
     storageLayout: z.record(z.object({ slot: schemas.Fr })),
-    fileMap: z.record(
-      z.coerce.number(),
-      z.object({
-        source: z.string(),
-        path: z.string(),
-        function_locations: z.array(z.object({ start: z.number(), name: z.string() })),
-      }),
+    // Legacy v4-next contract artifacts (e.g. `protocol-contracts/artifacts/AuthRegistry.json`) were emitted
+    // before Noir started including `function_locations` in their `file_map` entries — see
+    // {@link fillMissingFunctionLocations} for the full rationale. The preprocessor injects `[]` for missing
+    // entries so parsing succeeds without weakening the static `DebugFileMap` type.
+    fileMap: z.preprocess(
+      fillMissingFunctionLocations,
+      z.record(
+        z.coerce.number(),
+        z.object({
+          source: z.string(),
+          path: z.string(),
+          function_locations: z.array(z.object({ start: z.number(), name: z.string() })),
+        }),
+      ),
     ),
   }),
 );

package/src/abi/selector.ts

@@ -4,7 +4,7 @@ import { bufferToHex } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
-/** A selector is the first 4 bytes of the hash of a signature. */
+/** A selector is the low 4 bytes of the poseidon2 hash of a signature. */
 export abstract class Selector {
   /** The size of the selector in bytes. */
   public static SIZE = 4;

package/src/avm/avm_accumulated_data.ts

@@ -88,11 +88,11 @@ export class AvmAccumulatedData {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new this(
-      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
-      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readTuple(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
       reader.readObject(FlatPublicLogs),
-      reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
+      reader.readTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
 
@@ -115,9 +115,9 @@ export class AvmAccumulatedData {
     return new this(
       reader.readFieldArray(MAX_NOTE_HASHES_PER_TX),
       reader.readFieldArray(MAX_NULLIFIERS_PER_TX),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
       reader.readObject(FlatPublicLogs),
-      reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
+      reader.readTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
 

package/src/avm/avm_circuit_public_inputs.ts

@@ -143,8 +143,8 @@ export class AvmCircuitPublicInputs {
       reader.readObject(AztecAddress),
       reader.readObject(Fr),
       reader.readObject(PublicCallRequestArrayLengths),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readObject(PublicCallRequest),
       reader.readObject(PrivateToAvmAccumulatedDataArrayLengths),
       reader.readObject(PrivateToAvmAccumulatedDataArrayLengths),
@@ -206,8 +206,8 @@ export class AvmCircuitPublicInputs {
       AztecAddress.fromFields(reader),
       reader.readField(),
       PublicCallRequestArrayLengths.fromFields(reader),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       PublicCallRequest.fromFields(reader),
       PrivateToAvmAccumulatedDataArrayLengths.fromFields(reader),
       PrivateToAvmAccumulatedDataArrayLengths.fromFields(reader),

package/src/avm/revert_code.ts

@@ -5,35 +5,17 @@ import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 
-/**
- * Tracks which revertible phases of a transaction's public execution reverted.
- *
- * A transaction executes in three sequential phases:
- *   1. SETUP     – non-revertible; if this fails the entire transaction is rejected.
- *   2. APP_LOGIC – revertible; its state changes are rolled back on failure.
- *   3. TEARDOWN  – revertible; always runs (even after app-logic revert) so the fee-payment contract can clean up.
- *
- * Only APP_LOGIC and TEARDOWN can produce a revert code. SETUP failures throw instead and discard the transaction
- * entirely.
- */
+/** Whether a transaction's public execution reverted. */
 export enum RevertCodeEnum {
   /** All phases completed successfully; no state was rolled back. */
   OK = 0,
-  /** APP_LOGIC reverted; its state changes were discarded. If present, TEARDOWN still ran and succeeded. */
-  APP_LOGIC_REVERTED = 1,
-  /** TEARDOWN reverted; its state changes were discarded. APP_LOGIC succeeded. */
-  TEARDOWN_REVERTED = 2,
-  /** Both APP_LOGIC and TEARDOWN reverted; only SETUP effects are kept. */
-  BOTH_REVERTED = 3,
+  /** One or more revertible phases reverted; their state changes were discarded. */
+  REVERTED = 1,
 }
 
-function isRevertCodeEnum(value: number): value is RevertCodeEnum {
-  return (
-    (value as RevertCodeEnum) === RevertCodeEnum.OK ||
-    (value as RevertCodeEnum) === RevertCodeEnum.APP_LOGIC_REVERTED ||
-    (value as RevertCodeEnum) === RevertCodeEnum.TEARDOWN_REVERTED ||
-    (value as RevertCodeEnum) === RevertCodeEnum.BOTH_REVERTED
-  );
+/** Returns a valid RevertCodeEnum, coercing any value >= 1 to REVERTED. */
+function toRevertCodeEnum(value: number): RevertCodeEnum {
+  return value >= 1 ? RevertCodeEnum.REVERTED : RevertCodeEnum.OK;
 }
 
 /**
@@ -45,9 +27,13 @@ export class RevertCode {
     this.code = e.valueOf();
   }
   static readonly OK: RevertCode = new RevertCode(RevertCodeEnum.OK);
-  static readonly APP_LOGIC_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.APP_LOGIC_REVERTED);
-  static readonly TEARDOWN_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.TEARDOWN_REVERTED);
-  static readonly BOTH_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.BOTH_REVERTED);
+  static readonly REVERTED: RevertCode = new RevertCode(RevertCodeEnum.REVERTED);
+  /** @deprecated Use REVERTED instead. */
+  static readonly APP_LOGIC_REVERTED: RevertCode = RevertCode.REVERTED;
+  /** @deprecated Use REVERTED instead. */
+  static readonly TEARDOWN_REVERTED: RevertCode = RevertCode.REVERTED;
+  /** @deprecated Use REVERTED instead. */
+  static readonly BOTH_REVERTED: RevertCode = RevertCode.REVERTED;
 
   public getCode(): RevertCodeEnum {
     return this.code;
@@ -65,12 +51,8 @@ export class RevertCode {
     switch (this.code as RevertCodeEnum) {
       case RevertCodeEnum.OK:
         return 'OK';
-      case RevertCodeEnum.APP_LOGIC_REVERTED:
-        return 'Application logic reverted';
-      case RevertCodeEnum.TEARDOWN_REVERTED:
-        return 'Teardown reverted';
-      case RevertCodeEnum.BOTH_REVERTED:
-        return 'Both reverted';
+      case RevertCodeEnum.REVERTED:
+        return 'Reverted';
       default:
         return `Unknown RevertCode: ${this.code}`;
     }
@@ -81,7 +63,11 @@ export class RevertCode {
   }
 
   static get schema(): ZodFor<RevertCode> {
-    return z.nativeEnum(RevertCodeEnum).transform(value => new RevertCode(value));
+    return z
+      .number()
+      .int()
+      .min(0)
+      .transform(value => new RevertCode(toRevertCodeEnum(value)));
   }
 
   /**
@@ -96,10 +82,10 @@ export class RevertCode {
       return obj;
     }
     const code = typeof obj === 'number' ? obj : (obj.code ?? obj);
-    if (!isRevertCodeEnum(code)) {
+    if (typeof code !== 'number' || code < 0) {
       throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(code);
+    return new RevertCode(toRevertCodeEnum(code));
   }
 
   /**
@@ -131,10 +117,10 @@ export class RevertCode {
   }
 
   public static fromNumber(code: number): RevertCode {
-    if (!isRevertCodeEnum(code)) {
+    if (code < 0) {
       throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(code);
+    return new RevertCode(toRevertCodeEnum(code));
   }
 
   public static fromField(field: Fr): RevertCode {
@@ -152,7 +138,7 @@ export class RevertCode {
     return RevertCode.fromNumber(code);
   }
 
-  private static readonly NUM_OPTIONS = 4;
+  private static readonly NUM_OPTIONS = 2;
   static random(): RevertCode {
     return new RevertCode(Math.floor(Math.random() * RevertCode.NUM_OPTIONS));
   }

package/src/block/l2_block_stream/interfaces.ts

@@ -2,10 +2,14 @@ import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.
 import type { L2Block } from '../l2_block.js';
 import type { CheckpointId, L2BlockId, L2Tips } from '../l2_block_source.js';
 
+/** Provides the current chain tips. Implemented by world-state, l2-tips-store, and AztecNode. */
+export interface L2TipsProvider {
+  getL2Tips(): Promise<L2Tips>;
+}
+
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
-export interface L2BlockStreamLocalDataProvider {
+export interface L2BlockStreamLocalDataProvider extends L2TipsProvider {
   getL2BlockHash(number: number): Promise<string | undefined>;
-  getL2Tips(): Promise<L2Tips>;
 }
 
 /** Interface to a handler of events emitted. */

package/src/config/index.ts

@@ -1,4 +1,3 @@
 export * from './chain-config.js';
 export * from './node-rpc-config.js';
-export * from './pipelining-config.js';
 export * from './sequencer-config.js';

package/src/config/sequencer-config.ts

@@ -2,9 +2,6 @@ import type { ConfigMappingsType } from '@aztec/foundation/config';
 
 import type { SequencerConfig } from '../interfaces/configs.js';
 
-/** Default maximum number of transactions per block. */
-export const DEFAULT_MAX_TXS_PER_BLOCK = 32;
-
 /**
  * Partial sequencer config mappings for fields that need to be shared across packages.
  * The full sequencer config mappings remain in sequencer-client, but shared fields

package/src/contract/contract_address.ts

@@ -13,9 +13,9 @@ import type { ContractInstance } from './interfaces/contract_instance.js';
 /**
  * Returns the deployment address for a given contract instance.
  * ```
- * salted_initialization_hash = poseidon2(DOM_SEP__PARTIAL_ADDRESS, [salt, initialization_hash, deployer])
- * partial_address = poseidon2(DOM_SEP__PARTIAL_ADDRESS, [contract_class_id, salted_initialization_hash])
- * address = ((poseidon2(DOM_SEP__CONTRACT_ADDRESS_V1, [public_keys_hash, partial_address]) * G) + ivpk_m).x <- the x-coordinate of the address point
+ * 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.
  */

package/src/contract/contract_class_id.ts

@@ -13,10 +13,10 @@ import { computePrivateFunctionsRoot } from './private_function.js';
  *
  * ```
  * version = 1
- * private_function_leaves = private_functions.map(fn => poseidon2(DOM_SEP__PRIVATE_FUNCTION_LEAF, [fn.function_selector as Field, fn.vk_hash]))
+ * private_function_leaves = private_functions.map(fn => pedersen([fn.function_selector as Field, fn.vk_hash], GENERATOR__PRIVATE_FUNCTION_LEAF))
  * private_functions_root = merkleize(private_function_leaves)
  * bytecode_commitment = calculate_commitment(packed_bytecode)
- * contract_class_id = poseidon2(DOM_SEP__CONTRACT_CLASS_ID, [version, artifact_hash, private_functions_root, bytecode_commitment])
+ * contract_class_id = pedersen([version, artifact_hash, private_functions_root, bytecode_commitment], GENERATOR__CLASS_IDENTIFIER)
  * ```
  * @param contractClass - Contract class.
  * @returns The identifier.

package/src/contract/index.ts

@@ -6,6 +6,8 @@ export * from './contract_deployment_data.js';
 export * from './contract_instance.js';
 export * from './contract_instance_update.js';
 export * from './private_function.js';
+export * from './private_function_membership_proof.js';
+export * from './utility_function_membership_proof.js';
 export * from './interfaces/index.js';
 export * from './contract_function_dao.js';
 export * from './partial_address.js';

package/src/contract/interfaces/contract_class.ts

@@ -42,6 +42,79 @@ const PrivateFunctionSchema = zodFor<PrivateFunction>()(
   }),
 );
 
+/** Private function definition with executable bytecode. */
+export interface ExecutablePrivateFunction extends PrivateFunction {
+  /** ACIR and Brillig bytecode */
+  bytecode: Buffer;
+}
+
+const ExecutablePrivateFunctionSchema = zodFor<ExecutablePrivateFunction>()(
+  PrivateFunctionSchema.and(z.object({ bytecode: schemas.Buffer })),
+);
+
+/** Utility function definition. */
+export interface UtilityFunction {
+  /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
+  selector: FunctionSelector;
+  /** Brillig. */
+  bytecode: Buffer;
+}
+
+const UtilityFunctionSchema = zodFor<UtilityFunction>()(
+  z.object({
+    selector: FunctionSelector.schema,
+    bytecode: schemas.Buffer,
+  }),
+);
+
+/** Sibling paths and sibling commitments for proving membership of a private function within a contract class. */
+export type PrivateFunctionMembershipProof = {
+  artifactMetadataHash: Fr;
+  functionMetadataHash: Fr;
+  utilityFunctionsTreeRoot: Fr;
+  privateFunctionTreeSiblingPath: Fr[];
+  privateFunctionTreeLeafIndex: number;
+  artifactTreeSiblingPath: Fr[];
+  artifactTreeLeafIndex: number;
+};
+
+const PrivateFunctionMembershipProofSchema = zodFor<PrivateFunctionMembershipProof>()(
+  z.object({
+    artifactMetadataHash: schemas.Fr,
+    functionMetadataHash: schemas.Fr,
+    utilityFunctionsTreeRoot: schemas.Fr,
+    privateFunctionTreeSiblingPath: z.array(schemas.Fr),
+    privateFunctionTreeLeafIndex: schemas.Integer,
+    artifactTreeSiblingPath: z.array(schemas.Fr),
+    artifactTreeLeafIndex: schemas.Integer,
+  }),
+);
+
+/** A private function with a membership proof. */
+export type ExecutablePrivateFunctionWithMembershipProof = ExecutablePrivateFunction & PrivateFunctionMembershipProof;
+
+/** Sibling paths and commitments for proving membership of a utility  function within a contract class. */
+export type UtilityFunctionMembershipProof = {
+  artifactMetadataHash: Fr;
+  functionMetadataHash: Fr;
+  privateFunctionsArtifactTreeRoot: Fr;
+  artifactTreeSiblingPath: Fr[];
+  artifactTreeLeafIndex: number;
+};
+
+const UtilityFunctionMembershipProofSchema = zodFor<UtilityFunctionMembershipProof>()(
+  z.object({
+    artifactMetadataHash: schemas.Fr,
+    functionMetadataHash: schemas.Fr,
+    privateFunctionsArtifactTreeRoot: schemas.Fr,
+    artifactTreeSiblingPath: z.array(schemas.Fr),
+    artifactTreeLeafIndex: schemas.Integer,
+  }),
+);
+
+/** A utility function with a membership proof. */
+export type UtilityFunctionWithMembershipProof = UtilityFunction & UtilityFunctionMembershipProof;
+
 export const ContractClassSchema = zodFor<ContractClass>()(
   z.object({
     version: z.literal(VERSION),
@@ -70,8 +143,11 @@ export const ContractClassWithIdSchema = zodFor<ContractClassWithId>()(
   }),
 );
 
-/** A contract class with public bytecode information. */
-export type ContractClassPublic = Pick<ContractClassCommitments, 'id' | 'privateFunctionsRoot'> &
+/** A contract class with public bytecode information, and optional private and utility functions. */
+export type ContractClassPublic = {
+  privateFunctions: ExecutablePrivateFunctionWithMembershipProof[];
+  utilityFunctions: UtilityFunctionWithMembershipProof[];
+} & Pick<ContractClassCommitments, 'id' | 'privateFunctionsRoot'> &
   Omit<ContractClass, 'privateFunctions'>;
 
 export type ContractClassPublicWithCommitment = ContractClassPublic &
@@ -82,6 +158,8 @@ export const ContractClassPublicSchema = zodFor<ContractClassPublic>()(
     .object({
       id: schemas.Fr,
       privateFunctionsRoot: schemas.Fr,
+      privateFunctions: z.array(ExecutablePrivateFunctionSchema.and(PrivateFunctionMembershipProofSchema)),
+      utilityFunctions: z.array(UtilityFunctionSchema.and(UtilityFunctionMembershipProofSchema)),
     })
     .and(ContractClassSchema.omit({ privateFunctions: true })),
 );
@@ -101,6 +179,8 @@ export function contractClassPublicFromPlainObject(obj: any): ContractClassPubli
     version: 1,
     artifactHash: Fr.fromPlainObject(obj.artifactHash),
     privateFunctionsRoot: Fr.fromPlainObject(obj.privateFunctionsRoot),
+    privateFunctions: [],
+    utilityFunctions: [],
     packedBytecode: obj.packedBytecode instanceof Buffer ? obj.packedBytecode : Buffer.from(obj.packedBytecode),
   };
 }

package/src/contract/private_function_membership_proof.ts

@@ -0,0 +1,167 @@
+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;
+}