@aztec/protocol-contracts 3.0.3-rc.3 → 3.9.9-nightly.20260312

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

@@ -0,0 +1,5 @@
+import type { ProtocolContract } from '../protocol_contract.js';
+export declare const PublicChecksArtifact: import("@aztec/stdlib/abi").ContractArtifact;
+/** Returns the canonical deployment of the contract. */
+export declare function getCanonicalPublicChecks(): Promise<ProtocolContract>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtY2hlY2tzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFaEUsZUFBTyxNQUFNLG9CQUFvQiw4Q0FBaUUsQ0FBQztBQUluRyx3REFBd0Q7QUFDeEQsd0JBQWdCLHdCQUF3QixJQUFJLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUtwRSJ9

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,eAAO,MAAM,oBAAoB,8CAAiE,CAAC;AAInG,wDAAwD;AACxD,wBAAgB,wBAAwB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAKpE"}

package/dest/public-checks/index.js

@@ -0,0 +1,13 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import PublicChecksJson from '../../artifacts/PublicChecks.json' with {
+    type: 'json'
+};
+import { makeProtocolContract } from '../make_protocol_contract.js';
+export const PublicChecksArtifact = loadContractArtifact(PublicChecksJson);
+let protocolContract;
+/** Returns the canonical deployment of the contract. */ export function getCanonicalPublicChecks() {
+    if (!protocolContract) {
+        protocolContract = makeProtocolContract('PublicChecks', PublicChecksArtifact);
+    }
+    return Promise.resolve(protocolContract);
+}

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

@@ -0,0 +1,6 @@
+import { type ContractArtifact } from '@aztec/stdlib/abi';
+import type { ProtocolContract } from '../protocol_contract.js';
+export declare function getPublicChecksArtifact(): Promise<ContractArtifact>;
+/** Returns the canonical deployment of the public checks contract. */
+export declare function getCanonicalPublicChecks(): Promise<ProtocolContract>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF6eS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpYy1jaGVja3MvbGF6eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBd0IsTUFBTSxtQkFBbUIsQ0FBQztBQUdoRixPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBS2hFLHdCQUFzQix1QkFBdUIsSUFBSSxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FXekU7QUFFRCxzRUFBc0U7QUFDdEUsd0JBQXNCLHdCQUF3QixJQUFJLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQU0xRSJ9

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;AAKhE,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAWzE;AAED,sEAAsE;AACtE,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAM1E"}

package/dest/{router → public-checks}/lazy.js

@@ -2,22 +2,22 @@ import { loadContractArtifact } from '@aztec/stdlib/abi';
 import { makeProtocolContract } from '../make_protocol_contract.js';
 let protocolContract;
 let protocolContractArtifact;
-export async function getRouterArtifact() {
+export async function getPublicChecksArtifact() {
     if (!protocolContractArtifact) {
         // 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 al major browsers, the MIME type is replaced with
         // "text/javascript"
         // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
-        const { default: routerJson } = await import('../../artifacts/Router.json');
-        protocolContractArtifact = loadContractArtifact(routerJson);
+        const { default: publicChecksJson } = await import('../../artifacts/PublicChecks.json');
+        protocolContractArtifact = loadContractArtifact(publicChecksJson);
     }
     return protocolContractArtifact;
 }
-/** Returns the canonical deployment of the auth registry. */ export async function getCanonicalRouter() {
+/** Returns the canonical deployment of the public checks contract. */ export async function getCanonicalPublicChecks() {
     if (!protocolContract) {
-        const routerArtifact = await getRouterArtifact();
-        protocolContract = await makeProtocolContract('Router', routerArtifact);
+        const publicChecksArtifact = await getPublicChecksArtifact();
+        protocolContract = makeProtocolContract('PublicChecks', publicChecksArtifact);
     }
     return protocolContract;
 }

package/dest/scripts/generate_data.js

@@ -1,11 +1,16 @@
-import { CANONICAL_AUTH_REGISTRY_ADDRESS, CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, FEE_JUICE_ADDRESS, MAX_PROTOCOL_CONTRACTS, MULTI_CALL_ENTRYPOINT_ADDRESS, ROUTER_ADDRESS } from '@aztec/constants';
+// Reads compiled Noir artifacts for each protocol contract and derives their addresses, class IDs,
+// bytecode commitments, and other deployment data, emitting everything as precomputed constants into
+// `protocol_contract_data.ts`. This avoids clients repeating the expensive hashing at runtime and
+// ensures a single source of truth for the protocol contracts hash enforced by circuits, P2P, and L1.
+import { CANONICAL_AUTH_REGISTRY_ADDRESS, CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, FEE_JUICE_ADDRESS, MAX_PROTOCOL_CONTRACTS, MULTI_CALL_ENTRYPOINT_ADDRESS, PUBLIC_CHECKS_ADDRESS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createConsoleLogger } from '@aztec/foundation/log';
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import { computeContractAddressFromInstance, computeInitializationHash, getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { computeSiloedPrivateLogFirstField } from '@aztec/stdlib/hash';
+import { PublicKeys } from '@aztec/stdlib/keys';
 import { ProtocolContracts } from '@aztec/stdlib/tx';
 import { promises as fs } from 'fs';
 import path from 'path';
@@ -21,7 +26,7 @@ const contractAddressMapping = {
     ContractClassRegistry: CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
     MultiCallEntrypoint: MULTI_CALL_ENTRYPOINT_ADDRESS,
     FeeJuice: FEE_JUICE_ADDRESS,
-    Router: ROUTER_ADDRESS
+    PublicChecks: PUBLIC_CHECKS_ADDRESS
 };
 async function clearDestDir() {
     try {
@@ -50,11 +55,32 @@ async function copyArtifact(srcName, destName) {
     await fs.copyFile(src, dest);
     return artifact;
 }
-async function computeAddress(artifact) {
-    const instance = await getContractInstanceFromInstantiationParams(loadContractArtifact(artifact), {
-        salt
-    });
-    return instance.address;
+// Precompute all the expensive contract data that can be obtained from the artifact, to avoid redundant computations in clients.
+// Protocol contracts come from a trusted source, so no class verifications are needed.
+async function computeContractData(artifact, deployer) {
+    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: 1,
+        currentContractClassId: contractClass.id,
+        originalContractClassId: contractClass.id,
+        initializationHash,
+        publicKeys: PublicKeys.default(),
+        salt,
+        deployer
+    };
+    const address = await computeContractAddressFromInstance(instance);
+    return {
+        address,
+        classId: contractClass.id,
+        artifactHash: contractClass.artifactHash,
+        privateFunctionsRoot: contractClass.privateFunctionsRoot,
+        publicBytecodeCommitment: contractClass.publicBytecodeCommitment,
+        initializationHash,
+        privateFunctions: contractClass.privateFunctions
+    };
 }
 async function generateDeclarationFile(destName) {
     const content = `
@@ -88,14 +114,37 @@ function generateContractAddresses(names) {
     };
   `;
 }
-function generateDerivedAddresses(names, derivedAddresses) {
+function generateDerivedAddresses(names, contractData) {
     return `
     export const ProtocolContractDerivedAddress = {
-      ${derivedAddresses.map((address, i)=>`${names[i]}: AztecAddress.fromString('${address.toString()}')`).join(',\n')}
+      ${contractData.map((d, i)=>`${names[i]}: AztecAddress.fromString('${d.address.toString()}')`).join(',\n')}
+    };
+  `;
+}
+function generateClassIdPreimages(names, contractData) {
+    return `
+    export const ProtocolContractClassId: Record<ProtocolContractName, Fr> = {
+      ${contractData.map((d, i)=>`${names[i]}: Fr.fromString('${d.classId.toString()}')`).join(',\n')}
+    };
+
+    export const ProtocolContractClassIdPreimage: Record<ProtocolContractName, { 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 ProtocolContractInitializationHash: Record<ProtocolContractName, Fr> = {
+      ${contractData.map((d, i)=>`${names[i]}: Fr.fromString('${d.initializationHash.toString()}')`).join(',\n')}
+    };
+
+    export const ProtocolContractPrivateFunctions: Record<ProtocolContractName, { 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')}
     };
   `;
 }
-async function generateProtocolContractsList(names, derivedAddresses) {
+async function generateProtocolContractsList(names, contractData) {
     const list = makeTuple(MAX_PROTOCOL_CONTRACTS, ()=>AztecAddress.zero());
     for(let i = 0; i < names.length; i++){
         const name = names[i];
@@ -104,7 +153,7 @@ async function generateProtocolContractsList(names, derivedAddresses) {
         if (!list[derivedAddressIndex].equals(AztecAddress.zero())) {
             throw new Error(`Duplicate protocol contract address: ${address.toString()}`);
         }
-        list[derivedAddressIndex] = derivedAddresses[i];
+        list[derivedAddressIndex] = contractData[i].address;
     }
     return `
     export const ProtocolContractsList = new ProtocolContracts([
@@ -117,16 +166,14 @@ async function generateProtocolContractsList(names, derivedAddresses) {
 // Generate the siloed log tags for events emitted via private logs.
 async function generateLogTags() {
     return `
-  export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('${await poseidon2Hash([
-        CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE
-    ])}');
+  export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('${await computeSiloedPrivateLogFirstField(new AztecAddress(new Fr(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS)), new Fr(CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE))}');
   `;
 }
-async function generateOutputFile(names, derivedAddresses) {
+async function generateOutputFile(names, contractData) {
     const content = `
     // 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';
     import { ProtocolContracts } from '@aztec/stdlib/tx';
 
@@ -136,9 +183,11 @@ async function generateOutputFile(names, derivedAddresses) {
 
     ${generateContractAddresses(names)}
 
-    ${generateDerivedAddresses(names, derivedAddresses)}
+    ${generateDerivedAddresses(names, contractData)}
+
+    ${generateClassIdPreimages(names, contractData)}
 
-    ${await generateProtocolContractsList(names, derivedAddresses)}
+    ${await generateProtocolContractsList(names, contractData)}
 
     ${await generateLogTags()}
   `;
@@ -147,16 +196,16 @@ async function generateOutputFile(names, derivedAddresses) {
 async function main() {
     await clearDestDir();
     const srcNames = JSON.parse(await fs.readFile(path.join(noirContractsRoot, 'protocol_contracts.json'), 'utf8'));
-    const derivedAddresses = [];
+    const contractDataList = [];
     const destNames = srcNames.map((n)=>n.split('-')[1]);
     for(let i = 0; i < srcNames.length; i++){
         const srcName = srcNames[i];
         const destName = destNames[i];
         const artifact = await copyArtifact(srcName, destName);
         await generateDeclarationFile(destName);
-        derivedAddresses.push(await computeAddress(artifact));
+        contractDataList.push(await computeContractData(artifact, AztecAddress.fromBigInt(BigInt(contractAddressMapping[destName]))));
     }
-    await generateOutputFile(destNames, derivedAddresses);
+    await generateOutputFile(destNames, contractDataList);
 }
 try {
     await main();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@aztec/protocol-contracts",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/protocol-contracts",
   "description": "Canonical Noir contracts for the Aztec Network",
-  "version": "3.0.3-rc.3",
+  "version": "3.9.9-nightly.20260312",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -22,12 +22,12 @@
   },
   "scripts": {
     "build": "yarn clean && yarn generate && yarn generate:cleanup-artifacts && ../scripts/tsc.sh",
-    "build:keep-debug-symbols": "yarn clean && yarn generate && tsgo -b",
+    "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": "tsgo -b",
+    "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}"
   },
@@ -73,9 +73,9 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "3.0.3-rc.3",
-    "@aztec/foundation": "3.0.3-rc.3",
-    "@aztec/stdlib": "3.0.3-rc.3",
+    "@aztec/constants": "3.9.9-nightly.20260312",
+    "@aztec/foundation": "3.9.9-nightly.20260312",
+    "@aztec/stdlib": "3.9.9-nightly.20260312",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"
@@ -86,7 +86,7 @@
     "@types/lodash.chunk": "^4.2.9",
     "@types/lodash.omit": "^4.5.9",
     "@types/node": "^22.15.17",
-    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "ts-loader": "^9.5.4",

package/src/auth-registry/index.ts

@@ -10,9 +10,9 @@ let protocolContract: ProtocolContract;
 export const AuthRegistryArtifact: ContractArtifact = loadContractArtifact(AuthRegistryJson as NoirCompiledContract);
 
 /** Returns the canonical deployment of the auth registry. */
-export async function getCanonicalAuthRegistry(): Promise<ProtocolContract> {
+export function getCanonicalAuthRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    protocolContract = await makeProtocolContract('AuthRegistry', AuthRegistryArtifact);
+    protocolContract = makeProtocolContract('AuthRegistry', AuthRegistryArtifact);
   }
-  return protocolContract;
+  return Promise.resolve(protocolContract);
 }

package/src/auth-registry/lazy.ts

@@ -23,7 +23,7 @@ export async function getAuthRegistryArtifact(): Promise<ContractArtifact> {
 export async function getCanonicalAuthRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const authRegistryArtifact = await getAuthRegistryArtifact();
-    protocolContract = await makeProtocolContract('AuthRegistry', authRegistryArtifact);
+    protocolContract = makeProtocolContract('AuthRegistry', authRegistryArtifact);
   }
   return protocolContract;
 }

package/src/class-registry/contract_class_published_event.ts

@@ -29,7 +29,7 @@ export class ContractClassPublishedEvent {
   }
 
   static fromLog(log: ContractClassLog) {
-    // See how the log is serialized in `noir-projects/noir-contracts/contracts/protocol/contract_class_registry/src/events/class_published.nr`.
+    // See how the log is serialized in `noir-projects/noir-contracts/contracts/protocol/contract_class_registry_contract/src/events/class_published.nr`.
     const fieldsWithoutTag = log.fields.fields.slice(1);
     const reader = new FieldReader(fieldsWithoutTag);
     const contractClassId = reader.readField();

package/src/class-registry/index.ts

@@ -14,10 +14,10 @@ export const ContractClassRegistryArtifact = loadContractArtifact(ContractClassR
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalClassRegistry(): Promise<ProtocolContract> {
+export function getCanonicalClassRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const artifact = ContractClassRegistryArtifact;
-    protocolContract = await makeProtocolContract('ContractClassRegistry', artifact);
+    protocolContract = makeProtocolContract('ContractClassRegistry', artifact);
   }
-  return protocolContract;
+  return Promise.resolve(protocolContract);
 }

package/src/class-registry/lazy.ts

@@ -27,7 +27,7 @@ export async function getContractClassRegistryArtifact(): Promise<ContractArtifa
 export async function getCanonicalClassRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const contractClassRegistryArtifact = await getContractClassRegistryArtifact();
-    protocolContract = await makeProtocolContract('ContractClassRegistry', contractClassRegistryArtifact);
+    protocolContract = makeProtocolContract('ContractClassRegistry', contractClassRegistryArtifact);
   }
   return protocolContract;
 }

package/src/fee-juice/index.ts

@@ -14,11 +14,11 @@ export const FeeJuiceArtifact = loadContractArtifact(FeeJuiceJson as NoirCompile
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalFeeJuice(): Promise<ProtocolContract> {
+export function getCanonicalFeeJuice(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    protocolContract = await makeProtocolContract('FeeJuice', FeeJuiceArtifact);
+    protocolContract = makeProtocolContract('FeeJuice', FeeJuiceArtifact);
   }
-  return protocolContract;
+  return Promise.resolve(protocolContract);
 }
 
 /**

package/src/fee-juice/lazy.ts

@@ -23,7 +23,7 @@ export async function getFeeJuiceArtifact(): Promise<ContractArtifact> {
 export async function getCanonicalFeeJuice(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const feeJuiceArtifact = await getFeeJuiceArtifact();
-    protocolContract = await makeProtocolContract('FeeJuice', feeJuiceArtifact);
+    protocolContract = makeProtocolContract('FeeJuice', feeJuiceArtifact);
   }
   return protocolContract;
 }

package/src/instance-registry/index.ts

@@ -15,9 +15,9 @@ export const ContractInstanceRegistryArtifact = loadContractArtifact(
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalInstanceRegistry(): Promise<ProtocolContract> {
+export function getCanonicalInstanceRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    protocolContract = await makeProtocolContract('ContractInstanceRegistry', ContractInstanceRegistryArtifact);
+    protocolContract = makeProtocolContract('ContractInstanceRegistry', ContractInstanceRegistryArtifact);
   }
-  return protocolContract;
+  return Promise.resolve(protocolContract);
 }

package/src/instance-registry/lazy.ts

@@ -26,7 +26,7 @@ export async function getContractInstanceRegistryArtifact(): Promise<ContractArt
 export async function getCanonicalInstanceRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const contractInstanceRegistryArtifact = await getContractInstanceRegistryArtifact();
-    protocolContract = await makeProtocolContract('ContractInstanceRegistry', contractInstanceRegistryArtifact);
+    protocolContract = makeProtocolContract('ContractInstanceRegistry', contractInstanceRegistryArtifact);
   }
   return protocolContract;
 }

package/src/make_protocol_contract.ts

@@ -1,26 +1,48 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
-import { getContractClassFromArtifact, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import { PublicKeys } from '@aztec/stdlib/keys';
 
 import type { ProtocolContract } from './protocol_contract.js';
-import { ProtocolContractAddress, type ProtocolContractName, ProtocolContractSalt } from './protocol_contract_data.js';
+import {
+  ProtocolContractAddress,
+  ProtocolContractClassId,
+  ProtocolContractClassIdPreimage,
+  ProtocolContractInitializationHash,
+  type ProtocolContractName,
+  ProtocolContractPrivateFunctions,
+  ProtocolContractSalt,
+} from './protocol_contract_data.js';
 
 /**
- * Returns the canonical deployment given its name and artifact.
- * To be used internally within the protocol-contracts package.
+ * Reconstructs a ProtocolContract from precomputed data without performing any hash computations.
+ * Internal to the protocol-contracts package — not part of the public API.
  */
-export async function makeProtocolContract(
-  name: ProtocolContractName,
-  artifact: ContractArtifact,
-): Promise<ProtocolContract> {
+export function makeProtocolContract(name: ProtocolContractName, artifact: ContractArtifact): ProtocolContract {
   const address = ProtocolContractAddress[name];
   const salt = ProtocolContractSalt[name];
-  // TODO(@spalladino): This computes the contract class from the artifact twice.
-  const contractClass = await getContractClassFromArtifact(artifact);
-  const instance = await getContractInstanceFromInstantiationParams(artifact, { salt });
-  return {
-    instance: { ...instance, address },
-    contractClass,
-    artifact,
+  const classId = ProtocolContractClassId[name];
+  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment } = ProtocolContractClassIdPreimage[name];
+  const initializationHash = ProtocolContractInitializationHash[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: ProtocolContractPrivateFunctions[name],
+  };
+
+  const instance = {
+    version: 1 as const,
+    currentContractClassId: classId,
+    originalContractClassId: classId,
+    initializationHash,
+    publicKeys: PublicKeys.default(),
+    salt,
+    deployer: address,
     address,
   };
+
+  return { instance, contractClass, artifact, address };
 }

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

@@ -10,9 +10,9 @@ export const MultiCallEntrypointArtifact = loadContractArtifact(MultiCallEntrypo
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalMultiCallEntrypoint(): Promise<ProtocolContract> {
+export function getCanonicalMultiCallEntrypoint(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    protocolContract = await makeProtocolContract('MultiCallEntrypoint', MultiCallEntrypointArtifact);
+    protocolContract = makeProtocolContract('MultiCallEntrypoint', MultiCallEntrypointArtifact);
   }
-  return protocolContract;
+  return Promise.resolve(protocolContract);
 }

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

@@ -23,7 +23,7 @@ export async function getMultiCallEntrypointArtifact(): Promise<ContractArtifact
 export async function getCanonicalMultiCallEntrypoint(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const multiCallEntrypointArtifact = await getMultiCallEntrypointArtifact();
-    protocolContract = await makeProtocolContract('MultiCallEntrypoint', multiCallEntrypointArtifact);
+    protocolContract = makeProtocolContract('MultiCallEntrypoint', multiCallEntrypointArtifact);
   }
   return protocolContract;
 }

package/src/protocol_contract_data.ts

@@ -1,6 +1,7 @@
 
     // 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';
     import { ProtocolContracts } from '@aztec/stdlib/tx';
 
@@ -11,7 +12,7 @@
 'ContractClassRegistry',
 'MultiCallEntrypoint',
 'FeeJuice',
-'Router'
+'PublicChecks'
     ] as const;
 
     export type ProtocolContractName = typeof protocolContractNames[number];
@@ -24,7 +25,7 @@ ContractInstanceRegistry: new Fr(1),
 ContractClassRegistry: new Fr(1),
 MultiCallEntrypoint: new Fr(1),
 FeeJuice: new Fr(1),
-Router: new Fr(1)
+PublicChecks: new Fr(1)
     };
   
 
@@ -35,29 +36,91 @@ ContractInstanceRegistry: AztecAddress.fromBigInt(2n),
 ContractClassRegistry: AztecAddress.fromBigInt(3n),
 MultiCallEntrypoint: AztecAddress.fromBigInt(4n),
 FeeJuice: AztecAddress.fromBigInt(5n),
-Router: AztecAddress.fromBigInt(6n)
+PublicChecks: AztecAddress.fromBigInt(6n)
     };
   
 
     
     export const ProtocolContractDerivedAddress = {
-      AuthRegistry: AztecAddress.fromString('0x154bc3dc5cea44ef4c3d3578cdce2f81f34300d2d7819a8d72ef0d4d135cdfd4'),
-ContractInstanceRegistry: AztecAddress.fromString('0x04265e72412c0b74d741e805252a0cb54e703a68f513cd91306ad0b400a24b0d'),
-ContractClassRegistry: AztecAddress.fromString('0x0b7a3b99c7051ee329d2c905b9f646d3706ed031fa1f97b0c19274e5773ebec5'),
-MultiCallEntrypoint: AztecAddress.fromString('0x0961995245e0f34801e7ca5e83a0a6fbf2d78cfce788134b6ef6e877715d594a'),
-FeeJuice: AztecAddress.fromString('0x13d932791f9e77dce1dcbdbb0a562ceab5dcb491866905471cf7cfc1136001b0'),
-Router: AztecAddress.fromString('0x2fed59e101da3e1f0f7e959fd154d042ca447729a80925faf4da42bc8ff05865')
+      AuthRegistry: AztecAddress.fromString('0x139f8eb6d6e7e7a7c0322c3b7558687a7e24201f11bf2c4cb2fe56c18d363695'),
+ContractInstanceRegistry: AztecAddress.fromString('0x1254246c88aca5a66fa66f3aa78c408a698ebca3b713120497c7555dfc718592'),
+ContractClassRegistry: AztecAddress.fromString('0x14d670efa326a07b99777b01fb706427ca776095246569150f2a3f17a7d4dc66'),
+MultiCallEntrypoint: AztecAddress.fromString('0x230d0b47ba6d5ed99afb89d584f32ff33438b64f51000f252a140cf995781628'),
+FeeJuice: AztecAddress.fromString('0x204913186c0dd70015d05bf9100a12e31ccb7cc2527aacdfae0c19ad6439fcf4'),
+PublicChecks: AztecAddress.fromString('0x1198142fd84a58c0ab22d5fde371ce527042db49487e05206a326ad154952ac8')
+    };
+  
+
+    
+    export const ProtocolContractClassId: Record<ProtocolContractName, Fr> = {
+      AuthRegistry: Fr.fromString('0x17ad10e1b5dba2877b9a973449c03d5227f2c719c0eb1989427c10c1d83867a5'),
+ContractInstanceRegistry: Fr.fromString('0x187c710b0d69b2da7a6f0663c15093a5d595c04e77762c249aa9b654bc12158c'),
+ContractClassRegistry: Fr.fromString('0x013466b8a65dea98ad80c119cf236a0acf53acfede687769410cfd57876b8242'),
+MultiCallEntrypoint: Fr.fromString('0x1acd7ab8bf186c16eafc9c4fe9049f35df27e172bb2d8319a2a22ddd0006966d'),
+FeeJuice: Fr.fromString('0x16b2d5ef5044c11126a16ccdb3778082eb423375977da9458d493fdf84505e81'),
+PublicChecks: Fr.fromString('0x03f2ebaef8d692422185e35d8fe35d0bb7289702cf023b525c022d77fc6b5ed5')
+    };
+
+    export const ProtocolContractClassIdPreimage: Record<ProtocolContractName, { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }> = {
+      AuthRegistry: {
+        artifactHash: Fr.fromString('0x029f3b5582e9e2f9cddb4f887fa67c06d8dbe9aef604aa7de91a6f5328bf477c'),
+        privateFunctionsRoot: Fr.fromString('0x0826df9bf86cf460935b2bd024edcb5a58532fcf0392abbdb33f5f2150753756'),
+        publicBytecodeCommitment: Fr.fromString('0x22db1f0a70bfefaf90371c7728e558cf60507b718e99ed276ed3143bec615f6f'),
+      },
+ContractInstanceRegistry: {
+        artifactHash: Fr.fromString('0x18601566bacdca7a5a40528f221b04ee7b74f382e6cd34fbdf69d31c50d5ee88'),
+        privateFunctionsRoot: Fr.fromString('0x136a6705c7ad1d47f65cb881a56909d4c78d3fa8944f5b103734cd91e654ed63'),
+        publicBytecodeCommitment: Fr.fromString('0x01c573f470ba9a17d362c7dd5a28931c39432f9ce527555049c71432f895ad6c'),
+      },
+ContractClassRegistry: {
+        artifactHash: Fr.fromString('0x232d868db8a4d1e0f013efa4bfe5c39d96e11f16a62e3e73abbbafc3028fc410'),
+        privateFunctionsRoot: Fr.fromString('0x2ac3bf890a7d534a768079aa86889caa1a86373c8e6fc2db48215b11bbb79106'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
+      },
+MultiCallEntrypoint: {
+        artifactHash: Fr.fromString('0x0d30526b6b786cf887d7e44ba59d2e9561d5791b0e3c78c681d0499ae45b225a'),
+        privateFunctionsRoot: Fr.fromString('0x266505ecb7c02ce6e227227c0b6bdb44713c8ecd43164ee7bb00b8fb340e8b03'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
+      },
+FeeJuice: {
+        artifactHash: Fr.fromString('0x2eb476f12cce5207be118047fb7f603378b78aa619d6539a4d9eec4700ea2507'),
+        privateFunctionsRoot: Fr.fromString('0x0abef3cfc6ae314886c841b42dc33d3eed255ad3dee7773daabf05b229573759'),
+        publicBytecodeCommitment: Fr.fromString('0x2a144b28b36efa21b7488467aba7e06b33e016d00bfe083a7bfa06ad6ff5aa2f'),
+      },
+PublicChecks: {
+        artifactHash: Fr.fromString('0x228ea8af66ff150f40a4b01b64115d12777b2f7fd3a4bfc0d97d38a91f139ef6'),
+        privateFunctionsRoot: Fr.fromString('0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1'),
+        publicBytecodeCommitment: Fr.fromString('0x2d0834fc9468fd2092091852543a2fbd7b6b313c7e5e4defe8730c8065366a03'),
+      }
+    };
+
+    export const ProtocolContractInitializationHash: Record<ProtocolContractName, Fr> = {
+      AuthRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+ContractInstanceRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+ContractClassRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+MultiCallEntrypoint: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+FeeJuice: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+PublicChecks: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+    };
+
+    export const ProtocolContractPrivateFunctions: Record<ProtocolContractName, { selector: FunctionSelector; vkHash: Fr }[]> = {
+      AuthRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000079a3d418')), vkHash: Fr.fromString('0x019c553854290b9b547841e45bf45e344d4a2d4f6702fee430ec5897ce7d3b78') }],
+ContractInstanceRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000016ec12aa')), vkHash: Fr.fromString('0x262f7a90ecf055779001b67dad01a3add1e549f6c27931f0e71e463ce2142b57') }],
+ContractClassRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x000000000000000000000000000000000000000000000000000000006934ed0d')), vkHash: Fr.fromString('0x1163f31e191528254c877fce0c7f62dd738f5552bbd2dda97512fe4777377f5b') }],
+MultiCallEntrypoint: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000f04908a9')), vkHash: Fr.fromString('0x21732ab3cecf633e4c31a030df62c93e35a005b89941fdab568d2818c1355192') }],
+FeeJuice: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000cbe67243')), vkHash: Fr.fromString('0x2ad6083b4595f8076c014e5152191013167ab1b5a31ad0cbb06490054c7c59ae') }, { selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000e8d374b6')), vkHash: Fr.fromString('0x05aaffffdf797625ff24575d939339303775c5db77fb6bdcecbf955f726fd071') }],
+PublicChecks: []
     };
   
 
     
     export const ProtocolContractsList = new ProtocolContracts([
-      AztecAddress.fromString('0x154bc3dc5cea44ef4c3d3578cdce2f81f34300d2d7819a8d72ef0d4d135cdfd4'),
-AztecAddress.fromString('0x04265e72412c0b74d741e805252a0cb54e703a68f513cd91306ad0b400a24b0d'),
-AztecAddress.fromString('0x0b7a3b99c7051ee329d2c905b9f646d3706ed031fa1f97b0c19274e5773ebec5'),
-AztecAddress.fromString('0x0961995245e0f34801e7ca5e83a0a6fbf2d78cfce788134b6ef6e877715d594a'),
-AztecAddress.fromString('0x13d932791f9e77dce1dcbdbb0a562ceab5dcb491866905471cf7cfc1136001b0'),
-AztecAddress.fromString('0x2fed59e101da3e1f0f7e959fd154d042ca447729a80925faf4da42bc8ff05865'),
+      AztecAddress.fromString('0x139f8eb6d6e7e7a7c0322c3b7558687a7e24201f11bf2c4cb2fe56c18d363695'),
+AztecAddress.fromString('0x1254246c88aca5a66fa66f3aa78c408a698ebca3b713120497c7555dfc718592'),
+AztecAddress.fromString('0x14d670efa326a07b99777b01fb706427ca776095246569150f2a3f17a7d4dc66'),
+AztecAddress.fromString('0x230d0b47ba6d5ed99afb89d584f32ff33438b64f51000f252a140cf995781628'),
+AztecAddress.fromString('0x204913186c0dd70015d05bf9100a12e31ccb7cc2527aacdfae0c19ad6439fcf4'),
+AztecAddress.fromString('0x1198142fd84a58c0ab22d5fde371ce527042db49487e05206a326ad154952ac8'),
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
@@ -65,10 +128,10 @@ AztecAddress.fromString('0x00000000000000000000000000000000000000000000000000000
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
     ]);
 
-    export const protocolContractsHash = Fr.fromString('0x2348b12e0edd63c38dbb849b6c788c4975ed3f1f3706fcb5e17431e805da672d');
+    export const protocolContractsHash = Fr.fromString('0x2672340d9a0107a7b81e6d10d25b854debe613f3272e8738e8df0ca2ff297141');
   
 
     
-  export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x28da3fc471387d4e20b646b77abc8cdfc02a339a7507285a73d84f9b97b13486');
+  export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x1a7e1badb79abdd38c684b3c8306ffe7ecb33c69e3380d9855730aaaa83a21a8');