@aztec/stdlib 0.83.1 → 0.84.0

package/src/abi/contract_artifact.ts

@@ -21,6 +21,7 @@ import {
   AZTEC_INTERNAL_ATTRIBUTE,
   AZTEC_PRIVATE_ATTRIBUTE,
   AZTEC_PUBLIC_ATTRIBUTE,
+  AZTEC_UTILITY_ATTRIBUTE,
   AZTEC_VIEW_ATTRIBUTE,
   type NoirCompiledContract,
 } from '../noir/index.js';
@@ -155,14 +156,14 @@ function generateFunctionAbi(fn: NoirCompiledContractFunction, contract: NoirCom
   const isInternal = fn.custom_attributes.includes(AZTEC_INTERNAL_ATTRIBUTE);
   const isStatic = fn.custom_attributes.includes(AZTEC_VIEW_ATTRIBUTE);
 
-  // If the function is not unconstrained, the first item is inputs or CallContext which we should omit
+  // If the function is not a utility function, the first item is inputs or CallContext which we should omit
   let parameters = fn.abi.parameters.map(generateFunctionParameter);
   if (hasKernelFunctionInputs(parameters)) {
     parameters = parameters.slice(1);
   }
 
   let returnTypes: AbiType[] = [];
-  if (functionType === FunctionType.UNCONSTRAINED) {
+  if (functionType === FunctionType.UTILITY) {
     returnTypes = fn.abi.return_type ? [fn.abi.return_type.abi_type] : returnTypes;
   } else {
     const pathToFind = `${contract.name}::${fn.name}_abi`;
@@ -215,18 +216,31 @@ function generateFunctionArtifact(
 }
 
 function getFunctionType(fn: NoirCompiledContractFunction): FunctionType {
-  if (fn.custom_attributes.includes(AZTEC_PRIVATE_ATTRIBUTE)) {
+  if (fn.custom_attributes.some(attr => attr.endsWith(AZTEC_PRIVATE_ATTRIBUTE))) {
     return FunctionType.PRIVATE;
-  } else if (fn.custom_attributes.includes(AZTEC_PUBLIC_ATTRIBUTE)) {
+  } else if (fn.custom_attributes.some(attr => attr.endsWith(AZTEC_PUBLIC_ATTRIBUTE))) {
     return FunctionType.PUBLIC;
-  } else if (fn.is_unconstrained) {
-    return FunctionType.UNCONSTRAINED;
+  } else if (fn.custom_attributes.some(attr => attr.endsWith(AZTEC_UTILITY_ATTRIBUTE))) {
+    return FunctionType.UTILITY;
   } else {
-    // Default to a private function (see simple_macro_example_expanded for an example of this behavior)
-    return FunctionType.PRIVATE;
+    throw new Error(`Invalid function type for a noir contract function ${fn.name}`);
   }
 }
 
+// TODO(https://github.com/noir-lang/noir/issues/7912): Replace the above function with this one once the linked issue
+// is fixed.
+// function getFunctionType(fn: NoirCompiledContractFunction): FunctionType {
+//   if (fn.custom_attributes.includes(AZTEC_PRIVATE_ATTRIBUTE)) {
+//     return FunctionType.PRIVATE;
+//   } else if (fn.custom_attributes.includes(AZTEC_PUBLIC_ATTRIBUTE)) {
+//     return FunctionType.PUBLIC;
+//   } else if (fn.custom_attributes.includes(AZTEC_UTILITY_ATTRIBUTE)) {
+//     return FunctionType.UTILITY;
+//   } else {
+//     throw new Error(`Invalid function type for a noir contract function ${fn.name}`);
+//   }
+// }
+
 /**
  * Returns true if the first parameter is kernel function inputs.
  *

package/src/avm/avm.ts

@@ -10,6 +10,7 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 import { NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
 import { PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
+import type { Tx } from '../tx/index.js';
 import { AvmCircuitPublicInputs } from './avm_circuit_public_inputs.js';
 import { serializeWithMessagePack } from './message_pack.js';
 
@@ -287,9 +288,92 @@ export class AvmEnqueuedCallHint {
   }
 }
 
+export class AvmTxHint {
+  constructor(
+    public readonly nonRevertibleAccumulatedData: {
+      noteHashes: Fr[];
+      nullifiers: Fr[];
+      // TODO: add as needed.
+    },
+    public readonly revertibleAccumulatedData: {
+      noteHashes: Fr[];
+      nullifiers: Fr[];
+      // TODO: add as needed.
+    },
+    public readonly setupEnqueuedCalls: AvmEnqueuedCallHint[],
+    public readonly appLogicEnqueuedCalls: AvmEnqueuedCallHint[],
+    // We need this to be null and not undefined because that's what
+    // MessagePack expects for an std::optional.
+    public readonly teardownEnqueuedCall: AvmEnqueuedCallHint | null,
+  ) {}
+
+  static fromTx(tx: Tx): AvmTxHint {
+    const setupCallRequests = tx.getNonRevertiblePublicCallRequestsWithCalldata();
+    const appLogicCallRequests = tx.getRevertiblePublicCallRequestsWithCalldata();
+    const teardownCallRequest = tx.getTeardownPublicCallRequestWithCalldata();
+
+    return new AvmTxHint(
+      {
+        noteHashes: tx.data.forPublic!.nonRevertibleAccumulatedData.noteHashes.filter(x => !x.isZero()),
+        nullifiers: tx.data.forPublic!.nonRevertibleAccumulatedData.nullifiers.filter(x => !x.isZero()),
+      },
+      {
+        noteHashes: tx.data.forPublic!.revertibleAccumulatedData.noteHashes.filter(x => !x.isZero()),
+        nullifiers: tx.data.forPublic!.revertibleAccumulatedData.nullifiers.filter(x => !x.isZero()),
+      },
+      setupCallRequests.map(
+        call =>
+          new AvmEnqueuedCallHint(
+            call.request.msgSender,
+            call.request.contractAddress,
+            call.calldata,
+            call.request.isStaticCall,
+          ),
+      ),
+      appLogicCallRequests.map(
+        call =>
+          new AvmEnqueuedCallHint(
+            call.request.msgSender,
+            call.request.contractAddress,
+            call.calldata,
+            call.request.isStaticCall,
+          ),
+      ),
+      teardownCallRequest
+        ? new AvmEnqueuedCallHint(
+            teardownCallRequest.request.msgSender,
+            teardownCallRequest.request.contractAddress,
+            teardownCallRequest.calldata,
+            teardownCallRequest.request.isStaticCall,
+          )
+        : null,
+    );
+  }
+
+  static empty() {
+    return new AvmTxHint({ noteHashes: [], nullifiers: [] }, { noteHashes: [], nullifiers: [] }, [], [], null);
+  }
+
+  static get schema() {
+    return z.object({
+      nonRevertibleAccumulatedData: z.object({
+        noteHashes: schemas.Fr.array(),
+        nullifiers: schemas.Fr.array(),
+      }),
+      revertibleAccumulatedData: z.object({
+        noteHashes: schemas.Fr.array(),
+        nullifiers: schemas.Fr.array(),
+      }),
+      setupEnqueuedCalls: AvmEnqueuedCallHint.schema.array(),
+      appLogicEnqueuedCalls: AvmEnqueuedCallHint.schema.array(),
+      teardownEnqueuedCall: AvmEnqueuedCallHint.schema.nullable(),
+    });
+  }
+}
+
 export class AvmExecutionHints {
   constructor(
-    public readonly enqueuedCalls: AvmEnqueuedCallHint[] = [],
+    public tx: AvmTxHint,
     // Contract hints.
     public readonly contractInstances: AvmContractInstanceHint[] = [],
     public readonly contractClasses: AvmContractClassHint[] = [],
@@ -305,13 +389,13 @@ export class AvmExecutionHints {
   ) {}
 
   static empty() {
-    return new AvmExecutionHints();
+    return new AvmExecutionHints(AvmTxHint.empty());
   }
 
   static get schema() {
     return z
       .object({
-        enqueuedCalls: AvmEnqueuedCallHint.schema.array(),
+        tx: AvmTxHint.schema,
         contractInstances: AvmContractInstanceHint.schema.array(),
         contractClasses: AvmContractClassHint.schema.array(),
         bytecodeCommitments: AvmBytecodeCommitmentHint.schema.array(),
@@ -325,7 +409,7 @@ export class AvmExecutionHints {
       })
       .transform(
         ({
-          enqueuedCalls,
+          tx,
           contractInstances,
           contractClasses,
           bytecodeCommitments,
@@ -338,7 +422,7 @@ export class AvmExecutionHints {
           sequentialInsertHintsNullifierTree,
         }) =>
           new AvmExecutionHints(
-            enqueuedCalls,
+            tx,
             contractInstances,
             contractClasses,
             bytecodeCommitments,

package/src/config/config.ts

@@ -2,7 +2,8 @@ import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresse
 import type { ConfigMappingsType } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-export { type AllowedElement, type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
+export { type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
+export { type AllowedElement } from '../interfaces/allowed_element.js';
 
 export const emptyChainConfig: ChainConfig = {
   l1ChainId: 0,

package/src/contract/artifact_hash.ts

@@ -21,26 +21,26 @@ const sha256Fr = reduceFn(sha256, Fr);
  *   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 =>
+ * utility_functions_artifact_leaves = artifact.utility_functions.map fn =>
  *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
- * unconstrained_functions_artifact_tree_root = merkleize(unconstrained_functions_artifact_leaves)
+ * utility_functions_artifact_tree_root = merkleize(utility_functions_artifact_leaves)
  *
  * version = 1
  * artifact_hash = sha256(
  *   version,
  *   private_functions_artifact_tree_root,
- *   unconstrained_functions_artifact_tree_root,
+ *   utility_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 },
+  artifact: ContractArtifact | { privateFunctionRoot: Fr; utilityFunctionRoot: 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());
+  if ('privateFunctionRoot' in artifact && 'utilityFunctionRoot' in artifact && 'metadataHash' in artifact) {
+    const { privateFunctionRoot, utilityFunctionRoot, metadataHash } = artifact;
+    const preimage = [privateFunctionRoot, utilityFunctionRoot, metadataHash].map(x => x.toBuffer());
     return sha256Fr(Buffer.concat([numToUInt8(VERSION), ...preimage]));
   }
 
@@ -52,9 +52,9 @@ export async function computeArtifactHash(
 
 export async function computeArtifactHashPreimage(artifact: ContractArtifact) {
   const privateFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.PRIVATE);
-  const unconstrainedFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.UNCONSTRAINED);
+  const utilityFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.UTILITY);
   const metadataHash = computeArtifactMetadataHash(artifact);
-  return { privateFunctionRoot, unconstrainedFunctionRoot, metadataHash };
+  return { privateFunctionRoot, utilityFunctionRoot, metadataHash };
 }
 
 export function computeArtifactMetadataHash(artifact: ContractArtifact) {

package/src/contract/index.ts

@@ -6,7 +6,7 @@ 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 './unconstrained_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

@@ -15,7 +15,11 @@ const VERSION = 1 as const;
 export interface ContractClass {
   /** Version of the contract class. */
   version: typeof VERSION;
-  /** Hash of the contract artifact. The specification of this hash is not enforced by the protocol. Should include commitments to unconstrained code and compilation metadata. Intended to be used by clients to verify that an off-chain fetched artifact matches a registered class. */
+  /**
+   * Hash of the contract artifact. The specification of this hash is not enforced by the protocol. Should include
+   * commitments to code of utility functions and compilation metadata. Intended to be used by clients to verify that
+   * an off-chain fetched artifact matches a registered class.
+   */
   artifactHash: Fr;
   /** List of individual private functions, constructors included. */
   privateFunctions: PrivateFunction[];
@@ -46,25 +50,25 @@ const ExecutablePrivateFunctionSchema = PrivateFunctionSchema.and(
   z.object({ bytecode: schemas.Buffer }),
 ) satisfies ZodFor<ExecutablePrivateFunction>;
 
-/** Unconstrained function definition. */
-export interface UnconstrainedFunction {
+/** 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 UnconstrainedFunctionSchema = z.object({
+const UtilityFunctionSchema = z.object({
   /** lala */
   selector: FunctionSelector.schema,
   bytecode: schemas.Buffer,
-}) satisfies ZodFor<UnconstrainedFunction>;
+}) satisfies ZodFor<UtilityFunction>;
 
 /** Sibling paths and sibling commitments for proving membership of a private function within a contract class. */
 export type PrivateFunctionMembershipProof = {
   artifactMetadataHash: Fr;
   functionMetadataHash: Fr;
-  unconstrainedFunctionsArtifactTreeRoot: Fr;
+  utilityFunctionsTreeRoot: Fr;
   privateFunctionTreeSiblingPath: Fr[];
   privateFunctionTreeLeafIndex: number;
   artifactTreeSiblingPath: Fr[];
@@ -74,18 +78,18 @@ export type PrivateFunctionMembershipProof = {
 const PrivateFunctionMembershipProofSchema = z.object({
   artifactMetadataHash: schemas.Fr,
   functionMetadataHash: schemas.Fr,
-  unconstrainedFunctionsArtifactTreeRoot: schemas.Fr,
+  utilityFunctionsTreeRoot: schemas.Fr,
   privateFunctionTreeSiblingPath: z.array(schemas.Fr),
   privateFunctionTreeLeafIndex: schemas.Integer,
   artifactTreeSiblingPath: z.array(schemas.Fr),
   artifactTreeLeafIndex: schemas.Integer,
 }) satisfies ZodFor<PrivateFunctionMembershipProof>;
 
-/** A private function with a memebership proof. */
+/** A private function with a membership proof. */
 export type ExecutablePrivateFunctionWithMembershipProof = ExecutablePrivateFunction & PrivateFunctionMembershipProof;
 
-/** Sibling paths and commitments for proving membership of an unconstrained function within a contract class. */
-export type UnconstrainedFunctionMembershipProof = {
+/** Sibling paths and commitments for proving membership of a utility  function within a contract class. */
+export type UtilityFunctionMembershipProof = {
   artifactMetadataHash: Fr;
   functionMetadataHash: Fr;
   privateFunctionsArtifactTreeRoot: Fr;
@@ -93,16 +97,16 @@ export type UnconstrainedFunctionMembershipProof = {
   artifactTreeLeafIndex: number;
 };
 
-const UnconstrainedFunctionMembershipProofSchema = z.object({
+const UtilityFunctionMembershipProofSchema = z.object({
   artifactMetadataHash: schemas.Fr,
   functionMetadataHash: schemas.Fr,
   privateFunctionsArtifactTreeRoot: schemas.Fr,
   artifactTreeSiblingPath: z.array(schemas.Fr),
   artifactTreeLeafIndex: schemas.Integer,
-}) satisfies ZodFor<UnconstrainedFunctionMembershipProof>;
+}) satisfies ZodFor<UtilityFunctionMembershipProof>;
 
-/** An unconstrained function with a membership proof. */
-export type UnconstrainedFunctionWithMembershipProof = UnconstrainedFunction & UnconstrainedFunctionMembershipProof;
+/** A utility function with a membership proof. */
+export type UtilityFunctionWithMembershipProof = UtilityFunction & UtilityFunctionMembershipProof;
 
 export const ContractClassSchema = z.object({
   version: z.literal(VERSION),
@@ -128,10 +132,10 @@ export const ContractClassWithIdSchema = ContractClassSchema.extend({
   id: schemas.Fr,
 }) satisfies ZodFor<ContractClassWithId>;
 
-/** A contract class with public bytecode information, and optional private and unconstrained. */
+/** A contract class with public bytecode information, and optional private and utility functions. */
 export type ContractClassPublic = {
   privateFunctions: ExecutablePrivateFunctionWithMembershipProof[];
-  unconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[];
+  utilityFunctions: UtilityFunctionWithMembershipProof[];
 } & Pick<ContractClassCommitments, 'id' | 'privateFunctionsRoot'> &
   Omit<ContractClass, 'privateFunctions'>;
 
@@ -143,7 +147,7 @@ export const ContractClassPublicSchema = z
     id: schemas.Fr,
     privateFunctionsRoot: schemas.Fr,
     privateFunctions: z.array(ExecutablePrivateFunctionSchema.and(PrivateFunctionMembershipProofSchema)),
-    unconstrainedFunctions: z.array(UnconstrainedFunctionSchema.and(UnconstrainedFunctionMembershipProofSchema)),
+    utilityFunctions: z.array(UtilityFunctionSchema.and(UtilityFunctionMembershipProofSchema)),
   })
   .and(ContractClassSchema.omit({ privateFunctions: true })) satisfies ZodFor<ContractClassPublic>;
 

package/src/contract/private_function_membership_proof.ts

@@ -51,7 +51,7 @@ export async function createPrivateFunctionMembershipProof(
   }
 
   // Compute preimage for the artifact hash
-  const { unconstrainedFunctionRoot: unconstrainedFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } =
+  const { utilityFunctionRoot: utilityFunctionsTreeRoot, metadataHash: artifactMetadataHash } =
     await computeArtifactHashPreimage(artifact);
 
   // We need two sibling paths because private function information is split across two trees:
@@ -74,7 +74,7 @@ export async function createPrivateFunctionMembershipProof(
     functionLeaf: '0x' + functionLeaf.toString('hex'),
     artifactMetadataHash,
     privateFunctionsTreeRoot: '0x' + functionsTree.root.toString('hex'),
-    unconstrainedFunctionsArtifactTreeRoot,
+    utilityFunctionsTreeRoot,
     artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
     privateFunctionTreeSiblingPath: functionsTreeSiblingPath.map(fr => fr.toString()).join(','),
   });
@@ -84,7 +84,7 @@ export async function createPrivateFunctionMembershipProof(
     artifactTreeLeafIndex,
     artifactMetadataHash,
     functionMetadataHash,
-    unconstrainedFunctionsArtifactTreeRoot,
+    utilityFunctionsTreeRoot,
     privateFunctionTreeSiblingPath: functionsTreeSiblingPath,
     privateFunctionTreeLeafIndex: functionsTreeLeafIndex,
   };
@@ -106,7 +106,7 @@ export async function createPrivateFunctionMembershipProof(
  * // 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, unconstrained_functions_artifact_tree_root, artifact_metadata_hash)
+ * 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.
@@ -147,7 +147,7 @@ export async function isValidPrivateFunctionMembershipProof(
   const computedArtifactPrivateFunctionTreeRoot = Fr.fromBuffer(computedArtifactPrivateFunctionTreeRootBuffer);
   const computedArtifactHash = await computeArtifactHash({
     privateFunctionRoot: computedArtifactPrivateFunctionTreeRoot,
-    unconstrainedFunctionRoot: fn.unconstrainedFunctionsArtifactTreeRoot,
+    utilityFunctionRoot: fn.utilityFunctionsTreeRoot,
     metadataHash: fn.artifactMetadataHash,
   });
   if (!contractClass.artifactHash.equals(computedArtifactHash)) {
@@ -156,7 +156,7 @@ export async function isValidPrivateFunctionMembershipProof(
       computedArtifactHash,
       computedFunctionArtifactHash: functionArtifactHash,
       computedArtifactPrivateFunctionTreeRoot,
-      unconstrainedFunctionRoot: fn.unconstrainedFunctionsArtifactTreeRoot,
+      utilityFunctionRoot: fn.utilityFunctionsTreeRoot,
       metadataHash: fn.artifactMetadataHash,
       artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
     });

package/src/contract/{unconstrained_function_membership_proof.ts → utility_function_membership_proof.ts}

@@ -13,29 +13,29 @@ import {
 } from './artifact_hash.js';
 import type {
   ContractClassPublic,
-  UnconstrainedFunctionMembershipProof,
-  UnconstrainedFunctionWithMembershipProof,
+  UtilityFunctionMembershipProof,
+  UtilityFunctionWithMembershipProof,
 } from './interfaces/index.js';
 
 /**
- * Creates a membership proof for an unconstrained function in a contract class, to be verified via `isValidUnconstrainedFunctionMembershipProof`.
+ * 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 createUnconstrainedFunctionMembershipProof(
+export async function createUtilityFunctionMembershipProof(
   selector: FunctionSelector,
   artifact: ContractArtifact,
-): Promise<UnconstrainedFunctionMembershipProof> {
+): Promise<UtilityFunctionMembershipProof> {
   const log = createLogger('circuits:function_membership_proof');
 
   // Locate function artifact
-  const uncontrainedFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UNCONSTRAINED);
-  const unconstrainedFunctionsAndSelectors = await Promise.all(
-    uncontrainedFunctions.map(async fn => ({ fn, selector: await FunctionSelector.fromNameAndParameters(fn) })),
+  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 = unconstrainedFunctionsAndSelectors.find(fnAndSelector => selector.equals(fnAndSelector.selector))?.fn;
+  const fn = utilityFunctionsAndSelectors.find(fnAndSelector => selector.equals(fnAndSelector.selector))?.fn;
   if (!fn) {
-    throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
+    throw new Error(`Utility function with selector ${selector.toString()} not found`);
   }
   // Compute preimage for the artifact hash
   const { privateFunctionRoot: privateFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } =
@@ -44,11 +44,11 @@ export async function createUnconstrainedFunctionMembershipProof(
   // Compute the sibling path for the "artifact tree"
   const functionMetadataHash = computeFunctionMetadataHash(fn);
   const functionArtifactHash = await computeFunctionArtifactHash({ ...fn, functionMetadataHash });
-  const artifactTree = (await computeArtifactFunctionTree(artifact, FunctionType.UNCONSTRAINED))!;
+  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 unconstrained function with selector ${selector.toString()}`, {
+  log.debug(`Computed proof for utility function with selector ${selector.toString()}`, {
     functionArtifactHash,
     functionMetadataHash,
     artifactMetadataHash,
@@ -66,7 +66,7 @@ export async function createUnconstrainedFunctionMembershipProof(
 }
 
 /**
- * Verifies that an unconstrained function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * Verifies that a utility  function with a membership proof as emitted by the ClassRegisterer contract is valid,
  * as defined in the protocol specs at contract-deployment/classes:
  *
  * ```
@@ -75,15 +75,15 @@ export async function createUnconstrainedFunctionMembershipProof(
  *
  * // Compute artifact leaf and assert it belongs to the artifact
  * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_unconstrained_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_unconstrained_function_tree_root, artifact_metadata_hash)
+ * 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 isValidUnconstrainedFunctionMembershipProof(
-  fn: UnconstrainedFunctionWithMembershipProof,
+export async function isValidUtilityFunctionMembershipProof(
+  fn: UtilityFunctionWithMembershipProof,
   contractClass: Pick<ContractClassPublic, 'artifactHash'>,
 ) {
   const log = createLogger('circuits:function_membership_proof');
@@ -98,7 +98,7 @@ export async function isValidUnconstrainedFunctionMembershipProof(
   const computedArtifactFunctionTreeRoot = Fr.fromBuffer(computedArtifactFunctionTreeRootBuffer);
   const computedArtifactHash = await computeArtifactHash({
     privateFunctionRoot: fn.privateFunctionsArtifactTreeRoot,
-    unconstrainedFunctionRoot: computedArtifactFunctionTreeRoot,
+    utilityFunctionRoot: computedArtifactFunctionTreeRoot,
     metadataHash: fn.artifactMetadataHash,
   });
   if (!contractClass.artifactHash.equals(computedArtifactHash)) {

package/src/interfaces/allowed_element.ts

@@ -0,0 +1,21 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+import { z } from 'zod';
+
+import type { FunctionSelector } from '../abi/function_selector.js';
+import type { AztecAddress } from '../aztec-address/index.js';
+import { type ZodFor, schemas } from '../schemas/index.js';
+
+type AllowedInstance = { address: AztecAddress };
+type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
+type AllowedClass = { classId: Fr };
+type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
+
+export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
+
+export const AllowedElementSchema = z.union([
+  z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
+  z.object({ address: schemas.AztecAddress }),
+  z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
+  z.object({ classId: schemas.Fr }),
+]) satisfies ZodFor<AllowedElement>;

package/src/interfaces/configs.ts

@@ -1,18 +1,10 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 
 import { z } from 'zod';
 
-import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
 import { type ZodFor, schemas } from '../schemas/index.js';
-
-type AllowedInstance = { address: AztecAddress };
-type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
-type AllowedClass = { classId: Fr };
-type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
-
-export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
+import { type AllowedElement, AllowedElementSchema } from './allowed_element.js';
 
 /**
  * The sequencer configuration.
@@ -37,7 +29,7 @@ export interface SequencerConfig {
   /** The path to the ACVM binary */
   acvmBinaryPath?: string;
   /** The list of functions calls allowed to run in setup */
-  allowedInSetup?: AllowedElement[];
+  txPublicSetupAllowList?: AllowedElement[];
   /** Max block size */
   maxBlockSizeInBytes?: number;
   /** Payload address to vote for */
@@ -48,13 +40,6 @@ export interface SequencerConfig {
   maxL1TxInclusionTimeIntoSlot?: number;
 }
 
-const AllowedElementSchema = z.union([
-  z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
-  z.object({ address: schemas.AztecAddress }),
-  z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
-  z.object({ classId: schemas.Fr }),
-]) satisfies ZodFor<AllowedElement>;
-
 export const SequencerConfigSchema = z.object({
   transactionPollingIntervalMS: z.number().optional(),
   maxTxsPerBlock: z.number().optional(),
@@ -65,7 +50,7 @@ export const SequencerConfigSchema = z.object({
   feeRecipient: schemas.AztecAddress.optional(),
   acvmWorkingDirectory: z.string().optional(),
   acvmBinaryPath: z.string().optional(),
-  allowedInSetup: z.array(AllowedElementSchema).optional(),
+  txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
   maxBlockSizeInBytes: z.number().optional(),
   governanceProposerPayload: schemas.EthAddress.optional(),
   maxL1TxInclusionTimeIntoSlot: z.number().optional(),

package/src/interfaces/public_state_source.ts

@@ -0,0 +1,9 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+  /** Returns the value for a given slot at a given contract. */
+  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}

package/src/interfaces/pxe.ts

@@ -264,19 +264,18 @@ export interface PXE {
   getCurrentBaseFees(): Promise<GasFees>;
 
   /**
-   * Simulate the execution of an unconstrained function on a deployed contract without actually modifying state.
-   * This is useful to inspect contract state, for example fetching a variable value or calling a getter function.
-   * The function takes function name and arguments as parameters, along with the contract address
-   * and optionally the sender's address.
+   * Simulate the execution of a contract utility function.
    *
-   * @param functionName - The name of the function to be called in the contract.
+   * @param functionName - The name of the utility contract function to be called.
    * @param args - The arguments to be provided to the function.
    * @param to - The address of the contract to be called.
+   * @param authwits - (Optional) The authentication witnesses required for the function call.
    * @param from - (Optional) The msg sender to set for the call.
-   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will default to all.
-   * @returns The result of the view function call, structured based on the function ABI.
+   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will
+   * default to all.
+   * @returns The result of the utility function call, structured based on the function ABI.
    */
-  simulateUnconstrained(
+  simulateUtility(
     functionName: string,
     args: any[],
     to: AztecAddress,
@@ -491,7 +490,7 @@ export const PXESchema: ApiSchemaFor<PXE> = {
     .returns(z.union([L2Block.schema, z.undefined()])),
   getCurrentBaseFees: z.function().returns(GasFees.schema),
 
-  simulateUnconstrained: z
+  simulateUtility: z
     .function()
     .args(
       z.string(),

package/src/interfaces/server.ts

@@ -17,3 +17,4 @@ export * from './p2p.js';
 export * from './p2p-bootstrap.js';
 export * from './l2_logs_source.js';
 export * from './merkle_tree_operations.js';
+export * from './allowed_element.js';