@aztec/protocol-contracts 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/package.json

@@ -2,7 +2,7 @@
   "name": "@aztec/protocol-contracts",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/protocol-contracts",
   "description": "Canonical Noir contracts for the Aztec Network",
-  "version": "0.0.0-test.0",
+  "version": "0.0.1-commit.24de95ac",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -14,8 +14,8 @@
   "typedocOptions": {
     "entryPoints": [
       "./src/index.ts",
-      "./src/class-registerer/index.ts",
-      "./src/instance-deployer/index.ts"
+      "./src/class-registry/index.ts",
+      "./src/instance-registry/index.ts"
     ],
     "name": "Protocol Contracts",
     "tsconfig": "./tsconfig.json"
@@ -29,8 +29,6 @@
     "build:dev": "tsc -b --watch",
     "build:ts": "tsc -b",
     "clean": "rm -rf ./dest .tsbuildinfo ./artifacts",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
@@ -68,27 +66,31 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.0-test.0",
-    "@aztec/foundation": "0.0.0-test.0",
-    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/constants": "0.0.1-commit.24de95ac",
+    "@aztec/foundation": "0.0.1-commit.24de95ac",
+    "@aztec/stdlib": "0.0.1-commit.24de95ac",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
     "@types/lodash.chunk": "^4.2.9",
     "@types/lodash.omit": "^4.5.9",
-    "@types/node": "^18.7.23",
-    "jest": "^29.5.0",
-    "jest-mock-extended": "^3.0.3",
-    "ts-loader": "^9.4.4",
+    "@types/node": "^22.15.17",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-loader": "^9.5.4",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -98,6 +100,6 @@
     "!src/scripts/*"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/auth-registry/index.ts

@@ -1,13 +1,13 @@
-import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
 import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import AuthRegistryJson from '../../artifacts/AuthRegistry.json' assert { type: 'json' };
+import AuthRegistryJson from '../../artifacts/AuthRegistry.json' with { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 
 let protocolContract: ProtocolContract;
 
-export const AuthRegistryArtifact = loadContractArtifact(AuthRegistryJson as NoirCompiledContract);
+export const AuthRegistryArtifact: ContractArtifact = loadContractArtifact(AuthRegistryJson as NoirCompiledContract);
 
 /** Returns the canonical deployment of the auth registry. */
 export async function getCanonicalAuthRegistry(): Promise<ProtocolContract> {

package/src/auth-registry/lazy.ts

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

package/src/class-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/{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 { CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 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/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,14 @@ 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: [],
     };
   }
 }

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

@@ -1,25 +1,23 @@
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import ContractClassRegistererJson from '../../artifacts/ContractClassRegisterer.json' assert { type: 'json' };
+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_registered_event.js';
+export * from './contract_class_published_event.js';
 export * from './private_function_broadcasted_event.js';
-export * from './unconstrained_function_broadcasted_event.js';
+export * from './utility_function_broadcasted_event.js';
 
-export const ContractClassRegistererArtifact = loadContractArtifact(
-  ContractClassRegistererJson as NoirCompiledContract,
-);
+export const ContractClassRegistryArtifact = loadContractArtifact(ContractClassRegistryJson as NoirCompiledContract);
 
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalClassRegisterer(): Promise<ProtocolContract> {
+export async function getCanonicalClassRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    const artifact = ContractClassRegistererArtifact;
-    protocolContract = await makeProtocolContract('ContractClassRegisterer', artifact);
+    const artifact = ContractClassRegistryArtifact;
+    protocolContract = await makeProtocolContract('ContractClassRegistry', artifact);
   }
   return 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 = await makeProtocolContract('ContractClassRegistry', contractClassRegistryArtifact);
+  }
+  return protocolContract;
+}

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

@@ -1,5 +1,6 @@
 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';
@@ -10,14 +11,14 @@ 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 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,

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