@aztec/protocol-contracts 0.0.0-test.1 → 0.0.1-commit.5daedc8

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 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

@@ -4,7 +4,7 @@ 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';

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);

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}

@@ -5,10 +5,10 @@ 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 { CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
+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-deployer → instance-registry}/index.ts

@@ -1,23 +1,23 @@
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import ContractInstanceDeployerJson from '../../artifacts/ContractInstanceDeployer.json' assert { type: 'json' };
+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_deployed_event.js';
+export * from './contract_instance_published_event.js';
 export * from './contract_instance_updated_event.js';
 
-export const ContractInstanceDeployerArtifact = loadContractArtifact(
-  ContractInstanceDeployerJson as NoirCompiledContract,
+export const ContractInstanceRegistryArtifact = loadContractArtifact(
+  ContractInstanceRegistryJson as NoirCompiledContract,
 );
 
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalInstanceDeployer(): Promise<ProtocolContract> {
+export async function getCanonicalInstanceRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    protocolContract = await makeProtocolContract('ContractInstanceDeployer', ContractInstanceDeployerArtifact);
+    protocolContract = await makeProtocolContract('ContractInstanceRegistry', ContractInstanceRegistryArtifact);
   }
   return protocolContract;
 }

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

@@ -3,30 +3,30 @@ 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_deployed_event.js';
+export * from './contract_instance_published_event.js';
 export * from './contract_instance_updated_event.js';
 
 let protocolContract: ProtocolContract;
 let protocolContractArtifact: ContractArtifact;
 
-export async function getContractInstanceDeployerArtifact(): Promise<ContractArtifact> {
+export async function getContractInstanceRegistryArtifact(): 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: contractInstanceDeployerJson } = await import('../../artifacts/ContractInstanceDeployer.json');
-    protocolContractArtifact = loadContractArtifact(contractInstanceDeployerJson);
+    const { default: contractInstanceRegistryJson } = await import('../../artifacts/ContractInstanceRegistry.json');
+    protocolContractArtifact = loadContractArtifact(contractInstanceRegistryJson);
   }
   return protocolContractArtifact;
 }
 
 /** Returns the canonical deployment of the auth registry. */
-export async function getCanonicalInstanceDeployer(): Promise<ProtocolContract> {
+export async function getCanonicalInstanceRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    const contractInstanceDeployerArtifact = await getContractInstanceDeployerArtifact();
-    protocolContract = await makeProtocolContract('ContractInstanceDeployer', contractInstanceDeployerArtifact);
+    const contractInstanceRegistryArtifact = await getContractInstanceRegistryArtifact();
+    protocolContract = await makeProtocolContract('ContractInstanceRegistry', contractInstanceRegistryArtifact);
   }
   return protocolContract;
 }

package/src/make_protocol_contract.ts

@@ -1,5 +1,5 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
-import { getContractClassFromArtifact, getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
+import { getContractClassFromArtifact, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 
 import type { ProtocolContract } from './protocol_contract.js';
 import { ProtocolContractAddress, type ProtocolContractName, ProtocolContractSalt } from './protocol_contract_data.js';
@@ -16,7 +16,7 @@ export async function makeProtocolContract(
   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 });
+  const instance = await getContractInstanceFromInstantiationParams(artifact, { salt });
   return {
     instance: { ...instance, address },
     contractClass,

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

@@ -1,7 +1,7 @@
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import MultiCallEntrypointJson from '../../artifacts/MultiCallEntrypoint.json' assert { type: 'json' };
+import MultiCallEntrypointJson from '../../artifacts/MultiCallEntrypoint.json' with { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 

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

@@ -8,10 +8,10 @@ let protocolContractArtifact: ContractArtifact;
 
 export async function getMultiCallEntrypointArtifact(): 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: multiCallEntrypointJson } = await import('../../artifacts/MultiCallEntrypoint.json');
     protocolContractArtifact = loadContractArtifact(multiCallEntrypointJson);

package/src/protocol_contract_data.ts

@@ -2,12 +2,13 @@
     // GENERATED FILE - DO NOT EDIT. RUN `yarn generate` or `yarn generate:data`
     import { Fr } from '@aztec/foundation/fields';
     import { AztecAddress } from '@aztec/stdlib/aztec-address';
+    import { ProtocolContracts } from '@aztec/stdlib/tx';
 
     
     export const protocolContractNames = [
       'AuthRegistry',
-'ContractInstanceDeployer',
-'ContractClassRegisterer',
+'ContractInstanceRegistry',
+'ContractClassRegistry',
 'MultiCallEntrypoint',
 'FeeJuice',
 'Router'
@@ -19,8 +20,8 @@
     
     export const ProtocolContractSalt: Record<ProtocolContractName, Fr> = {
       AuthRegistry: new Fr(1),
-ContractInstanceDeployer: new Fr(1),
-ContractClassRegisterer: new Fr(1),
+ContractInstanceRegistry: new Fr(1),
+ContractClassRegistry: new Fr(1),
 MultiCallEntrypoint: new Fr(1),
 FeeJuice: new Fr(1),
 Router: new Fr(1)
@@ -30,8 +31,8 @@ Router: new Fr(1)
     
     export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress> = {
       AuthRegistry: AztecAddress.fromBigInt(1n),
-ContractInstanceDeployer: AztecAddress.fromBigInt(2n),
-ContractClassRegisterer: AztecAddress.fromBigInt(3n),
+ContractInstanceRegistry: AztecAddress.fromBigInt(2n),
+ContractClassRegistry: AztecAddress.fromBigInt(3n),
 MultiCallEntrypoint: AztecAddress.fromBigInt(4n),
 FeeJuice: AztecAddress.fromBigInt(5n),
 Router: AztecAddress.fromBigInt(6n)
@@ -39,25 +40,35 @@ Router: AztecAddress.fromBigInt(6n)
   
 
     
-    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 = {
+      AuthRegistry: AztecAddress.fromString('0x1dc64374e96b37a36d94b737a049efb4686f45f628457f5d6d74f5d45817944b'),
+ContractInstanceRegistry: AztecAddress.fromString('0x24b7c46308ae93c05e3bac8201935effd50b61504954eef96d7b0384f27ee80c'),
+ContractClassRegistry: AztecAddress.fromString('0x2f6b4852b69e0381596da99b3aad9b8d493312f47e1c0e3523928e010e1f9df2'),
+MultiCallEntrypoint: AztecAddress.fromString('0x1c93c2cb51b87faa1ee26b5f933a8136642cec5cdf95216bdd9aa4873d4b38ff'),
+FeeJuice: AztecAddress.fromString('0x2223ff211abddd65cb27b3fd9ef6cbcdfed867b1b5c2421f87624c6fe86c39ff'),
+Router: AztecAddress.fromString('0x090dc318c793abc5ee9a560dcf9f0ba54c73902086dd7258cd48da8c79ef201a')
     };
   
 
     
-    export const protocolContractTreeRoot = Fr.fromHexString('0x093cc9324e5a7b44883f515ac490e7294ef8cb1e6d2d8c503255b1b3a9409262');
+    export const ProtocolContractsList = new ProtocolContracts([
+      AztecAddress.fromString('0x1dc64374e96b37a36d94b737a049efb4686f45f628457f5d6d74f5d45817944b'),
+AztecAddress.fromString('0x24b7c46308ae93c05e3bac8201935effd50b61504954eef96d7b0384f27ee80c'),
+AztecAddress.fromString('0x2f6b4852b69e0381596da99b3aad9b8d493312f47e1c0e3523928e010e1f9df2'),
+AztecAddress.fromString('0x1c93c2cb51b87faa1ee26b5f933a8136642cec5cdf95216bdd9aa4873d4b38ff'),
+AztecAddress.fromString('0x2223ff211abddd65cb27b3fd9ef6cbcdfed867b1b5c2421f87624c6fe86c39ff'),
+AztecAddress.fromString('0x090dc318c793abc5ee9a560dcf9f0ba54c73902086dd7258cd48da8c79ef201a'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+    ]);
+
+    export const protocolContractsHash = Fr.fromString('0x12f22ad1b89f09c9a684cb5f36820a7d678527270547e489536c586d3c1756a4');
   
 
     
-  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('0x28da3fc471387d4e20b646b77abc8cdfc02a339a7507285a73d84f9b97b13486');
   
   

package/src/provider/bundle.ts

@@ -1,9 +1,9 @@
 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';
@@ -13,8 +13,8 @@ import type { ProtocolContractsProvider } from './protocol_contracts_provider.js
 
 export const ProtocolContractArtifact: Record<ProtocolContractName, ContractArtifact> = {
   AuthRegistry: AuthRegistryArtifact,
-  ContractInstanceDeployer: ContractInstanceDeployerArtifact,
-  ContractClassRegisterer: ContractClassRegistererArtifact,
+  ContractInstanceRegistry: ContractInstanceRegistryArtifact,
+  ContractClassRegistry: ContractClassRegistryArtifact,
   MultiCallEntrypoint: MultiCallEntrypointArtifact,
   FeeJuice: FeeJuiceArtifact,
   Router: RouterArtifact,

package/src/provider/lazy.ts

@@ -1,7 +1,7 @@
 import { getCanonicalAuthRegistry } from '../auth-registry/lazy.js';
-import { getCanonicalClassRegisterer } from '../class-registerer/lazy.js';
+import { getCanonicalClassRegistry } from '../class-registry/lazy.js';
 import { getCanonicalFeeJuice } from '../fee-juice/lazy.js';
-import { getCanonicalInstanceDeployer } from '../instance-deployer/lazy.js';
+import { getCanonicalInstanceRegistry } from '../instance-registry/lazy.js';
 import { getCanonicalMultiCallEntrypoint } from '../multi-call-entrypoint/lazy.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 import type { ProtocolContractName } from '../protocol_contract_data.js';
@@ -13,10 +13,10 @@ export class LazyProtocolContractsProvider implements ProtocolContractsProvider
     switch (name) {
       case 'AuthRegistry':
         return getCanonicalAuthRegistry();
-      case 'ContractInstanceDeployer':
-        return getCanonicalInstanceDeployer();
-      case 'ContractClassRegisterer':
-        return getCanonicalClassRegisterer();
+      case 'ContractInstanceRegistry':
+        return getCanonicalInstanceRegistry();
+      case 'ContractClassRegistry':
+        return getCanonicalClassRegistry();
       case 'MultiCallEntrypoint':
         return getCanonicalMultiCallEntrypoint();
       case 'FeeJuice':

package/src/router/index.ts

@@ -1,7 +1,7 @@
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import RouterJson from '../../artifacts/Router.json' assert { type: 'json' };
+import RouterJson from '../../artifacts/Router.json' with { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 

package/src/router/lazy.ts

@@ -8,10 +8,10 @@ let protocolContractArtifact: ContractArtifact;
 
 export async function getRouterArtifact(): 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: routerJson } = await import('../../artifacts/Router.json');
     protocolContractArtifact = loadContractArtifact(routerJson);

package/src/tests/fixtures.ts

@@ -3,8 +3,8 @@ import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
 // Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
-export function getSampleContractClassRegisteredEventPayload(): Buffer {
-  const path = getPathToFixture('ContractClassRegisteredEventData.hex');
+export function getSampleContractClassPublishedEventPayload(): Buffer {
+  const path = getPathToFixture('ContractClassPublishedEventData.hex');
   return Buffer.from(readFileSync(path).toString(), 'hex');
 }
 
@@ -15,14 +15,14 @@ export function getSamplePrivateFunctionBroadcastedEventPayload(): Buffer {
 }
 
 // Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
-export function getSampleUnconstrainedFunctionBroadcastedEventPayload(): Buffer {
-  const path = getPathToFixture('UnconstrainedFunctionBroadcastedEventData.hex');
+export function getSampleUtilityFunctionBroadcastedEventPayload(): Buffer {
+  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 getSampleContractInstanceDeployedEventPayload(): Buffer {
-  const path = getPathToFixture('ContractInstanceDeployedEventData.hex');
+export function getSampleContractInstancePublishedEventPayload(): Buffer {
+  const path = getPathToFixture('ContractInstancePublishedEventData.hex');
   return Buffer.from(readFileSync(path).toString(), 'hex');
 }