@aztec/stdlib 0.83.1 → 0.84.0

package/src/noir/index.ts

@@ -10,6 +10,7 @@ import type {
 
 export const AZTEC_PRIVATE_ATTRIBUTE = 'private';
 export const AZTEC_PUBLIC_ATTRIBUTE = 'public';
+export const AZTEC_UTILITY_ATTRIBUTE = 'utility';
 export const AZTEC_INTERNAL_ATTRIBUTE = 'internal';
 export const AZTEC_INITIALIZER_ATTRIBUTE = 'initializer';
 export const AZTEC_VIEW_ATTRIBUTE = 'view';
@@ -36,7 +37,7 @@ export interface NoirFunctionAbi {
 /**
  * The compilation result of an Aztec.nr function.
  */
-export interface NoirFunctionEntry {
+interface NoirFunctionEntry {
   /** The name of the function. */
   name: string;
   /** Whether the function is unconstrained. */

package/src/proofs/proof.ts

@@ -17,11 +17,6 @@ export class Proof {
   // Make sure this type is not confused with other buffer wrappers
   readonly __proofBrand: any;
 
-  // Honk proofs start with a 4 byte length prefix
-  // the proof metadata starts immediately after
-  // TODO(https://github.com/AztecProtocol/barretenberg/issues/1312): Get rid of if possible.
-  private readonly metadataOffset = 4;
-
   constructor(
     /**
      * Holds the serialized proof data in a binary buffer format.
@@ -69,14 +64,14 @@ export class Proof {
       return this.buffer;
     }
     // We are indexing to this particular size because we are assuming the proof buffer looks like:
-    // [4 bytes of metadata for public inputs, binary public inputs, 4 bytes of metadata for proof, binary proof]
-    const proofStart = this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs + this.metadataOffset;
+    // [binary public inputs, binary proof]
+    const proofStart = Fr.SIZE_IN_BYTES * this.numPublicInputs;
     assert(this.buffer.length >= proofStart, 'Proof buffer is not appropriately sized to call withoutPublicInputs()');
     return this.buffer.subarray(proofStart);
   }
 
   // This function assumes that the proof will contain an aggregation object and look something like:
-  // [4 bytes of metadata for public inputs, binary public inputs, 4 bytes of metadata for proof, aggregation object, rest of proof]
+  // [binary public inputs, aggregation object, rest of proof]
   // We are extracting the binary public inputs and reading them as Frs, and also extracting the aggregation object.
   public extractPublicInputs(): Fr[] {
     if (this.isEmpty()) {
@@ -85,9 +80,7 @@ export class Proof {
     }
     assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
     const numInnerPublicInputs = this.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-    const reader = BufferReader.asReader(
-      this.buffer.subarray(this.metadataOffset, this.metadataOffset + Fr.SIZE_IN_BYTES * numInnerPublicInputs),
-    );
+    const reader = BufferReader.asReader(this.buffer.subarray(0, Fr.SIZE_IN_BYTES * numInnerPublicInputs));
     let publicInputs = reader.readArray(numInnerPublicInputs, Fr);
     // concatenate Fr[] with aggregation object
     publicInputs = publicInputs.concat(this.extractAggregationObject());
@@ -101,12 +94,9 @@ export class Proof {
     }
     assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
     const numInnerPublicInputs = this.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-    // The aggregation object is currently stored after the initial inner public inputs and after the 4 byte proof metadata.
+    // The aggregation object is currently stored after the initial inner public inputs.
     const reader = BufferReader.asReader(
-      this.buffer.subarray(
-        this.metadataOffset + Fr.SIZE_IN_BYTES * numInnerPublicInputs + this.metadataOffset,
-        this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs + this.metadataOffset,
-      ),
+      this.buffer.subarray(Fr.SIZE_IN_BYTES * numInnerPublicInputs, Fr.SIZE_IN_BYTES * this.numPublicInputs),
     );
     return reader.readArray(AGGREGATION_OBJECT_LENGTH, Fr);
   }

package/src/tests/factories.ts

@@ -69,6 +69,7 @@ import {
   AvmGetSiblingPathHint,
   AvmSequentialInsertHintNullifierTree,
   AvmSequentialInsertHintPublicDataTree,
+  AvmTxHint,
   RevertCode,
 } from '../avm/index.js';
 import { PublicDataHint } from '../avm/public_data_hint.js';
@@ -81,7 +82,7 @@ import {
   type ExecutablePrivateFunctionWithMembershipProof,
   type PrivateFunction,
   SerializableContractInstance,
-  type UnconstrainedFunctionWithMembershipProof,
+  type UtilityFunctionWithMembershipProof,
   computeContractClassId,
   computePublicBytecodeCommitment,
 } from '../contract/index.js';
@@ -1168,12 +1169,12 @@ export function makeExecutablePrivateFunctionWithMembershipProof(
     privateFunctionTreeLeafIndex: seed + 3,
     artifactMetadataHash: fr(seed + 4),
     functionMetadataHash: fr(seed + 5),
-    unconstrainedFunctionsArtifactTreeRoot: fr(seed + 6),
+    utilityFunctionsTreeRoot: fr(seed + 6),
     vkHash: fr(seed + 7),
   };
 }
 
-export function makeUnconstrainedFunctionWithMembershipProof(seed = 0): UnconstrainedFunctionWithMembershipProof {
+export function makeUtilityFunctionWithMembershipProof(seed = 0): UtilityFunctionWithMembershipProof {
   return {
     selector: makeSelector(seed),
     bytecode: makeBytes(100, seed + 1),
@@ -1197,7 +1198,7 @@ export async function makeContractClassPublic(seed = 0, publicBytecode?: Buffer)
     packedBytecode,
     privateFunctionsRoot,
     privateFunctions: [],
-    unconstrainedFunctions: [],
+    utilityFunctions: [],
     version: 1,
   };
 }
@@ -1427,6 +1428,22 @@ export function makeAvmEnqueuedCallHint(seed = 0): AvmEnqueuedCallHint {
   );
 }
 
+export function makeAvmTxHint(seed = 0): AvmTxHint {
+  return new AvmTxHint(
+    {
+      noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
+      nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x2000),
+    },
+    {
+      noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x3000),
+      nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x4000),
+    },
+    makeArray((seed % 20) + 4, i => makeAvmEnqueuedCallHint(i), seed + 0x5000), // setupEnqueuedCalls
+    makeArray((seed % 20) + 4, i => makeAvmEnqueuedCallHint(i), seed + 0x6000), // appLogicEnqueuedCalls
+    makeAvmEnqueuedCallHint(seed + 0x7000), // teardownEnqueuedCall
+  );
+}
+
 /**
  * Creates arbitrary AvmExecutionHints.
  * @param seed - The seed to use for generating the hints.
@@ -1441,7 +1458,7 @@ export async function makeAvmExecutionHints(
   const baseLength = lengthOffset + (seed % lengthSeedMod);
 
   const fields = {
-    enqueuedCalls: makeArray(baseLength, makeAvmEnqueuedCallHint, seed + 0x4100),
+    tx: makeAvmTxHint(seed + 0x4100),
     contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
     contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
     bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
@@ -1468,7 +1485,7 @@ export async function makeAvmExecutionHints(
   };
 
   return new AvmExecutionHints(
-    fields.enqueuedCalls,
+    fields.tx,
     fields.contractInstances,
     fields.contractClasses,
     fields.bytecodeCommitments,

package/src/trees/database_public_state_source.ts

@@ -0,0 +1,30 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { computePublicDataTreeLeafSlot } from '../hash/hash.js';
+import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operations.js';
+import type { PublicStateSource } from '../interfaces/public_state_source.js';
+import { MerkleTreeId } from './merkle_tree_id.js';
+import type { PublicDataTreeLeafPreimage } from './public_data_leaf.js';
+
+export type { PublicStateSource };
+
+export class DatabasePublicStateSource implements PublicStateSource {
+  constructor(private db: MerkleTreeReadOperations) {}
+
+  async storageRead(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
+    const leafSlot = (await computePublicDataTreeLeafSlot(contractAddress, slot)).toBigInt();
+
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+      return Fr.ZERO;
+    }
+
+    const preimage = (await this.db.getLeafPreimage(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      lowLeafResult.index,
+    )) as PublicDataTreeLeafPreimage;
+
+    return preimage.leaf.value;
+  }
+}

package/src/trees/index.ts

@@ -6,3 +6,4 @@ export * from './merkle_tree_id.js';
 export * from './nullifier_membership_witness.js';
 export * from './public_data_witness.js';
 export * from '../interfaces/merkle_tree_operations.js';
+export * from './database_public_state_source.js';

package/dest/contract/unconstrained_function_membership_proof.d.ts

@@ -1,27 +0,0 @@
-import { type ContractArtifact, FunctionSelector } from '../abi/index.js';
-import type { ContractClassPublic, UnconstrainedFunctionMembershipProof, UnconstrainedFunctionWithMembershipProof } from './interfaces/index.js';
-/**
- * Creates a membership proof for an unconstrained function in a contract class, to be verified via `isValidUnconstrainedFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */
-export declare function createUnconstrainedFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<UnconstrainedFunctionMembershipProof>;
-/**
- * Verifies that an unconstrained function with a membership proof as emitted by the ClassRegisterer 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_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)
- * 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 declare function isValidUnconstrainedFunctionMembershipProof(fn: UnconstrainedFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'artifactHash'>): Promise<boolean>;
-//# sourceMappingURL=unconstrained_function_membership_proof.d.ts.map

package/dest/contract/unconstrained_function_membership_proof.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unconstrained_function_membership_proof.d.ts","sourceRoot":"","sources":["../../src/contract/unconstrained_function_membership_proof.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AASxF,OAAO,KAAK,EACV,mBAAmB,EACnB,oCAAoC,EACpC,wCAAwC,EACzC,MAAM,uBAAuB,CAAC;AAE/B;;;;GAIG;AACH,wBAAsB,0CAA0C,CAC9D,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,oCAAoC,CAAC,CAsC/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,2CAA2C,CAC/D,EAAE,EAAE,wCAAwC,EAC5C,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,CAAC,oBA+BzD"}