@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/contract/private_function.js

@@ -1,6 +1,7 @@
 import { FUNCTION_TREE_HEIGHT, GeneratorIndex } from '@aztec/constants';
-import { pedersenHash, poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
+import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { MerkleTreeCalculator } from '@aztec/foundation/trees';
 // Memoize the merkle tree calculators to avoid re-computing the zero-hash for each level in each call
 let privateFunctionTreeCalculator;

package/dest/contract/private_function_membership_proof.d.ts

@@ -7,7 +7,7 @@ import type { ContractClassPublic, ExecutablePrivateFunctionWithMembershipProof,
  */
 export declare function createPrivateFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<PrivateFunctionMembershipProof>;
 /**
- * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * 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:
  *
  * ```
@@ -17,16 +17,16 @@ export declare function createPrivateFunctionMembershipProof(selector: FunctionS
  * // Compute function leaf and assert it belongs to the private functions tree
  * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__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_function_root
+ * 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, 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.
  * @param contractClass - In which contract class the function is expected to be.
  */
 export declare function isValidPrivateFunctionMembershipProof(fn: ExecutablePrivateFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'privateFunctionsRoot' | 'artifactHash'>): Promise<boolean>;
-//# sourceMappingURL=private_function_membership_proof.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9mdW5jdGlvbl9tZW1iZXJzaGlwX3Byb29mLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3QvcHJpdmF0ZV9mdW5jdGlvbl9tZW1iZXJzaGlwX3Byb29mLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUFFLGdCQUFnQixFQUFnQixNQUFNLGlCQUFpQixDQUFDO0FBVXhGLE9BQU8sS0FBSyxFQUNWLG1CQUFtQixFQUNuQiw0Q0FBNEMsRUFDNUMsOEJBQThCLEVBQy9CLE1BQU0sdUJBQXVCLENBQUM7QUFHL0I7Ozs7R0FJRztBQUNILHdCQUFzQixvQ0FBb0MsQ0FDeEQsUUFBUSxFQUFFLGdCQUFnQixFQUMxQixRQUFRLEVBQUUsZ0JBQWdCLEdBQ3pCLE9BQU8sQ0FBQyw4QkFBOEIsQ0FBQyxDQTREekM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBQ0gsd0JBQXNCLHFDQUFxQyxDQUN6RCxFQUFFLEVBQUUsNENBQTRDLEVBQ2hELGFBQWEsRUFBRSxJQUFJLENBQUMsbUJBQW1CLEVBQUUsc0JBQXNCLEdBQUcsY0FBYyxDQUFDLG9CQWtEbEYifQ==

package/dest/contract/private_function_membership_proof.js

@@ -1,5 +1,5 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+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 { FunctionSelector, FunctionType } from '../abi/index.js';
@@ -25,7 +25,7 @@ import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './priva
         throw new Error(`Private function with selector ${selector.toString()} not found`);
     }
     // Compute preimage for the artifact hash
-    const { unconstrainedFunctionRoot: unconstrainedFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } = await computeArtifactHashPreimage(artifact);
+    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);
@@ -47,7 +47,7 @@ import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './priva
         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(',')
     });
@@ -56,13 +56,13 @@ import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './priva
         artifactTreeLeafIndex,
         artifactMetadataHash,
         functionMetadataHash,
-        unconstrainedFunctionsArtifactTreeRoot,
+        utilityFunctionsTreeRoot,
         privateFunctionTreeSiblingPath: functionsTreeSiblingPath,
         privateFunctionTreeLeafIndex: functionsTreeLeafIndex
     };
 }
 /**
- * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * 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:
  *
  * ```
@@ -72,12 +72,12 @@ import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './priva
  * // Compute function leaf and assert it belongs to the private functions tree
  * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__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_function_root
+ * 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, 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.
@@ -105,7 +105,7 @@ import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './priva
     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)) {
@@ -114,7 +114,7 @@ import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './priva
             computedArtifactHash,
             computedFunctionArtifactHash: functionArtifactHash,
             computedArtifactPrivateFunctionTreeRoot,
-            unconstrainedFunctionRoot: fn.unconstrainedFunctionsArtifactTreeRoot,
+            utilityFunctionRoot: fn.utilityFunctionsTreeRoot,
             metadataHash: fn.artifactMetadataHash,
             artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map((fr)=>fr.toString()).join(',')
         });

package/dest/contract/utility_function_membership_proof.d.ts

@@ -0,0 +1,27 @@
+import { type ContractArtifact, FunctionSelector } from '../abi/index.js';
+import type { ContractClassPublic, UtilityFunctionMembershipProof, UtilityFunctionWithMembershipProof } from './interfaces/index.js';
+/**
+ * Creates a membership proof for a utility  function in a contract class, to be verified via `isValidUtilityFunctionMembershipProof`.
+ * @param selector - Selector of the function to create the proof for.
+ * @param artifact - Artifact of the contract class where the function is defined.
+ */
+export declare function createUtilityFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<UtilityFunctionMembershipProof>;
+/**
+ * Verifies that a utility  function with a membership proof as emitted by the ClassRegistry contract is valid,
+ * as defined in the protocol specs at contract-deployment/classes:
+ *
+ * ```
+ * // Load contract class from local db
+ * contract_class = db.get_contract_class(contract_class_id)
+ *
+ * // Compute artifact leaf and assert it belongs to the artifact
+ * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
+ * computed_artifact_utility_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path, artifact_function_tree_leaf_index)
+ * computed_artifact_hash = sha256(private_functions_artifact_tree_root, computed_artifact_utility_function_tree_root, artifact_metadata_hash)
+ * assert computed_artifact_hash == contract_class.artifact_hash
+ * ```
+ * @param fn - Function to check membership proof for.
+ * @param contractClass - In which contract class the function is expected to be.
+ */
+export declare function isValidUtilityFunctionMembershipProof(fn: UtilityFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'artifactHash'>): Promise<boolean>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbGl0eV9mdW5jdGlvbl9tZW1iZXJzaGlwX3Byb29mLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3QvdXRpbGl0eV9mdW5jdGlvbl9tZW1iZXJzaGlwX3Byb29mLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUFFLGdCQUFnQixFQUFnQixNQUFNLGlCQUFpQixDQUFDO0FBU3hGLE9BQU8sS0FBSyxFQUNWLG1CQUFtQixFQUNuQiw4QkFBOEIsRUFDOUIsa0NBQWtDLEVBQ25DLE1BQU0sdUJBQXVCLENBQUM7QUFFL0I7Ozs7R0FJRztBQUNILHdCQUFzQixvQ0FBb0MsQ0FDeEQsUUFBUSxFQUFFLGdCQUFnQixFQUMxQixRQUFRLEVBQUUsZ0JBQWdCLEdBQ3pCLE9BQU8sQ0FBQyw4QkFBOEIsQ0FBQyxDQXNDekM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILHdCQUFzQixxQ0FBcUMsQ0FDekQsRUFBRSxFQUFFLGtDQUFrQyxFQUN0QyxhQUFhLEVBQUUsSUFBSSxDQUFDLG1CQUFtQixFQUFFLGNBQWMsQ0FBQyxvQkErQnpEIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"utility_function_membership_proof.d.ts","sourceRoot":"","sources":["../../src/contract/utility_function_membership_proof.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AASxF,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC9B,kCAAkC,EACnC,MAAM,uBAAuB,CAAC;AAE/B;;;;GAIG;AACH,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CAsCzC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,qCAAqC,CACzD,EAAE,EAAE,kCAAkC,EACtC,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,CAAC,oBA+BzD"}

package/dest/contract/{unconstrained_function_membership_proof.js → utility_function_membership_proof.js}

@@ -1,23 +1,23 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
 import { FunctionSelector, FunctionType } from '../abi/index.js';
 import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPreimage, computeFunctionArtifactHash, computeFunctionMetadataHash, getArtifactMerkleTreeHasher } from './artifact_hash.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(selector, artifact) {
+ */ export async function createUtilityFunctionMembershipProof(selector, artifact) {
     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)=>({
+    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 } = await computeArtifactHashPreimage(artifact);
@@ -27,10 +27,10 @@ import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPr
         ...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,
@@ -46,7 +46,7 @@ import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPr
     };
 }
 /**
- * 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 ClassRegistry contract is valid,
  * as defined in the protocol specs at contract-deployment/classes:
  *
  * ```
@@ -55,20 +55,20 @@ import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPr
  *
  * // 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, contractClass) {
+ */ export async function isValidUtilityFunctionMembershipProof(fn, contractClass) {
     const log = createLogger('circuits:function_membership_proof');
     const functionArtifactHash = await computeFunctionArtifactHash(fn);
     const computedArtifactFunctionTreeRootBuffer = await computeRootFromSiblingPath(functionArtifactHash.toBuffer(), fn.artifactTreeSiblingPath.map((fr)=>fr.toBuffer()), fn.artifactTreeLeafIndex, getArtifactMerkleTreeHasher());
     const computedArtifactFunctionTreeRoot = Fr.fromBuffer(computedArtifactFunctionTreeRootBuffer);
     const computedArtifactHash = await computeArtifactHash({
         privateFunctionRoot: fn.privateFunctionsArtifactTreeRoot,
-        unconstrainedFunctionRoot: computedArtifactFunctionTreeRoot,
+        utilityFunctionRoot: computedArtifactFunctionTreeRoot,
         metadataHash: fn.artifactMetadataHash
     });
     if (!contractClass.artifactHash.equals(computedArtifactHash)) {

package/dest/database-version/index.d.ts

@@ -1,2 +1,2 @@
 export * from './version_manager.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kYXRhYmFzZS12ZXJzaW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUMifQ==

package/dest/database-version/version_manager.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger } from '@aztec/foundation/log';
 import fs from 'fs/promises';
+import { inspect } from 'node:util';
 import { z } from 'zod';
 /**
  * Represents a version record for storing in a version file.
@@ -10,7 +9,11 @@ import { z } from 'zod';
 export declare class DatabaseVersion {
     readonly schemaVersion: number;
     readonly rollupAddress: EthAddress;
-    constructor(schemaVersion: number, rollupAddress: EthAddress);
+    constructor(
+    /** The version of the data on disk. Used to perform upgrades */
+    schemaVersion: number, 
+    /** The rollup the data pertains to */
+    rollupAddress: EthAddress);
     toBuffer(): Buffer;
     static fromBuffer(buf: Buffer): DatabaseVersion;
     /**
@@ -28,35 +31,48 @@ export declare class DatabaseVersion {
         schemaVersion: z.ZodNumber;
         rollupAddress: z.ZodType<EthAddress, any, string>;
     }, "strip", z.ZodTypeAny, {
-        rollupAddress: EthAddress;
         schemaVersion: number;
+        rollupAddress: EthAddress;
     }, {
-        rollupAddress: string;
         schemaVersion: number;
-    }>, DatabaseVersion, {
         rollupAddress: string;
+    }>, DatabaseVersion, {
         schemaVersion: number;
+        rollupAddress: string;
     }>;
+    /** Allows for better introspection. */
+    [inspect.custom](): string;
+    toString(): string;
     /**
      * Returns an empty instance
      */
     static empty(): DatabaseVersion;
 }
 export type DatabaseVersionManagerFs = Pick<typeof fs, 'readFile' | 'writeFile' | 'rm' | 'mkdir'>;
+export declare const DATABASE_VERSION_FILE_NAME = "db_version";
+export type DatabaseVersionManagerOptions<T> = {
+    schemaVersion: number;
+    rollupAddress: EthAddress;
+    dataDirectory: string;
+    onOpen: (dataDir: string) => Promise<T>;
+    onUpgrade?: (dataDir: string, currentVersion: number, latestVersion: number) => Promise<void>;
+    fileSystem?: DatabaseVersionManagerFs;
+    log?: Logger;
+};
 /**
  * A manager for handling database versioning and migrations.
  * This class will check the version of data in a directory and either
  * reset or upgrade based on version compatibility.
  */
 export declare class DatabaseVersionManager<T> {
+    static readonly VERSION_FILE: string;
+    private readonly versionFile;
+    private readonly currentVersion;
     private dataDirectory;
     private onOpen;
     private onUpgrade?;
     private fileSystem;
     private log;
-    static readonly VERSION_FILE = "db_version";
-    private readonly versionFile;
-    private readonly currentVersion;
     /**
      * Create a new version manager
      *
@@ -69,7 +85,8 @@ export declare class DatabaseVersionManager<T> {
      * @param log - Optional custom logger
      * @param options - Configuration options
      */
-    constructor(schemaVersion: number, rollupAddress: EthAddress, dataDirectory: string, onOpen: (dataDir: string) => Promise<T>, onUpgrade?: ((dataDir: string, currentVersion: number, latestVersion: number) => Promise<void>) | undefined, fileSystem?: DatabaseVersionManagerFs, log?: import("@aztec/foundation/log").Logger);
+    constructor({ schemaVersion, rollupAddress, dataDirectory, onOpen, onUpgrade, fileSystem, log }: DatabaseVersionManagerOptions<T>);
+    static writeVersion(version: DatabaseVersion, dataDir: string, fileSystem?: DatabaseVersionManagerFs): Promise<void>;
     /**
      * Checks the stored version against the current version and handles the outcome
      * by either resetting the data directory or calling an upgrade function
@@ -82,11 +99,11 @@ export declare class DatabaseVersionManager<T> {
     /**
      * Writes the current version to the version file
      */
-    private writeVersion;
+    writeVersion(dir?: string): Promise<void>;
     /**
      * Resets the data directory by deleting it and recreating it
      */
-    private resetDataDirectory;
+    resetDataDirectory(): Promise<void>;
     /**
      * Get the data directory path
      */
@@ -96,4 +113,4 @@ export declare class DatabaseVersionManager<T> {
      */
     getSchemaVersion(): number;
 }
-//# sourceMappingURL=version_manager.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

package/dest/database-version/version_manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version_manager.d.ts","sourceRoot":"","sources":["../../src/database-version/version_manager.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAI3D,OAAO,EAAE,MAAM,aAAa,CAAC;AAE7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,qBAAa,eAAe;aACE,aAAa,EAAE,MAAM;aAAkB,aAAa,EAAE,UAAU;gBAAhE,aAAa,EAAE,MAAM,EAAkB,aAAa,EAAE,UAAU;IAErF,QAAQ,IAAI,MAAM;WAIX,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe;IAQtD;;OAEG;IACI,GAAG,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAa1D;;OAEG;IACI,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAI9C;;OAEG;IACH,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAED;;OAEG;IACH,MAAM,CAAC,KAAK;CAGb;AAED,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC;AAElG;;;;GAIG;AACH,qBAAa,sBAAsB,CAAC,CAAC;IAqBjC,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS,CAAC;IAClB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,GAAG;IAxBb,gBAAuB,YAAY,gBAAgB;IAEnD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAkB;IAEjD;;;;;;;;;;;OAWG;gBAED,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,UAAU,EACjB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACvC,SAAS,CAAC,aAAY,MAAM,kBAAkB,MAAM,iBAAiB,MAAM,KAAK,QAAQ,IAAI,CAAC,aAAA,EAC7F,UAAU,GAAE,wBAA6B,EACzC,GAAG,yCAA6C;IAU1D;;;;;;;OAOG;IACU,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAmD1C;;OAEG;YACW,YAAY;IAO1B;;OAEG;YACW,kBAAkB;IAUhC;;OAEG;IACI,gBAAgB,IAAI,MAAM;IAIjC;;OAEG;IACI,gBAAgB,IAAI,MAAM;CAGlC"}
+{"version":3,"file":"version_manager.d.ts","sourceRoot":"","sources":["../../src/database-version/version_manager.ts"],"names":[],"mappings":"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"}

package/dest/database-version/version_manager.js

@@ -1,15 +1,18 @@
+var _computedKey;
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { jsonParseWithSchemaSync, jsonStringify } from '@aztec/foundation/json-rpc';
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import fs from 'fs/promises';
+import { inspect } from 'node:util';
 import { join } from 'path';
 import { z } from 'zod';
+_computedKey = inspect.custom;
 /**
  * Represents a version record for storing in a version file.
  */ export class DatabaseVersion {
     schemaVersion;
     rollupAddress;
-    constructor(schemaVersion, rollupAddress){
+    constructor(/** The version of the data on disk. Used to perform upgrades */ schemaVersion, /** The rollup the data pertains to */ rollupAddress){
         this.schemaVersion = schemaVersion;
         this.rollupAddress = rollupAddress;
     }
@@ -18,7 +21,7 @@ import { z } from 'zod';
     }
     static fromBuffer(buf) {
         try {
-            return jsonParseWithSchemaSync(buf.toString('utf-8'), DatabaseVersion.schema);
+            return jsonParseWithSchema(buf.toString('utf-8'), DatabaseVersion.schema);
         } catch (err) {
             throw new Error(`Failed to deserialize version information: ${err}`, {
                 cause: err
@@ -52,25 +55,32 @@ import { z } from 'zod';
             rollupAddress: EthAddress.schema
         }).transform(({ schemaVersion, rollupAddress })=>new DatabaseVersion(schemaVersion, rollupAddress));
     }
+    /** Allows for better introspection. */ [_computedKey]() {
+        return this.toString();
+    }
+    toString() {
+        return `DatabaseVersion{schemaVersion=${this.schemaVersion},rollupAddress=${this.rollupAddress}"}`;
+    }
     /**
    * Returns an empty instance
    */ static empty() {
         return new DatabaseVersion(0, EthAddress.ZERO);
     }
 }
+export const DATABASE_VERSION_FILE_NAME = 'db_version';
 /**
  * A manager for handling database versioning and migrations.
  * This class will check the version of data in a directory and either
  * reset or upgrade based on version compatibility.
  */ export class DatabaseVersionManager {
+    static VERSION_FILE = DATABASE_VERSION_FILE_NAME;
+    versionFile;
+    currentVersion;
     dataDirectory;
     onOpen;
     onUpgrade;
     fileSystem;
     log;
-    static VERSION_FILE = 'db_version';
-    versionFile;
-    currentVersion;
     /**
    * Create a new version manager
    *
@@ -82,17 +92,23 @@ import { z } from 'zod';
    * @param fileSystem - An interface to access the filesystem
    * @param log - Optional custom logger
    * @param options - Configuration options
-   */ constructor(schemaVersion, rollupAddress, dataDirectory, onOpen, onUpgrade, fileSystem = fs, log = createLogger(`foundation:version-manager`)){
+   */ constructor({ schemaVersion, rollupAddress, dataDirectory, onOpen, onUpgrade, fileSystem = fs, log = createLogger(`foundation:version-manager`) }){
+        if (schemaVersion < 1) {
+            throw new TypeError(`Invalid schema version received: ${schemaVersion}`);
+        }
+        this.versionFile = join(dataDirectory, DatabaseVersionManager.VERSION_FILE);
+        this.currentVersion = new DatabaseVersion(schemaVersion, rollupAddress);
         this.dataDirectory = dataDirectory;
         this.onOpen = onOpen;
         this.onUpgrade = onUpgrade;
         this.fileSystem = fileSystem;
         this.log = log;
-        if (schemaVersion < 1) {
-            throw new TypeError(`Invalid schema version received: ${schemaVersion}`);
-        }
-        this.versionFile = join(this.dataDirectory, DatabaseVersionManager.VERSION_FILE);
-        this.currentVersion = new DatabaseVersion(schemaVersion, rollupAddress);
+    }
+    static async writeVersion(version, dataDir, fileSystem = fs) {
+        await fileSystem.mkdir(dataDir, {
+            recursive: true
+        });
+        return fileSystem.writeFile(join(dataDir, DatabaseVersionManager.VERSION_FILE), version.toBuffer());
     }
     /**
    * Checks the stored version against the current version and handles the outcome
@@ -104,12 +120,16 @@ import { z } from 'zod';
    */ async open() {
         // const storedVersion = await DatabaseVersion.readVersion(this.versionFile);
         let storedVersion;
+        // a flag to suppress logs about 'resetting the data dir' when starting from an empty state
+        let shouldLogDataReset = true;
         try {
             const versionBuf = await this.fileSystem.readFile(this.versionFile);
             storedVersion = DatabaseVersion.fromBuffer(versionBuf);
         } catch (err) {
             if (err && err.code === 'ENOENT') {
                 storedVersion = DatabaseVersion.empty();
+                // only turn off these logs if the data dir didn't exist before
+                shouldLogDataReset = false;
             } else {
                 this.log.warn(`Failed to read stored version information: ${err}. Defaulting to empty version`);
                 storedVersion = DatabaseVersion.empty();
@@ -128,11 +148,19 @@ import { z } from 'zod';
                     needsReset = true;
                 }
             } else if (cmp !== 0) {
-                this.log.info(`Can't upgrade from version ${storedVersion.schemaVersion} to ${this.currentVersion}. Resetting database at ${this.dataDirectory}`);
+                if (shouldLogDataReset) {
+                    this.log.info(`Can't upgrade from version ${storedVersion} to ${this.currentVersion}. Resetting database at ${this.dataDirectory}`);
+                }
                 needsReset = true;
             }
         } else {
-            this.log.warn('Rollup address changed, resetting data directory');
+            if (shouldLogDataReset) {
+                this.log.warn('Rollup address has changed, resetting data directory', {
+                    versionFile: this.versionFile,
+                    storedVersion,
+                    currentVersion: this.currentVersion
+                });
+            }
             needsReset = true;
         }
         // Handle reset if needed
@@ -148,13 +176,8 @@ import { z } from 'zod';
     }
     /**
    * Writes the current version to the version file
-   */ async writeVersion() {
-        // Ensure the directory exists
-        await this.fileSystem.mkdir(this.dataDirectory, {
-            recursive: true
-        });
-        // Write the version file
-        await this.fileSystem.writeFile(this.versionFile, this.currentVersion.toBuffer());
+   */ writeVersion(dir) {
+        return DatabaseVersionManager.writeVersion(this.currentVersion, dir ?? this.dataDirectory, this.fileSystem);
     }
     /**
    * Resets the data directory by deleting it and recreating it

package/dest/delayed_public_mutable/delayed_public_mutable_values.d.ts

@@ -0,0 +1,20 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+export declare const DELAYED_PUBLIC_MUTABLE_VALUES_LEN: number;
+export declare class DelayedPublicMutableValues {
+    svc: ScheduledValueChange;
+    sdc: ScheduledDelayChange;
+    constructor(svc: ScheduledValueChange, sdc: ScheduledDelayChange);
+    static fromFields(fields: Fr[] | FieldReader): DelayedPublicMutableValues;
+    toFields(): Fr[];
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): DelayedPublicMutableValues;
+    static empty(valueSize: number): DelayedPublicMutableValues;
+    static readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>): Promise<DelayedPublicMutableValues>;
+    isEmpty(): boolean;
+    writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>): Promise<void>;
+    hash(): Promise<Fr>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXllZF9wdWJsaWNfbXV0YWJsZV92YWx1ZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kZWxheWVkX3B1YmxpY19tdXRhYmxlL2RlbGF5ZWRfcHVibGljX211dGFibGVfdmFsdWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNuRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVuRSxlQUFPLE1BQU0saUNBQWlDLFFBQTZCLENBQUM7QUFFNUUscUJBQWEsMEJBQTBCO0lBRTVCLEdBQUcsRUFBRSxvQkFBb0I7SUFDekIsR0FBRyxFQUFFLG9CQUFvQjtJQUZsQyxZQUNTLEdBQUcsRUFBRSxvQkFBb0IsRUFDekIsR0FBRyxFQUFFLG9CQUFvQixFQUM5QjtJQUVKLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLFdBQVcsOEJBeUIzQztJQUVELFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FXZjtJQUVELFFBQVEsSUFBSSxNQUFNLENBRWpCO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksRUFBRSxTQUFTLEVBQUUsTUFBTSxHQUFHLDBCQUEwQixDQUc5RjtJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLE1BQU0sOEJBRTdCO0lBRUQsT0FBYSxZQUFZLENBQUMsd0JBQXdCLEVBQUUsRUFBRSxFQUFFLFdBQVcsRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLEtBQUssT0FBTyxDQUFDLEVBQUUsQ0FBQyx1Q0FNcEc7SUFFRCxPQUFPLElBQUksT0FBTyxDQUVqQjtJQUVLLFdBQVcsQ0FBQyx3QkFBd0IsRUFBRSxFQUFFLEVBQUUsWUFBWSxFQUFFLENBQUMsV0FBVyxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLE9BQU8sQ0FBQyxJQUFJLENBQUMsaUJBTTFHO0lBRUssSUFBSSxJQUFJLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FJeEI7Q0FDRiJ9

package/dest/delayed_public_mutable/delayed_public_mutable_values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed_public_mutable_values.d.ts","sourceRoot":"","sources":["../../src/delayed_public_mutable/delayed_public_mutable_values.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,eAAO,MAAM,iCAAiC,QAA6B,CAAC;AAE5E,qBAAa,0BAA0B;IAE5B,GAAG,EAAE,oBAAoB;IACzB,GAAG,EAAE,oBAAoB;IAFlC,YACS,GAAG,EAAE,oBAAoB,EACzB,GAAG,EAAE,oBAAoB,EAC9B;IAEJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,8BAyB3C;IAED,QAAQ,IAAI,EAAE,EAAE,CAWf;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,0BAA0B,CAG9F;IAED,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,8BAE7B;IAED,OAAa,YAAY,CAAC,wBAAwB,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,WAAW,EAAE,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC,uCAMpG;IAED,OAAO,IAAI,OAAO,CAEjB;IAEK,WAAW,CAAC,wBAAwB,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC,WAAW,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,iBAM1G;IAEK,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC,CAIxB;CACF"}

package/dest/{shared_mutable/shared_mutable_values.js → delayed_public_mutable/delayed_public_mutable_values.js}

@@ -1,11 +1,11 @@
 import { UPDATES_VALUE_SIZE } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { ScheduledDelayChange } from './scheduled_delay_change.js';
 import { ScheduledValueChange } from './scheduled_value_change.js';
-export const SHARED_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
-export class SharedMutableValues {
+export const DELAYED_PUBLIC_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
+export class DelayedPublicMutableValues {
     svc;
     sdc;
     constructor(svc, sdc){
@@ -18,22 +18,22 @@ export class SharedMutableValues {
         // Extract fields for ScheduledValueChange
         const svcPre = reader.readFieldArray(UPDATES_VALUE_SIZE);
         const svcPost = reader.readFieldArray(UPDATES_VALUE_SIZE);
-        const svcBlockOfChange = firstField & 0xffffffffn;
-        const svc = new ScheduledValueChange(svcPre, svcPost, Number(svcBlockOfChange));
+        const svcTimestampOfChange = firstField & 0xffffffffn;
+        const svc = new ScheduledValueChange(svcPre, svcPost, svcTimestampOfChange);
         // Extract fields for ScheduledDelayChange from first field
-        const sdcBlockOfChange = firstField >> 32n & 0xffffffffn;
+        const sdcTimestampOfChange = firstField >> 32n & 0xffffffffn;
         const sdcIsPostSome = firstField >> 64n & 1n;
         const sdcPost = firstField >> 72n & 0xffffffffn;
         const sdcIsPreSome = firstField >> 104n & 1n;
         const sdcPre = firstField >> 112n & 0xffffffffn;
-        const sdc = new ScheduledDelayChange(sdcIsPreSome ? Number(sdcPre) : undefined, sdcIsPostSome ? Number(sdcPost) : undefined, Number(sdcBlockOfChange));
+        const sdc = new ScheduledDelayChange(sdcIsPreSome ? sdcPre : undefined, sdcIsPostSome ? sdcPost : undefined, sdcTimestampOfChange);
         return new this(svc, sdc);
     }
     toFields() {
         // Pack format matches Noir implementation:
-        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.block_of_change: u32 | svc.block_of_change: u32 ]
-        let firstField = BigInt(this.svc.blockOfChange);
-        firstField |= BigInt(this.sdc.blockOfChange) << 32n;
+        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]
+        let firstField = this.svc.timestampOfChange;
+        firstField |= this.sdc.timestampOfChange << 32n;
         firstField |= (this.sdc.post === undefined ? 0n : 1n) << 64n;
         firstField |= BigInt(this.sdc.post || 0) << 72n;
         firstField |= (this.sdc.pre === undefined ? 0n : 1n) << 104n;
@@ -49,25 +49,25 @@ export class SharedMutableValues {
     }
     static fromBuffer(buffer, valueSize) {
         const reader = BufferReader.asReader(buffer);
-        return SharedMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
+        return DelayedPublicMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
     }
     static empty(valueSize) {
         return new this(ScheduledValueChange.empty(valueSize), ScheduledDelayChange.empty());
     }
-    static async readFromTree(sharedMutableSlot, readStorage) {
+    static async readFromTree(delayedPublicMutableSlot, readStorage) {
         const fields = [];
-        for(let i = 0; i < SHARED_MUTABLE_VALUES_LEN; i++){
-            fields.push(await readStorage(sharedMutableSlot.add(new Fr(i))));
+        for(let i = 0; i < DELAYED_PUBLIC_MUTABLE_VALUES_LEN; i++){
+            fields.push(await readStorage(delayedPublicMutableSlot.add(new Fr(i))));
         }
-        return SharedMutableValues.fromFields(fields);
+        return DelayedPublicMutableValues.fromFields(fields);
     }
     isEmpty() {
         return this.svc.isEmpty() && this.sdc.isEmpty();
     }
-    async writeToTree(sharedMutableSlot, storageWrite) {
+    async writeToTree(delayedPublicMutableSlot, storageWrite) {
         const fields = this.toFields();
         for(let i = 0; i < fields.length; i++){
-            await storageWrite(sharedMutableSlot.add(new Fr(i)), fields[i]);
+            await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
         }
     }
     async hash() {