@aztec/protocol-contracts 0.76.4 → 0.77.0-testnet-ignition.21

package/src/class-registerer/contract_class_registered_event.ts

@@ -1,15 +1,14 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
 import {
   type ContractClassPublic,
-  PUBLIC_DISPATCH_SELECTOR,
   type PublicFunction,
   computeContractClassId,
   computePublicBytecodeCommitment,
-} from '@aztec/circuits.js';
-import { FunctionSelector, bufferFromFields } from '@aztec/foundation/abi';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
-
-import chunk from 'lodash.chunk';
+} from '@aztec/stdlib/contract';
+import type { ContractClassLog } from '@aztec/stdlib/logs';
 
 import { REGISTERER_CONTRACT_CLASS_REGISTERED_TAG } from '../protocol_contract_data.js';
 
@@ -23,19 +22,17 @@ export class ContractClassRegisteredEvent {
     public readonly packedPublicBytecode: Buffer,
   ) {}
 
-  static isContractClassRegisteredEvent(log: Buffer) {
-    return log.subarray(0, 32).equals(REGISTERER_CONTRACT_CLASS_REGISTERED_TAG.toBuffer());
+  static isContractClassRegisteredEvent(log: ContractClassLog) {
+    return log.fields[0].equals(REGISTERER_CONTRACT_CLASS_REGISTERED_TAG);
   }
 
-  static fromLog(log: Buffer) {
-    const reader = new BufferReader(log.subarray(32));
-    const contractClassId = reader.readObject(Fr);
-    const version = reader.readObject(Fr).toNumber();
-    const artifactHash = reader.readObject(Fr);
-    const privateFunctionsRoot = reader.readObject(Fr);
-    const packedPublicBytecode = bufferFromFields(
-      chunk(reader.readToEnd(), Fr.SIZE_IN_BYTES).map(Buffer.from).map(Fr.fromBuffer),
-    );
+  static fromLog(log: ContractClassLog) {
+    const reader = new FieldReader(log.fields.slice(1));
+    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,

package/src/class-registerer/index.ts

@@ -1,9 +1,9 @@
-import { loadContractArtifact } from '@aztec/types/abi';
-import { type NoirCompiledContract } from '@aztec/types/noir';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
 import ContractClassRegistererJson from '../../artifacts/ContractClassRegisterer.json' assert { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
-import { type ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
 
 export * from './contract_class_registered_event.js';
 export * from './private_function_broadcasted_event.js';

package/src/class-registerer/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_registered_event.js';
+export * from './private_function_broadcasted_event.js';
+export * from './unconstrained_function_broadcasted_event.js';
+
+let protocolContract: ProtocolContract;
+let protocolContractArtifact: ContractArtifact;
+
+export async function getContractClassRegistererArtifact(): 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
+    // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+    const { default: contractClassRegistererJson } = await import('../../artifacts/ContractClassRegisterer.json');
+    protocolContractArtifact = loadContractArtifact(contractClassRegistererJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalClassRegisterer(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const contractClassRegistererArtifact = await getContractClassRegistererArtifact();
+    protocolContract = await makeProtocolContract('ContractClassRegisterer', contractClassRegistererArtifact);
+  }
+  return protocolContract;
+}

package/src/class-registerer/private_function_broadcasted_event.ts

@@ -1,16 +1,14 @@
 import {
   ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
-  type ExecutablePrivateFunctionWithMembershipProof,
   FUNCTION_TREE_HEIGHT,
   MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  type PrivateFunction,
-  REGISTERER_PRIVATE_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS,
-} from '@aztec/circuits.js';
-import { FunctionSelector, bufferFromFields } from '@aztec/foundation/abi';
+} from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, type Tuple } from '@aztec/foundation/serialize';
-
-import chunk from 'lodash.chunk';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
+import type { ExecutablePrivateFunctionWithMembershipProof, PrivateFunction } from '@aztec/stdlib/contract';
+import type { ContractClassLog } from '@aztec/stdlib/logs';
 
 import { REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
 
@@ -27,42 +25,33 @@ export class PrivateFunctionBroadcastedEvent {
     public readonly privateFunction: BroadcastedPrivateFunction,
   ) {}
 
-  static isPrivateFunctionBroadcastedEvent(log: Buffer) {
-    return log.subarray(0, 32).equals(REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG.toBuffer());
+  static isPrivateFunctionBroadcastedEvent(log: ContractClassLog) {
+    return log.fields[0].equals(REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG);
   }
 
-  static fromLog(log: Buffer) {
-    const expectedLength =
-      32 *
-      (MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS +
-        REGISTERER_PRIVATE_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS);
-    if (log.length !== expectedLength) {
-      throw new Error(
-        `Unexpected PrivateFunctionBroadcastedEvent log length: got ${log.length} but expected ${expectedLength}`,
-      );
-    }
-
-    const reader = new BufferReader(log.subarray(32));
-    const event = PrivateFunctionBroadcastedEvent.fromBuffer(reader);
-    if (!reader.isEmpty()) {
-      throw new Error(
-        `Unexpected data after parsing PrivateFunctionBroadcastedEvent: ${reader.readToEnd().toString('hex')}`,
-      );
+  static fromLog(log: ContractClassLog) {
+    const reader = new FieldReader(log.fields.slice(1));
+    const event = PrivateFunctionBroadcastedEvent.fromFields(reader);
+    while (!reader.isFinished()) {
+      const field = reader.readField();
+      if (!field.isZero()) {
+        throw new Error(`Unexpected data after parsing PrivateFunctionBroadcastedEvent: ${field.toString()}`);
+      }
     }
 
     return event;
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    const contractClassId = reader.readObject(Fr);
-    const artifactMetadataHash = reader.readObject(Fr);
-    const unconstrainedFunctionsArtifactTreeRoot = reader.readObject(Fr);
-    const privateFunctionTreeSiblingPath = reader.readArray(FUNCTION_TREE_HEIGHT, Fr);
-    const privateFunctionTreeLeafIndex = reader.readObject(Fr).toNumber();
-    const artifactFunctionTreeSiblingPath = reader.readArray(ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, Fr);
-    const artifactFunctionTreeLeafIndex = reader.readObject(Fr).toNumber();
-    const privateFunction = BroadcastedPrivateFunction.fromBuffer(reader);
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const contractClassId = reader.readField();
+    const artifactMetadataHash = reader.readField();
+    const unconstrainedFunctionsArtifactTreeRoot = 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,
@@ -103,13 +92,14 @@ export class BroadcastedPrivateFunction implements PrivateFunction {
     public readonly bytecode: Buffer,
   ) {}
 
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    const selector = FunctionSelector.fromField(reader.readObject(Fr));
-    const metadataHash = reader.readObject(Fr);
-    const vkHash = reader.readObject(Fr);
-    const encodedBytecode = reader.readBytes(MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS * 32);
-    const bytecode = bufferFromFields(chunk(encodedBytecode, Fr.SIZE_IN_BYTES).map(Buffer.from).map(Fr.fromBuffer));
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const selector = FunctionSelector.fromField(reader.readField());
+    const metadataHash = reader.readField();
+    const vkHash = 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_PRIVATE_FUNCTION_IN_FIELDS * 1);
+    const bytecode = bufferFromFields(encodedBytecode);
     return new BroadcastedPrivateFunction(selector, metadataHash, vkHash, bytecode);
   }
 }

package/src/class-registerer/unconstrained_function_broadcasted_event.ts

@@ -1,16 +1,14 @@
 import {
   ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
   MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS,
-  REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS,
-  type UnconstrainedFunction,
-  type UnconstrainedFunctionWithMembershipProof,
-} from '@aztec/circuits.js';
-import { FunctionSelector, bufferFromFields } from '@aztec/foundation/abi';
+} from '@aztec/constants';
 import { removeArrayPaddingEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, type Tuple } from '@aztec/foundation/serialize';
-
-import chunk from 'lodash.chunk';
+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 { ContractClassLog } from '@aztec/stdlib/logs';
 
 import { REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
 
@@ -25,40 +23,31 @@ export class UnconstrainedFunctionBroadcastedEvent {
     public readonly unconstrainedFunction: BroadcastedUnconstrainedFunction,
   ) {}
 
-  static isUnconstrainedFunctionBroadcastedEvent(log: Buffer) {
-    return log.subarray(0, 32).equals(REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG.toBuffer());
+  static isUnconstrainedFunctionBroadcastedEvent(log: ContractClassLog) {
+    return log.fields[0].equals(REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG);
   }
 
-  static fromLog(log: Buffer) {
-    const expectedLength =
-      32 *
-      (MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS +
-        REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS);
-    if (log.length !== expectedLength) {
-      throw new Error(
-        `Unexpected UnconstrainedFunctionBroadcastedEvent log length: got ${log.length} but expected ${expectedLength}`,
-      );
-    }
-
-    const reader = new BufferReader(log.subarray(32));
-    const event = UnconstrainedFunctionBroadcastedEvent.fromBuffer(reader);
-    if (!reader.isEmpty()) {
-      throw new Error(
-        `Unexpected data after parsing UnconstrainedFunctionBroadcastedEvent: ${reader.readToEnd().toString('hex')}`,
-      );
+  static fromLog(log: ContractClassLog) {
+    const reader = new FieldReader(log.fields.slice(1));
+    const event = UnconstrainedFunctionBroadcastedEvent.fromFields(reader);
+    while (!reader.isFinished()) {
+      const field = reader.readField();
+      if (!field.isZero()) {
+        throw new Error(`Unexpected data after parsing UnconstrainedFunctionBroadcastedEvent: ${field.toString()}`);
+      }
     }
 
     return event;
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    const contractClassId = reader.readObject(Fr);
-    const artifactMetadataHash = reader.readObject(Fr);
-    const privateFunctionsArtifactTreeRoot = reader.readObject(Fr);
-    const artifactFunctionTreeSiblingPath = reader.readArray(ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, Fr);
-    const artifactFunctionTreeLeafIndex = reader.readObject(Fr).toNumber();
-    const unconstrainedFunction = BroadcastedUnconstrainedFunction.fromBuffer(reader);
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const contractClassId = reader.readField();
+    const artifactMetadataHash = reader.readField();
+    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,
@@ -98,12 +87,13 @@ export class BroadcastedUnconstrainedFunction implements UnconstrainedFunction {
     public readonly bytecode: Buffer,
   ) {}
 
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    const selector = FunctionSelector.fromField(reader.readObject(Fr));
-    const metadataHash = reader.readObject(Fr);
-    const encodedBytecode = reader.readBytes(MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS * 32);
-    const bytecode = bufferFromFields(chunk(encodedBytecode, Fr.SIZE_IN_BYTES).map(Buffer.from).map(Fr.fromBuffer));
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    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 bytecode = bufferFromFields(encodedBytecode);
     return new BroadcastedUnconstrainedFunction(selector, metadataHash, bytecode);
   }
 }

package/src/fee-juice/index.ts

@@ -1,9 +1,13 @@
-import { loadContractArtifact } from '@aztec/types/abi';
-import { type NoirCompiledContract } from '@aztec/types/noir';
+import type { Fr } from '@aztec/foundation/fields';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computePublicDataTreeLeafSlot, deriveStorageSlotInMap } from '@aztec/stdlib/hash';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
 import FeeJuiceJson from '../../artifacts/FeeJuice.json' assert { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
-import { type ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
 
 export const FeeJuiceArtifact = loadContractArtifact(FeeJuiceJson as NoirCompiledContract);
 
@@ -16,3 +20,18 @@ export async function getCanonicalFeeJuice(): Promise<ProtocolContract> {
   }
   return protocolContract;
 }
+
+/**
+ * Computes the storage slot within the Fee Juice contract for the balance of the fee payer.
+ */
+export function computeFeePayerBalanceStorageSlot(feePayer: AztecAddress): Promise<Fr> {
+  return deriveStorageSlotInMap(FeeJuiceArtifact.storageLayout.balances.slot, feePayer);
+}
+
+/**
+ * Computes the leaf slot in the public data tree for the balance of the fee payer in the Fee Juice.
+ */
+export async function computeFeePayerBalanceLeafSlot(feePayer: AztecAddress): Promise<Fr> {
+  const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
+  return computePublicDataTreeLeafSlot(ProtocolContractAddress.FeeJuice, balanceSlot);
+}

package/src/fee-juice/lazy.ts

@@ -0,0 +1,29 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+let protocolContract: ProtocolContract;
+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
+    // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+    const { default: feeJuiceJson } = await import('../../artifacts/FeeJuice.json');
+    protocolContractArtifact = loadContractArtifact(feeJuiceJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalFeeJuice(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const feeJuiceArtifact = await getFeeJuiceArtifact();
+    protocolContract = await makeProtocolContract('FeeJuice', feeJuiceArtifact);
+  }
+  return protocolContract;
+}

package/src/instance-deployer/contract_instance_deployed_event.ts

@@ -1,7 +1,9 @@
-import { type ContractInstanceWithAddress, type PrivateLog, PublicKeys } from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import type { PrivateLog } from '@aztec/stdlib/logs';
 
 import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '../protocol_contract_data.js';
 
@@ -51,7 +53,8 @@ export class ContractInstanceDeployedEvent {
     return {
       address: this.address,
       version: this.version,
-      contractClassId: this.contractClassId,
+      currentContractClassId: this.contractClassId,
+      originalContractClassId: this.contractClassId,
       initializationHash: this.initializationHash,
       publicKeys: this.publicKeys,
       salt: this.salt,

package/src/instance-deployer/contract_instance_updated_event.ts

@@ -0,0 +1,44 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } 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 { DEPLOYER_CONTRACT_INSTANCE_UPDATED_TAG, ProtocolContractAddress } from '../protocol_contract_data.js';
+
+/** Event emitted from the ContractInstanceDeployer. */
+export class ContractInstanceUpdatedEvent {
+  constructor(
+    public readonly address: AztecAddress,
+    public readonly prevContractClassId: Fr,
+    public readonly newContractClassId: Fr,
+    public readonly blockOfChange: number,
+  ) {}
+
+  static isContractInstanceUpdatedEvent(log: PublicLog) {
+    return (
+      log.contractAddress.equals(ProtocolContractAddress.ContractInstanceDeployer) &&
+      log.log[0].equals(DEPLOYER_CONTRACT_INSTANCE_UPDATED_TAG)
+    );
+  }
+
+  static fromLog(log: PublicLog) {
+    const bufferWithoutAddressAndTag = log.toBuffer().subarray(64);
+    const reader = new BufferReader(bufferWithoutAddressAndTag);
+    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);
+  }
+
+  toContractInstanceUpdate(): ContractInstanceUpdateWithAddress {
+    return {
+      address: this.address,
+      prevContractClassId: this.prevContractClassId,
+      newContractClassId: this.newContractClassId,
+      blockOfChange: this.blockOfChange,
+    };
+  }
+}

package/src/instance-deployer/index.ts

@@ -1,11 +1,12 @@
-import { loadContractArtifact } from '@aztec/types/abi';
-import { type NoirCompiledContract } from '@aztec/types/noir';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
 import ContractInstanceDeployerJson from '../../artifacts/ContractInstanceDeployer.json' assert { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
-import { type ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
 
 export * from './contract_instance_deployed_event.js';
+export * from './contract_instance_updated_event.js';
 
 export const ContractInstanceDeployerArtifact = loadContractArtifact(
   ContractInstanceDeployerJson as NoirCompiledContract,

package/src/instance-deployer/lazy.ts

@@ -0,0 +1,32 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+export * from './contract_instance_deployed_event.js';
+export * from './contract_instance_updated_event.js';
+
+let protocolContract: ProtocolContract;
+let protocolContractArtifact: ContractArtifact;
+
+export async function getContractInstanceDeployerArtifact(): 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
+    // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+    const { default: contractInstanceDeployerJson } = await import('../../artifacts/ContractInstanceDeployer.json');
+    protocolContractArtifact = loadContractArtifact(contractInstanceDeployerJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalInstanceDeployer(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const contractInstanceDeployerArtifact = await getContractInstanceDeployerArtifact();
+    protocolContract = await makeProtocolContract('ContractInstanceDeployer', contractInstanceDeployerArtifact);
+  }
+  return protocolContract;
+}

package/src/make_protocol_contract.ts

@@ -1,7 +1,7 @@
-import { getContractClassFromArtifact, getContractInstanceFromDeployParams } from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { getContractClassFromArtifact, getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
 
-import { type ProtocolContract } from './protocol_contract.js';
+import type { ProtocolContract } from './protocol_contract.js';
 import { ProtocolContractAddress, type ProtocolContractName, ProtocolContractSalt } from './protocol_contract_data.js';
 
 /**

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

@@ -1,9 +1,9 @@
-import { loadContractArtifact } from '@aztec/types/abi';
-import { type NoirCompiledContract } from '@aztec/types/noir';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
 import MultiCallEntrypointJson from '../../artifacts/MultiCallEntrypoint.json' assert { type: 'json' };
 import { makeProtocolContract } from '../make_protocol_contract.js';
-import { type ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
 
 export const MultiCallEntrypointArtifact = loadContractArtifact(MultiCallEntrypointJson as NoirCompiledContract);
 

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

@@ -0,0 +1,29 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+let protocolContract: ProtocolContract;
+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
+    // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+    const { default: multiCallEntrypointJson } = await import('../../artifacts/MultiCallEntrypoint.json');
+    protocolContractArtifact = loadContractArtifact(multiCallEntrypointJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalMultiCallEntrypoint(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const multiCallEntrypointArtifact = await getMultiCallEntrypointArtifact();
+    protocolContract = await makeProtocolContract('MultiCallEntrypoint', multiCallEntrypointArtifact);
+  }
+  return protocolContract;
+}

package/src/protocol_contract.ts

@@ -1,10 +1,6 @@
-import {
-  type AztecAddress,
-  type ContractClassIdPreimage,
-  type ContractClassWithId,
-  type ContractInstanceWithAddress,
-} from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassIdPreimage, ContractClassWithId, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import { ProtocolContractAddress } from './protocol_contract_data.js';
 
@@ -23,3 +19,5 @@ export interface ProtocolContract {
 export function isProtocolContract(address: AztecAddress) {
   return Object.values(ProtocolContractAddress).some(a => a.equals(address));
 }
+
+export { type ProtocolContractsProvider } from './provider/protocol_contracts_provider.js';