@aztec/standard-contracts 5.0.0-nightly.20260530

package/src/drift.ts

@@ -0,0 +1,201 @@
+// Build-time-only rendering and drift-detection plumbing shared by the generator
+// (`scripts/generate_data.ts`) and the backup jest test (`standard_contract_data.test.ts`). Lives
+// outside `contract_data.ts` so that `prettier` (a devDependency used only here) does not become a
+// transitive runtime import of the published package.
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import * as prettier from 'prettier';
+
+import {
+  type ContractData,
+  NOIR_STANDARD_ADDRESSES_PATHS,
+  STANDARD_CONTRACT_DATA_OUTPUT_PATH,
+  STANDARD_CONTRACT_SALT,
+  standardContracts,
+} from './contract_data.js';
+
+function generateNames(names: string[]) {
+  return `
+    export const standardContractNames = [
+      ${names.map(name => `'${name}'`).join(',\n')}
+    ] as const;
+
+    export type StandardContractName = typeof standardContractNames[number];
+  `;
+}
+
+function generateSalts(names: string[]) {
+  return `
+    export const StandardContractSalt: Record<StandardContractName, Fr> = {
+      ${names.map(name => `${name}: new Fr(${STANDARD_CONTRACT_SALT.toNumber()})`).join(',\n')}
+    };
+  `;
+}
+
+function generateAddresses(names: string[], contractData: ContractData[]) {
+  return `
+    export const StandardContractAddress: Record<StandardContractName, AztecAddress> = {
+      ${contractData.map((d, i) => `${names[i]}: AztecAddress.fromString('${d.address.toString()}')`).join(',\n')}
+    };
+  `;
+}
+
+function generateClassIdPreimages(names: string[], contractData: ContractData[]) {
+  return `
+    export const StandardContractClassId: Record<StandardContractName, Fr> = {
+      ${contractData.map((d, i) => `${names[i]}: Fr.fromString('${d.classId.toString()}')`).join(',\n')}
+    };
+
+    export const StandardContractClassIdPreimage: Record<StandardContractName, { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }> = {
+      ${contractData
+        .map(
+          (d, i) => `${names[i]}: {
+        artifactHash: Fr.fromString('${d.artifactHash.toString()}'),
+        privateFunctionsRoot: Fr.fromString('${d.privateFunctionsRoot.toString()}'),
+        publicBytecodeCommitment: Fr.fromString('${d.publicBytecodeCommitment.toString()}'),
+      }`,
+        )
+        .join(',\n')}
+    };
+
+    export const StandardContractInitializationHash: Record<StandardContractName, Fr> = {
+      ${contractData.map((d, i) => `${names[i]}: Fr.fromString('${d.initializationHash.toString()}')`).join(',\n')}
+    };
+
+    export const StandardContractPrivateFunctions: Record<StandardContractName, { selector: FunctionSelector; vkHash: Fr }[]> = {
+      ${contractData
+        .map(
+          (d, i) =>
+            `${names[i]}: [${d.privateFunctions
+              .map(
+                fn =>
+                  `{ selector: FunctionSelector.fromField(Fr.fromString('${fn.selector.toField().toString()}')), vkHash: Fr.fromString('${fn.vkHash.toString()}') }`,
+              )
+              .join(', ')}]`,
+        )
+        .join(',\n')}
+    };
+  `;
+}
+
+/**
+ * Renders the unformatted TypeScript content for `standard_contract_data.ts`. Run {@link formatTs}
+ * on the result before comparing against the committed file — the committed file has been
+ * prettier-formatted, so unformatted bytes will not byte-match.
+ */
+export function renderOutputFile(names: string[], contractData: ContractData[]): string {
+  return `
+    // GENERATED FILE - DO NOT EDIT. RUN \`yarn generate\` or \`yarn generate:data\`
+    import { Fr } from '@aztec/foundation/curves/bn254';
+    import { FunctionSelector } from '@aztec/stdlib/abi';
+    import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+    ${generateNames(names)}
+
+    ${generateSalts(names)}
+
+    ${generateAddresses(names, contractData)}
+
+    ${generateClassIdPreimages(names, contractData)}
+  `;
+}
+
+/**
+ * Renders the content for each `standard_addresses.nr` twin. Format-stable — `nargo fmt` will not
+ * rewrite the output, so the bytes returned here are byte-equal to what should be on disk.
+ */
+export function renderNoirAddresses(rows: { nrConst: string; address: AztecAddress }[]): string {
+  // Pre-wrapped to survive `nargo fmt`'s line-width pass without diff churn.
+  const globals = rows
+    .map(
+      r => `pub global ${r.nrConst}: AztecAddress = AztecAddress::from_field(
+    ${r.address.toField().toString()},
+);`,
+    )
+    .join('\n\n');
+  return `// GENERATED FILE - DO NOT EDIT. RUN \`yarn workspace @aztec/standard-contracts run generate\`.
+use protocol_types::{address::AztecAddress, traits::FromField};
+
+${globals}
+`;
+}
+
+/**
+ * Formats TypeScript content with the repo's prettier config so the bytes emitted by the generator
+ * (and the expected bytes used by the drift test) match what the eventual `format` step in
+ * bootstrap.sh produces. Without this normalization the drift check would false-positive on every
+ * run since the raw template-string output differs from the prettier-formatted committed content.
+ *
+ * The typescript/estree plugins are loaded eagerly and passed explicitly: prettier 3's default
+ * lazy-loading via ESM dynamic import is unreliable under jest's `experimental-vm-modules` (the
+ * VM context can tear down before the dynamic import resolves), which causes intermittent
+ * `Cannot read properties of undefined (reading 'estree')` failures.
+ */
+export async function formatTs(filePath: string, content: string): Promise<string> {
+  const [typescriptPlugin, estreePlugin] = await Promise.all([
+    import('prettier/plugins/typescript.js'),
+    import('prettier/plugins/estree.js'),
+  ]);
+  const config = (await prettier.resolveConfig(path.resolve(filePath))) ?? {};
+  return prettier.format(content, {
+    ...config,
+    filepath: filePath,
+    parser: 'typescript',
+    plugins: [typescriptPlugin.default ?? typescriptPlugin, estreePlugin.default ?? estreePlugin],
+  });
+}
+
+/** A rendered target file: the destination path and the exact bytes that should be on disk. */
+export type RenderedTarget = { path: string; content: string };
+
+/**
+ * Renders every generator output target (the TS data file plus each `standard_addresses.nr` twin)
+ * from a list of derived `ContractData`. The TS output is prettier-formatted so the result is
+ * byte-comparable against the committed file. Both the generator and the drift test build their
+ * comparison against this single function.
+ */
+export async function renderAllTargets(names: string[], contractData: ContractData[]): Promise<RenderedTarget[]> {
+  const tsContent = await formatTs(STANDARD_CONTRACT_DATA_OUTPUT_PATH, renderOutputFile(names, contractData));
+  const noirRows = standardContracts
+    .map((c, i) => ({ nrConst: c.nrConst, address: contractData[i].address }))
+    .filter((row): row is { nrConst: string; address: AztecAddress } => row.nrConst !== null);
+  const noirContent = renderNoirAddresses(noirRows);
+  return [
+    { path: STANDARD_CONTRACT_DATA_OUTPUT_PATH, content: tsContent },
+    ...NOIR_STANDARD_ADDRESSES_PATHS.map(p => ({ path: p, content: noirContent })),
+  ];
+}
+
+/**
+ * Reads a file's current content, or returns `null` if it doesn't exist. Used by the generator to
+ * compare against freshly rendered output before deciding to overwrite, and by the drift test to
+ * compare the committed file's bytes against the expected bytes.
+ */
+export async function readIfExists(filePath: string): Promise<string | null> {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      return null;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Compares `content` against the bytes currently at `filePath`. If they differ (including the file
+ * not existing), writes the new content and returns `true`. If they match, leaves the file
+ * untouched and returns `false`. Skipping the write when the content is identical avoids mtime
+ * churn that would otherwise re-trigger downstream build steps on every generator run.
+ */
+export async function writeIfChanged(filePath: string, content: string): Promise<boolean> {
+  const existing = await readIfExists(filePath);
+  if (existing === content) {
+    return false;
+  }
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+  return true;
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './auth-registry/index.js';
+export * from './public-checks/index.js';

package/src/make_standard_contract.ts

@@ -0,0 +1,51 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { PublicKeys } from '@aztec/stdlib/keys';
+
+import type { StandardContract } from './standard_contract.js';
+import {
+  StandardContractAddress,
+  StandardContractClassId,
+  StandardContractClassIdPreimage,
+  StandardContractInitializationHash,
+  type StandardContractName,
+  StandardContractPrivateFunctions,
+  StandardContractSalt,
+} from './standard_contract_data.js';
+
+/**
+ * Reconstructs a StandardContract from precomputed data without performing any hash computations.
+ * Internal to the standard-contracts package — not part of the public API.
+ */
+export function makeStandardContract(name: StandardContractName, artifact: ContractArtifact): StandardContract {
+  const address = StandardContractAddress[name];
+  const salt = StandardContractSalt[name];
+  const classId = StandardContractClassId[name];
+  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment } = StandardContractClassIdPreimage[name];
+  const initializationHash = StandardContractInitializationHash[name];
+
+  const contractClass = {
+    id: classId,
+    version: 1 as const,
+    artifactHash,
+    privateFunctionsRoot,
+    publicBytecodeCommitment,
+    packedBytecode: artifact.functions.find(f => f.name === 'public_dispatch')?.bytecode ?? Buffer.alloc(0),
+    privateFunctions: StandardContractPrivateFunctions[name],
+  };
+
+  const instance = {
+    version: 2 as const,
+    currentContractClassId: classId,
+    originalContractClassId: classId,
+    initializationHash,
+    immutablesHash: Fr.ZERO,
+    publicKeys: PublicKeys.default(),
+    salt,
+    deployer: AztecAddress.ZERO,
+    address,
+  };
+
+  return { instance, contractClass, artifact, address };
+}

package/src/public-checks/constants.ts

@@ -0,0 +1,8 @@
+// Lightweight metadata leaf export for browser bundles: importing from
+// `@aztec/standard-contracts/public-checks/constants` avoids dragging in the
+// `PublicChecks.json` static import.
+import { StandardContractAddress, StandardContractClassId, StandardContractSalt } from '../standard_contract_data.js';
+
+export const STANDARD_PUBLIC_CHECKS_ADDRESS = StandardContractAddress.PublicChecks;
+export const STANDARD_PUBLIC_CHECKS_CLASS_ID = StandardContractClassId.PublicChecks;
+export const STANDARD_PUBLIC_CHECKS_SALT = StandardContractSalt.PublicChecks;

package/src/public-checks/index.ts

@@ -0,0 +1,24 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import PublicChecksJson from '../../artifacts/PublicChecks.json' with { type: 'json' };
+import { makeStandardContract } from '../make_standard_contract.js';
+import type { StandardContract } from '../standard_contract.js';
+
+export {
+  STANDARD_PUBLIC_CHECKS_ADDRESS,
+  STANDARD_PUBLIC_CHECKS_CLASS_ID,
+  STANDARD_PUBLIC_CHECKS_SALT,
+} from './constants.js';
+
+export const PublicChecksArtifact = loadContractArtifact(PublicChecksJson as NoirCompiledContract);
+
+let standardContract: StandardContract;
+
+/** Returns the standard deployment of public_checks. */
+export function getStandardPublicChecks(): Promise<StandardContract> {
+  if (!standardContract) {
+    standardContract = makeStandardContract('PublicChecks', PublicChecksArtifact);
+  }
+  return Promise.resolve(standardContract);
+}

package/src/public-checks/lazy.ts

@@ -0,0 +1,35 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+import { makeStandardContract } from '../make_standard_contract.js';
+import type { StandardContract } from '../standard_contract.js';
+
+export {
+  STANDARD_PUBLIC_CHECKS_ADDRESS,
+  STANDARD_PUBLIC_CHECKS_CLASS_ID,
+  STANDARD_PUBLIC_CHECKS_SALT,
+} from './constants.js';
+
+let standardContract: StandardContract;
+let standardContractArtifact: ContractArtifact;
+
+export async function getPublicChecksArtifact(): Promise<ContractArtifact> {
+  if (!standardContractArtifact) {
+    // Cannot assert this import as it's incompatible with bundlers like vite
+    // https://github.com/vitejs/vite/issues/19095#issuecomment-2566074352
+    // Even if now supported by all major browsers, the MIME type is replaced with
+    // "text/javascript"
+    // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+    const { default: publicChecksJson } = await import('../../artifacts/PublicChecks.json');
+    standardContractArtifact = loadContractArtifact(publicChecksJson);
+  }
+  return standardContractArtifact;
+}
+
+/** Returns the standard deployment of public_checks. */
+export async function getStandardPublicChecks(): Promise<StandardContract> {
+  if (!standardContract) {
+    const artifact = await getPublicChecksArtifact();
+    standardContract = makeStandardContract('PublicChecks', artifact);
+  }
+  return standardContract;
+}

package/src/standard_contract.ts

@@ -0,0 +1,15 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassIdPreimage, ContractClassWithId, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+/** A non-protocol contract deployed at a canonical artifact-derived address. */
+export interface StandardContract {
+  /** Canonical deployed instance. */
+  instance: ContractInstanceWithAddress;
+  /** Contract class of this contract. */
+  contractClass: ContractClassWithId & ContractClassIdPreimage;
+  /** Complete contract artifact. */
+  artifact: ContractArtifact;
+  /** Deployment address for the canonical instance. */
+  address: AztecAddress;
+}

package/src/standard_contract_data.ts

@@ -0,0 +1,59 @@
+// GENERATED FILE - DO NOT EDIT. RUN `yarn generate` or `yarn generate:data`
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+export const standardContractNames = ['AuthRegistry', 'PublicChecks'] as const;
+
+export type StandardContractName = (typeof standardContractNames)[number];
+
+export const StandardContractSalt: Record<StandardContractName, Fr> = {
+  AuthRegistry: new Fr(1),
+  PublicChecks: new Fr(1),
+};
+
+export const StandardContractAddress: Record<StandardContractName, AztecAddress> = {
+  AuthRegistry: AztecAddress.fromString('0x27ced680dd8c176230127b42131054bce7fcd00623650eb695b5588bac81430b'),
+  PublicChecks: AztecAddress.fromString('0x05d900a6ed1b4ad3ff52cbe5f98d9b291b0f35c6dd5c41b1642659344d234bfe'),
+};
+
+export const StandardContractClassId: Record<StandardContractName, Fr> = {
+  AuthRegistry: Fr.fromString('0x2a2197818ebc248f6933c0364e50de7b4dcee6a4e53cfadcebae98d77ec0ca4a'),
+  PublicChecks: Fr.fromString('0x022bbd3c085d6a09ec500110852441419c7b1e6dc21a8d459233b72a84d03a1f'),
+};
+
+export const StandardContractClassIdPreimage: Record<
+  StandardContractName,
+  { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }
+> = {
+  AuthRegistry: {
+    artifactHash: Fr.fromString('0x1bf78e923b58f3e083093a39ccfc37576b9089c439797365cc7fe3b73a000dbc'),
+    privateFunctionsRoot: Fr.fromString('0x17b584350f4c3ccafd8f688729afb9feab8976114fb40012e9dee65022c072a4'),
+    publicBytecodeCommitment: Fr.fromString('0x2545f39893766508ce37bb5cea5e4dcab04c6f7f79f3089b1c076876e9d268b2'),
+  },
+  PublicChecks: {
+    artifactHash: Fr.fromString('0x030776b58475bf6a0545eaa4f4002f5fe6701bd0d306b68065f4b40ef4fdbe60'),
+    privateFunctionsRoot: Fr.fromString('0x202860adb1b8975971eeaf571aaaa88a27f4035290d58532ae7d60b0dfaad54c'),
+    publicBytecodeCommitment: Fr.fromString('0x013c4f854a5c87c9daf86c5f9bc07a42c2a061f1d924a5b3564ec7edc8e18cb7'),
+  },
+};
+
+export const StandardContractInitializationHash: Record<StandardContractName, Fr> = {
+  AuthRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+  PublicChecks: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+};
+
+export const StandardContractPrivateFunctions: Record<
+  StandardContractName,
+  { selector: FunctionSelector; vkHash: Fr }[]
+> = {
+  AuthRegistry: [
+    {
+      selector: FunctionSelector.fromField(
+        Fr.fromString('0x0000000000000000000000000000000000000000000000000000000079a3d418'),
+      ),
+      vkHash: Fr.fromString('0x06a5c1b3a636c954a90be43cb56a4bdd9dc8aec764151a012e0018753694ff54'),
+    },
+  ],
+  PublicChecks: [],
+};