@aztec/builder 0.36.0

package/src/cli/update/npm.ts

@@ -0,0 +1,154 @@
+import { type LogFn } from '@aztec/foundation/log';
+
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+import { type SemVer, parse } from 'semver';
+
+import { type DependencyChanges } from './common.js';
+import { atomicUpdateFile } from './utils.js';
+
+const deprecatedNpmPackages = new Set<string>(['@aztec/cli', '@aztec/aztec-sandbox']);
+const npmDeprecationMessage = `
+The following packages have been deprecated and will no longer be updated on the npm registry:
+${Array.from(deprecatedNpmPackages)
+  .map(pkg => `  - ${pkg}`)
+  .join('\n')}
+Remove them from package.json
+`;
+
+/**
+ * Looks up a package.json file and returns its contents
+ * @param projectPath - Path to Nodejs project
+ * @returns The parsed package.json
+ */
+export async function readPackageJson(projectPath: string): Promise<{
+  /** dependencies */
+  dependencies?: Record<string, string>;
+  /** devDependencies */
+  devDependencies?: Record<string, string>;
+}> {
+  const configFilepath = resolve(join(projectPath, 'package.json'));
+  const pkg = JSON.parse(await readFile(configFilepath, 'utf-8'));
+
+  return pkg;
+}
+
+/**
+ * Queries the npm registry for the latest version of a package
+ * @param packageName - The package to query
+ * @param distTag - The distribution tag
+ * @returns The latest version of the package on that distribution tag
+ */
+export async function getNewestVersion(packageName: string, distTag = 'latest'): Promise<SemVer> {
+  const url = new URL(packageName, 'https://registry.npmjs.org/');
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}`);
+  }
+
+  const body = await response.json();
+  const latestVersion = parse(body['dist-tags'][distTag]);
+  if (!latestVersion) {
+    throw new Error(`Failed to get latest version from registry`);
+  }
+
+  return latestVersion;
+}
+
+/**
+ * Updates a project's \@aztec/* dependencies to the specific version
+ * @param projectPath - Path to Nodejs project
+ * @param aztecVersion - The version to update to
+ * @returns True if the project was updated
+ */
+export async function updateAztecDeps(
+  projectPath: string,
+  aztecVersion: SemVer,
+  log: LogFn,
+): Promise<DependencyChanges> {
+  const pkg = await readPackageJson(projectPath);
+  const changes: DependencyChanges = {
+    file: resolve(join(projectPath, 'package.json')),
+    dependencies: [],
+  };
+
+  log(`Updating @aztec packages to ${aztecVersion} in ${relative(process.cwd(), changes.file)}`);
+  const version = aztecVersion.version;
+
+  let detectedDeprecatedPackages = false;
+
+  for (const depType of ['dependencies', 'devDependencies'] as const) {
+    const dependencies = pkg[depType];
+    if (!dependencies) {
+      continue;
+    }
+
+    for (const name of Object.keys(dependencies)) {
+      if (!name.startsWith('@aztec/')) {
+        continue;
+      }
+
+      // different release schedule
+      if (name === '@aztec/aztec-ui') {
+        continue;
+      }
+
+      if (deprecatedNpmPackages.has(name)) {
+        detectedDeprecatedPackages = true;
+        continue;
+      }
+
+      if (dependencies[name] !== version) {
+        changes.dependencies.push({
+          name,
+          from: dependencies[name],
+          to: version,
+        });
+
+        dependencies[name] = version;
+      }
+    }
+  }
+
+  if (detectedDeprecatedPackages) {
+    log(npmDeprecationMessage);
+  }
+
+  if (changes.dependencies.length > 0) {
+    const contents = JSON.stringify(pkg, null, 2) + '\n';
+    await atomicUpdateFile(resolve(join(projectPath, 'package.json')), contents);
+  }
+
+  return changes;
+}
+
+/**
+ * Updates a project's yarn.lock or package-lock.json
+ * @param projectPath - Path to Nodejs project
+ */
+export function updateLockfile(projectPath: string, log: LogFn): void {
+  const isNpm = existsSync(resolve(join(projectPath, 'package-lock.json')));
+  const isYarn = existsSync(resolve(join(projectPath, 'yarn.lock')));
+  const isPnpm = existsSync(resolve(join(projectPath, 'pnpm-lock.yaml')));
+
+  if (isPnpm) {
+    spawnSync('pnpm', ['install'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+  } else if (isYarn) {
+    spawnSync('yarn', ['install'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+  } else if (isNpm) {
+    spawnSync('npm', ['install'], {
+      cwd: projectPath,
+      stdio: 'inherit',
+    });
+  } else {
+    log(`No lockfile found in ${projectPath}. Skipping lockfile update...`);
+  }
+}

package/src/cli/update/update.ts

@@ -0,0 +1,79 @@
+/* eslint-disable jsdoc/require-jsdoc */
+import { type LogFn } from '@aztec/foundation/log';
+
+import { relative, resolve } from 'path';
+import { parse } from 'semver';
+
+import { type DependencyChanges } from './common.js';
+import { GITHUB_TAG_PREFIX } from './github.js';
+import { updateAztecNr } from './noir.js';
+import { getNewestVersion, updateAztecDeps, updateLockfile } from './npm.js';
+
+const AZTECJS_PACKAGE = '@aztec/aztec.js';
+const UPDATE_DOCS_URL = 'https://docs.aztec.network/developers/updating';
+
+export async function update(
+  projectPath: string,
+  contracts: string[],
+  pxeUrl: string,
+  aztecVersion: string,
+  log: LogFn,
+): Promise<void> {
+  const targetAztecVersion =
+    aztecVersion === 'latest' ? await getNewestVersion(AZTECJS_PACKAGE, 'latest') : parse(aztecVersion);
+
+  if (!targetAztecVersion) {
+    throw new Error(`Invalid aztec version ${aztecVersion}`);
+  }
+
+  const projectDependencyChanges: DependencyChanges[] = [];
+  try {
+    const npmChanges = await updateAztecDeps(resolve(process.cwd(), projectPath), targetAztecVersion, log);
+    if (npmChanges.dependencies.length > 0) {
+      updateLockfile(projectPath, log);
+    }
+
+    projectDependencyChanges.push(npmChanges);
+  } catch (err) {
+    if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+      log(`No package.json found in ${projectPath}. Skipping npm update...`);
+    } else {
+      throw err;
+    }
+  }
+
+  for (const contract of contracts) {
+    try {
+      projectDependencyChanges.push(
+        await updateAztecNr(
+          resolve(process.cwd(), projectPath, contract),
+          `${GITHUB_TAG_PREFIX}-v${targetAztecVersion.version}`,
+          log,
+        ),
+      );
+    } catch (err) {
+      if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+        log(`No Nargo.toml found in ${relative(process.cwd(), contract)}. Skipping...`);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  log(`To update Docker containers follow instructions at ${UPDATE_DOCS_URL}`);
+
+  projectDependencyChanges.forEach(changes => {
+    printChanges(changes, log);
+  });
+}
+
+function printChanges(changes: DependencyChanges, log: LogFn): void {
+  log(`\nIn ${relative(process.cwd(), changes.file)}:`);
+  if (changes.dependencies.length === 0) {
+    log('  No changes');
+  } else {
+    changes.dependencies.forEach(({ name, from, to }) => {
+      log(`  Updated ${name} from ${from} to ${to}`);
+    });
+  }
+}

package/src/cli/update/utils.ts

@@ -0,0 +1,50 @@
+import { type NoirPackageConfig } from '@aztec/foundation/noir';
+
+import TOML from '@iarna/toml';
+import { CommanderError } from 'commander';
+import { rename, writeFile } from 'fs/promises';
+
+/**
+ * Updates a file in place atomically.
+ * @param filePath - Path to file
+ * @param contents - New contents to write
+ */
+export async function atomicUpdateFile(filePath: string, contents: string) {
+  const tmpFilepath = filePath + '.tmp';
+  try {
+    await writeFile(tmpFilepath, contents, {
+      // let's crash if the tmp file already exists
+      flag: 'wx',
+    });
+    await rename(tmpFilepath, filePath);
+  } catch (e) {
+    if (e instanceof Error && 'code' in e && e.code === 'EEXIST') {
+      const commanderError = new CommanderError(
+        1,
+        e.code,
+        `Temporary file already exists: ${tmpFilepath}. Delete this file and try again.`,
+      );
+      commanderError.nestedError = e.message;
+      throw commanderError;
+    } else {
+      throw e;
+    }
+  }
+}
+
+/**
+ * Pretty prints Nargo.toml contents to a string
+ * @param config - Nargo.toml contents
+ * @returns The Nargo.toml contents as a string
+ */
+export function prettyPrintNargoToml(config: NoirPackageConfig): string {
+  const withoutDependencies = Object.fromEntries(Object.entries(config).filter(([key]) => key !== 'dependencies'));
+
+  const partialToml = TOML.stringify(withoutDependencies);
+  const dependenciesToml = Object.entries(config.dependencies).map(([name, dep]) => {
+    const depToml = TOML.stringify.value(dep);
+    return `${name} = ${depToml}`;
+  });
+
+  return partialToml + '\n[dependencies]\n' + dependenciesToml.join('\n') + '\n';
+}

package/src/cli.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { createConsoleLogger } from '@aztec/foundation/log';
+
+import { Command, Option } from 'commander';
+import { lookup } from 'dns/promises';
+import { dirname } from 'path';
+
+const program = new Command();
+const log = createConsoleLogger('aztec:compiler-cli');
+
+/**
+ * If we can successfully resolve 'host.docker.internal', then we are running in a container, and we should treat
+ * localhost as being host.docker.internal.
+ */
+const getLocalhost = () =>
+  lookup('host.docker.internal')
+    .then(() => 'host.docker.internal')
+    .catch(() => 'localhost');
+
+const LOCALHOST = await getLocalhost();
+
+const main = async () => {
+  const pxeOption = new Option('-u, --rpc-url <string>', 'URL of the PXE')
+    .env('PXE_URL')
+    .default(`http://${LOCALHOST}:8080`)
+    .makeOptionMandatory(true);
+
+  program.name('aztec-builder');
+  program
+    .command('codegen')
+    .argument('<noir-abi-path>', 'Path to the Noir ABI or project dir.')
+    .option('-o, --outdir <path>', 'Output folder for the generated code.')
+    .option('--force', 'Force code generation even when the contract has not changed.')
+    .description('Validates and generates an Aztec Contract ABI from Noir ABI.')
+    .action(async (noirAbiPath: string, { outdir, force }) => {
+      const { generateCode } = await import('./cli/codegen.js');
+      generateCode(outdir || dirname(noirAbiPath), noirAbiPath, { force });
+    });
+
+  program
+    .command('update')
+    .description('Updates Nodejs and Noir dependencies')
+    .argument('[projectPath]', 'Path to the project directory', process.cwd())
+    .option('--contract [paths...]', 'Paths to contracts to update dependencies', [])
+    .option('--aztec-version <semver>', 'The version to update Aztec packages to. Defaults to latest', 'latest')
+    .addOption(pxeOption)
+    .action(async (projectPath: string, options) => {
+      const { update } = await import('./cli/update/update.js');
+      const { contract, aztecVersion, rpcUrl } = options;
+      await update(projectPath, contract, rpcUrl, aztecVersion, log);
+    });
+
+  await program.parseAsync(process.argv);
+};
+
+main().catch(err => {
+  log(`Error running command`);
+  log(err);
+  process.exit(1);
+});

package/src/contract-interface-gen/typescript.ts

@@ -0,0 +1,311 @@
+import {
+  type ABIParameter,
+  type ContractArtifact,
+  type FunctionArtifact,
+  getDefaultInitializer,
+  isAztecAddressStruct,
+  isEthAddressStruct,
+  isFunctionSelectorStruct,
+  isWrappedFieldStruct,
+} from '@aztec/foundation/abi';
+
+/**
+ * Returns the corresponding typescript type for a given Noir type.
+ * @param type - The input Noir type.
+ * @returns An equivalent typescript type.
+ */
+function abiTypeToTypescript(type: ABIParameter['type']): string {
+  switch (type.kind) {
+    case 'field':
+      return 'FieldLike';
+    case 'boolean':
+      return 'boolean';
+    case 'integer':
+      return '(bigint | number)';
+    case 'string':
+      return 'string';
+    case 'array':
+      return `${abiTypeToTypescript(type.type)}[]`;
+    case 'struct':
+      if (isEthAddressStruct(type)) {
+        return 'EthAddressLike';
+      }
+      if (isAztecAddressStruct(type)) {
+        return 'AztecAddressLike';
+      }
+      if (isFunctionSelectorStruct(type)) {
+        return 'FunctionSelectorLike';
+      }
+      if (isWrappedFieldStruct(type)) {
+        return 'WrappedFieldLike';
+      }
+      return `{ ${type.fields.map(f => `${f.name}: ${abiTypeToTypescript(f.type)}`).join(', ')} }`;
+    default:
+      throw new Error(`Unknown type ${type}`);
+  }
+}
+
+/**
+ * Generates the typescript code to represent a Noir parameter.
+ * @param param - A Noir parameter with name and type.
+ * @returns The corresponding ts code.
+ */
+function generateParameter(param: ABIParameter) {
+  return `${param.name}: ${abiTypeToTypescript(param.type)}`;
+}
+
+/**
+ * Generates the typescript code to represent a Noir function as a type.
+ * @param param - A Noir function.
+ * @returns The corresponding ts code.
+ */
+function generateMethod(entry: FunctionArtifact) {
+  const args = entry.parameters.map(generateParameter).join(', ');
+  return `
+    /** ${entry.name}(${entry.parameters.map(p => `${p.name}: ${p.type.kind}`).join(', ')}) */
+    ${entry.name}: ((${args}) => ContractFunctionInteraction) & Pick<ContractMethod, 'selector'>;`;
+}
+
+/**
+ * Generates a deploy method for this contract.
+ * @param input - Build artifact of the contract.
+ * @returns A type-safe deploy method in ts.
+ */
+function generateDeploy(input: ContractArtifact) {
+  const ctor = getDefaultInitializer(input);
+  const args = (ctor?.parameters ?? []).map(generateParameter).join(', ');
+  const contractName = `${input.name}Contract`;
+  const artifactName = `${contractName}Artifact`;
+
+  return `
+  /**
+   * Creates a tx to deploy a new instance of this contract.
+   */
+  public static deploy(wallet: Wallet, ${args}) {
+    return new DeployMethod<${contractName}>(Fr.ZERO, wallet, ${artifactName}, ${contractName}.at, Array.from(arguments).slice(1));
+  }
+
+  /**
+   * Creates a tx to deploy a new instance of this contract using the specified public keys hash to derive the address.
+   */
+  public static deployWithPublicKeysHash(publicKeysHash: Fr, wallet: Wallet, ${args}) {
+    return new DeployMethod<${contractName}>(publicKeysHash, wallet, ${artifactName}, ${contractName}.at, Array.from(arguments).slice(2));
+  }
+
+  /**
+   * Creates a tx to deploy a new instance of this contract using the specified constructor method.
+   */
+  public static deployWithOpts<M extends keyof ${contractName}['methods']>(
+    opts: { publicKeysHash?: Fr; method?: M; wallet: Wallet },
+    ...args: Parameters<${contractName}['methods'][M]>
+  ) {
+    return new DeployMethod<${contractName}>(
+      opts.publicKeysHash ?? Fr.ZERO,
+      opts.wallet,
+      ${artifactName},
+      ${contractName}.at,
+      Array.from(arguments).slice(1),
+      opts.method ?? 'constructor',
+    );
+  }
+  `;
+}
+
+/**
+ * Generates the constructor by supplying the ABI to the parent class so the user doesn't have to.
+ * @param name - Name of the contract to derive the ABI name from.
+ * @returns A constructor method.
+ * @remarks The constructor is private because we want to force the user to use the create method.
+ */
+function generateConstructor(name: string) {
+  return `
+  private constructor(
+    instance: ContractInstanceWithAddress,
+    wallet: Wallet,
+  ) {
+    super(instance, ${name}ContractArtifact, wallet);
+  }
+  `;
+}
+
+/**
+ * Generates the at method for this contract.
+ * @param name - Name of the contract to derive the ABI name from.
+ * @returns An at method.
+ * @remarks We don't use constructor directly because of the async `wallet.getContractData` call.
+ */
+function generateAt(name: string) {
+  return `
+  /**
+   * Creates a contract instance.
+   * @param address - The deployed contract's address.
+   * @param wallet - The wallet to use when interacting with the contract.
+   * @returns A promise that resolves to a new Contract instance.
+   */
+  public static async at(
+    address: AztecAddress,
+    wallet: Wallet,
+  ) {
+    return Contract.at(address, ${name}Contract.artifact, wallet) as Promise<${name}Contract>;
+  }`;
+}
+
+/**
+ * Generates a static getter for the contract's artifact.
+ * @param name - Name of the contract used to derive name of the artifact import.
+ */
+function generateArtifactGetter(name: string) {
+  const artifactName = `${name}ContractArtifact`;
+  return `
+  /**
+   * Returns this contract's artifact.
+   */
+  public static get artifact(): ContractArtifact {
+    return ${artifactName};
+  }
+  `;
+}
+
+/**
+ * Generates statements for importing the artifact from json and re-exporting it.
+ * @param name - Name of the contract.
+ * @param artifactImportPath - Path to load the ABI from.
+ * @returns Code.
+ */
+function generateAbiStatement(name: string, artifactImportPath: string) {
+  const stmts = [
+    `import ${name}ContractArtifactJson from '${artifactImportPath}' assert { type: 'json' };`,
+    `export const ${name}ContractArtifact = loadContractArtifact(${name}ContractArtifactJson as NoirCompiledContract);`,
+  ];
+  return stmts.join('\n');
+}
+
+/**
+ * Generates a getter for the contract's storage layout.
+ * @param input - The contract artifact.
+ */
+function generateStorageLayoutGetter(input: ContractArtifact) {
+  const entries = Object.entries(input.storageLayout);
+
+  if (entries.length === 0) {
+    return '';
+  }
+
+  const storageFieldsUnionType = entries.map(([name]) => `'${name}'`).join(' | ');
+  const layout = entries
+    .map(
+      ([name, { slot, typ }]) =>
+        `${name}: {
+      slot: new Fr(${slot.toBigInt()}n),
+      typ: "${typ}",
+    }`,
+    )
+    .join(',\n');
+
+  return `public static get storage(): ContractStorageLayout<${storageFieldsUnionType}> {
+      return {
+        ${layout}
+      } as ContractStorageLayout<${storageFieldsUnionType}>;
+    }
+    `;
+}
+
+/**
+ * Generates a getter for the contract notes
+ * @param input - The contract artifact.
+ */
+function generateNotesGetter(input: ContractArtifact) {
+  const entries = Object.entries(input.notes);
+
+  if (entries.length === 0) {
+    return '';
+  }
+
+  const notesUnionType = entries.map(([name]) => `'${name}'`).join(' | ');
+  const noteMetadata = entries
+    .map(
+      ([name, { id }]) =>
+        `${name}: {
+          id: new Fr(${id.toBigInt()}n),
+        }`,
+    )
+    .join(',\n');
+
+  return `public static get notes(): ContractNotes<${notesUnionType}> {
+    return {
+      ${noteMetadata}
+    } as ContractNotes<${notesUnionType}>;
+  }
+  `;
+}
+
+/**
+ * Generates the typescript code to represent a contract.
+ * @param input - The compiled Noir artifact.
+ * @param artifactImportPath - Optional path to import the artifact (if not set, will be required in the constructor).
+ * @returns The corresponding ts code.
+ */
+export function generateTypescriptContractInterface(input: ContractArtifact, artifactImportPath?: string) {
+  const methods = input.functions.filter(f => !f.isInternal).map(generateMethod);
+  const deploy = artifactImportPath && generateDeploy(input);
+  const ctor = artifactImportPath && generateConstructor(input.name);
+  const at = artifactImportPath && generateAt(input.name);
+  const artifactStatement = artifactImportPath && generateAbiStatement(input.name, artifactImportPath);
+  const artifactGetter = artifactImportPath && generateArtifactGetter(input.name);
+  const storageLayoutGetter = artifactImportPath && generateStorageLayoutGetter(input);
+  const notesGetter = artifactImportPath && generateNotesGetter(input);
+
+  return `
+/* Autogenerated file, do not edit! */
+
+/* eslint-disable */
+import {
+  AztecAddress,
+  AztecAddressLike,
+  CompleteAddress,
+  Contract,
+  ContractArtifact,
+  ContractBase,
+  ContractFunctionInteraction,
+  ContractInstanceWithAddress,
+  ContractMethod,
+  ContractStorageLayout,
+  ContractNotes,
+  DeployMethod,
+  EthAddress,
+  EthAddressLike,
+  FieldLike,
+  Fr,
+  FunctionSelectorLike,
+  loadContractArtifact,
+  NoirCompiledContract,
+  Point,
+  PublicKey,
+  Wallet,
+  WrappedFieldLike,
+} from '@aztec/aztec.js';
+${artifactStatement}
+
+/**
+ * Type-safe interface for contract ${input.name};
+ */
+export class ${input.name}Contract extends ContractBase {
+  ${ctor}
+
+  ${at}
+
+  ${deploy}
+
+  ${artifactGetter}
+
+  ${storageLayoutGetter}
+
+  ${notesGetter}
+
+  /** Type-safe wrappers for the public methods exposed by the contract. */
+  public override methods!: {
+    ${methods.join('\n')}
+  };
+}
+`;
+}

package/src/fixtures/test_contract/Nargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "test"
+authors = [""]
+compiler_version = ">=0.18.0"
+type = "contract"
+
+[dependencies]
+test = { path = "../test_lib" }

package/src/fixtures/test_contract/src/main.nr

@@ -0,0 +1,11 @@
+contract TestContract {
+    use dep::test::module::foo;
+
+    fn constructor(param: Field, pub_param: pub Field) -> pub [Field; 2] {
+        [foo::bar(param), param + pub_param]
+    }
+
+    open fn openFunction() -> pub Field {
+        42
+    }
+}

package/src/fixtures/test_lib/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "testlib"
+authors = [""]
+compiler_version = ">=0.18.0"
+type = "lib"
+
+[dependencies]

package/src/fixtures/test_lib/src/lib.nr

@@ -0,0 +1 @@
+mod module;

package/src/fixtures/test_lib/src/module/foo.nr

@@ -0,0 +1,3 @@
+pub fn bar(param: Field) -> Field {
+    dep::std::hash::pedersen_hash([param])
+}

package/src/fixtures/test_lib/src/module.nr

@@ -0,0 +1 @@
+mod foo;

package/src/index.ts

@@ -0,0 +1 @@
+export { generateTypescriptContractInterface } from './contract-interface-gen/typescript.js';