refactor: check Aztec.nr version instead of Noir

yarn-project/aztec-sandbox/src/bin/index.ts

@@ -3,7 +3,7 @@ import { createAztecNodeRpcServer } from '@aztec/aztec-node';
 import { deployInitialSandboxAccounts } from '@aztec/aztec.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { fileURLToPath } from '@aztec/foundation/url';
-import { NoirWasmVersion } from '@aztec/noir-compiler/noir-version';
+import { NoirWasmVersion } from '@aztec/noir-compiler/versions';
 import { createPXERpcServer } from '@aztec/pxe';
 
 import { readFileSync } from 'fs';

yarn-project/aztec.js/src/artifacts/ecdsa_account_contract.json

@@ -696,5 +696,5 @@
     }
   ],
   "events": [],
-  "compilerVersion": "0.18.0-6ca33a2.aztec"
+  "aztecNrVersion": ""
 }

yarn-project/aztec.js/src/artifacts/schnorr_account_contract.json

@@ -684,5 +684,5 @@
     }
   ],
   "events": [],
-  "compilerVersion": "0.18.0-6ca33a2.aztec"
+  "aztecNrVersion": ""
 }

yarn-project/aztec.js/src/artifacts/schnorr_single_key_account_contract.json

@@ -619,5 +619,5 @@
     }
   ],
   "events": [],
-  "compilerVersion": "0.18.0-6ca33a2.aztec"
+  "aztecNrVersion": ""
 }

yarn-project/cli/src/index.ts

@@ -32,6 +32,7 @@ import { mnemonicToAccount } from 'viem/accounts';
 
 import { createCompatibleClient } from './client.js';
 import { encodeArgs, parseStructString } from './encoding.js';
+import { GITHUB_TAG_PREFIX } from './github.js';
 import { unboxContract } from './unbox.js';
 import { update } from './update/update.js';
 import {
@@ -248,9 +249,10 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
 
       const client = await createCompatibleClient(rpcUrl, debugLogger);
       const nodeInfo = await client.getNodeInfo();
-      if (contractArtifact.compilerVersion && contractArtifact.compilerVersion !== nodeInfo.compatibleNargoVersion) {
+      const expectedAztecNrVersion = `${GITHUB_TAG_PREFIX}-v${nodeInfo.sandboxVersion}`;
+      if (contractArtifact.aztecNrVersion && contractArtifact.aztecNrVersion !== expectedAztecNrVersion) {
         log(
-          `\nWarning: Contract was compiled with a different version of Noir: ${contractArtifact.compilerVersion}. Consider re-compiling the contract with Noir ${nodeInfo.compatibleNargoVersion}\n`,
+          `\nWarning: Contract was compiled with a different version of Aztec.nr: ${contractArtifact.aztecNrVersion}. Consider updating Aztec.nr to ${expectedAztecNrVersion}\n`,
         );
       }
 

yarn-project/foundation/src/abi/abi.ts

@@ -253,7 +253,7 @@ export interface ContractArtifact {
   /**
    * The version of compiler used to create this artifact
    */
-  compilerVersion?: string;
+  aztecNrVersion?: string;
 
   /**
    * The functions of the contract.

yarn-project/noir-compiler/package.json

@@ -5,7 +5,7 @@
   "exports": {
     ".": "./dest/index.js",
     "./cli": "./dest/cli/index.js",
-    "./noir-version": "./dest/noir-version.js"
+    "./versions": "./dest/versions.js"
   },
   "typedocOptions": {
     "entryPoints": [

yarn-project/noir-compiler/src/__snapshots__/index.test.ts.snap

@@ -3,6 +3,7 @@
 exports[`noir-compiler using nargo compiles the test contract 1`] = `
 [
   {
+    "aztecNrVersion": undefined,
     "events": [],
     "functions": [
       {
@@ -195,6 +196,7 @@ export class TestContractContract extends ContractBase {
 exports[`noir-compiler using wasm binary compiles the test contract 1`] = `
 [
   {
+    "aztecNrVersion": undefined,
     "events": [],
     "functions": [
       {

yarn-project/noir-compiler/src/compile/noir/dependencies/dependency-manager.test.ts

@@ -2,7 +2,7 @@ import { NoirDependencyConfig } from '@aztec/foundation/noir';
 
 import { NoirPackage } from '../package.js';
 import { NoirDependencyManager } from './dependency-manager.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { Dependency, DependencyResolver } from './dependency-resolver.js';
 
 describe('DependencyManager', () => {
   let manager: NoirDependencyManager;
@@ -51,42 +51,51 @@ describe('DependencyManager', () => {
 
 class TestDependencyResolver implements DependencyResolver {
   // eslint-disable-next-line require-await
-  public async resolveDependency(pkg: NoirPackage, dep: NoirDependencyConfig): Promise<NoirPackage | null> {
+  public async resolveDependency(pkg: NoirPackage, dep: NoirDependencyConfig): Promise<Dependency | null> {
     if (!('path' in dep)) {
       return null;
     }
 
     switch (dep.path) {
       case '/lib1':
-        return new NoirPackage('/lib1', '/lib1/src', {
-          dependencies: {},
-          package: {
-            name: 'lib1',
-            type: 'lib',
-          },
-        });
+        return {
+          version: '',
+          package: new NoirPackage('/lib1', '/lib1/src', {
+            dependencies: {},
+            package: {
+              name: 'lib1',
+              type: 'lib',
+            },
+          }),
+        };
 
       case '/lib2':
-        return new NoirPackage('/lib2', '/lib2/src', {
-          dependencies: {
-            lib3: {
-              path: '/lib3',
+        return {
+          version: '',
+          package: new NoirPackage('/lib2', '/lib2/src', {
+            dependencies: {
+              lib3: {
+                path: '/lib3',
+              },
             },
-          },
-          package: {
-            name: 'lib2',
-            type: 'lib',
-          },
-        });
+            package: {
+              name: 'lib2',
+              type: 'lib',
+            },
+          }),
+        };
 
       case '/lib3':
-        return new NoirPackage('/lib3', '/lib3/src', {
-          dependencies: {},
-          package: {
-            name: 'lib3',
-            type: 'lib',
-          },
-        });
+        return {
+          version: '',
+          package: new NoirPackage('/lib3', '/lib3/src', {
+            dependencies: {},
+            package: {
+              name: 'lib3',
+              type: 'lib',
+            },
+          }),
+        };
 
       default:
         throw new Error();

yarn-project/noir-compiler/src/compile/noir/dependencies/dependency-manager.ts

@@ -4,14 +4,14 @@ import { NoirDependencyConfig } from '@aztec/foundation/noir';
 import { join } from 'node:path';
 
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { Dependency, DependencyResolver } from './dependency-resolver.js';
 
 /**
  * Noir Dependency Resolver
  */
 export class NoirDependencyManager {
   #entryPoint: NoirPackage;
-  #libraries = new Map<string, NoirPackage>();
+  #libraries = new Map<string, Dependency>();
   #dependencies = new Map<string, string[]>();
   #log: LogFn;
   #resolvers: readonly DependencyResolver[];
@@ -49,6 +49,16 @@ export class NoirDependencyManager {
     await this.#recursivelyResolveDependencies('', this.#entryPoint);
   }
 
+  /**
+   * Gets the version of a dependency in the dependency tree
+   * @param name - Dependency name
+   * @returns The dependency's version
+   */
+  public getVersionOf(name: string): string | undefined {
+    const dep = this.#libraries.get(name);
+    return dep?.version;
+  }
+
   async #recursivelyResolveDependencies(packageName: string, noirPackage: NoirPackage): Promise<void> {
     for (const [name, config] of Object.entries(noirPackage.getDependencies())) {
       // TODO what happens if more than one package has the same name but different versions?
@@ -60,20 +70,20 @@ export class NoirDependencyManager {
       }
 
       const dependency = await this.#resolveDependency(noirPackage, config);
-      if (dependency.getType() !== 'lib') {
+      if (dependency.package.getType() !== 'lib') {
         this.#log(`Non-library package ${name}`, config);
         throw new Error(`Dependency ${name} is not a library`);
       }
 
       this.#libraries.set(name, dependency);
       this.#dependencies.set(packageName, [...(this.#dependencies.get(packageName) ?? []), name]);
 
-      await this.#recursivelyResolveDependencies(name, dependency);
+      await this.#recursivelyResolveDependencies(name, dependency.package);
     }
   }
 
-  async #resolveDependency(pkg: NoirPackage, config: NoirDependencyConfig) {
-    let dependency: NoirPackage | null = null;
+  async #resolveDependency(pkg: NoirPackage, config: NoirDependencyConfig): Promise<Dependency> {
+    let dependency: Dependency | null = null;
     for (const resolver of this.#resolvers) {
       dependency = await resolver.resolveDependency(pkg, config);
       if (dependency) {
@@ -102,9 +112,9 @@ export class NoirDependencyManager {
    */
   public findFile(sourceId: string): string | null {
     const [lib, ...path] = sourceId.split('/').filter(x => x);
-    const pkg = this.#libraries.get(lib);
-    if (pkg) {
-      return join(pkg.getSrcPath(), ...path);
+    const dep = this.#libraries.get(lib);
+    if (dep) {
+      return join(dep.package.getSrcPath(), ...path);
     } else {
       return null;
     }

yarn-project/noir-compiler/src/compile/noir/dependencies/dependency-resolver.ts

@@ -2,6 +2,16 @@ import { NoirDependencyConfig } from '@aztec/foundation/noir';
 
 import { NoirPackage } from '../package.js';
 
+/**
+ * A Noir dependency
+ */
+export type Dependency = {
+  /** version string as determined by the resolver */
+  version: string;
+  /** the actual package source code */
+  package: NoirPackage;
+};
+
 /**
  * Resolves a dependency for a package.
  */
@@ -11,5 +21,5 @@ export interface DependencyResolver {
    * @param pkg - The package to resolve dependencies for
    * @param dep - The dependency config to resolve
    */
-  resolveDependency(pkg: NoirPackage, dep: NoirDependencyConfig): Promise<NoirPackage | null>;
+  resolveDependency(pkg: NoirPackage, dep: NoirDependencyConfig): Promise<Dependency | null>;
 }

yarn-project/noir-compiler/src/compile/noir/dependencies/github-dependency-resolver.test.ts

@@ -62,9 +62,10 @@ describe('GithubDependencyResolver', () => {
 
   it('resolves Github dependency', async () => {
     fetchMock.mockResolvedValueOnce(new Response(await readFile(join(fixtures, 'test_lib.zip')), { status: 200 }));
-    const libPkg = await resolver.resolveDependency(pkg, libDependency);
-    expect(libPkg).toBeDefined();
-    expect(fm.hasFileSync(libPkg!.getEntryPointPath())).toBe(true);
+    const lib = await resolver.resolveDependency(pkg, libDependency);
+    expect(lib).toBeDefined();
+    expect(lib!.version).toEqual(libDependency.tag);
+    expect(fm.hasFileSync(lib!.package.getEntryPointPath())).toBe(true);
   });
 
   it.each<[NoirGitDependencyConfig, 'zip' | 'tar', string]>([

yarn-project/noir-compiler/src/compile/noir/dependencies/github-dependency-resolver.ts

@@ -6,7 +6,7 @@ import { unzip } from 'unzipit';
 
 import { FileManager } from '../file-manager/file-manager.js';
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { Dependency, DependencyResolver } from './dependency-resolver.js';
 
 /**
  * Downloads dependencies from github
@@ -25,7 +25,7 @@ export class GithubDependencyResolver implements DependencyResolver {
    * @param dependency - The dependency configuration
    * @returns asd
    */
-  async resolveDependency(_pkg: NoirPackage, dependency: NoirDependencyConfig): Promise<NoirPackage | null> {
+  async resolveDependency(_pkg: NoirPackage, dependency: NoirDependencyConfig): Promise<Dependency | null> {
     // TODO accept ssh urls?
     // TODO github authentication?
     if (!('git' in dependency) || !dependency.git.startsWith('https://github.com')) {
@@ -34,7 +34,10 @@ export class GithubDependencyResolver implements DependencyResolver {
 
     const archivePath = await this.#fetchZipFromGithub(dependency);
     const libPath = await this.#extractZip(dependency, archivePath);
-    return NoirPackage.open(libPath, this.#fm);
+    return {
+      version: dependency.tag,
+      package: NoirPackage.open(libPath, this.#fm),
+    };
   }
 
   async #fetchZipFromGithub(dependency: Pick<NoirGitDependencyConfig, 'git' | 'tag'>): Promise<string> {

yarn-project/noir-compiler/src/compile/noir/dependencies/local-dependency-resolver.test.ts

@@ -43,10 +43,11 @@ describe('DependencyResolver', () => {
   });
 
   it.each(['../test_contract', '/test_contract'])('resolves a known dependency', async path => {
-    const libPkg = await resolver.resolveDependency(pkg, {
+    const lib = await resolver.resolveDependency(pkg, {
       path,
     });
-    expect(libPkg).toBeDefined();
-    expect(fm.hasFileSync(libPkg!.getEntryPointPath())).toBe(true);
+    expect(lib).toBeDefined();
+    expect(lib!.version).toBe('');
+    expect(fm.hasFileSync(lib!.package.getEntryPointPath())).toBe(true);
   });
 });

yarn-project/noir-compiler/src/compile/noir/dependencies/local-dependency-resolver.ts

@@ -4,7 +4,7 @@ import { resolve } from 'path';
 
 import { FileManager } from '../file-manager/file-manager.js';
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { Dependency, DependencyResolver } from './dependency-resolver.js';
 
 /**
  * Resolves dependencies on-disk, relative to current package
@@ -16,9 +16,13 @@ export class LocalDependencyResolver implements DependencyResolver {
     this.#fm = fm;
   }
 
-  resolveDependency(pkg: NoirPackage, config: NoirDependencyConfig): Promise<NoirPackage | null> {
+  resolveDependency(pkg: NoirPackage, config: NoirDependencyConfig): Promise<Dependency | null> {
     if ('path' in config) {
-      return Promise.resolve(NoirPackage.open(resolve(pkg.getPackagePath(), config.path), this.#fm));
+      return Promise.resolve({
+        // unknown version, Nargo.toml doesn't have a version field
+        version: '',
+        package: NoirPackage.open(resolve(pkg.getPackagePath(), config.path), this.#fm),
+      });
     } else {
       return Promise.resolve(null);
     }

yarn-project/noir-compiler/src/compile/noir/noir-wasm-compiler.ts

@@ -70,6 +70,15 @@ export class NoirWasmContractCompiler {
     return new NoirWasmContractCompiler(noirPackage, dependencyManager, fileManager, opts);
   }
 
+  /**
+   * Gets the version of Aztec.nr that was used compiling this contract.
+   */
+  public getResolvedAztecNrVersion() {
+    // TODO eliminate this hardcoded library name!
+    // see docs/docs/dev_docs/contracts/setup.md
+    return this.#dependencyManager.getVersionOf('aztec');
+  }
+
   /**
    * Compiles the project.
    */

yarn-project/noir-compiler/src/compile/noir/package.ts

@@ -14,6 +14,7 @@ export class NoirPackage {
   #packagePath: string;
   #srcPath: string;
   #config: NoirPackageConfig;
+  #version: string | null = null;
 
   public constructor(path: string, srcDir: string, config: NoirPackageConfig) {
     this.#packagePath = path;

yarn-project/noir-compiler/src/contract-interface-gen/abi.ts

@@ -39,7 +39,7 @@ function generateFunctionArtifact(fn: NoirFunctionEntry): FunctionArtifact {
  */
 export function generateContractArtifact(
   { contract, debug }: NoirCompilationArtifacts,
-  compilerVersion: string,
+  aztecNrVersion?: string,
 ): ContractArtifact {
   const originalFunctions = contract.functions;
   // TODO why sort? we should have idempotent compilation so this should not be needed.
@@ -61,6 +61,6 @@ export function generateContractArtifact(
     functions: sortedFunctions.map(generateFunctionArtifact),
     events: contract.events,
     debug: parsedDebug,
-    compilerVersion,
+    aztecNrVersion,
   };
 }