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

package/src/contract_data.ts

@@ -0,0 +1,124 @@
+// 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: 'MultiCallEntrypoint',
+    src: 'multi_call_entrypoint_contract-MultiCallEntrypoint',
+    nrConst: 'STANDARD_MULTI_CALL_ENTRYPOINT_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,
+  };
+}

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,3 @@
+export * from './auth-registry/index.js';
+export * from './multi-call-entrypoint/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/multi-call-entrypoint/constants.ts

@@ -0,0 +1,8 @@
+// Lightweight metadata leaf export for browser bundles: importing from
+// `@aztec/standard-contracts/multi-call-entrypoint/constants` avoids dragging in the
+// `MultiCallEntrypoint.json` static import.
+import { StandardContractAddress, StandardContractClassId, StandardContractSalt } from '../standard_contract_data.js';
+
+export const STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS = StandardContractAddress.MultiCallEntrypoint;
+export const STANDARD_MULTI_CALL_ENTRYPOINT_CLASS_ID = StandardContractClassId.MultiCallEntrypoint;
+export const STANDARD_MULTI_CALL_ENTRYPOINT_SALT = StandardContractSalt.MultiCallEntrypoint;

package/src/multi-call-entrypoint/index.ts

@@ -0,0 +1,24 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import MultiCallEntrypointJson from '../../artifacts/MultiCallEntrypoint.json' with { type: 'json' };
+import { makeStandardContract } from '../make_standard_contract.js';
+import type { StandardContract } from '../standard_contract.js';
+
+export {
+  STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS,
+  STANDARD_MULTI_CALL_ENTRYPOINT_CLASS_ID,
+  STANDARD_MULTI_CALL_ENTRYPOINT_SALT,
+} from './constants.js';
+
+export const MultiCallEntrypointArtifact = loadContractArtifact(MultiCallEntrypointJson as NoirCompiledContract);
+
+let standardContract: StandardContract;
+
+/** Returns the standard deployment of the multi-call entrypoint. */
+export function getStandardMultiCallEntrypoint(): Promise<StandardContract> {
+  if (!standardContract) {
+    standardContract = makeStandardContract('MultiCallEntrypoint', MultiCallEntrypointArtifact);
+  }
+  return Promise.resolve(standardContract);
+}

package/src/multi-call-entrypoint/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_MULTI_CALL_ENTRYPOINT_ADDRESS,
+  STANDARD_MULTI_CALL_ENTRYPOINT_CLASS_ID,
+  STANDARD_MULTI_CALL_ENTRYPOINT_SALT,
+} from './constants.js';
+
+let standardContract: StandardContract;
+let standardContractArtifact: ContractArtifact;
+
+export async function getMultiCallEntrypointArtifact(): 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: multiCallEntrypointJson } = await import('../../artifacts/MultiCallEntrypoint.json');
+    standardContractArtifact = loadContractArtifact(multiCallEntrypointJson);
+  }
+  return standardContractArtifact;
+}
+
+/** Returns the standard deployment of the multi-call entrypoint. */
+export async function getStandardMultiCallEntrypoint(): Promise<StandardContract> {
+  if (!standardContract) {
+    const artifact = await getMultiCallEntrypointArtifact();
+    standardContract = makeStandardContract('MultiCallEntrypoint', artifact);
+  }
+  return standardContract;
+}

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,76 @@
+// 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'] as const;
+
+export type StandardContractName = (typeof standardContractNames)[number];
+
+export const StandardContractSalt: Record<StandardContractName, Fr> = {
+  AuthRegistry: new Fr(1),
+  MultiCallEntrypoint: new Fr(1),
+  PublicChecks: new Fr(1),
+};
+
+export const StandardContractAddress: Record<StandardContractName, AztecAddress> = {
+  AuthRegistry: AztecAddress.fromString('0x01de9d215d1845808cf388d3a88f9066af1e73ec280e979c3b1aec8ba6b149ea'),
+  MultiCallEntrypoint: AztecAddress.fromString('0x09a72c4cb473b087f59f28f913aa103c214b4f9bbf10d4157e06745169359210'),
+  PublicChecks: AztecAddress.fromString('0x05d900a6ed1b4ad3ff52cbe5f98d9b291b0f35c6dd5c41b1642659344d234bfe'),
+};
+
+export const StandardContractClassId: Record<StandardContractName, Fr> = {
+  AuthRegistry: Fr.fromString('0x2cfbdd0ce7cc31b5cc5f4eb8f680e0e245882b2208bd67828e41a8bd24a19292'),
+  MultiCallEntrypoint: Fr.fromString('0x188160c82cb3a9a24c6f156f270e962afa124cdd2dabce78aaa0bf04fdd799f6'),
+  PublicChecks: Fr.fromString('0x022bbd3c085d6a09ec500110852441419c7b1e6dc21a8d459233b72a84d03a1f'),
+};
+
+export const StandardContractClassIdPreimage: Record<
+  StandardContractName,
+  { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }
+> = {
+  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: Record<StandardContractName, Fr> = {
+  AuthRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+  MultiCallEntrypoint: 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'),
+    },
+  ],
+  MultiCallEntrypoint: [
+    {
+      selector: FunctionSelector.fromField(
+        Fr.fromString('0x00000000000000000000000000000000000000000000000000000000f04908a9'),
+      ),
+      vkHash: Fr.fromString('0x0b19b2f937f2581922c2ead5411ad9ff4ed9710efe9849bde494d9a0f94812ec'),
+    },
+  ],
+  PublicChecks: [],
+};