@aztec/protocol-contracts 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5d02921e

package/dest/public-checks/lazy.js

@@ -17,7 +17,7 @@ export async function getPublicChecksArtifact() {
 /** Returns the canonical deployment of the public checks contract. */ export async function getCanonicalPublicChecks() {
     if (!protocolContract) {
         const publicChecksArtifact = await getPublicChecksArtifact();
-        protocolContract = await makeProtocolContract('PublicChecks', publicChecksArtifact);
+        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, GeneratorIndex, MAX_PROTOCOL_CONTRACTS, MULTI_CALL_ENTRYPOINT_ADDRESS, PUBLIC_CHECKS_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 { poseidon2HashWithSeparator } 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';
@@ -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 poseidon2HashWithSeparator([
-        CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE
-    ], GeneratorIndex.PRIVATE_LOG_FIRST_FIELD)}');
+  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/dest/tests/fixtures.d.ts

@@ -1,6 +1,4 @@
 export declare function getSampleContractClassPublishedEventPayload(): Buffer;
-export declare function getSamplePrivateFunctionBroadcastedEventPayload(): Buffer;
-export declare function getSampleUtilityFunctionBroadcastedEventPayload(): Buffer;
 export declare function getSampleContractInstancePublishedEventPayload(): Buffer;
 export declare function getPathToFixture(name: string): string;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0cy9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSx3QkFBZ0IsMkNBQTJDLElBQUksTUFBTSxDQUdwRTtBQUdELHdCQUFnQiwrQ0FBK0MsSUFBSSxNQUFNLENBR3hFO0FBR0Qsd0JBQWdCLCtDQUErQyxJQUFJLE1BQU0sQ0FHeEU7QUFHRCx3QkFBZ0IsOENBQThDLElBQUksTUFBTSxDQUd2RTtBQUVELHdCQUFnQixnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsTUFBTSxVQUU1QyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0cy9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSx3QkFBZ0IsMkNBQTJDLElBQUksTUFBTSxDQUdwRTtBQUdELHdCQUFnQiw4Q0FBOEMsSUFBSSxNQUFNLENBR3ZFO0FBRUQsd0JBQWdCLGdCQUFnQixDQUFDLElBQUksRUFBRSxNQUFNLFVBRTVDIn0=

package/dest/tests/fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/tests/fixtures.ts"],"names":[],"mappings":"AAKA,wBAAgB,2CAA2C,IAAI,MAAM,CAGpE;AAGD,wBAAgB,+CAA+C,IAAI,MAAM,CAGxE;AAGD,wBAAgB,+CAA+C,IAAI,MAAM,CAGxE;AAGD,wBAAgB,8CAA8C,IAAI,MAAM,CAGvE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,UAE5C"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/tests/fixtures.ts"],"names":[],"mappings":"AAKA,wBAAgB,2CAA2C,IAAI,MAAM,CAGpE;AAGD,wBAAgB,8CAA8C,IAAI,MAAM,CAGvE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,UAE5C"}

package/dest/tests/fixtures.js

@@ -7,16 +7,6 @@ export function getSampleContractClassPublishedEventPayload() {
     return Buffer.from(readFileSync(path).toString(), 'hex');
 }
 // Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
-export function getSamplePrivateFunctionBroadcastedEventPayload() {
-    const path = getPathToFixture('PrivateFunctionBroadcastedEventData.hex');
-    return Buffer.from(readFileSync(path).toString(), 'hex');
-}
-// Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
-export function getSampleUtilityFunctionBroadcastedEventPayload() {
-    const path = getPathToFixture('UtilityFunctionBroadcastedEventData.hex');
-    return Buffer.from(readFileSync(path).toString(), 'hex');
-}
-// Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
 export function getSampleContractInstancePublishedEventPayload() {
     const path = getPathToFixture('ContractInstancePublishedEventData.hex');
     return Buffer.from(readFileSync(path).toString(), 'hex');

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": "0.0.1-commit.f2ce05ee",
+  "version": "0.0.1-commit.f5d02921e",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -73,9 +73,9 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.f2ce05ee",
-    "@aztec/foundation": "0.0.1-commit.f2ce05ee",
-    "@aztec/stdlib": "0.0.1-commit.f2ce05ee",
+    "@aztec/constants": "0.0.1-commit.f5d02921e",
+    "@aztec/foundation": "0.0.1-commit.f5d02921e",
+    "@aztec/stdlib": "0.0.1-commit.f5d02921e",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"

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

@@ -4,7 +4,7 @@ import { FieldReader } from '@aztec/foundation/serialize';
 import { bufferFromFields } from '@aztec/stdlib/abi';
 import {
   type ContractClassPublic,
-  computeContractClassId,
+  type ContractClassPublicWithCommitment,
   computePublicBytecodeCommitment,
 } from '@aztec/stdlib/contract';
 import type { ContractClassLog } from '@aztec/stdlib/logs';
@@ -47,34 +47,23 @@ export class ContractClassPublishedEvent {
     );
   }
 
-  async toContractClassPublic(): Promise<ContractClassPublic> {
-    const computedClassId = await computeContractClassId({
-      artifactHash: this.artifactHash,
-      privateFunctionsRoot: this.privateFunctionsRoot,
-      publicBytecodeCommitment: await computePublicBytecodeCommitment(this.packedPublicBytecode),
-    });
-
-    if (!computedClassId.equals(this.contractClassId)) {
-      throw new Error(
-        `Invalid contract class id: computed ${computedClassId.toString()} but event broadcasted ${this.contractClassId.toString()}`,
-      );
-    }
-
-    if (this.version !== 1) {
-      throw new Error(`Unexpected contract class version ${this.version}`);
-    }
-
+  /** Converts the event to a contract class, without computing or validating the bytecode commitment. */
+  toContractClassPublic(): ContractClassPublic {
     return {
       id: this.contractClassId,
       artifactHash: this.artifactHash,
       packedBytecode: this.packedPublicBytecode,
       privateFunctionsRoot: this.privateFunctionsRoot,
-      version: this.version,
-      privateFunctions: [],
-      utilityFunctions: [],
+      version: this.version as 1,
     };
   }
 
+  /** Converts the event to a contract class with its bytecode commitment (expensive). */
+  async toContractClassPublicWithBytecodeCommitment(): Promise<ContractClassPublicWithCommitment> {
+    const publicBytecodeCommitment = await computePublicBytecodeCommitment(this.packedPublicBytecode);
+    return { ...this.toContractClassPublic(), publicBytecodeCommitment };
+  }
+
   public static extractContractClassEvents(logs: ContractClassLog[]): ContractClassPublishedEvent[] {
     return logs
       .filter((log: ContractClassLog) => ContractClassPublishedEvent.isContractClassPublishedEvent(log))

package/src/class-registry/index.ts

@@ -6,18 +6,16 @@ import { makeProtocolContract } from '../make_protocol_contract.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 
 export * from './contract_class_published_event.js';
-export * from './private_function_broadcasted_event.js';
-export * from './utility_function_broadcasted_event.js';
 
 export const ContractClassRegistryArtifact = loadContractArtifact(ContractClassRegistryJson as NoirCompiledContract);
 
 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

@@ -4,8 +4,6 @@ import { makeProtocolContract } from '../make_protocol_contract.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 
 export * from './contract_class_published_event.js';
-export * from './private_function_broadcasted_event.js';
-export * from './utility_function_broadcasted_event.js';
 
 let protocolContract: ProtocolContract;
 let protocolContractArtifact: ContractArtifact;
@@ -27,7 +25,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';
 
@@ -41,23 +42,85 @@ PublicChecks: AztecAddress.fromBigInt(6n)
 
     
     export const ProtocolContractDerivedAddress = {
-      AuthRegistry: AztecAddress.fromString('0x00c052aa878325ba78fac127c40ae563511318e9e6948263e379a03d5f1e4a6e'),
-ContractInstanceRegistry: AztecAddress.fromString('0x21ff2465da821a8cf18c4cd2a9b84e6bc02619f836405fba1b12f49b40451916'),
-ContractClassRegistry: AztecAddress.fromString('0x0cbc4ac84fd49f6f87625e93c24b3713be69ec8d048ea4c9ef731535922eb566'),
-MultiCallEntrypoint: AztecAddress.fromString('0x25a2606e5b0475329de902e1c02d8cd6b127b075495fa98f4ed2401a18c0e601'),
-FeeJuice: AztecAddress.fromString('0x163da85a17e1762dff0020832656ece3d2f89ac74fcc6572dda8c9492510c0c2'),
-PublicChecks: AztecAddress.fromString('0x2e1a5de981901564e30ec6268592dcf39e0b4c6bea131c079c9ce4fb52e9f181')
+      AuthRegistry: AztecAddress.fromString('0x264998bb5c222d3d7e8983314abb14b8cd338dd191870e8da5cbe339fb42b0c4'),
+ContractInstanceRegistry: AztecAddress.fromString('0x1248ac9927762017c75d333f8eb19177025c7a942981a99e92490f5133ae716a'),
+ContractClassRegistry: AztecAddress.fromString('0x1378f6d83443d61cebbc432712ee49da558c557c40c391750fefce04826a9ce6'),
+MultiCallEntrypoint: AztecAddress.fromString('0x0fcfd159ff069dc484d4195c385aad2169c283ca4a5c12f653876f618496b7ff'),
+FeeJuice: AztecAddress.fromString('0x0d20a03336d11485e1c0a7578782fda5dd50492f453650d821c2d91deae48649'),
+PublicChecks: AztecAddress.fromString('0x07e00d7dc55bbd64a8533d98f040f4d1450137d145fa630dd94d2f6998a9a974')
+    };
+  
+
+    
+    export const ProtocolContractClassId: Record<ProtocolContractName, Fr> = {
+      AuthRegistry: Fr.fromString('0x0a65400c5d9c67c03670547a0b409570e7c8e14ad0b3213bb70fa4e6e9f5885c'),
+ContractInstanceRegistry: Fr.fromString('0x101ab410f4b81317be705851b1375232d8b3e5779978372d04df77c8beb93086'),
+ContractClassRegistry: Fr.fromString('0x15490ac1701acd7366ada630e082a248e414894928dec70d072126b0c93debd5'),
+MultiCallEntrypoint: Fr.fromString('0x2147cc5d0adb172810d21850b27a1fc7ad1367b2f0eb5f606aadda0c6cacbe4b'),
+FeeJuice: Fr.fromString('0x162dd5be99ce8fbd38f8a3434836de1021249562a7f9f38493078325360c8d14'),
+PublicChecks: Fr.fromString('0x0b3a808271b9f1ff3236f4044a4a3ad1bff0f37bb2b545be87ab173d1addafe4')
+    };
+
+    export const ProtocolContractClassIdPreimage: Record<ProtocolContractName, { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }> = {
+      AuthRegistry: {
+        artifactHash: Fr.fromString('0x247fb90ca0e108a5f0fc161ec48a2d1206595e02522e0ca28ea33182dc640300'),
+        privateFunctionsRoot: Fr.fromString('0x27784529e3cec8776bdc7a624084353cf1372b247279344625458dbd14b6f1f6'),
+        publicBytecodeCommitment: Fr.fromString('0x28cfc03b3eb55cff2f03bb573fb5a9a014e83fbcb37ec2f0ee72866c35d6f95f'),
+      },
+ContractInstanceRegistry: {
+        artifactHash: Fr.fromString('0x24bb640b5b8c5d553f6b00ecd0f1fbbc43334109219728a915f0311cbcadca8b'),
+        privateFunctionsRoot: Fr.fromString('0x1a5ad2d8a129666ca3d7eb7e801e1239517fbccc10be0334b39100b17fbc96d2'),
+        publicBytecodeCommitment: Fr.fromString('0x14512a81eae728ff93f7d6ed568b231c33364a4dba36bfe0f239761065df2a67'),
+      },
+ContractClassRegistry: {
+        artifactHash: Fr.fromString('0x2c50755a4c70f9cea6e1c9e07189554cd62bafb22107720c9cea29392d179fee'),
+        privateFunctionsRoot: Fr.fromString('0x2bbf7adfd5b94bfd32760346d955342e967aab205e1ddafe71755223a1ea56b3'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
+      },
+MultiCallEntrypoint: {
+        artifactHash: Fr.fromString('0x0c5722ce0f3a531c42a45ad2583bf592e0b98ddde43ee7aba6f56b1803a99eff'),
+        privateFunctionsRoot: Fr.fromString('0x274e418b4b3723ace4b55099f926e76d883a8c057a34296f15a52e04ea4ec593'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
+      },
+FeeJuice: {
+        artifactHash: Fr.fromString('0x0750f796b97b8bf554313bb98f6a2bfc9cf8fd49adccad7ff3b993cb7db00d79'),
+        privateFunctionsRoot: Fr.fromString('0x0abef3cfc6ae314886c841b42dc33d3eed255ad3dee7773daabf05b229573759'),
+        publicBytecodeCommitment: Fr.fromString('0x2f2fd4c1d886faa614efbc750c5e49ad0fa83fc5a411f42ea0a70cab49f6251e'),
+      },
+PublicChecks: {
+        artifactHash: Fr.fromString('0x079752d98445c9174250371728d1482b1c9886489bffb6bba147f1e324f9292c'),
+        privateFunctionsRoot: Fr.fromString('0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1'),
+        publicBytecodeCommitment: Fr.fromString('0x23a718888ee4815f0145eebf241e5a7071e6791ea2fa9b635c48b94d68b97c58'),
+      }
+    };
+
+    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('0x08f3d088b55a22ddda33df11198647b5d3fa0e0da47b79d88744f26b00fab824') }],
+ContractInstanceRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000016ec12aa')), vkHash: Fr.fromString('0x174db1fba7dfefa38f56ba0e54abb8c01eb2a1f437bb346a97949667e3b7f399') }],
+ContractClassRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x000000000000000000000000000000000000000000000000000000006934ed0d')), vkHash: Fr.fromString('0x03df8d6492115c243c78effa13dc3c86a7babd3898cce52083d0d603e51acdfa') }],
+MultiCallEntrypoint: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000f04908a9')), vkHash: Fr.fromString('0x01a9fe65b628a72771fe90e3b3cf4d16fa87069b788359624e1820980c0a0dd3') }],
+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('0x00c052aa878325ba78fac127c40ae563511318e9e6948263e379a03d5f1e4a6e'),
-AztecAddress.fromString('0x21ff2465da821a8cf18c4cd2a9b84e6bc02619f836405fba1b12f49b40451916'),
-AztecAddress.fromString('0x0cbc4ac84fd49f6f87625e93c24b3713be69ec8d048ea4c9ef731535922eb566'),
-AztecAddress.fromString('0x25a2606e5b0475329de902e1c02d8cd6b127b075495fa98f4ed2401a18c0e601'),
-AztecAddress.fromString('0x163da85a17e1762dff0020832656ece3d2f89ac74fcc6572dda8c9492510c0c2'),
-AztecAddress.fromString('0x2e1a5de981901564e30ec6268592dcf39e0b4c6bea131c079c9ce4fb52e9f181'),
+      AztecAddress.fromString('0x264998bb5c222d3d7e8983314abb14b8cd338dd191870e8da5cbe339fb42b0c4'),
+AztecAddress.fromString('0x1248ac9927762017c75d333f8eb19177025c7a942981a99e92490f5133ae716a'),
+AztecAddress.fromString('0x1378f6d83443d61cebbc432712ee49da558c557c40c391750fefce04826a9ce6'),
+AztecAddress.fromString('0x0fcfd159ff069dc484d4195c385aad2169c283ca4a5c12f653876f618496b7ff'),
+AztecAddress.fromString('0x0d20a03336d11485e1c0a7578782fda5dd50492f453650d821c2d91deae48649'),
+AztecAddress.fromString('0x07e00d7dc55bbd64a8533d98f040f4d1450137d145fa630dd94d2f6998a9a974'),
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
@@ -65,7 +128,7 @@ AztecAddress.fromString('0x00000000000000000000000000000000000000000000000000000
 AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
     ]);
 
-    export const protocolContractsHash = Fr.fromString('0x2c9691061d1684b0ca37688b363c56b3c53e49ce7c9066aec9e00592e70b70d5');
+    export const protocolContractsHash = Fr.fromString('0x2c38131f6c8746008631d3aec92c39d3e6c2149baeaa69026a416562a8b8743b');
   
 
     

package/src/provider/bundle.ts

@@ -22,6 +22,6 @@ export const ProtocolContractArtifact: Record<ProtocolContractName, ContractArti
 
 export class BundledProtocolContractsProvider implements ProtocolContractsProvider {
   getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract> {
-    return makeProtocolContract(name, ProtocolContractArtifact[name]);
+    return Promise.resolve(makeProtocolContract(name, ProtocolContractArtifact[name]));
   }
 }

package/src/public-checks/index.ts

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