@aztec/stdlib 0.0.1-commit.c0b82b2 → 0.0.1-commit.c2eed6949

package/src/update-checker/version_checker.ts

@@ -0,0 +1,65 @@
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+
+import { EventEmitter } from 'node:events';
+
+export type EventMap = {
+  newVersion: [{ name: string; currentVersion: string; latestVersion: string }];
+};
+
+export type VersionCheck = {
+  name: string;
+  currentVersion: string;
+  getLatestVersion: () => Promise<string | undefined>;
+};
+
+export class VersionChecker extends EventEmitter<EventMap> {
+  private runningPromise: RunningPromise;
+  constructor(
+    private checks: Array<VersionCheck>,
+    intervalCheckMs = 60_000,
+    private logger = createLogger('version_checker'),
+  ) {
+    super();
+    this.runningPromise = new RunningPromise(this.run, logger, intervalCheckMs);
+  }
+
+  public start(): void {
+    if (this.runningPromise.isRunning()) {
+      this.logger.warn('VersionChecker is already running');
+      return;
+    }
+
+    this.runningPromise.start();
+    this.logger.info('Version check started');
+  }
+
+  public trigger(): Promise<void> {
+    return this.runningPromise.trigger();
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.runningPromise.isRunning()) {
+      this.logger.warn('VersionChecker is not running');
+      return;
+    }
+
+    await this.runningPromise.stop();
+    this.logger.info('Version checker stopped');
+  }
+
+  private run = async () => {
+    await Promise.allSettled(this.checks.map(check => this.checkVersion(check)));
+  };
+
+  private async checkVersion({ name, currentVersion, getLatestVersion }: VersionCheck): Promise<void> {
+    try {
+      const latestVersion = await getLatestVersion();
+      if (latestVersion && latestVersion !== currentVersion) {
+        this.emit('newVersion', { name, latestVersion, currentVersion });
+      }
+    } catch (err) {
+      this.logger.warn(`Error checking for new ${name} versions: ${err}`, { err });
+    }
+  }
+}

package/src/validators/errors.ts

@@ -36,6 +36,15 @@ export class FailedToReExecuteTransactionsError extends ValidatorError {
   }
 }
 
+export class ReExInitialStateMismatchError extends ValidatorError {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+  ) {
+    super('Re-execution initial state mismatch');
+  }
+}
+
 export class ReExStateMismatchError extends ValidatorError {
   constructor(
     public readonly expectedArchiveRoot: Fr,

package/src/versioning/versioning.ts

@@ -115,7 +115,7 @@ export function validatePartialComponentVersionsMatch(
 }
 
 /** Returns a Koa middleware that injects the versioning info as headers. */
-export function getVersioningMiddleware(versions: Partial<ComponentsVersions>) {
+export function getVersioningMiddleware(versions: Partial<ComponentsVersions>, opts?: { packageVersion?: string }) {
   return async (ctx: Koa.Context, next: () => Promise<void>) => {
     try {
       await next();
@@ -128,6 +128,9 @@ export function getVersioningMiddleware(versions: Partial<ComponentsVersions>) {
           ctx.set(`x-aztec-${key}`, value.toString());
         }
       }
+      if (opts?.packageVersion) {
+        ctx.set('x-aztec-packageVersion', opts.packageVersion);
+      }
     }
   };
 }

package/dest/contract/private_function_membership_proof.d.ts

@@ -1,32 +0,0 @@
-import { type ContractArtifact, FunctionSelector } from '../abi/index.js';
-import type { ContractClassPublic, ExecutablePrivateFunctionWithMembershipProof, PrivateFunctionMembershipProof } from './interfaces/index.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 declare function createPrivateFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<PrivateFunctionMembershipProof>;
-/**
- * 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 declare function isValidPrivateFunctionMembershipProof(fn: ExecutablePrivateFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'privateFunctionsRoot' | 'artifactHash'>): Promise<boolean>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9mdW5jdGlvbl9tZW1iZXJzaGlwX3Byb29mLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3QvcHJpdmF0ZV9mdW5jdGlvbl9tZW1iZXJzaGlwX3Byb29mLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUFFLGdCQUFnQixFQUFnQixNQUFNLGlCQUFpQixDQUFDO0FBVXhGLE9BQU8sS0FBSyxFQUNWLG1CQUFtQixFQUNuQiw0Q0FBNEMsRUFDNUMsOEJBQThCLEVBQy9CLE1BQU0sdUJBQXVCLENBQUM7QUFHL0I7Ozs7R0FJRztBQUNILHdCQUFzQixvQ0FBb0MsQ0FDeEQsUUFBUSxFQUFFLGdCQUFnQixFQUMxQixRQUFRLEVBQUUsZ0JBQWdCLEdBQ3pCLE9BQU8sQ0FBQyw4QkFBOEIsQ0FBQyxDQTREekM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBQ0gsd0JBQXNCLHFDQUFxQyxDQUN6RCxFQUFFLEVBQUUsNENBQTRDLEVBQ2hELGFBQWEsRUFBRSxJQUFJLENBQUMsbUJBQW1CLEVBQUUsc0JBQXNCLEdBQUcsY0FBYyxDQUFDLG9CQWtEbEYifQ==

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

@@ -1 +0,0 @@
-{"version":3,"file":"private_function_membership_proof.d.ts","sourceRoot":"","sources":["../../src/contract/private_function_membership_proof.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AAUxF,OAAO,KAAK,EACV,mBAAmB,EACnB,4CAA4C,EAC5C,8BAA8B,EAC/B,MAAM,uBAAuB,CAAC;AAG/B;;;;GAIG;AACH,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CA4DzC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,qCAAqC,CACzD,EAAE,EAAE,4CAA4C,EAChD,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,sBAAsB,GAAG,cAAc,CAAC,oBAkDlF"}

package/dest/contract/private_function_membership_proof.js

@@ -1,124 +0,0 @@
-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';
-import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPreimage, computeFunctionArtifactHash, computeFunctionMetadataHash, getArtifactMerkleTreeHasher } from './artifact_hash.js';
-import { getContractClassPrivateFunctionFromArtifact } from './contract_class.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, artifact) {
-    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, contractClass) {
-    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;
-}

package/dest/contract/utility_function_membership_proof.d.ts

@@ -1,27 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/utility_function_membership_proof.js

@@ -1,87 +0,0 @@
-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 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 createUtilityFunctionMembershipProof(selector, artifact) {
-    const log = createLogger('circuits:function_membership_proof');
-    // Locate function artifact
-    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 = utilityFunctionsAndSelectors.find((fnAndSelector)=>selector.equals(fnAndSelector.selector))?.fn;
-    if (!fn) {
-        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);
-    // Compute the sibling path for the "artifact tree"
-    const functionMetadataHash = computeFunctionMetadataHash(fn);
-    const functionArtifactHash = await computeFunctionArtifactHash({
-        ...fn,
-        functionMetadataHash
-    });
-    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 utility function with selector ${selector.toString()}`, {
-        functionArtifactHash,
-        functionMetadataHash,
-        artifactMetadataHash,
-        artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map((fr)=>fr.toString()).join(','),
-        privateFunctionsArtifactTreeRoot
-    });
-    return {
-        artifactTreeSiblingPath,
-        artifactTreeLeafIndex,
-        artifactMetadataHash,
-        functionMetadataHash,
-        privateFunctionsArtifactTreeRoot
-    };
-}
-/**
- * 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 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,
-        utilityFunctionRoot: computedArtifactFunctionTreeRoot,
-        metadataHash: fn.artifactMetadataHash
-    });
-    if (!contractClass.artifactHash.equals(computedArtifactHash)) {
-        log.debug(`Artifact hash mismatch`, {
-            expected: contractClass.artifactHash,
-            computedArtifactHash,
-            computedFunctionArtifactHash: functionArtifactHash,
-            computedArtifactFunctionTreeRoot,
-            privateFunctionsArtifactTreeRoot: fn.privateFunctionsArtifactTreeRoot,
-            metadataHash: fn.artifactMetadataHash,
-            artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map((fr)=>fr.toString()).join(',')
-        });
-        return false;
-    }
-    return true;
-}

package/dest/update-checker/update-checker.d.ts

@@ -1,49 +0,0 @@
-import type { ViemClient } from '@aztec/ethereum/types';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { EventEmitter } from 'events';
-export type EventMap = {
-    newRollupVersion: [{
-        currentVersion: bigint;
-        latestVersion: bigint;
-    }];
-    newNodeVersion: [{
-        currentVersion: string;
-        latestVersion: string;
-    }];
-    updateNodeConfig: [object];
-    updatePublicTelemetryConfig: [object];
-};
-type Config = {
-    baseURL: URL;
-    nodeVersion?: string;
-    checkIntervalMs?: number;
-    registryContractAddress: EthAddress;
-    publicClient: ViemClient;
-    fetch?: typeof fetch;
-};
-export declare class UpdateChecker extends EventEmitter<EventMap> {
-    private updatesUrl;
-    private nodeVersion;
-    private rollupVersion;
-    private fetch;
-    private getLatestRollupVersion;
-    private checkIntervalMs;
-    private log;
-    private runningPromise;
-    private lastPatchedConfig;
-    private lastPatchedPublicTelemetryConfig;
-    constructor(updatesUrl: URL, nodeVersion: string | undefined, rollupVersion: bigint, fetch: typeof globalThis.fetch, getLatestRollupVersion: () => Promise<bigint>, checkIntervalMs?: number, log?: import("@aztec/foundation/log").Logger);
-    static new(config: Config): Promise<UpdateChecker>;
-    start(): void;
-    stop(): Promise<void>;
-    trigger(): Promise<void>;
-    private runChecks;
-    private checkRollupVersion;
-    private checkConfig;
-}
-/**
- * Returns package version.
- */
-export declare function getPackageVersion(): string | undefined;
-export {};
-//# sourceMappingURL=data:application/json;base64,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

package/dest/update-checker/update-checker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"update-checker.d.ts","sourceRoot":"","sources":["../../src/update-checker/update-checker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAK3D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAYtC,MAAM,MAAM,QAAQ,GAAG;IACrB,gBAAgB,EAAE,CAAC;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtE,cAAc,EAAE,CAAC;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpE,gBAAgB,EAAE,CAAC,MAAM,CAAC,CAAC;IAC3B,2BAA2B,EAAE,CAAC,MAAM,CAAC,CAAC;CACvC,CAAC;AAEF,KAAK,MAAM,GAAG;IACZ,OAAO,EAAE,GAAG,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,UAAU,CAAC;IACpC,YAAY,EAAE,UAAU,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB,CAAC;AAEF,qBAAa,aAAc,SAAQ,YAAY,CAAC,QAAQ,CAAC;IAMrD,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,sBAAsB;IAC9B,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,GAAG;IAXb,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,iBAAiB,CAAc;IACvC,OAAO,CAAC,gCAAgC,CAAc;IAEtD,YACU,UAAU,EAAE,GAAG,EACf,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,EAC9B,sBAAsB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAC7C,eAAe,SAAc,EAC7B,GAAG,yCAA0C,EAItD;IAED,OAAoB,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAY9D;IAEM,KAAK,IAAI,IAAI,CAWnB;IAEM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAM3B;IAEM,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAE9B;IAED,OAAO,CAAC,SAAS,CAEf;YAEY,kBAAkB;YAelB,WAAW;CAsC1B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,SAAS,CAWtD"}

package/dest/update-checker/update-checker.js

@@ -1,130 +0,0 @@
-import { RegistryContract } from '@aztec/ethereum/contracts';
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import { fileURLToPath } from '@aztec/foundation/url';
-import { EventEmitter } from 'events';
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { isDeepStrictEqual } from 'util';
-import { z } from 'zod';
-const updateConfigSchema = z.object({
-    version: z.string().optional(),
-    publicTelemetry: z.any().optional(),
-    config: z.any().optional()
-});
-export class UpdateChecker extends EventEmitter {
-    updatesUrl;
-    nodeVersion;
-    rollupVersion;
-    fetch;
-    getLatestRollupVersion;
-    checkIntervalMs;
-    log;
-    runningPromise;
-    lastPatchedConfig;
-    lastPatchedPublicTelemetryConfig;
-    constructor(updatesUrl, nodeVersion, rollupVersion, fetch1, getLatestRollupVersion, checkIntervalMs = 10 * 60_000, log = createLogger('foundation:update-check')){
-        super(), this.updatesUrl = updatesUrl, this.nodeVersion = nodeVersion, this.rollupVersion = rollupVersion, this.fetch = fetch1, this.getLatestRollupVersion = getLatestRollupVersion, this.checkIntervalMs = checkIntervalMs, this.log = log, this.lastPatchedConfig = {}, this.lastPatchedPublicTelemetryConfig = {}, this.runChecks = async ()=>{
-            await Promise.all([
-                this.checkRollupVersion(),
-                this.checkConfig()
-            ]);
-        };
-        this.runningPromise = new RunningPromise(this.runChecks, this.log, this.checkIntervalMs);
-    }
-    static async new(config) {
-        const registryContract = new RegistryContract(config.publicClient, config.registryContractAddress);
-        const getLatestRollupVersion = ()=>registryContract.getRollupVersions().then((versions)=>versions.at(-1));
-        return new UpdateChecker(config.baseURL, config.nodeVersion ?? getPackageVersion(), await getLatestRollupVersion(), config.fetch ?? fetch, getLatestRollupVersion, config.checkIntervalMs);
-    }
-    start() {
-        if (this.runningPromise.isRunning()) {
-            this.log.debug(`Can't start update checker again`);
-            return;
-        }
-        this.log.info('Starting update checker', {
-            nodeVersion: this.nodeVersion,
-            rollupVersion: this.rollupVersion
-        });
-        this.runningPromise.start();
-    }
-    stop() {
-        if (!this.runningPromise.isRunning()) {
-            this.log.debug(`Can't stop update checker because it is not running`);
-            return Promise.resolve();
-        }
-        return this.runningPromise.stop();
-    }
-    trigger() {
-        return this.runningPromise.trigger();
-    }
-    runChecks;
-    async checkRollupVersion() {
-        try {
-            const canonicalRollupVersion = await this.getLatestRollupVersion();
-            if (canonicalRollupVersion !== this.rollupVersion) {
-                this.log.debug('New canonical rollup version', {
-                    currentVersion: this.rollupVersion,
-                    latestVersion: canonicalRollupVersion
-                });
-                this.emit('newRollupVersion', {
-                    currentVersion: this.rollupVersion,
-                    latestVersion: canonicalRollupVersion
-                });
-            }
-        } catch (err) {
-            this.log.warn(`Failed to check if there is a new rollup`, err);
-        }
-    }
-    async checkConfig() {
-        try {
-            const response = await this.fetch(this.updatesUrl);
-            const body = await response.json();
-            if (!response.ok) {
-                this.log.warn(`Unexpected HTTP response checking for updates`, {
-                    status: response.status,
-                    body: await response.text(),
-                    url: this.updatesUrl
-                });
-            }
-            const { version, config, publicTelemetry } = updateConfigSchema.parse(body);
-            if (this.nodeVersion && version && version !== this.nodeVersion) {
-                this.log.debug('New node version', {
-                    currentVersion: this.nodeVersion,
-                    latestVersion: version
-                });
-                this.emit('newNodeVersion', {
-                    currentVersion: this.nodeVersion,
-                    latestVersion: version
-                });
-            }
-            if (config && Object.keys(config).length > 0 && !isDeepStrictEqual(config, this.lastPatchedConfig)) {
-                this.log.debug('New node config', {
-                    config
-                });
-                this.lastPatchedConfig = config;
-                this.emit('updateNodeConfig', config);
-            }
-            if (publicTelemetry && Object.keys(publicTelemetry).length > 0 && !isDeepStrictEqual(publicTelemetry, this.lastPatchedPublicTelemetryConfig)) {
-                this.log.debug('New metrics config', {
-                    config
-                });
-                this.lastPatchedPublicTelemetryConfig = publicTelemetry;
-                this.emit('updatePublicTelemetryConfig', publicTelemetry);
-            }
-        } catch (err) {
-            this.log.warn(`Failed to check if there is an update`, err);
-        }
-    }
-}
-/**
- * Returns package version.
- */ export function getPackageVersion() {
-    try {
-        const releasePleaseManifestPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../.release-please-manifest.json');
-        const version = JSON.parse(readFileSync(releasePleaseManifestPath).toString())['.'];
-        return version;
-    } catch  {
-        return undefined;
-    }
-}