@aztec/protocol-contracts 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/class-registry/contract_class_published_event.ts

@@ -0,0 +1,72 @@
+import { CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { bufferFromFields } from '@aztec/stdlib/abi';
+import {
+  type ContractClassPublic,
+  type ContractClassPublicWithCommitment,
+  computePublicBytecodeCommitment,
+} from '@aztec/stdlib/contract';
+import type { ContractClassLog } from '@aztec/stdlib/logs';
+
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
+
+/** Event emitted from the ContractClassRegistry. */
+export class ContractClassPublishedEvent {
+  constructor(
+    public readonly contractClassId: Fr,
+    public readonly version: number,
+    public readonly artifactHash: Fr,
+    public readonly privateFunctionsRoot: Fr,
+    public readonly packedPublicBytecode: Buffer,
+  ) {}
+
+  static isContractClassPublishedEvent(log: ContractClassLog) {
+    return (
+      log.contractAddress.equals(ProtocolContractAddress.ContractClassRegistry) &&
+      log.fields.fields[0].toBigInt() === CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE
+    );
+  }
+
+  static fromLog(log: ContractClassLog) {
+    // 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(fieldsWithoutTag.length - reader.cursor));
+
+    return new ContractClassPublishedEvent(
+      contractClassId,
+      version,
+      artifactHash,
+      privateFunctionsRoot,
+      packedPublicBytecode,
+    );
+  }
+
+  /** 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 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))
+      .map((log: ContractClassLog) => ContractClassPublishedEvent.fromLog(log));
+  }
+}

package/src/class-registry/index.ts

@@ -0,0 +1,21 @@
+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 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,31 @@
+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';
+
+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/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,26 +1,27 @@
-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,
     public readonly salt: Fr,
     public readonly contractClassId: Fr,
     public readonly initializationHash: Fr,
+    public readonly immutablesHash: Fr,
     public readonly publicKeys: PublicKeys,
     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) {
@@ -31,22 +32,24 @@ export class ContractInstanceDeployedEvent {
     const salt = reader.readObject(Fr);
     const contractClassId = reader.readObject(Fr);
     const initializationHash = reader.readObject(Fr);
+    const immutablesHash = reader.readObject(Fr);
     const publicKeys = reader.readObject(PublicKeys);
     const deployer = reader.readObject(AztecAddress);
 
-    return new ContractInstanceDeployedEvent(
+    return new ContractInstancePublishedEvent(
       address,
       version,
       salt,
       contractClassId,
       initializationHash,
+      immutablesHash,
       publicKeys,
       deployer,
     );
   }
 
   toContractInstance(): ContractInstanceWithAddress {
-    if (this.version !== 1) {
+    if (this.version !== 2) {
       throw new Error(`Unexpected contract instance version ${this.version}`);
     }
 
@@ -56,9 +59,16 @@ export class ContractInstanceDeployedEvent {
       currentContractClassId: this.contractClassId,
       originalContractClassId: this.contractClassId,
       initializationHash: this.initializationHash,
+      immutablesHash: this.immutablesHash,
       publicKeys: this.publicKeys,
       salt: this.salt,
       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,50 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 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: 2 as const,
+    currentContractClassId: classId,
+    originalContractClassId: classId,
+    initializationHash,
+    immutablesHash: Fr.ZERO, // Protocol Contracts Have No Immutables
+    publicKeys: PublicKeys.default(),
+    salt,
+    deployer: address,
     address,
   };
+
+  return { instance, contractClass, artifact, address };
 }

package/src/protocol_contract_data.ts

@@ -1,16 +1,15 @@
 
     // GENERATED FILE - DO NOT EDIT. RUN `yarn generate` or `yarn generate:data`
-    import { Fr } from '@aztec/foundation/fields';
+    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';
 
     
     export const protocolContractNames = [
-      'AuthRegistry',
-'ContractInstanceDeployer',
-'ContractClassRegisterer',
-'MultiCallEntrypoint',
-'FeeJuice',
-'Router'
+      'ContractInstanceRegistry',
+'ContractClassRegistry',
+'FeeJuice'
     ] as const;
 
     export type ProtocolContractName = typeof protocolContractNames[number];
@@ -18,46 +17,85 @@
 
     
     export const ProtocolContractSalt: Record<ProtocolContractName, Fr> = {
-      AuthRegistry: new Fr(1),
-ContractInstanceDeployer: new Fr(1),
-ContractClassRegisterer: new Fr(1),
-MultiCallEntrypoint: new Fr(1),
-FeeJuice: new Fr(1),
-Router: new Fr(1)
+      ContractInstanceRegistry: new Fr(1),
+ContractClassRegistry: new Fr(1),
+FeeJuice: new Fr(1)
     };
   
 
     
     export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress> = {
-      AuthRegistry: AztecAddress.fromBigInt(1n),
-ContractInstanceDeployer: AztecAddress.fromBigInt(2n),
-ContractClassRegisterer: AztecAddress.fromBigInt(3n),
-MultiCallEntrypoint: AztecAddress.fromBigInt(4n),
-FeeJuice: AztecAddress.fromBigInt(5n),
-Router: AztecAddress.fromBigInt(6n)
+      ContractInstanceRegistry: AztecAddress.fromBigInt(2n),
+ContractClassRegistry: AztecAddress.fromBigInt(1n),
+FeeJuice: AztecAddress.fromBigInt(3n)
     };
   
 
     
-    export const ProtocolContractLeaves = {
-      AuthRegistry: Fr.fromHexString('0x1dc70bdab08ce08aef9f6ddcc8fd54fb91fdb72a6433c2dd6b69b33cf1fb87a2'),
-ContractInstanceDeployer: Fr.fromHexString('0x005d6d6addbbda03dcad6fc9a3c3b7de457c30990ec2acaaf74f139a3a506e06'),
-ContractClassRegisterer: Fr.fromHexString('0x110ef3d93e27fd61a5a56e479a9f9cbdb099d2d968cdcc16c01d2bdfd6cb0ddd'),
-MultiCallEntrypoint: Fr.fromHexString('0x121f834b03a64d38463ae18ddebceeb4dce8192cc289052e175ad754a883a7fe'),
-FeeJuice: Fr.fromHexString('0x141a566ade0bef915526762c2c2fb19b2a756ad7c82e83fde6dbf86848ecc131'),
-Router: Fr.fromHexString('0x2c20bd328fbd33c01fbcda9e6299c31da5d5b29ea30e9c7b9d631618b839bca9')
+    export const ProtocolContractDerivedAddress = {
+      ContractInstanceRegistry: AztecAddress.fromString('0x290f7bf7cea0eb4c440a06dc8bcf825865479348c9ebf8f540b10ad10fd32c44'),
+ContractClassRegistry: AztecAddress.fromString('0x20b16259faa0a096d687572fc76221263f1cad4a4b726ef49e2cd7b7ce7c7465'),
+FeeJuice: AztecAddress.fromString('0x0fa3ba3e01e6646cd2adade41018dbfff04e59c444760e33bf773ec43d683019')
     };
   
 
     
-    export const protocolContractTreeRoot = Fr.fromHexString('0x093cc9324e5a7b44883f515ac490e7294ef8cb1e6d2d8c503255b1b3a9409262');
+    export const ProtocolContractClassId: Record<ProtocolContractName, Fr> = {
+      ContractInstanceRegistry: Fr.fromString('0x123597d7f3c460a3e91bfb92e729fcd048d4f50a88b7c25e694cf75827062e3f'),
+ContractClassRegistry: Fr.fromString('0x243b6ce1af8f520d531b26ce5081fa29c0870ce8d5949c5304a6705b07947a2e'),
+FeeJuice: Fr.fromString('0x1f65e3db036c48ac8f8635b156880ed17e9437ed8904a0c0554f0d6251bf0997')
+    };
+
+    export const ProtocolContractClassIdPreimage: Record<ProtocolContractName, { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }> = {
+      ContractInstanceRegistry: {
+        artifactHash: Fr.fromString('0x0cb37c0b0ec8670b88b472fca5858f8cb112a41ba2aad664903ac1a3bed468b3'),
+        privateFunctionsRoot: Fr.fromString('0x0239b0f293384aad456e2e27901eb97cd9073322a28d14b0ac7816a5297b2812'),
+        publicBytecodeCommitment: Fr.fromString('0x2c79b6699098244e947caca071a31799c20aa20e7124910a2b7c918fe817d65e'),
+      },
+ContractClassRegistry: {
+        artifactHash: Fr.fromString('0x1e252471ee2b770fba961d03289344f1798336d9a94e1d8f137397754708de0e'),
+        privateFunctionsRoot: Fr.fromString('0x0672f623ec0753ab9fbb02a9a241df81b9bcc0dbed8628d8cab8790e0cb0c03d'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
+      },
+FeeJuice: {
+        artifactHash: Fr.fromString('0x1243f24c1d3e8b42c900aa95d3a12448d84f8b5da3fe047f8ac8a46e67bb10b7'),
+        privateFunctionsRoot: Fr.fromString('0x247aaafc67f6bf5b06736649181a477dac9f18d3468969b14669708c3dabb275'),
+        publicBytecodeCommitment: Fr.fromString('0x1d4b1a8f71b8250d4fb65f8e16a4604e9165648279f47d80e024ce2684c4bdfb'),
+      }
+    };
+
+    export const ProtocolContractInitializationHash: Record<ProtocolContractName, Fr> = {
+      ContractInstanceRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+ContractClassRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+FeeJuice: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+    };
+
+    export const ProtocolContractPrivateFunctions: Record<ProtocolContractName, { selector: FunctionSelector; vkHash: Fr }[]> = {
+      ContractInstanceRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000077cff62f')), vkHash: Fr.fromString('0x08a57d0b4d164c6c8d92da9c3bfe57a4ac1a639ab0a2a0ccb60bbb6bcd37f245') }],
+ContractClassRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x000000000000000000000000000000000000000000000000000000006934ed0d')), vkHash: Fr.fromString('0x1531ed0e20d6d05f1aeb06f746c8c4b8f467174836d6edf915b0c45099b393ed') }],
+FeeJuice: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000cbe67243')), vkHash: Fr.fromString('0x2dbad42bf59fe7ea908485dea59573b4d7fb8ddefb6a0f73bbcce79aa27d545c') }, { selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000e8d374b6')), vkHash: Fr.fromString('0x2e9880e15fb0c9a5494faef915861144769e94aded54c737819ee75918fbda51') }]
+    };
+  
+
+    
+    export const ProtocolContractsList = new ProtocolContracts([
+      AztecAddress.fromString('0x20b16259faa0a096d687572fc76221263f1cad4a4b726ef49e2cd7b7ce7c7465'),
+AztecAddress.fromString('0x290f7bf7cea0eb4c440a06dc8bcf825865479348c9ebf8f540b10ad10fd32c44'),
+AztecAddress.fromString('0x0fa3ba3e01e6646cd2adade41018dbfff04e59c444760e33bf773ec43d683019'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+    ]);
+
+    export const protocolContractsHash = Fr.fromString('0x04194c6dd98d175d07d300b253a9967f5c46782d0e9c3c88473f79ca8b8b16d6');
   
 
     
-  export const REGISTERER_CONTRACT_CLASS_REGISTERED_TAG = Fr.fromHexString('0x20cd27645f65c15a38720ca984aef936592f3938a705db706d068ad13fc58ae9');
-  export const REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG = Fr.fromHexString('0x0abf338154e355442d9916d630da0491036d5a7b23c42b477c1395ba3bf9b42d');
-  export const REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG = Fr.fromHexString('0x27774539896271d6dbe0c1de45ddc44709d1e8d9a9fb686ca3c105d87c417bb8');
-  export const DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG = Fr.fromHexString('0x2ec28b91a5f838506d6042915005ff55cf7a0a5f889a83b11faed33a31b486f2');
-   export const DEPLOYER_CONTRACT_INSTANCE_UPDATED_TAG = new Fr(1534834688047131268740281708431107902615560100979874281215533519862n);
+  export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x1a7e1badb79abdd38c684b3c8306ffe7ecb33c69e3380d9855730aaaa83a21a8');
   
   

package/src/provider/bundle.ts

@@ -1,27 +1,21 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 
-import { AuthRegistryArtifact } from '../auth-registry/index.js';
-import { ContractClassRegistererArtifact } from '../class-registerer/index.js';
+import { ContractClassRegistryArtifact } from '../class-registry/index.js';
 import { FeeJuiceArtifact } from '../fee-juice/index.js';
-import { ContractInstanceDeployerArtifact } from '../instance-deployer/index.js';
+import { ContractInstanceRegistryArtifact } from '../instance-registry/index.js';
 import { makeProtocolContract } from '../make_protocol_contract.js';
-import { MultiCallEntrypointArtifact } from '../multi-call-entrypoint/index.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 import type { ProtocolContractName } from '../protocol_contract_data.js';
-import { RouterArtifact } from '../router/index.js';
 import type { ProtocolContractsProvider } from './protocol_contracts_provider.js';
 
 export const ProtocolContractArtifact: Record<ProtocolContractName, ContractArtifact> = {
-  AuthRegistry: AuthRegistryArtifact,
-  ContractInstanceDeployer: ContractInstanceDeployerArtifact,
-  ContractClassRegisterer: ContractClassRegistererArtifact,
-  MultiCallEntrypoint: MultiCallEntrypointArtifact,
+  ContractInstanceRegistry: ContractInstanceRegistryArtifact,
+  ContractClassRegistry: ContractClassRegistryArtifact,
   FeeJuice: FeeJuiceArtifact,
-  Router: RouterArtifact,
 };
 
 export class BundledProtocolContractsProvider implements ProtocolContractsProvider {
   getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract> {
-    return makeProtocolContract(name, ProtocolContractArtifact[name]);
+    return Promise.resolve(makeProtocolContract(name, ProtocolContractArtifact[name]));
   }
 }