feat: tag artifacts with the compiler version (#3220)

This PR adds the Aztec.nr version used to compile a contract. The CLI's
`compile` and `deploy` commands now check it against the expected
version and warn the user of incompatibilities (just warns, doesn't stop
the compilation/deployment).

Fix #2973 

# Checklist:
Remove the checklist to signal you've completed it. Enable auto-merge if
the PR is ready to merge.
- [ ] If the pull request requires a cryptography review (e.g.
cryptographic algorithm implementations) I have added the 'crypto' tag.
- [x] I have reviewed my diff in github, line by line and removed
unexpected formatting changes, testing logs, or commented-out code.
- [x] Every change is related to the PR description.
- [x] I have
[linked](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)
this pull request to relevant issues (if any exist).

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/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 {
@@ -247,6 +248,14 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       const constructorArtifact = contractArtifact.functions.find(({ name }) => name === 'constructor');
 
       const client = await createCompatibleClient(rpcUrl, debugLogger);
+      const nodeInfo = await client.getNodeInfo();
+      const expectedAztecNrVersion = `${GITHUB_TAG_PREFIX}-v${nodeInfo.sandboxVersion}`;
+      if (contractArtifact.aztecNrVersion && contractArtifact.aztecNrVersion !== expectedAztecNrVersion) {
+        log(
+          `\nWarning: Contract was compiled with a different version of Aztec.nr: ${contractArtifact.aztecNrVersion}. Consider updating Aztec.nr to ${expectedAztecNrVersion}\n`,
+        );
+      }
+
       const deployer = new ContractDeployer(contractArtifact, client, publicKey);
 
       const constructor = getFunctionArtifact(contractArtifact, 'constructor');

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

@@ -249,6 +249,12 @@ export interface ContractArtifact {
    * The name of the contract.
    */
   name: string;
+
+  /**
+   * The version of compiler used to create this artifact
+   */
+  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 { NoirDependency, NoirDependencyResolver } from './dependency-resolver.js';
 
 describe('DependencyManager', () => {
   let manager: NoirDependencyManager;
@@ -49,44 +49,53 @@ describe('DependencyManager', () => {
   });
 });
 
-class TestDependencyResolver implements DependencyResolver {
+class TestDependencyResolver implements NoirDependencyResolver {
   // eslint-disable-next-line require-await
-  public async resolveDependency(pkg: NoirPackage, dep: NoirDependencyConfig): Promise<NoirPackage | null> {
+  public async resolveDependency(pkg: NoirPackage, dep: NoirDependencyConfig): Promise<NoirDependency | 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,24 +4,24 @@ import { NoirDependencyConfig } from '@aztec/foundation/noir';
 import { join } from 'node:path';
 
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { NoirDependency, NoirDependencyResolver } from './dependency-resolver.js';
 
 /**
  * Noir Dependency Resolver
  */
 export class NoirDependencyManager {
   #entryPoint: NoirPackage;
-  #libraries = new Map<string, NoirPackage>();
+  #libraries = new Map<string, NoirDependency>();
   #dependencies = new Map<string, string[]>();
   #log: LogFn;
-  #resolvers: readonly DependencyResolver[];
+  #resolvers: readonly NoirDependencyResolver[];
 
   /**
    * Creates a new dependency resolver
    * @param resolvers - A list of dependency resolvers to use
    * @param entryPoint - The entry point of the project
    */
-  constructor(resolvers: readonly DependencyResolver[] = [], entryPoint: NoirPackage) {
+  constructor(resolvers: readonly NoirDependencyResolver[] = [], entryPoint: NoirPackage) {
     this.#log = createDebugOnlyLogger('noir:dependency-resolver');
     this.#resolvers = resolvers;
     this.#entryPoint = entryPoint;
@@ -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<NoirDependency> {
+    let dependency: NoirDependency | 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,14 +2,24 @@ import { NoirDependencyConfig } from '@aztec/foundation/noir';
 
 import { NoirPackage } from '../package.js';
 
+/**
+ * A Noir dependency
+ */
+export type NoirDependency = {
+  /** version string as determined by the resolver */
+  version?: string;
+  /** the actual package source code */
+  package: NoirPackage;
+};
+
 /**
  * Resolves a dependency for a package.
  */
-export interface DependencyResolver {
+export interface NoirDependencyResolver {
   /**
    * Resolve a dependency for a package.
    * @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<NoirDependency | null>;
 }

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

@@ -9,13 +9,13 @@ import { dirname, join } from 'node:path';
 import { FileManager } from '../file-manager/file-manager.js';
 import { createMemFSFileManager } from '../file-manager/memfs-file-manager.js';
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { NoirDependencyResolver } from './dependency-resolver.js';
 import { GithubDependencyResolver, resolveGithubCodeArchive, safeFilename } from './github-dependency-resolver.js';
 
 const fixtures = join(dirname(fileURLToPath(import.meta.url)), '../../../fixtures');
 
 describe('GithubDependencyResolver', () => {
-  let resolver: DependencyResolver;
+  let resolver: NoirDependencyResolver;
   let fm: FileManager;
   let pkg: NoirPackage;
   let libDependency: NoirGitDependencyConfig;
@@ -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,12 +6,12 @@ import { unzip } from 'unzipit';
 
 import { FileManager } from '../file-manager/file-manager.js';
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { NoirDependency, NoirDependencyResolver } from './dependency-resolver.js';
 
 /**
  * Downloads dependencies from github
  */
-export class GithubDependencyResolver implements DependencyResolver {
+export class GithubDependencyResolver implements NoirDependencyResolver {
   #fm: FileManager;
   #log = createDebugOnlyLogger('aztec:compile:github-dependency-resolver');
 
@@ -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<NoirDependency | 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

@@ -8,11 +8,11 @@ import { dirname, join } from 'node:path';
 import { FileManager } from '../file-manager/file-manager.js';
 import { createMemFSFileManager } from '../file-manager/memfs-file-manager.js';
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { NoirDependencyResolver } from './dependency-resolver.js';
 import { LocalDependencyResolver } from './local-dependency-resolver.js';
 
 describe('DependencyResolver', () => {
-  let resolver: DependencyResolver;
+  let resolver: NoirDependencyResolver;
   let fm: FileManager;
   let pkg: NoirPackage;
 
@@ -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).toBeUndefined();
+    expect(fm.hasFileSync(lib!.package.getEntryPointPath())).toBe(true);
   });
 });

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

@@ -4,21 +4,25 @@ import { resolve } from 'path';
 
 import { FileManager } from '../file-manager/file-manager.js';
 import { NoirPackage } from '../package.js';
-import { DependencyResolver } from './dependency-resolver.js';
+import { NoirDependency, NoirDependencyResolver } from './dependency-resolver.js';
 
 /**
  * Resolves dependencies on-disk, relative to current package
  */
-export class LocalDependencyResolver implements DependencyResolver {
+export class LocalDependencyResolver implements NoirDependencyResolver {
   #fm: FileManager;
 
   constructor(fm: FileManager) {
     this.#fm = fm;
   }
 
-  resolveDependency(pkg: NoirPackage, config: NoirDependencyConfig): Promise<NoirPackage | null> {
+  resolveDependency(pkg: NoirPackage, config: NoirDependencyConfig): Promise<NoirDependency | 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: undefined,
+        package: NoirPackage.open(resolve(pkg.getPackagePath(), config.path), this.#fm),
+      });
     } else {
       return Promise.resolve(null);
     }