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

package/dest/auth-registry/index.d.ts

@@ -1,5 +1,6 @@
+import { type ContractArtifact } from '@aztec/stdlib/abi';
 import type { ProtocolContract } from '../protocol_contract.js';
-export declare const AuthRegistryArtifact: import("@aztec/stdlib/abi").ContractArtifact;
+export declare const AuthRegistryArtifact: ContractArtifact;
 /** Returns the canonical deployment of the auth registry. */
 export declare function getCanonicalAuthRegistry(): Promise<ProtocolContract>;
 //# sourceMappingURL=index.d.ts.map

package/dest/auth-registry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth-registry/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAIhE,eAAO,MAAM,oBAAoB,8CAAiE,CAAC;AAEnG,6DAA6D;AAC7D,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAK1E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth-registry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAwB,MAAM,mBAAmB,CAAC;AAKhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAIhE,eAAO,MAAM,oBAAoB,EAAE,gBAAiF,CAAC;AAErH,6DAA6D;AAC7D,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAK1E"}

package/dest/auth-registry/index.js

@@ -1,5 +1,5 @@
 import { loadContractArtifact } from '@aztec/stdlib/abi';
-import AuthRegistryJson from '../../artifacts/AuthRegistry.json' assert {
+import AuthRegistryJson from '../../artifacts/AuthRegistry.json' with {
     type: 'json'
 };
 import { makeProtocolContract } from '../make_protocol_contract.js';

package/dest/auth-registry/lazy.js

@@ -4,10 +4,10 @@ let protocolContract;
 let protocolContractArtifact;
 export async function getAuthRegistryArtifact() {
     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/dest/{class-registerer/contract_class_registered_event.d.ts → class-registry/contract_class_published_event.d.ts}

@@ -1,18 +1,16 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Fr } from '@aztec/foundation/fields';
 import { type ContractClassPublic } from '@aztec/stdlib/contract';
 import type { ContractClassLog } from '@aztec/stdlib/logs';
-/** Event emitted from the ContractClassRegisterer. */
-export declare class ContractClassRegisteredEvent {
+/** Event emitted from the ContractClassRegistry. */
+export declare class ContractClassPublishedEvent {
     readonly contractClassId: Fr;
     readonly version: number;
     readonly artifactHash: Fr;
     readonly privateFunctionsRoot: Fr;
     readonly packedPublicBytecode: Buffer;
     constructor(contractClassId: Fr, version: number, artifactHash: Fr, privateFunctionsRoot: Fr, packedPublicBytecode: Buffer);
-    static isContractClassRegisteredEvent(log: ContractClassLog): boolean;
-    static fromLog(log: ContractClassLog): ContractClassRegisteredEvent;
+    static isContractClassPublishedEvent(log: ContractClassLog): boolean;
+    static fromLog(log: ContractClassLog): ContractClassPublishedEvent;
     toContractClassPublic(): Promise<ContractClassPublic>;
 }
-//# sourceMappingURL=contract_class_registered_event.d.ts.map
+//# sourceMappingURL=contract_class_published_event.d.ts.map

package/dest/class-registry/contract_class_published_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_class_published_event.d.ts","sourceRoot":"","sources":["../../src/class-registry/contract_class_published_event.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D,oDAAoD;AACpD,qBAAa,2BAA2B;aAEpB,eAAe,EAAE,EAAE;aACnB,OAAO,EAAE,MAAM;aACf,YAAY,EAAE,EAAE;aAChB,oBAAoB,EAAE,EAAE;aACxB,oBAAoB,EAAE,MAAM;gBAJ5B,eAAe,EAAE,EAAE,EACnB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,EAAE,EAChB,oBAAoB,EAAE,EAAE,EACxB,oBAAoB,EAAE,MAAM;IAG9C,MAAM,CAAC,6BAA6B,CAAC,GAAG,EAAE,gBAAgB;IAO1D,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,gBAAgB;IAmB9B,qBAAqB,IAAI,OAAO,CAAC,mBAAmB,CAAC;CA2B5D"}

package/dest/{class-registerer/contract_class_registered_event.js → class-registry/contract_class_published_event.js}

@@ -1,10 +1,9 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE } from '@aztec/constants';
 import { FieldReader } from '@aztec/foundation/serialize';
-import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
+import { bufferFromFields } from '@aztec/stdlib/abi';
 import { computeContractClassId, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
-import { REGISTERER_CONTRACT_CLASS_REGISTERED_TAG } from '../protocol_contract_data.js';
-/** Event emitted from the ContractClassRegisterer. */ export class ContractClassRegisteredEvent {
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
+/** Event emitted from the ContractClassRegistry. */ export class ContractClassPublishedEvent {
     contractClassId;
     version;
     artifactHash;
@@ -17,17 +16,19 @@ import { REGISTERER_CONTRACT_CLASS_REGISTERED_TAG } from '../protocol_contract_d
         this.privateFunctionsRoot = privateFunctionsRoot;
         this.packedPublicBytecode = packedPublicBytecode;
     }
-    static isContractClassRegisteredEvent(log) {
-        return log.fields[0].equals(REGISTERER_CONTRACT_CLASS_REGISTERED_TAG);
+    static isContractClassPublishedEvent(log) {
+        return log.contractAddress.equals(ProtocolContractAddress.ContractClassRegistry) && log.fields.fields[0].toBigInt() === CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE;
     }
     static fromLog(log) {
-        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));
-        return new ContractClassRegisteredEvent(contractClassId, version, artifactHash, privateFunctionsRoot, packedPublicBytecode);
+        const packedPublicBytecode = bufferFromFields(reader.readFieldArray(fieldsWithoutTag.length - reader.cursor));
+        return new ContractClassPublishedEvent(contractClassId, version, artifactHash, privateFunctionsRoot, packedPublicBytecode);
     }
     async toContractClassPublic() {
         const computedClassId = await computeContractClassId({
@@ -41,23 +42,14 @@ import { REGISTERER_CONTRACT_CLASS_REGISTERED_TAG } from '../protocol_contract_d
         if (this.version !== 1) {
             throw new Error(`Unexpected contract class version ${this.version}`);
         }
-        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
-        const publicFunctions = [];
-        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/dest/class-registry/index.d.ts

@@ -0,0 +1,8 @@
+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 declare const ContractClassRegistryArtifact: import("@aztec/stdlib/abi").ContractArtifact;
+/** Returns the canonical deployment of the contract. */
+export declare function getCanonicalClassRegistry(): Promise<ProtocolContract>;
+//# sourceMappingURL=index.d.ts.map

package/dest/class-registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/class-registry/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,yCAAyC,CAAC;AAExD,eAAO,MAAM,6BAA6B,8CAA0E,CAAC;AAIrH,wDAAwD;AACxD,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAM3E"}

package/dest/class-registry/index.js

@@ -0,0 +1,17 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import ContractClassRegistryJson from '../../artifacts/ContractClassRegistry.json' with {
+    type: 'json'
+};
+import { makeProtocolContract } from '../make_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);
+let protocolContract;
+/** Returns the canonical deployment of the contract. */ export async function getCanonicalClassRegistry() {
+    if (!protocolContract) {
+        const artifact = ContractClassRegistryArtifact;
+        protocolContract = await makeProtocolContract('ContractClassRegistry', artifact);
+    }
+    return protocolContract;
+}

package/dest/class-registry/lazy.d.ts

@@ -0,0 +1,9 @@
+import { type ContractArtifact } from '@aztec/stdlib/abi';
+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 declare function getContractClassRegistryArtifact(): Promise<ContractArtifact>;
+/** Returns the canonical deployment of the auth registry. */
+export declare function getCanonicalClassRegistry(): Promise<ProtocolContract>;
+//# sourceMappingURL=lazy.d.ts.map

package/dest/class-registry/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/class-registry/lazy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAwB,MAAM,mBAAmB,CAAC;AAGhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,yCAAyC,CAAC;AAKxD,wBAAsB,gCAAgC,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAWlF;AAED,6DAA6D;AAC7D,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAM3E"}

package/dest/class-registry/lazy.js

@@ -0,0 +1,26 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { makeProtocolContract } from '../make_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;
+let protocolContractArtifact;
+export async function getContractClassRegistryArtifact() {
+    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() {
+    if (!protocolContract) {
+        const contractClassRegistryArtifact = await getContractClassRegistryArtifact();
+        protocolContract = await makeProtocolContract('ContractClassRegistry', contractClassRegistryArtifact);
+    }
+    return protocolContract;
+}

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

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, FUNCTION_TREE_HEIGHT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
@@ -7,17 +5,17 @@ import { FieldReader } from '@aztec/foundation/serialize';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { ExecutablePrivateFunctionWithMembershipProof, PrivateFunction } from '@aztec/stdlib/contract';
 import type { ContractClassLog } from '@aztec/stdlib/logs';
-/** Event emitted from the ContractClassRegisterer. */
+/** Event emitted from the ContractClassRegistry. */
 export declare class PrivateFunctionBroadcastedEvent {
     readonly contractClassId: Fr;
     readonly artifactMetadataHash: Fr;
-    readonly unconstrainedFunctionsArtifactTreeRoot: Fr;
+    readonly utilityFunctionsTreeRoot: Fr;
     readonly privateFunctionTreeSiblingPath: Tuple<Fr, typeof FUNCTION_TREE_HEIGHT>;
     readonly privateFunctionTreeLeafIndex: number;
     readonly artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>;
     readonly artifactFunctionTreeLeafIndex: number;
     readonly privateFunction: BroadcastedPrivateFunction;
-    constructor(contractClassId: Fr, artifactMetadataHash: Fr, unconstrainedFunctionsArtifactTreeRoot: Fr, privateFunctionTreeSiblingPath: Tuple<Fr, typeof FUNCTION_TREE_HEIGHT>, privateFunctionTreeLeafIndex: number, artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>, artifactFunctionTreeLeafIndex: number, privateFunction: BroadcastedPrivateFunction);
+    constructor(contractClassId: Fr, artifactMetadataHash: Fr, utilityFunctionsTreeRoot: Fr, privateFunctionTreeSiblingPath: Tuple<Fr, typeof FUNCTION_TREE_HEIGHT>, privateFunctionTreeLeafIndex: number, artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>, artifactFunctionTreeLeafIndex: number, privateFunction: BroadcastedPrivateFunction);
     static isPrivateFunctionBroadcastedEvent(log: ContractClassLog): boolean;
     static fromLog(log: ContractClassLog): PrivateFunctionBroadcastedEvent;
     static fromFields(fields: Fr[] | FieldReader): PrivateFunctionBroadcastedEvent;

package/dest/class-registry/private_function_broadcasted_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_function_broadcasted_event.d.ts","sourceRoot":"","sources":["../../src/class-registry/private_function_broadcasted_event.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EAEjC,oBAAoB,EAErB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,4CAA4C,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC5G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D,oDAAoD;AACpD,qBAAa,+BAA+B;aAExB,eAAe,EAAE,EAAE;aACnB,oBAAoB,EAAE,EAAE;aACxB,wBAAwB,EAAE,EAAE;aAC5B,8BAA8B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,oBAAoB,CAAC;aACtE,4BAA4B,EAAE,MAAM;aACpC,+BAA+B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,iCAAiC,CAAC;aACpF,6BAA6B,EAAE,MAAM;aACrC,eAAe,EAAE,0BAA0B;gBAP3C,eAAe,EAAE,EAAE,EACnB,oBAAoB,EAAE,EAAE,EACxB,wBAAwB,EAAE,EAAE,EAC5B,8BAA8B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,oBAAoB,CAAC,EACtE,4BAA4B,EAAE,MAAM,EACpC,+BAA+B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,iCAAiC,CAAC,EACpF,6BAA6B,EAAE,MAAM,EACrC,eAAe,EAAE,0BAA0B;IAG7D,MAAM,CAAC,iCAAiC,CAAC,GAAG,EAAE,gBAAgB;IAO9D,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,gBAAgB;IAapC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAuB5C,6BAA6B,IAAI,4CAA4C;CAa9E;AAED,qBAAa,0BAA2B,YAAW,eAAe;IAE9D,qJAAqJ;aACrI,QAAQ,EAAE,gBAAgB;IAC1C,6BAA6B;aACb,YAAY,EAAE,EAAE;IAChC,wEAAwE;aACxD,MAAM,EAAE,EAAE;IAC1B,gCAAgC;aAChB,QAAQ,EAAE,MAAM;;IAPhC,qJAAqJ;IACrI,QAAQ,EAAE,gBAAgB;IAC1C,6BAA6B;IACb,YAAY,EAAE,EAAE;IAChC,wEAAwE;IACxD,MAAM,EAAE,EAAE;IAC1B,gCAAgC;IAChB,QAAQ,EAAE,MAAM;IAGlC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;CAU7C"}

package/dest/{class-registerer → class-registry}/private_function_broadcasted_event.js

@@ -1,20 +1,20 @@
-import { ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, FUNCTION_TREE_HEIGHT, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS } from '@aztec/constants';
+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 { FieldReader } from '@aztec/foundation/serialize';
 import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
-import { REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
-/** Event emitted from the ContractClassRegisterer. */ export class PrivateFunctionBroadcastedEvent {
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
+/** Event emitted from the ContractClassRegistry. */ export class PrivateFunctionBroadcastedEvent {
     contractClassId;
     artifactMetadataHash;
-    unconstrainedFunctionsArtifactTreeRoot;
+    utilityFunctionsTreeRoot;
     privateFunctionTreeSiblingPath;
     privateFunctionTreeLeafIndex;
     artifactFunctionTreeSiblingPath;
     artifactFunctionTreeLeafIndex;
     privateFunction;
-    constructor(contractClassId, artifactMetadataHash, unconstrainedFunctionsArtifactTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, privateFunction){
+    constructor(contractClassId, artifactMetadataHash, utilityFunctionsTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, privateFunction){
         this.contractClassId = contractClassId;
         this.artifactMetadataHash = artifactMetadataHash;
-        this.unconstrainedFunctionsArtifactTreeRoot = unconstrainedFunctionsArtifactTreeRoot;
+        this.utilityFunctionsTreeRoot = utilityFunctionsTreeRoot;
         this.privateFunctionTreeSiblingPath = privateFunctionTreeSiblingPath;
         this.privateFunctionTreeLeafIndex = privateFunctionTreeLeafIndex;
         this.artifactFunctionTreeSiblingPath = artifactFunctionTreeSiblingPath;
@@ -22,10 +22,10 @@ import { REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG } from '../protocol_contrac
         this.privateFunction = privateFunction;
     }
     static isPrivateFunctionBroadcastedEvent(log) {
-        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) {
-        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();
@@ -39,13 +39,13 @@ import { REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG } from '../protocol_contrac
         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);
         const artifactFunctionTreeLeafIndex = reader.readField().toNumber();
         const privateFunction = BroadcastedPrivateFunction.fromFields(reader);
-        return new PrivateFunctionBroadcastedEvent(contractClassId, artifactMetadataHash, unconstrainedFunctionsArtifactTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, privateFunction);
+        return new PrivateFunctionBroadcastedEvent(contractClassId, artifactMetadataHash, utilityFunctionsTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, privateFunction);
     }
     toFunctionWithMembershipProof() {
         return {
@@ -53,7 +53,7 @@ import { REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG } from '../protocol_contrac
             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/dest/{class-registerer/unconstrained_function_broadcasted_event.d.ts → class-registry/utility_function_broadcasted_event.d.ts}

@@ -1,27 +1,25 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { ARTIFACT_FUNCTION_TREE_MAX_HEIGHT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { FunctionSelector } 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';
-/** Event emitted from the ContractClassRegisterer. */
-export declare class UnconstrainedFunctionBroadcastedEvent {
+/** Event emitted from the ContractClassRegistry. */
+export declare class UtilityFunctionBroadcastedEvent {
     readonly contractClassId: Fr;
     readonly artifactMetadataHash: Fr;
     readonly privateFunctionsArtifactTreeRoot: Fr;
     readonly artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>;
     readonly artifactFunctionTreeLeafIndex: number;
-    readonly unconstrainedFunction: BroadcastedUnconstrainedFunction;
-    constructor(contractClassId: Fr, artifactMetadataHash: Fr, privateFunctionsArtifactTreeRoot: Fr, artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>, artifactFunctionTreeLeafIndex: number, unconstrainedFunction: BroadcastedUnconstrainedFunction);
-    static isUnconstrainedFunctionBroadcastedEvent(log: ContractClassLog): boolean;
-    static fromLog(log: ContractClassLog): UnconstrainedFunctionBroadcastedEvent;
-    static fromFields(fields: Fr[] | FieldReader): UnconstrainedFunctionBroadcastedEvent;
-    toFunctionWithMembershipProof(): UnconstrainedFunctionWithMembershipProof;
+    readonly utilityFunction: BroadcastedUtilityFunction;
+    constructor(contractClassId: Fr, artifactMetadataHash: Fr, privateFunctionsArtifactTreeRoot: Fr, artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>, artifactFunctionTreeLeafIndex: number, utilityFunction: BroadcastedUtilityFunction);
+    static isUtilityFunctionBroadcastedEvent(log: ContractClassLog): boolean;
+    static fromLog(log: ContractClassLog): UtilityFunctionBroadcastedEvent;
+    static fromFields(fields: Fr[] | FieldReader): UtilityFunctionBroadcastedEvent;
+    toFunctionWithMembershipProof(): UtilityFunctionWithMembershipProof;
 }
-export declare class BroadcastedUnconstrainedFunction implements UnconstrainedFunction {
+export declare class BroadcastedUtilityFunction implements UtilityFunction {
     /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
     readonly selector: FunctionSelector;
     /** Artifact metadata hash */
@@ -35,6 +33,6 @@ export declare class BroadcastedUnconstrainedFunction implements UnconstrainedFu
     metadataHash: Fr, 
     /** Brillig bytecode */
     bytecode: Buffer);
-    static fromFields(fields: Fr[] | FieldReader): BroadcastedUnconstrainedFunction;
+    static fromFields(fields: Fr[] | FieldReader): BroadcastedUtilityFunction;
 }
-//# sourceMappingURL=unconstrained_function_broadcasted_event.d.ts.map
+//# sourceMappingURL=utility_function_broadcasted_event.d.ts.map

package/dest/class-registry/utility_function_broadcasted_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility_function_broadcasted_event.d.ts","sourceRoot":"","sources":["../../src/class-registry/utility_function_broadcasted_event.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EAGlC,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,kCAAkC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D,oDAAoD;AACpD,qBAAa,+BAA+B;aAExB,eAAe,EAAE,EAAE;aACnB,oBAAoB,EAAE,EAAE;aACxB,gCAAgC,EAAE,EAAE;aACpC,+BAA+B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,iCAAiC,CAAC;aACpF,6BAA6B,EAAE,MAAM;aACrC,eAAe,EAAE,0BAA0B;gBAL3C,eAAe,EAAE,EAAE,EACnB,oBAAoB,EAAE,EAAE,EACxB,gCAAgC,EAAE,EAAE,EACpC,+BAA+B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,iCAAiC,CAAC,EACpF,6BAA6B,EAAE,MAAM,EACrC,eAAe,EAAE,0BAA0B;IAG7D,MAAM,CAAC,iCAAiC,CAAC,GAAG,EAAE,gBAAgB;IAO9D,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,gBAAgB;IAapC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAmB5C,6BAA6B,IAAI,kCAAkC;CAgBpE;AAED,qBAAa,0BAA2B,YAAW,eAAe;IAE9D,qJAAqJ;aACrI,QAAQ,EAAE,gBAAgB;IAC1C,6BAA6B;aACb,YAAY,EAAE,EAAE;IAChC,uBAAuB;aACP,QAAQ,EAAE,MAAM;;IALhC,qJAAqJ;IACrI,QAAQ,EAAE,gBAAgB;IAC1C,6BAA6B;IACb,YAAY,EAAE,EAAE;IAChC,uBAAuB;IACP,QAAQ,EAAE,MAAM;IAGlC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;CAS7C"}

package/dest/{class-registerer/unconstrained_function_broadcasted_event.js → class-registry/utility_function_broadcasted_event.js}

@@ -1,34 +1,34 @@
-import { ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS } from '@aztec/constants';
+import { ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, 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 { FieldReader } from '@aztec/foundation/serialize';
 import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
-import { REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
-/** Event emitted from the ContractClassRegisterer. */ export class UnconstrainedFunctionBroadcastedEvent {
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
+/** Event emitted from the ContractClassRegistry. */ export class UtilityFunctionBroadcastedEvent {
     contractClassId;
     artifactMetadataHash;
     privateFunctionsArtifactTreeRoot;
     artifactFunctionTreeSiblingPath;
     artifactFunctionTreeLeafIndex;
-    unconstrainedFunction;
-    constructor(contractClassId, artifactMetadataHash, privateFunctionsArtifactTreeRoot, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, unconstrainedFunction){
+    utilityFunction;
+    constructor(contractClassId, artifactMetadataHash, privateFunctionsArtifactTreeRoot, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, utilityFunction){
         this.contractClassId = contractClassId;
         this.artifactMetadataHash = artifactMetadataHash;
         this.privateFunctionsArtifactTreeRoot = privateFunctionsArtifactTreeRoot;
         this.artifactFunctionTreeSiblingPath = artifactFunctionTreeSiblingPath;
         this.artifactFunctionTreeLeafIndex = artifactFunctionTreeLeafIndex;
-        this.unconstrainedFunction = unconstrainedFunction;
+        this.utilityFunction = utilityFunction;
     }
-    static isUnconstrainedFunctionBroadcastedEvent(log) {
-        return log.fields[0].equals(REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG);
+    static isUtilityFunctionBroadcastedEvent(log) {
+        return log.contractAddress.equals(ProtocolContractAddress.ContractClassRegistry) && log.fields.fields[0].toBigInt() === CONTRACT_CLASS_REGISTRY_UTILITY_FUNCTION_BROADCASTED_MAGIC_VALUE;
     }
     static fromLog(log) {
-        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()}`);
             }
         }
         return event;
@@ -40,8 +40,8 @@ import { REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG } from '../protocol_c
         const privateFunctionsArtifactTreeRoot = reader.readField();
         const artifactFunctionTreeSiblingPath = reader.readFieldArray(ARTIFACT_FUNCTION_TREE_MAX_HEIGHT);
         const artifactFunctionTreeLeafIndex = reader.readField().toNumber();
-        const unconstrainedFunction = BroadcastedUnconstrainedFunction.fromFields(reader);
-        return new UnconstrainedFunctionBroadcastedEvent(contractClassId, artifactMetadataHash, privateFunctionsArtifactTreeRoot, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, unconstrainedFunction);
+        const utilityFunction = BroadcastedUtilityFunction.fromFields(reader);
+        return new UtilityFunctionBroadcastedEvent(contractClassId, artifactMetadataHash, privateFunctionsArtifactTreeRoot, artifactFunctionTreeSiblingPath, artifactFunctionTreeLeafIndex, utilityFunction);
     }
     toFunctionWithMembershipProof() {
         // We should be able to safely remove the zero elements that pad the variable-length sibling path,
@@ -50,9 +50,9 @@ import { REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG } from '../protocol_c
         // 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,
@@ -60,7 +60,7 @@ import { REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG } from '../protocol_c
         };
     }
 }
-export class BroadcastedUnconstrainedFunction {
+export class BroadcastedUtilityFunction {
     selector;
     metadataHash;
     bytecode;
@@ -74,8 +74,8 @@ export class BroadcastedUnconstrainedFunction {
         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/dest/fee-juice/index.js

@@ -1,6 +1,6 @@
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import { computePublicDataTreeLeafSlot, deriveStorageSlotInMap } from '@aztec/stdlib/hash';
-import FeeJuiceJson from '../../artifacts/FeeJuice.json' assert {
+import FeeJuiceJson from '../../artifacts/FeeJuice.json' with {
     type: 'json'
 };
 import { makeProtocolContract } from '../make_protocol_contract.js';

package/dest/fee-juice/lazy.js

@@ -4,10 +4,10 @@ let protocolContract;
 let protocolContractArtifact;
 export async function getFeeJuiceArtifact() {
     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/dest/index.d.ts

@@ -1,4 +1,3 @@
 export * from './protocol_contract.js';
 export * from './protocol_contract_data.js';
-export * from './protocol_contract_tree.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC"}

package/dest/index.js

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

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

@@ -3,8 +3,8 @@ 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';
-/** Event emitted from the ContractInstanceDeployer. */
-export declare class ContractInstanceDeployedEvent {
+/** Event emitted from the ContractInstanceRegistry. */
+export declare class ContractInstancePublishedEvent {
     readonly address: AztecAddress;
     readonly version: number;
     readonly salt: Fr;
@@ -13,8 +13,8 @@ export declare class ContractInstanceDeployedEvent {
     readonly publicKeys: PublicKeys;
     readonly deployer: AztecAddress;
     constructor(address: AztecAddress, version: number, salt: Fr, contractClassId: Fr, initializationHash: Fr, publicKeys: PublicKeys, deployer: AztecAddress);
-    static isContractInstanceDeployedEvent(log: PrivateLog): boolean;
-    static fromLog(log: PrivateLog): ContractInstanceDeployedEvent;
+    static isContractInstancePublishedEvent(log: PrivateLog): boolean;
+    static fromLog(log: PrivateLog): ContractInstancePublishedEvent;
     toContractInstance(): ContractInstanceWithAddress;
 }
-//# sourceMappingURL=contract_instance_deployed_event.d.ts.map
+//# sourceMappingURL=contract_instance_published_event.d.ts.map

package/dest/instance-registry/contract_instance_published_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_instance_published_event.d.ts","sourceRoot":"","sources":["../../src/instance-registry/contract_instance_published_event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIrD,uDAAuD;AACvD,qBAAa,8BAA8B;aAEvB,OAAO,EAAE,YAAY;aACrB,OAAO,EAAE,MAAM;aACf,IAAI,EAAE,EAAE;aACR,eAAe,EAAE,EAAE;aACnB,kBAAkB,EAAE,EAAE;aACtB,UAAU,EAAE,UAAU;aACtB,QAAQ,EAAE,YAAY;gBANtB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,EAAE,EACR,eAAe,EAAE,EAAE,EACnB,kBAAkB,EAAE,EAAE,EACtB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,YAAY;IAGxC,MAAM,CAAC,gCAAgC,CAAC,GAAG,EAAE,UAAU;IAIvD,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,UAAU;IAsB9B,kBAAkB,IAAI,2BAA2B;CAgBlD"}

package/dest/{instance-deployer/contract_instance_deployed_event.js → instance-registry/contract_instance_published_event.js}

@@ -2,8 +2,8 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicKeys } from '@aztec/stdlib/keys';
-import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '../protocol_contract_data.js';
-/** Event emitted from the ContractInstanceDeployer. */ export class ContractInstanceDeployedEvent {
+import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '../protocol_contract_data.js';
+/** Event emitted from the ContractInstanceRegistry. */ export class ContractInstancePublishedEvent {
     address;
     version;
     salt;
@@ -20,8 +20,8 @@ import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '../protocol_contract_da
         this.publicKeys = publicKeys;
         this.deployer = deployer;
     }
-    static isContractInstanceDeployedEvent(log) {
-        return log.fields[0].equals(DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG);
+    static isContractInstancePublishedEvent(log) {
+        return log.fields[0].equals(CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG);
     }
     static fromLog(log) {
         const bufferWithoutTag = log.toBuffer().subarray(32);
@@ -33,7 +33,7 @@ import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '../protocol_contract_da
         const initializationHash = reader.readObject(Fr);
         const publicKeys = reader.readObject(PublicKeys);
         const deployer = reader.readObject(AztecAddress);
-        return new ContractInstanceDeployedEvent(address, version, salt, contractClassId, initializationHash, publicKeys, deployer);
+        return new ContractInstancePublishedEvent(address, version, salt, contractClassId, initializationHash, publicKeys, deployer);
     }
     toContractInstance() {
         if (this.version !== 1) {

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

@@ -2,13 +2,14 @@ import { Fr } from '@aztec/foundation/fields';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstanceUpdateWithAddress } from '@aztec/stdlib/contract';
 import type { PublicLog } from '@aztec/stdlib/logs';
-/** Event emitted from the ContractInstanceDeployer. */
+import type { UInt64 } from '@aztec/stdlib/types';
+/** Event emitted from the ContractInstanceRegistry. */
 export declare class ContractInstanceUpdatedEvent {
     readonly address: AztecAddress;
     readonly prevContractClassId: Fr;
     readonly newContractClassId: Fr;
-    readonly blockOfChange: number;
-    constructor(address: AztecAddress, prevContractClassId: Fr, newContractClassId: Fr, blockOfChange: number);
+    readonly timestampOfChange: UInt64;
+    constructor(address: AztecAddress, prevContractClassId: Fr, newContractClassId: Fr, timestampOfChange: UInt64);
     static isContractInstanceUpdatedEvent(log: PublicLog): boolean;
     static fromLog(log: PublicLog): ContractInstanceUpdatedEvent;
     toContractInstanceUpdate(): ContractInstanceUpdateWithAddress;

package/dest/instance-registry/contract_instance_updated_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_instance_updated_event.d.ts","sourceRoot":"","sources":["../../src/instance-registry/contract_instance_updated_event.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAIlD,uDAAuD;AACvD,qBAAa,4BAA4B;aAErB,OAAO,EAAE,YAAY;aACrB,mBAAmB,EAAE,EAAE;aACvB,kBAAkB,EAAE,EAAE;aACtB,iBAAiB,EAAE,MAAM;gBAHzB,OAAO,EAAE,YAAY,EACrB,mBAAmB,EAAE,EAAE,EACvB,kBAAkB,EAAE,EAAE,EACtB,iBAAiB,EAAE,MAAM;IAG3C,MAAM,CAAC,8BAA8B,CAAC,GAAG,EAAE,SAAS;IAOpD,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,SAAS;IAS7B,wBAAwB,IAAI,iCAAiC;CAQ9D"}