@aztec/protocol-contracts 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/{class-registerer/contract_class_registered_event.ts → class-registry/contract_class_published_event.ts}

@@ -1,19 +1,18 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
-import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
+import { bufferFromFields } from '@aztec/stdlib/abi';
 import {
   type ContractClassPublic,
-  type PublicFunction,
   computeContractClassId,
   computePublicBytecodeCommitment,
 } from '@aztec/stdlib/contract';
 import type { ContractClassLog } from '@aztec/stdlib/logs';
 
-import { REGISTERER_CONTRACT_CLASS_REGISTERED_TAG } from '../protocol_contract_data.js';
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
 
-/** Event emitted from the ContractClassRegisterer. */
-export class ContractClassRegisteredEvent {
+/** Event emitted from the ContractClassRegistry. */
+export class ContractClassPublishedEvent {
   constructor(
     public readonly contractClassId: Fr,
     public readonly version: number,
@@ -22,19 +21,24 @@ export class ContractClassRegisteredEvent {
     public readonly packedPublicBytecode: Buffer,
   ) {}
 
-  static isContractClassRegisteredEvent(log: ContractClassLog) {
-    return log.fields[0].equals(REGISTERER_CONTRACT_CLASS_REGISTERED_TAG);
+  static isContractClassPublishedEvent(log: ContractClassLog) {
+    return (
+      log.contractAddress.equals(ProtocolContractAddress.ContractClassRegistry) &&
+      log.fields.fields[0].toBigInt() === CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE
+    );
   }
 
   static fromLog(log: ContractClassLog) {
-    const reader = new FieldReader(log.fields.slice(1));
+    // 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();
     const version = reader.readField().toNumber();
     const artifactHash = reader.readField();
     const privateFunctionsRoot = reader.readField();
-    const packedPublicBytecode = bufferFromFields(reader.readFieldArray(log.fields.slice(1).length - reader.cursor));
+    const packedPublicBytecode = bufferFromFields(reader.readFieldArray(fieldsWithoutTag.length - reader.cursor));
 
-    return new ContractClassRegisteredEvent(
+    return new ContractClassPublishedEvent(
       contractClassId,
       version,
       artifactHash,
@@ -60,24 +64,20 @@ export class ContractClassRegisteredEvent {
       throw new Error(`Unexpected contract class version ${this.version}`);
     }
 
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
-    const publicFunctions: PublicFunction[] = [];
-    if (this.packedPublicBytecode.length > 0) {
-      publicFunctions.push({
-        selector: FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-        bytecode: this.packedPublicBytecode,
-      });
-    }
-
     return {
       id: this.contractClassId,
       artifactHash: this.artifactHash,
       packedBytecode: this.packedPublicBytecode,
       privateFunctionsRoot: this.privateFunctionsRoot,
-      publicFunctions: publicFunctions,
       version: this.version,
       privateFunctions: [],
-      unconstrainedFunctions: [],
+      utilityFunctions: [],
     };
   }
+
+  public static extractContractClassEvents(logs: ContractClassLog[]): ContractClassPublishedEvent[] {
+    return logs
+      .filter((log: ContractClassLog) => ContractClassPublishedEvent.isContractClassPublishedEvent(log))
+      .map((log: ContractClassLog) => ContractClassPublishedEvent.fromLog(log));
+  }
 }

package/src/class-registry/index.ts

@@ -0,0 +1,23 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import ContractClassRegistryJson from '../../artifacts/ContractClassRegistry.json' with { type: 'json' };
+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 function getCanonicalClassRegistry(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const artifact = ContractClassRegistryArtifact;
+    protocolContract = makeProtocolContract('ContractClassRegistry', artifact);
+  }
+  return Promise.resolve(protocolContract);
+}

package/src/class-registry/lazy.ts

@@ -0,0 +1,33 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+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;
+
+export async function getContractClassRegistryArtifact(): Promise<ContractArtifact> {
+  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: contractClassRegistryJson } = await import('../../artifacts/ContractClassRegistry.json');
+    protocolContractArtifact = loadContractArtifact(contractClassRegistryJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalClassRegistry(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const contractClassRegistryArtifact = await getContractClassRegistryArtifact();
+    protocolContract = makeProtocolContract('ContractClassRegistry', contractClassRegistryArtifact);
+  }
+  return protocolContract;
+}

package/src/{class-registerer → class-registry}/private_function_broadcasted_event.ts

@@ -1,23 +1,24 @@
 import {
   ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
+  CONTRACT_CLASS_REGISTRY_PRIVATE_FUNCTION_BROADCASTED_MAGIC_VALUE,
   FUNCTION_TREE_HEIGHT,
   MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
 import type { ExecutablePrivateFunctionWithMembershipProof, PrivateFunction } from '@aztec/stdlib/contract';
 import type { ContractClassLog } from '@aztec/stdlib/logs';
 
-import { REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
 
-/** Event emitted from the ContractClassRegisterer. */
+/** Event emitted from the ContractClassRegistry. */
 export class PrivateFunctionBroadcastedEvent {
   constructor(
     public readonly contractClassId: Fr,
     public readonly artifactMetadataHash: Fr,
-    public readonly unconstrainedFunctionsArtifactTreeRoot: Fr,
+    public readonly utilityFunctionsTreeRoot: Fr,
     public readonly privateFunctionTreeSiblingPath: Tuple<Fr, typeof FUNCTION_TREE_HEIGHT>,
     public readonly privateFunctionTreeLeafIndex: number,
     public readonly artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>,
@@ -26,11 +27,14 @@ export class PrivateFunctionBroadcastedEvent {
   ) {}
 
   static isPrivateFunctionBroadcastedEvent(log: ContractClassLog) {
-    return log.fields[0].equals(REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG);
+    return (
+      log.contractAddress.equals(ProtocolContractAddress.ContractClassRegistry) &&
+      log.fields.fields[0].toBigInt() === CONTRACT_CLASS_REGISTRY_PRIVATE_FUNCTION_BROADCASTED_MAGIC_VALUE
+    );
   }
 
   static fromLog(log: ContractClassLog) {
-    const reader = new FieldReader(log.fields.slice(1));
+    const reader = new FieldReader(log.fields.fields.slice(1));
     const event = PrivateFunctionBroadcastedEvent.fromFields(reader);
     while (!reader.isFinished()) {
       const field = reader.readField();
@@ -46,7 +50,7 @@ export class PrivateFunctionBroadcastedEvent {
     const reader = FieldReader.asReader(fields);
     const contractClassId = reader.readField();
     const artifactMetadataHash = reader.readField();
-    const unconstrainedFunctionsArtifactTreeRoot = reader.readField();
+    const utilityFunctionsTreeRoot = reader.readField();
     const privateFunctionTreeSiblingPath = reader.readFieldArray(FUNCTION_TREE_HEIGHT);
     const privateFunctionTreeLeafIndex = reader.readField().toNumber();
     const artifactFunctionTreeSiblingPath = reader.readFieldArray(ARTIFACT_FUNCTION_TREE_MAX_HEIGHT);
@@ -56,7 +60,7 @@ export class PrivateFunctionBroadcastedEvent {
     return new PrivateFunctionBroadcastedEvent(
       contractClassId,
       artifactMetadataHash,
-      unconstrainedFunctionsArtifactTreeRoot,
+      utilityFunctionsTreeRoot,
       privateFunctionTreeSiblingPath,
       privateFunctionTreeLeafIndex,
       artifactFunctionTreeSiblingPath,
@@ -71,7 +75,7 @@ export class PrivateFunctionBroadcastedEvent {
       bytecode: this.privateFunction.bytecode,
       functionMetadataHash: this.privateFunction.metadataHash,
       artifactMetadataHash: this.artifactMetadataHash,
-      unconstrainedFunctionsArtifactTreeRoot: this.unconstrainedFunctionsArtifactTreeRoot,
+      utilityFunctionsTreeRoot: this.utilityFunctionsTreeRoot,
       privateFunctionTreeSiblingPath: this.privateFunctionTreeSiblingPath,
       privateFunctionTreeLeafIndex: this.privateFunctionTreeLeafIndex,
       artifactTreeSiblingPath: this.artifactFunctionTreeSiblingPath.filter(fr => !fr.isZero()),

package/src/{class-registerer/unconstrained_function_broadcasted_event.ts → class-registry/utility_function_broadcasted_event.ts}

@@ -1,39 +1,43 @@
 import {
   ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
-  MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS,
+  CONTRACT_CLASS_REGISTRY_UTILITY_FUNCTION_BROADCASTED_MAGIC_VALUE,
+  MAX_PACKED_BYTECODE_SIZE_PER_UTILITY_FUNCTION_IN_FIELDS,
 } from '@aztec/constants';
 import { removeArrayPaddingEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
-import type { UnconstrainedFunction, UnconstrainedFunctionWithMembershipProof } from '@aztec/stdlib/contract';
+import type { UtilityFunction, UtilityFunctionWithMembershipProof } from '@aztec/stdlib/contract';
 import type { ContractClassLog } from '@aztec/stdlib/logs';
 
-import { REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
 
-/** Event emitted from the ContractClassRegisterer. */
-export class UnconstrainedFunctionBroadcastedEvent {
+/** Event emitted from the ContractClassRegistry. */
+export class UtilityFunctionBroadcastedEvent {
   constructor(
     public readonly contractClassId: Fr,
     public readonly artifactMetadataHash: Fr,
     public readonly privateFunctionsArtifactTreeRoot: Fr,
     public readonly artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>,
     public readonly artifactFunctionTreeLeafIndex: number,
-    public readonly unconstrainedFunction: BroadcastedUnconstrainedFunction,
+    public readonly utilityFunction: BroadcastedUtilityFunction,
   ) {}
 
-  static isUnconstrainedFunctionBroadcastedEvent(log: ContractClassLog) {
-    return log.fields[0].equals(REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG);
+  static isUtilityFunctionBroadcastedEvent(log: ContractClassLog) {
+    return (
+      log.contractAddress.equals(ProtocolContractAddress.ContractClassRegistry) &&
+      log.fields.fields[0].toBigInt() === CONTRACT_CLASS_REGISTRY_UTILITY_FUNCTION_BROADCASTED_MAGIC_VALUE
+    );
   }
 
   static fromLog(log: ContractClassLog) {
-    const reader = new FieldReader(log.fields.slice(1));
-    const event = UnconstrainedFunctionBroadcastedEvent.fromFields(reader);
+    const reader = new FieldReader(log.fields.fields.slice(1));
+    const event = UtilityFunctionBroadcastedEvent.fromFields(reader);
     while (!reader.isFinished()) {
       const field = reader.readField();
       if (!field.isZero()) {
-        throw new Error(`Unexpected data after parsing UnconstrainedFunctionBroadcastedEvent: ${field.toString()}`);
+        throw new Error(`Unexpected data after parsing UtilityFunctionBroadcastedEvent: ${field.toString()}`);
       }
     }
 
@@ -47,28 +51,28 @@ export class UnconstrainedFunctionBroadcastedEvent {
     const privateFunctionsArtifactTreeRoot = reader.readField();
     const artifactFunctionTreeSiblingPath = reader.readFieldArray(ARTIFACT_FUNCTION_TREE_MAX_HEIGHT);
     const artifactFunctionTreeLeafIndex = reader.readField().toNumber();
-    const unconstrainedFunction = BroadcastedUnconstrainedFunction.fromFields(reader);
+    const utilityFunction = BroadcastedUtilityFunction.fromFields(reader);
 
-    return new UnconstrainedFunctionBroadcastedEvent(
+    return new UtilityFunctionBroadcastedEvent(
       contractClassId,
       artifactMetadataHash,
       privateFunctionsArtifactTreeRoot,
       artifactFunctionTreeSiblingPath,
       artifactFunctionTreeLeafIndex,
-      unconstrainedFunction,
+      utilityFunction,
     );
   }
 
-  toFunctionWithMembershipProof(): UnconstrainedFunctionWithMembershipProof {
+  toFunctionWithMembershipProof(): UtilityFunctionWithMembershipProof {
     // We should be able to safely remove the zero elements that pad the variable-length sibling path,
     // since a sibling with value zero can only occur on the tree leaves, so the sibling path will never end
     // in a zero. The only exception is a tree with depth 2 with one non-zero leaf, where the sibling path would
     // be a single zero element, but in that case the artifact tree should be just the single leaf.
     const artifactTreeSiblingPath = removeArrayPaddingEnd(this.artifactFunctionTreeSiblingPath, Fr.isZero);
     return {
-      ...this.unconstrainedFunction,
-      bytecode: this.unconstrainedFunction.bytecode,
-      functionMetadataHash: this.unconstrainedFunction.metadataHash,
+      ...this.utilityFunction,
+      bytecode: this.utilityFunction.bytecode,
+      functionMetadataHash: this.utilityFunction.metadataHash,
       artifactMetadataHash: this.artifactMetadataHash,
       privateFunctionsArtifactTreeRoot: this.privateFunctionsArtifactTreeRoot,
       artifactTreeSiblingPath,
@@ -77,7 +81,7 @@ export class UnconstrainedFunctionBroadcastedEvent {
   }
 }
 
-export class BroadcastedUnconstrainedFunction implements UnconstrainedFunction {
+export class BroadcastedUtilityFunction implements UtilityFunction {
   constructor(
     /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
     public readonly selector: FunctionSelector,
@@ -92,8 +96,8 @@ export class BroadcastedUnconstrainedFunction implements UnconstrainedFunction {
     const selector = FunctionSelector.fromField(reader.readField());
     const metadataHash = reader.readField();
     // The '* 1' removes the 'Type instantiation is excessively deep and possibly infinite. ts(2589)' err
-    const encodedBytecode = reader.readFieldArray(MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS * 1);
+    const encodedBytecode = reader.readFieldArray(MAX_PACKED_BYTECODE_SIZE_PER_UTILITY_FUNCTION_IN_FIELDS * 1);
     const bytecode = bufferFromFields(encodedBytecode);
-    return new BroadcastedUnconstrainedFunction(selector, metadataHash, bytecode);
+    return new BroadcastedUtilityFunction(selector, metadataHash, bytecode);
   }
 }

package/src/fee-juice/index.ts

@@ -1,10 +1,10 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computePublicDataTreeLeafSlot, deriveStorageSlotInMap } from '@aztec/stdlib/hash';
 import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import FeeJuiceJson from '../../artifacts/FeeJuice.json' assert { type: 'json' };
+import FeeJuiceJson from '../../artifacts/FeeJuice.json' with { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 import { ProtocolContractAddress } from '../protocol_contract_data.js';
@@ -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

@@ -8,10 +8,10 @@ let protocolContractArtifact: ContractArtifact;
 
 export async function getFeeJuiceArtifact(): Promise<ContractArtifact> {
   if (!protocolContractArtifact) {
-    // Cannot assert this import as it's incompatible with browsers
-    // https://caniuse.com/mdn-javascript_statements_import_import_assertions_type_json
-    // Use the new "with" syntax once supported by firefox
-    // https://caniuse.com/mdn-javascript_statements_import_import_attributes_type_json
+    // 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: feeJuiceJson } = await import('../../artifacts/FeeJuice.json');
     protocolContractArtifact = loadContractArtifact(feeJuiceJson);
@@ -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/index.ts

@@ -1,3 +1,2 @@
 export * from './protocol_contract.js';
 export * from './protocol_contract_data.js';
-export * from './protocol_contract_tree.js';

package/src/instance-registry/__snapshots__/README.md

@@ -0,0 +1,9 @@
+# How to update these snapshots
+
+(You probably need to have done a `./bootstrap.sh` at some point)
+
+From the root:
+
+`cd yarn-project/protocol-contracts`
+
+`yarn test -u`

package/src/{instance-deployer/contract_instance_deployed_event.ts → instance-registry/contract_instance_published_event.ts}

@@ -1,14 +1,14 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 import type { PrivateLog } from '@aztec/stdlib/logs';
 
-import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '../protocol_contract_data.js';
+import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '../protocol_contract_data.js';
 
-/** Event emitted from the ContractInstanceDeployer. */
-export class ContractInstanceDeployedEvent {
+/** Event emitted from the ContractInstanceRegistry. */
+export class ContractInstancePublishedEvent {
   constructor(
     public readonly address: AztecAddress,
     public readonly version: number,
@@ -19,8 +19,8 @@ export class ContractInstanceDeployedEvent {
     public readonly deployer: AztecAddress,
   ) {}
 
-  static isContractInstanceDeployedEvent(log: PrivateLog) {
-    return log.fields[0].equals(DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG);
+  static isContractInstancePublishedEvent(log: PrivateLog) {
+    return log.fields[0].equals(CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG);
   }
 
   static fromLog(log: PrivateLog) {
@@ -34,7 +34,7 @@ export class ContractInstanceDeployedEvent {
     const publicKeys = reader.readObject(PublicKeys);
     const deployer = reader.readObject(AztecAddress);
 
-    return new ContractInstanceDeployedEvent(
+    return new ContractInstancePublishedEvent(
       address,
       version,
       salt,
@@ -61,4 +61,10 @@ export class ContractInstanceDeployedEvent {
       deployer: this.deployer,
     };
   }
+
+  public static extractContractInstanceEvents(logs: PrivateLog[]): ContractInstancePublishedEvent[] {
+    return logs
+      .filter(log => ContractInstancePublishedEvent.isContractInstancePublishedEvent(log))
+      .map(log => ContractInstancePublishedEvent.fromLog(log));
+  }
 }

package/src/{instance-deployer → instance-registry}/contract_instance_updated_event.ts

@@ -1,36 +1,36 @@
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
+import { CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FieldReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstanceUpdateWithAddress } from '@aztec/stdlib/contract';
 import type { PublicLog } from '@aztec/stdlib/logs';
+import type { UInt64 } from '@aztec/stdlib/types';
 
-import { DEPLOYER_CONTRACT_INSTANCE_UPDATED_TAG, ProtocolContractAddress } from '../protocol_contract_data.js';
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
 
-/** Event emitted from the ContractInstanceDeployer. */
+/** Event emitted from the ContractInstanceRegistry. */
 export class ContractInstanceUpdatedEvent {
   constructor(
     public readonly address: AztecAddress,
     public readonly prevContractClassId: Fr,
     public readonly newContractClassId: Fr,
-    public readonly blockOfChange: number,
+    public readonly timestampOfChange: UInt64,
   ) {}
 
   static isContractInstanceUpdatedEvent(log: PublicLog) {
     return (
-      log.contractAddress.equals(ProtocolContractAddress.ContractInstanceDeployer) &&
-      log.log[0].equals(DEPLOYER_CONTRACT_INSTANCE_UPDATED_TAG)
+      log.contractAddress.equals(ProtocolContractAddress.ContractInstanceRegistry) &&
+      log.fields[0].toBigInt() === CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE
     );
   }
 
   static fromLog(log: PublicLog) {
-    const bufferWithoutAddressAndTag = log.toBuffer().subarray(64);
-    const reader = new BufferReader(bufferWithoutAddressAndTag);
+    const reader = new FieldReader(log.fields.slice(1) /* remove tag */);
     const address = reader.readObject(AztecAddress);
-    const prevContractClassId = reader.readObject(Fr);
-    const newContractClassId = reader.readObject(Fr);
-    const blockOfChange = reader.readObject(Fr).toNumber();
-
-    return new ContractInstanceUpdatedEvent(address, prevContractClassId, newContractClassId, blockOfChange);
+    const prevContractClassId = reader.readField();
+    const newContractClassId = reader.readField();
+    const timestampOfChange = reader.readField().toBigInt();
+    return new ContractInstanceUpdatedEvent(address, prevContractClassId, newContractClassId, timestampOfChange);
   }
 
   toContractInstanceUpdate(): ContractInstanceUpdateWithAddress {
@@ -38,7 +38,7 @@ export class ContractInstanceUpdatedEvent {
       address: this.address,
       prevContractClassId: this.prevContractClassId,
       newContractClassId: this.newContractClassId,
-      blockOfChange: this.blockOfChange,
+      timestampOfChange: this.timestampOfChange,
     };
   }
 }

package/src/instance-registry/index.ts

@@ -0,0 +1,23 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import ContractInstanceRegistryJson from '../../artifacts/ContractInstanceRegistry.json' with { type: 'json' };
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+export * from './contract_instance_published_event.js';
+export * from './contract_instance_updated_event.js';
+
+export const ContractInstanceRegistryArtifact = loadContractArtifact(
+  ContractInstanceRegistryJson as NoirCompiledContract,
+);
+
+let protocolContract: ProtocolContract;
+
+/** Returns the canonical deployment of the contract. */
+export function getCanonicalInstanceRegistry(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    protocolContract = makeProtocolContract('ContractInstanceRegistry', ContractInstanceRegistryArtifact);
+  }
+  return Promise.resolve(protocolContract);
+}

package/src/instance-registry/lazy.ts

@@ -0,0 +1,32 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+export * from './contract_instance_published_event.js';
+export * from './contract_instance_updated_event.js';
+
+let protocolContract: ProtocolContract;
+let protocolContractArtifact: ContractArtifact;
+
+export async function getContractInstanceRegistryArtifact(): Promise<ContractArtifact> {
+  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: contractInstanceRegistryJson } = await import('../../artifacts/ContractInstanceRegistry.json');
+    protocolContractArtifact = loadContractArtifact(contractInstanceRegistryJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalInstanceRegistry(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const contractInstanceRegistryArtifact = await getContractInstanceRegistryArtifact();
+    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, getContractInstanceFromDeployParams } 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 getContractInstanceFromDeployParams(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 };
 }