@aztec/standard-contracts 0.0.1-commit.04d373f

package/dest/multi-call-entrypoint/lazy.js

@@ -0,0 +1,24 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { makeStandardContract } from '../make_standard_contract.js';
+export { STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS, STANDARD_MULTI_CALL_ENTRYPOINT_CLASS_ID, STANDARD_MULTI_CALL_ENTRYPOINT_SALT } from './constants.js';
+let standardContract;
+let standardContractArtifact;
+export async function getMultiCallEntrypointArtifact() {
+    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: multiCallEntrypointJson } = await import('../../artifacts/MultiCallEntrypoint.json');
+        standardContractArtifact = loadContractArtifact(multiCallEntrypointJson);
+    }
+    return standardContractArtifact;
+}
+/** Returns the standard deployment of the multi-call entrypoint. */ export async function getStandardMultiCallEntrypoint() {
+    if (!standardContract) {
+        const artifact = await getMultiCallEntrypointArtifact();
+        standardContract = makeStandardContract('MultiCallEntrypoint', artifact);
+    }
+    return standardContract;
+}

package/dest/public-checks/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const STANDARD_PUBLIC_CHECKS_ADDRESS: import("@aztec/stdlib/aztec-address").AztecAddress;
+export declare const STANDARD_PUBLIC_CHECKS_CLASS_ID: import("@aztec/foundation/schemas").Fr;
+export declare const STANDARD_PUBLIC_CHECKS_SALT: import("@aztec/foundation/schemas").Fr;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGljLWNoZWNrcy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsZUFBTyxNQUFNLDhCQUE4QixvREFBdUMsQ0FBQztBQUNuRixlQUFPLE1BQU0sK0JBQStCLHdDQUF1QyxDQUFDO0FBQ3BGLGVBQU8sTUFBTSwyQkFBMkIsd0NBQW9DLENBQUMifQ==

package/dest/public-checks/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/public-checks/constants.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,8BAA8B,oDAAuC,CAAC;AACnF,eAAO,MAAM,+BAA+B,wCAAuC,CAAC;AACpF,eAAO,MAAM,2BAA2B,wCAAoC,CAAC"}

package/dest/public-checks/constants.js

@@ -0,0 +1,7 @@
+// 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/dest/public-checks/index.d.ts

@@ -0,0 +1,6 @@
+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 declare const PublicChecksArtifact: import("@aztec/stdlib/abi").ContractArtifact;
+/** Returns the standard deployment of public_checks. */
+export declare function getStandardPublicChecks(): Promise<StandardContract>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtY2hlY2tzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFaEUsT0FBTyxFQUNMLDhCQUE4QixFQUM5QiwrQkFBK0IsRUFDL0IsMkJBQTJCLEdBQzVCLE1BQU0sZ0JBQWdCLENBQUM7QUFFeEIsZUFBTyxNQUFNLG9CQUFvQiw4Q0FBaUUsQ0FBQztBQUluRyx3REFBd0Q7QUFDeEQsd0JBQWdCLHVCQUF1QixJQUFJLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUtuRSJ9

package/dest/public-checks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/public-checks/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,2BAA2B,GAC5B,MAAM,gBAAgB,CAAC;AAExB,eAAO,MAAM,oBAAoB,8CAAiE,CAAC;AAInG,wDAAwD;AACxD,wBAAgB,uBAAuB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAKnE"}

package/dest/public-checks/index.js

@@ -0,0 +1,14 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import PublicChecksJson from '../../artifacts/PublicChecks.json' with {
+    type: 'json'
+};
+import { makeStandardContract } from '../make_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);
+let standardContract;
+/** Returns the standard deployment of public_checks. */ export function getStandardPublicChecks() {
+    if (!standardContract) {
+        standardContract = makeStandardContract('PublicChecks', PublicChecksArtifact);
+    }
+    return Promise.resolve(standardContract);
+}

package/dest/public-checks/lazy.d.ts

@@ -0,0 +1,7 @@
+import { type ContractArtifact } from '@aztec/stdlib/abi';
+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 declare function getPublicChecksArtifact(): Promise<ContractArtifact>;
+/** Returns the standard deployment of public_checks. */
+export declare function getStandardPublicChecks(): Promise<StandardContract>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF6eS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpYy1jaGVja3MvbGF6eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBd0IsTUFBTSxtQkFBbUIsQ0FBQztBQUdoRixPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRWhFLE9BQU8sRUFDTCw4QkFBOEIsRUFDOUIsK0JBQStCLEVBQy9CLDJCQUEyQixHQUM1QixNQUFNLGdCQUFnQixDQUFDO0FBS3hCLHdCQUFzQix1QkFBdUIsSUFBSSxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FXekU7QUFFRCx3REFBd0Q7QUFDeEQsd0JBQXNCLHVCQUF1QixJQUFJLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQU16RSJ9

package/dest/public-checks/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/public-checks/lazy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAwB,MAAM,mBAAmB,CAAC;AAGhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,2BAA2B,GAC5B,MAAM,gBAAgB,CAAC;AAKxB,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAWzE;AAED,wDAAwD;AACxD,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAMzE"}

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,136 @@
+// 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);
+}
+/**
+ * Reads the currently-committed derived values out of the generated `standard_contract_data.ts`
+ * module so the drift report can show old → new. Returns `undefined` if the module doesn't exist
+ * yet (first-ever generation).
+ */ async function loadCommittedValues() {
+    let mod;
+    try {
+        mod = await import('../standard_contract_data.js');
+    } catch  {
+        return undefined;
+    }
+    const out = {};
+    for (const name of Object.keys(mod.StandardContractAddress)){
+        const preimage = mod.StandardContractClassIdPreimage[name];
+        out[name] = {
+            address: mod.StandardContractAddress[name].toString(),
+            classId: mod.StandardContractClassId[name].toString(),
+            artifactHash: preimage.artifactHash.toString(),
+            privateFunctionsRoot: preimage.privateFunctionsRoot.toString(),
+            publicBytecodeCommitment: preimage.publicBytecodeCommitment.toString(),
+            initializationHash: mod.StandardContractInitializationHash[name].toString(),
+            privateFunctionsCount: mod.StandardContractPrivateFunctions[name].length
+        };
+    }
+    return out;
+}
+/**
+ * Lists which derived consts changed, comparing the freshly-derived values against the committed
+ * snapshot — one indented line per changed field.
+ */ function describeChanges(names, derived, committed) {
+    const lines = [];
+    names.forEach((name, i)=>{
+        const d = derived[i];
+        const prev = committed?.[name];
+        if (!prev) {
+            lines.push(`  ${name}: newly added (no prior committed values)`);
+            return;
+        }
+        const cmp = (field, oldV, newV)=>{
+            if (oldV !== newV) {
+                lines.push(`  ${name}.${field}: ${oldV} → ${newV}`);
+            }
+        };
+        cmp('address', prev.address, d.address.toString());
+        cmp('classId', prev.classId, d.classId.toString());
+        cmp('artifactHash', prev.artifactHash, d.artifactHash.toString());
+        cmp('privateFunctionsRoot', prev.privateFunctionsRoot, d.privateFunctionsRoot.toString());
+        cmp('publicBytecodeCommitment', prev.publicBytecodeCommitment, d.publicBytecodeCommitment.toString());
+        cmp('initializationHash', prev.initializationHash, d.initializationHash.toString());
+        cmp('privateFunctions count', String(prev.privateFunctionsCount), String(d.privateFunctions.length));
+    });
+    // Possible if only the generated-file formatting changed (e.g. a codegen tweak) with no value delta.
+    return lines.length > 0 ? lines.join('\n') : '  (no derived value changed — only generated-file formatting)';
+}
+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));
+    }
+    // Snapshot the committed values before we overwrite the data file, so the drift report can show
+    // exactly which consts changed (old → new) rather than a raw text diff.
+    const committed = await loadCommittedValues();
+    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` + `Changed values (old → new):\n${describeChanges(names, contractDataList, committed)}\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", "MultiCallEntrypoint", "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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfY29udHJhY3RfZGF0YS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3N0YW5kYXJkX2NvbnRyYWN0X2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRCxlQUFPLE1BQU0scUJBQXFCLGtFQUFtRSxDQUFDO0FBRXRHLE1BQU0sTUFBTSxvQkFBb0IsR0FBRyxDQUFDLE9BQU8scUJBQXFCLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUUxRSxlQUFPLE1BQU0sb0JBQW9CLEVBQUUsTUFBTSxDQUFDLG9CQUFvQixFQUFFLEVBQUUsQ0FJakUsQ0FBQztBQUVGLGVBQU8sTUFBTSx1QkFBdUIsRUFBRSxNQUFNLENBQUMsb0JBQW9CLEVBQUUsWUFBWSxDQUk5RSxDQUFDO0FBRUYsZUFBTyxNQUFNLHVCQUF1QixFQUFFLE1BQU0sQ0FBQyxvQkFBb0IsRUFBRSxFQUFFLENBSXBFLENBQUM7QUFFRixlQUFPLE1BQU0sK0JBQStCLEVBQUUsTUFBTSxDQUNsRCxvQkFBb0IsRUFDcEI7SUFBRSxZQUFZLEVBQUUsRUFBRSxDQUFDO0lBQUMsb0JBQW9CLEVBQUUsRUFBRSxDQUFDO0lBQUMsd0JBQXdCLEVBQUUsRUFBRSxDQUFBO0NBQUUsQ0FpQjdFLENBQUM7QUFFRixlQUFPLE1BQU0sa0NBQWtDLEVBQUUsTUFBTSxDQUFDLG9CQUFvQixFQUFFLEVBQUUsQ0FJL0UsQ0FBQztBQUVGLGVBQU8sTUFBTSxnQ0FBZ0MsRUFBRSxNQUFNLENBQ25ELG9CQUFvQixFQUNwQjtJQUFFLFFBQVEsRUFBRSxnQkFBZ0IsQ0FBQztJQUFDLE1BQU0sRUFBRSxFQUFFLENBQUE7Q0FBRSxFQUFFLENBbUI3QyxDQUFDIn0=

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,kEAAmE,CAAC;AAEtG,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,oBAAoB,EAAE,EAAE,CAIjE,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,oBAAoB,EAAE,YAAY,CAI9E,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,oBAAoB,EAAE,EAAE,CAIpE,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,CAiB7E,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,oBAAoB,EAAE,EAAE,CAI/E,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,MAAM,CACnD,oBAAoB,EACpB;IAAE,QAAQ,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,EAAE,CAAA;CAAE,EAAE,CAmB7C,CAAC"}

package/dest/standard_contract_data.js

@@ -0,0 +1,61 @@
+// 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',
+    'MultiCallEntrypoint',
+    'PublicChecks'
+];
+export const StandardContractSalt = {
+    AuthRegistry: new Fr(1),
+    MultiCallEntrypoint: new Fr(1),
+    PublicChecks: new Fr(1)
+};
+export const StandardContractAddress = {
+    AuthRegistry: AztecAddress.fromString('0x01de9d215d1845808cf388d3a88f9066af1e73ec280e979c3b1aec8ba6b149ea'),
+    MultiCallEntrypoint: AztecAddress.fromString('0x09a72c4cb473b087f59f28f913aa103c214b4f9bbf10d4157e06745169359210'),
+    PublicChecks: AztecAddress.fromString('0x05d900a6ed1b4ad3ff52cbe5f98d9b291b0f35c6dd5c41b1642659344d234bfe')
+};
+export const StandardContractClassId = {
+    AuthRegistry: Fr.fromString('0x2cfbdd0ce7cc31b5cc5f4eb8f680e0e245882b2208bd67828e41a8bd24a19292'),
+    MultiCallEntrypoint: Fr.fromString('0x188160c82cb3a9a24c6f156f270e962afa124cdd2dabce78aaa0bf04fdd799f6'),
+    PublicChecks: Fr.fromString('0x022bbd3c085d6a09ec500110852441419c7b1e6dc21a8d459233b72a84d03a1f')
+};
+export const StandardContractClassIdPreimage = {
+    AuthRegistry: {
+        artifactHash: Fr.fromString('0x0dd24a86cce5ff4ef33ca14f16359c5a154ce3f1ed91a9570dd5343569f5386f'),
+        privateFunctionsRoot: Fr.fromString('0x17b584350f4c3ccafd8f688729afb9feab8976114fb40012e9dee65022c072a4'),
+        publicBytecodeCommitment: Fr.fromString('0x2545f39893766508ce37bb5cea5e4dcab04c6f7f79f3089b1c076876e9d268b2')
+    },
+    MultiCallEntrypoint: {
+        artifactHash: Fr.fromString('0x1f8c5717b0e478e63f462f9792969865684f8403b4608980b1a83324c03dd498'),
+        privateFunctionsRoot: Fr.fromString('0x0e68dfbb256e80b08b3aef47aca1f2669e97a9c6259787893c1223ac083ad5d5'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e')
+    },
+    PublicChecks: {
+        artifactHash: Fr.fromString('0x030776b58475bf6a0545eaa4f4002f5fe6701bd0d306b68065f4b40ef4fdbe60'),
+        privateFunctionsRoot: Fr.fromString('0x202860adb1b8975971eeaf571aaaa88a27f4035290d58532ae7d60b0dfaad54c'),
+        publicBytecodeCommitment: Fr.fromString('0x013c4f854a5c87c9daf86c5f9bc07a42c2a061f1d924a5b3564ec7edc8e18cb7')
+    }
+};
+export const StandardContractInitializationHash = {
+    AuthRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+    MultiCallEntrypoint: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+    PublicChecks: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+};
+export const StandardContractPrivateFunctions = {
+    AuthRegistry: [
+        {
+            selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000079a3d418')),
+            vkHash: Fr.fromString('0x06a5c1b3a636c954a90be43cb56a4bdd9dc8aec764151a012e0018753694ff54')
+        }
+    ],
+    MultiCallEntrypoint: [
+        {
+            selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000f04908a9')),
+            vkHash: Fr.fromString('0x0b19b2f937f2581922c2ead5411ad9ff4ed9710efe9849bde494d9a0f94812ec')
+        }
+    ],
+    PublicChecks: []
+};

package/package.json

@@ -0,0 +1,102 @@
+{
+  "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": "0.0.1-commit.04d373f",
+  "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",
+    "./multi-call-entrypoint/constants": "./dest/multi-call-entrypoint/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": "0.0.1-commit.04d373f",
+    "@aztec/stdlib": "0.0.1-commit.04d373f",
+    "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;
+}