@aztec/standard-contracts 5.0.0-nightly.20260530

package/dest/public-checks/lazy.js

@@ -0,0 +1,24 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { makeStandardContract } from '../make_standard_contract.js';
+export { STANDARD_PUBLIC_CHECKS_ADDRESS, STANDARD_PUBLIC_CHECKS_CLASS_ID, STANDARD_PUBLIC_CHECKS_SALT } from './constants.js';
+let standardContract;
+let standardContractArtifact;
+export async function getPublicChecksArtifact() {
+    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() {
+    if (!standardContract) {
+        const artifact = await getPublicChecksArtifact();
+        standardContract = makeStandardContract('PublicChecks', artifact);
+    }
+    return standardContract;
+}

package/dest/scripts/cleanup_artifacts.js

@@ -0,0 +1,16 @@
+import { fileURLToPath } from '@aztec/foundation/url';
+import { readFile, readdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+async function cleanupArtifacts(target) {
+    const files = await readdir(target);
+    for (const file of files){
+        if (!file.endsWith('.json')) {
+            continue;
+        }
+        const fileData = JSON.parse((await readFile(join(target, file), 'utf8')).toString());
+        /* eslint-disable camelcase */ fileData.file_map = {};
+        fileData.debug_symbols = {};
+        /* eslint-enable camelcase */ await writeFile(join(target, file), JSON.stringify(fileData));
+    }
+}
+await cleanupArtifacts(fileURLToPath(new URL('../../artifacts', import.meta.url).href));

package/dest/scripts/generate_data.js

@@ -0,0 +1,79 @@
+// Reads compiled Noir artifacts for each standard contract and derives their addresses, class IDs,
+// bytecode commitments, and initialization hashes — emitting everything as precomputed constants
+// into `standard_contract_data.ts` and as Noir address stamps into the `standard_addresses.nr`
+// modules of `aztec-nr/aztec` and `noir-contracts/.../aztec_sublib`. This avoids clients repeating
+// the expensive hashing at runtime and keeps the Noir-side address aligned with the TS-side.
+//
+// Drift detection: every invocation renders the expected output in memory and compares against the
+// existing on-disk content. Files that match are left untouched (no mtime churn). Files that
+// differ are overwritten with the fresh content and the generator exits non-zero with a clear
+// error — so the developer gets the regeneration for free, and a second `./bootstrap.sh` pass
+// recompiles dependent Noir contracts against the now-correct values.
+import { createConsoleLogger } from '@aztec/foundation/log';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { NOIR_ARTIFACTS_SRC_PATH, STANDARD_ARTIFACTS_DEST_DIR, computeContractData, loadArtifact, standardContracts } from '../contract_data.js';
+import { renderAllTargets, writeIfChanged } from '../drift.js';
+const log = createConsoleLogger('autogenerate');
+async function clearDestDir() {
+    try {
+        await fs.access(STANDARD_ARTIFACTS_DEST_DIR);
+        // If the directory exists, remove it recursively.
+        await fs.rm(STANDARD_ARTIFACTS_DEST_DIR, {
+            recursive: true,
+            force: true,
+            maxRetries: 3
+        });
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+        // If the directory does not exist, do nothing.
+        } else {
+            log(`Error removing dest directory: ${err}`);
+        }
+    }
+    await fs.mkdir(STANDARD_ARTIFACTS_DEST_DIR, {
+        recursive: true
+    });
+}
+async function copyArtifact(srcName, destName) {
+    const artifact = await loadArtifact(srcName);
+    const src = path.join(NOIR_ARTIFACTS_SRC_PATH, `${srcName}.json`);
+    const dest = path.join(STANDARD_ARTIFACTS_DEST_DIR, `${destName}.json`);
+    await fs.copyFile(src, dest);
+    return artifact;
+}
+async function generateDeclarationFile(destName) {
+    const content = `
+    import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+    const circuit: NoirCompiledContract;
+    export = circuit;
+  `;
+    await fs.writeFile(path.join(STANDARD_ARTIFACTS_DEST_DIR, `${destName}.d.json.ts`), content);
+}
+async function main() {
+    await clearDestDir();
+    const names = standardContracts.map((c)=>c.name);
+    const contractDataList = [];
+    for (const { name, src } of standardContracts){
+        const artifact = await copyArtifact(src, name);
+        await generateDeclarationFile(name);
+        contractDataList.push(await computeContractData(artifact));
+    }
+    const targets = await renderAllTargets(names, contractDataList);
+    const driftedFiles = [];
+    for (const { path: filePath, content } of targets){
+        if (await writeIfChanged(filePath, content)) {
+            driftedFiles.push(filePath);
+        }
+    }
+    if (driftedFiles.length > 0) {
+        const list = driftedFiles.map((f)=>`  - ${f}`).join('\n');
+        throw new Error(`Standard contract addresses have changed. The following generated files were out of date and have been rewritten in-place with the freshly-derived values:\n${list}\n\n` + `Any noir-contract that imports the stale addresses (via aztec-nr or aztec_sublib) now has stale bytecode and must be rebuilt.\n\n` + `To recover, the simplest option is to re-run \`./bootstrap.sh\` from the repo root: the second pass picks up the now-correct values.\n\n` + `For a faster targeted recovery without rebuilding everything, run from the repo root:\n` + `  1. \`./bootstrap.sh build noir-contracts\`  (rebuilds contracts against the now-stamped addresses; equivalent to \`make noir-contracts\`)\n` + `  2. \`./bootstrap.sh build yarn-project\`    (the generator re-runs, sees no drift, and the build proceeds)\n\n` + `Commit the rewritten files alongside whatever source change triggered the drift.`);
+    }
+}
+try {
+    await main();
+} catch (err) {
+    log(`Error generating standard contract data: ${err}`);
+    process.exit(1);
+}

package/dest/standard_contract.d.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;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfY29udHJhY3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zdGFuZGFyZF9jb250cmFjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzFELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLHVCQUF1QixFQUFFLG1CQUFtQixFQUFFLDJCQUEyQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFeEgsZ0ZBQWdGO0FBQ2hGLE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0IsbUNBQW1DO0lBQ25DLFFBQVEsRUFBRSwyQkFBMkIsQ0FBQztJQUN0Qyx1Q0FBdUM7SUFDdkMsYUFBYSxFQUFFLG1CQUFtQixHQUFHLHVCQUF1QixDQUFDO0lBQzdELGtDQUFrQztJQUNsQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUM7SUFDM0IscURBQXFEO0lBQ3JELE9BQU8sRUFBRSxZQUFZLENBQUM7Q0FDdkIifQ==

package/dest/standard_contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_contract.d.ts","sourceRoot":"","sources":["../src/standard_contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAExH,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,QAAQ,EAAE,2BAA2B,CAAC;IACtC,uCAAuC;IACvC,aAAa,EAAE,mBAAmB,GAAG,uBAAuB,CAAC;IAC7D,kCAAkC;IAClC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAC;CACvB"}

package/dest/standard_contract.js

@@ -0,0 +1 @@
+/** A non-protocol contract deployed at a canonical artifact-derived address. */ export { };

package/dest/standard_contract_data.d.ts

@@ -0,0 +1,19 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export declare const standardContractNames: readonly ["AuthRegistry", "PublicChecks"];
+export type StandardContractName = (typeof standardContractNames)[number];
+export declare const StandardContractSalt: Record<StandardContractName, Fr>;
+export declare const StandardContractAddress: Record<StandardContractName, AztecAddress>;
+export declare const StandardContractClassId: Record<StandardContractName, Fr>;
+export declare const StandardContractClassIdPreimage: Record<StandardContractName, {
+    artifactHash: Fr;
+    privateFunctionsRoot: Fr;
+    publicBytecodeCommitment: Fr;
+}>;
+export declare const StandardContractInitializationHash: Record<StandardContractName, Fr>;
+export declare const StandardContractPrivateFunctions: Record<StandardContractName, {
+    selector: FunctionSelector;
+    vkHash: Fr;
+}[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfY29udHJhY3RfZGF0YS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3N0YW5kYXJkX2NvbnRyYWN0X2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRCxlQUFPLE1BQU0scUJBQXFCLDJDQUE0QyxDQUFDO0FBRS9FLE1BQU0sTUFBTSxvQkFBb0IsR0FBRyxDQUFDLE9BQU8scUJBQXFCLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUUxRSxlQUFPLE1BQU0sb0JBQW9CLEVBQUUsTUFBTSxDQUFDLG9CQUFvQixFQUFFLEVBQUUsQ0FHakUsQ0FBQztBQUVGLGVBQU8sTUFBTSx1QkFBdUIsRUFBRSxNQUFNLENBQUMsb0JBQW9CLEVBQUUsWUFBWSxDQUc5RSxDQUFDO0FBRUYsZUFBTyxNQUFNLHVCQUF1QixFQUFFLE1BQU0sQ0FBQyxvQkFBb0IsRUFBRSxFQUFFLENBR3BFLENBQUM7QUFFRixlQUFPLE1BQU0sK0JBQStCLEVBQUUsTUFBTSxDQUNsRCxvQkFBb0IsRUFDcEI7SUFBRSxZQUFZLEVBQUUsRUFBRSxDQUFDO0lBQUMsb0JBQW9CLEVBQUUsRUFBRSxDQUFDO0lBQUMsd0JBQXdCLEVBQUUsRUFBRSxDQUFBO0NBQUUsQ0FZN0UsQ0FBQztBQUVGLGVBQU8sTUFBTSxrQ0FBa0MsRUFBRSxNQUFNLENBQUMsb0JBQW9CLEVBQUUsRUFBRSxDQUcvRSxDQUFDO0FBRUYsZUFBTyxNQUFNLGdDQUFnQyxFQUFFLE1BQU0sQ0FDbkQsb0JBQW9CLEVBQ3BCO0lBQUUsUUFBUSxFQUFFLGdCQUFnQixDQUFDO0lBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQTtDQUFFLEVBQUUsQ0FXN0MsQ0FBQyJ9

package/dest/standard_contract_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_contract_data.d.ts","sourceRoot":"","sources":["../src/standard_contract_data.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,eAAO,MAAM,qBAAqB,2CAA4C,CAAC;AAE/E,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,oBAAoB,EAAE,EAAE,CAGjE,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,oBAAoB,EAAE,YAAY,CAG9E,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,oBAAoB,EAAE,EAAE,CAGpE,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,MAAM,CAClD,oBAAoB,EACpB;IAAE,YAAY,EAAE,EAAE,CAAC;IAAC,oBAAoB,EAAE,EAAE,CAAC;IAAC,wBAAwB,EAAE,EAAE,CAAA;CAAE,CAY7E,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,oBAAoB,EAAE,EAAE,CAG/E,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,MAAM,CACnD,oBAAoB,EACpB;IAAE,QAAQ,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,EAAE,CAAA;CAAE,EAAE,CAW7C,CAAC"}

package/dest/standard_contract_data.js

@@ -0,0 +1,45 @@
+// 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'
+];
+export const StandardContractSalt = {
+    AuthRegistry: new Fr(1),
+    PublicChecks: new Fr(1)
+};
+export const StandardContractAddress = {
+    AuthRegistry: AztecAddress.fromString('0x27ced680dd8c176230127b42131054bce7fcd00623650eb695b5588bac81430b'),
+    PublicChecks: AztecAddress.fromString('0x05d900a6ed1b4ad3ff52cbe5f98d9b291b0f35c6dd5c41b1642659344d234bfe')
+};
+export const StandardContractClassId = {
+    AuthRegistry: Fr.fromString('0x2a2197818ebc248f6933c0364e50de7b4dcee6a4e53cfadcebae98d77ec0ca4a'),
+    PublicChecks: Fr.fromString('0x022bbd3c085d6a09ec500110852441419c7b1e6dc21a8d459233b72a84d03a1f')
+};
+export const StandardContractClassIdPreimage = {
+    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 = {
+    AuthRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+    PublicChecks: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+};
+export const StandardContractPrivateFunctions = {
+    AuthRegistry: [
+        {
+            selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000079a3d418')),
+            vkHash: Fr.fromString('0x06a5c1b3a636c954a90be43cb56a4bdd9dc8aec764151a012e0018753694ff54')
+        }
+    ],
+    PublicChecks: []
+};

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@aztec/standard-contracts",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/standard-contracts",
+  "description": "Standard non-protocol contracts for the Aztec Network",
+  "version": "5.0.0-nightly.20260530",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./*": "./dest/*/index.js",
+    "./*/lazy": "./dest/*/lazy.js",
+    "./auth-registry/constants": "./dest/auth-registry/constants.js",
+    "./public-checks/constants": "./dest/public-checks/constants.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts",
+      "./src/auth-registry/index.ts"
+    ],
+    "name": "Standard Contracts",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn generate && yarn generate:cleanup-artifacts && ../scripts/tsc.sh",
+    "build:keep-debug-symbols": "yarn clean && yarn generate && ../scripts/tsc.sh",
+    "generate": "yarn generate:data",
+    "generate:cleanup-artifacts": "node --no-warnings --loader @swc-node/register/esm src/scripts/cleanup_artifacts.ts",
+    "generate:data": "node --no-warnings --loader @swc-node/register/esm src/scripts/generate_data.ts",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "build:ts": "../scripts/tsc.sh",
+    "clean": "rm -rf ./dest .tsbuildinfo ./artifacts",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json",
+    "./package.local.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/foundation": "5.0.0-nightly.20260530",
+    "@aztec/stdlib": "5.0.0-nightly.20260530",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "prettier": "^3.5.3",
+    "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*",
+    "artifacts",
+    "!src/scripts/*"
+  ],
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/auth-registry/constants.ts

@@ -0,0 +1,8 @@
+// Address-only leaf export for browser bundles: importing from
+// `@aztec/standard-contracts/auth-registry/constants` avoids dragging in the
+// `AuthRegistry.json` static import.
+import { StandardContractAddress, StandardContractClassId, StandardContractSalt } from '../standard_contract_data.js';
+
+export const STANDARD_AUTH_REGISTRY_ADDRESS = StandardContractAddress.AuthRegistry;
+export const STANDARD_AUTH_REGISTRY_CLASS_ID = StandardContractClassId.AuthRegistry;
+export const STANDARD_AUTH_REGISTRY_SALT = StandardContractSalt.AuthRegistry;

package/src/auth-registry/index.ts

@@ -0,0 +1,24 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import AuthRegistryJson from '../../artifacts/AuthRegistry.json' with { type: 'json' };
+import { makeStandardContract } from '../make_standard_contract.js';
+import type { StandardContract } from '../standard_contract.js';
+
+export {
+  STANDARD_AUTH_REGISTRY_ADDRESS,
+  STANDARD_AUTH_REGISTRY_CLASS_ID,
+  STANDARD_AUTH_REGISTRY_SALT,
+} from './constants.js';
+
+export const AuthRegistryArtifact = loadContractArtifact(AuthRegistryJson as NoirCompiledContract);
+
+let standardContract: StandardContract;
+
+/** Returns the standard deployment of the auth registry. */
+export function getStandardAuthRegistry(): Promise<StandardContract> {
+  if (!standardContract) {
+    standardContract = makeStandardContract('AuthRegistry', AuthRegistryArtifact);
+  }
+  return Promise.resolve(standardContract);
+}

package/src/auth-registry/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_AUTH_REGISTRY_ADDRESS,
+  STANDARD_AUTH_REGISTRY_CLASS_ID,
+  STANDARD_AUTH_REGISTRY_SALT,
+} from './constants.js';
+
+let standardContract: StandardContract;
+let standardContractArtifact: ContractArtifact;
+
+export async function getAuthRegistryArtifact(): 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: authRegistryJson } = await import('../../artifacts/AuthRegistry.json');
+    standardContractArtifact = loadContractArtifact(authRegistryJson);
+  }
+  return standardContractArtifact;
+}
+
+/** Returns the standard deployment of the auth registry. */
+export async function getStandardAuthRegistry(): Promise<StandardContract> {
+  if (!standardContract) {
+    const artifact = await getAuthRegistryArtifact();
+    standardContract = makeStandardContract('AuthRegistry', artifact);
+  }
+  return standardContract;
+}

package/src/contract_data.ts

@@ -0,0 +1,119 @@
+// Shared core for the standard-contracts data generator (`scripts/generate_data.ts`) and its
+// drift-detection test (`standard_contract_data.test.ts`). Keeping the `standardContracts[]`
+// list, paths, and the `computeContractData` derivation in one module ensures the generator
+// (which writes the data) and the test (which checks the committed data is fresh) run the exact
+// same code path. Adding a new standard contract is a one-row change in the array below — both
+// the generator and the drift test pick it up automatically.
+//
+// The rendering and write-if-changed plumbing lives in `drift.ts`, a build-time-only sibling
+// module — keeping `prettier` out of this module avoids pulling a formatter into the published
+// package's transitive imports.
+//
+// Paths below are relative to `yarn-project/standard-contracts` (the cwd when scripts run).
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FunctionSelector, loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  computeContractAddressFromInstance,
+  computeInitializationHash,
+  getContractClassFromArtifact,
+} from '@aztec/stdlib/contract';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+/** Root of the noir-contracts package relative to `yarn-project/standard-contracts`. */
+export const NOIR_CONTRACTS_ROOT = '../../noir-projects/noir-contracts';
+/** Directory holding the freshly-compiled Noir artifacts the generator reads from. */
+export const NOIR_ARTIFACTS_SRC_PATH = path.join(NOIR_CONTRACTS_ROOT, './target');
+/** Output directory inside this package where the trimmed artifacts get copied. */
+export const STANDARD_ARTIFACTS_DEST_DIR = './artifacts';
+/** Path of the generated TS data file (addresses, class IDs, etc.). */
+export const STANDARD_CONTRACT_DATA_OUTPUT_PATH = './src/standard_contract_data.ts';
+// Both consumers (aztec-nr's `aztec` crate and noir-contracts' `aztec_sublib`) need an identical
+// twin of the generated addresses module. `aztec_sublib` cannot depend on `aztec`, so we stamp the
+// same file into both locations rather than introducing a shared crate.
+export const NOIR_STANDARD_ADDRESSES_PATHS = [
+  '../../noir-projects/aztec-nr/aztec/src/standard_addresses.nr',
+  '../../noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/standard_addresses.nr',
+];
+
+/** The deployment salt baked into every standard contract instance. */
+export const STANDARD_CONTRACT_SALT = new Fr(1);
+/** Every standard contract is deployed by the zero address (universal deploy). */
+export const STANDARD_CONTRACT_DEPLOYER = AztecAddress.zero();
+
+/**
+ * Single source of truth for which contracts are "standard" (non-protocol, but with deterministic
+ * addresses baked into circuits via `standard_addresses.nr`).
+ *
+ * - `name`: TS-side name used as the key in the generated `StandardContractAddress` map.
+ * - `src`: artifact filename (without `.json`) inside `noir-contracts/target/`.
+ * - `nrConst`: Noir-side constant to emit in `standard_addresses.nr`, or `null` to skip the Noir
+ *    stamp (used for account-side entrypoints with no Noir consumer).
+ *
+ * Adding a new standard contract is a one-row change here. The drift-detection check in the
+ * generator and the backup jest test both iterate this list, so coverage is automatic.
+ */
+export const standardContracts: { name: string; src: string; nrConst: string | null }[] = [
+  { name: 'AuthRegistry', src: 'auth_registry_contract-AuthRegistry', nrConst: 'STANDARD_AUTH_REGISTRY_ADDRESS' },
+  { name: 'PublicChecks', src: 'public_checks_contract-PublicChecks', nrConst: 'STANDARD_PUBLIC_CHECKS_ADDRESS' },
+];
+
+/** Everything derived from a compiled standard-contract artifact that the generator emits. */
+export type ContractData = {
+  address: AztecAddress;
+  classId: Fr;
+  artifactHash: Fr;
+  privateFunctionsRoot: Fr;
+  publicBytecodeCommitment: Fr;
+  initializationHash: Fr;
+  privateFunctions: { selector: FunctionSelector; vkHash: Fr }[];
+};
+
+/**
+ * Loads a compiled Noir contract artifact from `noir-contracts/target/` by its source name.
+ * Throws with `ENOENT` if the artifact isn't built yet — callers may catch this to provide a
+ * friendlier "run the build first" message.
+ */
+export async function loadArtifact(srcName: string): Promise<NoirCompiledContract> {
+  const src = path.join(NOIR_ARTIFACTS_SRC_PATH, `${srcName}.json`);
+  return JSON.parse(await fs.readFile(src, 'utf8')) as NoirCompiledContract;
+}
+
+/**
+ * Derives the address, class ID, and other deployment data for a standard contract from its
+ * compiled artifact. Used by both the generator (to write `standard_contract_data.ts`) and the
+ * drift test (to verify the committed data matches).
+ *
+ * Standard contracts come from a trusted source (the build pipeline), so no class verifications
+ * are performed.
+ */
+export async function computeContractData(artifact: NoirCompiledContract): Promise<ContractData> {
+  const loaded = loadContractArtifact(artifact);
+  const contractClass = await getContractClassFromArtifact(loaded);
+  const constructorArtifact = loaded.functions.find(f => f.name === 'constructor');
+  const initializationHash = await computeInitializationHash(constructorArtifact, []);
+  const instance = {
+    version: 2 as const,
+    currentContractClassId: contractClass.id,
+    originalContractClassId: contractClass.id,
+    initializationHash,
+    immutablesHash: Fr.ZERO,
+    publicKeys: PublicKeys.default(),
+    salt: STANDARD_CONTRACT_SALT,
+    deployer: STANDARD_CONTRACT_DEPLOYER,
+  };
+  const address = await computeContractAddressFromInstance(instance);
+  return {
+    address,
+    classId: contractClass.id,
+    artifactHash: contractClass.artifactHash,
+    privateFunctionsRoot: contractClass.privateFunctionsRoot,
+    publicBytecodeCommitment: contractClass.publicBytecodeCommitment,
+    initializationHash,
+    privateFunctions: contractClass.privateFunctions,
+  };
+}