@aztec/protocol-contracts 0.0.1-commit.993d52e → 0.0.1-commit.9a89641

package/dest/provider/lazy.js

@@ -1,24 +1,15 @@
-import { getCanonicalAuthRegistry } from '../auth-registry/lazy.js';
 import { getCanonicalClassRegistry } from '../class-registry/lazy.js';
 import { getCanonicalFeeJuice } from '../fee-juice/lazy.js';
 import { getCanonicalInstanceRegistry } from '../instance-registry/lazy.js';
-import { getCanonicalMultiCallEntrypoint } from '../multi-call-entrypoint/lazy.js';
-import { getCanonicalPublicChecks } from '../public-checks/lazy.js';
 export class LazyProtocolContractsProvider {
     getProtocolContractArtifact(name) {
         switch(name){
-            case 'AuthRegistry':
-                return getCanonicalAuthRegistry();
             case 'ContractInstanceRegistry':
                 return getCanonicalInstanceRegistry();
             case 'ContractClassRegistry':
                 return getCanonicalClassRegistry();
-            case 'MultiCallEntrypoint':
-                return getCanonicalMultiCallEntrypoint();
             case 'FeeJuice':
                 return getCanonicalFeeJuice();
-            case 'PublicChecks':
-                return getCanonicalPublicChecks();
             default:
                 throw new Error(`Unknown protocol contract name: ${name}`);
         }

package/dest/scripts/generate_data.js

@@ -2,10 +2,11 @@
 // bytecode commitments, and other deployment data, emitting everything as precomputed constants into
 // `protocol_contract_data.ts`. This avoids clients repeating the expensive hashing at runtime and
 // ensures a single source of truth for the protocol contracts hash enforced by circuits, P2P, and L1.
-import { CANONICAL_AUTH_REGISTRY_ADDRESS, CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, FEE_JUICE_ADDRESS, MAX_PROTOCOL_CONTRACTS, MULTI_CALL_ENTRYPOINT_ADDRESS, PUBLIC_CHECKS_ADDRESS } from '@aztec/constants';
+import { CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, FEE_JUICE_ADDRESS, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createConsoleLogger } from '@aztec/foundation/log';
+import { fileURLToPath } from '@aztec/foundation/url';
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeContractAddressFromInstance, computeInitializationHash, getContractClassFromArtifact } from '@aztec/stdlib/contract';
@@ -15,18 +16,15 @@ import { ProtocolContracts } from '@aztec/stdlib/tx';
 import { promises as fs } from 'fs';
 import path from 'path';
 const log = createConsoleLogger('autogenerate');
-const noirContractsRoot = '../../noir-projects/noir-contracts';
-const srcPath = path.join(noirContractsRoot, './target');
+const artifactsPkgRoot = path.dirname(fileURLToPath(import.meta.resolve('@aztec/protocol-contracts-artifacts/package.json')));
+const srcPath = path.join(artifactsPkgRoot, 'artifacts');
 const destArtifactsDir = './artifacts';
 const outputFilePath = './src/protocol_contract_data.ts';
 const salt = new Fr(1);
 const contractAddressMapping = {
-    AuthRegistry: CANONICAL_AUTH_REGISTRY_ADDRESS,
     ContractInstanceRegistry: CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
     ContractClassRegistry: CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
-    MultiCallEntrypoint: MULTI_CALL_ENTRYPOINT_ADDRESS,
-    FeeJuice: FEE_JUICE_ADDRESS,
-    PublicChecks: PUBLIC_CHECKS_ADDRESS
+    FeeJuice: FEE_JUICE_ADDRESS
 };
 async function clearDestDir() {
     try {
@@ -63,10 +61,11 @@ async function computeContractData(artifact, deployer) {
     const constructorArtifact = loaded.functions.find((f)=>f.name === 'constructor');
     const initializationHash = await computeInitializationHash(constructorArtifact, []);
     const instance = {
-        version: 1,
+        version: 2,
         currentContractClassId: contractClass.id,
         originalContractClassId: contractClass.id,
         initializationHash,
+        immutablesHash: Fr.ZERO,
         publicKeys: PublicKeys.default(),
         salt,
         deployer
@@ -107,7 +106,7 @@ function generateSalts(names) {
   `;
 }
 function generateContractAddresses(names) {
-    const addresses = names.map((name)=>`${name}: AztecAddress.fromBigInt(${contractAddressMapping[name]}n)`).join(',\n');
+    const addresses = names.map((name)=>`${name}: AztecAddress.fromBigIntUnsafe(${contractAddressMapping[name]}n)`).join(',\n');
     return `
     export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress> = {
       ${addresses}
@@ -117,7 +116,7 @@ function generateContractAddresses(names) {
 function generateDerivedAddresses(names, contractData) {
     return `
     export const ProtocolContractDerivedAddress = {
-      ${contractData.map((d, i)=>`${names[i]}: AztecAddress.fromString('${d.address.toString()}')`).join(',\n')}
+      ${contractData.map((d, i)=>`${names[i]}: AztecAddress.fromStringUnsafe('${d.address.toString()}')`).join(',\n')}
     };
   `;
 }
@@ -157,7 +156,7 @@ async function generateProtocolContractsList(names, contractData) {
     }
     return `
     export const ProtocolContractsList = new ProtocolContracts([
-      ${list.map((address)=>`AztecAddress.fromString('${address.toString()}')`).join(',\n')}
+      ${list.map((address)=>`AztecAddress.fromStringUnsafe('${address.toString()}')`).join(',\n')}
     ]);
 
     export const protocolContractsHash = Fr.fromString('${(await new ProtocolContracts(list).hash()).toString()}');
@@ -195,7 +194,7 @@ async function generateOutputFile(names, contractData) {
 }
 async function main() {
     await clearDestDir();
-    const srcNames = JSON.parse(await fs.readFile(path.join(noirContractsRoot, 'protocol_contracts.json'), 'utf8'));
+    const srcNames = JSON.parse(await fs.readFile(path.join(artifactsPkgRoot, 'protocol_contracts.json'), 'utf8'));
     const contractDataList = [];
     const destNames = srcNames.map((n)=>n.split('-')[1]);
     for(let i = 0; i < srcNames.length; i++){
@@ -203,7 +202,7 @@ async function main() {
         const destName = destNames[i];
         const artifact = await copyArtifact(srcName, destName);
         await generateDeclarationFile(destName);
-        contractDataList.push(await computeContractData(artifact, AztecAddress.fromBigInt(BigInt(contractAddressMapping[destName]))));
+        contractDataList.push(await computeContractData(artifact, AztecAddress.fromBigIntUnsafe(BigInt(contractAddressMapping[destName]))));
     }
     await generateOutputFile(destNames, contractDataList);
 }

package/dest/tests/fixtures.d.ts

@@ -1,6 +1,4 @@
 export declare function getSampleContractClassPublishedEventPayload(): Buffer;
-export declare function getSamplePrivateFunctionBroadcastedEventPayload(): Buffer;
-export declare function getSampleUtilityFunctionBroadcastedEventPayload(): Buffer;
 export declare function getSampleContractInstancePublishedEventPayload(): Buffer;
 export declare function getPathToFixture(name: string): string;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0cy9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSx3QkFBZ0IsMkNBQTJDLElBQUksTUFBTSxDQUdwRTtBQUdELHdCQUFnQiwrQ0FBK0MsSUFBSSxNQUFNLENBR3hFO0FBR0Qsd0JBQWdCLCtDQUErQyxJQUFJLE1BQU0sQ0FHeEU7QUFHRCx3QkFBZ0IsOENBQThDLElBQUksTUFBTSxDQUd2RTtBQUVELHdCQUFnQixnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsTUFBTSxVQUU1QyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0cy9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSx3QkFBZ0IsMkNBQTJDLElBQUksTUFBTSxDQUdwRTtBQUdELHdCQUFnQiw4Q0FBOEMsSUFBSSxNQUFNLENBR3ZFO0FBRUQsd0JBQWdCLGdCQUFnQixDQUFDLElBQUksRUFBRSxNQUFNLFVBRTVDIn0=

package/dest/tests/fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/tests/fixtures.ts"],"names":[],"mappings":"AAKA,wBAAgB,2CAA2C,IAAI,MAAM,CAGpE;AAGD,wBAAgB,+CAA+C,IAAI,MAAM,CAGxE;AAGD,wBAAgB,+CAA+C,IAAI,MAAM,CAGxE;AAGD,wBAAgB,8CAA8C,IAAI,MAAM,CAGvE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,UAE5C"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/tests/fixtures.ts"],"names":[],"mappings":"AAKA,wBAAgB,2CAA2C,IAAI,MAAM,CAGpE;AAGD,wBAAgB,8CAA8C,IAAI,MAAM,CAGvE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,UAE5C"}

package/dest/tests/fixtures.js

@@ -1,22 +1,12 @@
 import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-// Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
+// Generated from end-to-end/src/automine/contracts/deploy/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
 export function getSampleContractClassPublishedEventPayload() {
     const path = getPathToFixture('ContractClassPublishedEventData.hex');
     return Buffer.from(readFileSync(path).toString(), 'hex');
 }
-// Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
-export function getSamplePrivateFunctionBroadcastedEventPayload() {
-    const path = getPathToFixture('PrivateFunctionBroadcastedEventData.hex');
-    return Buffer.from(readFileSync(path).toString(), 'hex');
-}
-// Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
-export function getSampleUtilityFunctionBroadcastedEventPayload() {
-    const path = getPathToFixture('UtilityFunctionBroadcastedEventData.hex');
-    return Buffer.from(readFileSync(path).toString(), 'hex');
-}
-// Generated from end-to-end/src/e2e_deploy_contract/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
+// Generated from end-to-end/src/automine/contracts/deploy/contract_class_registration.test.ts with AZTEC_GENERATE_TEST_DATA=1
 export function getSampleContractInstancePublishedEventPayload() {
     const path = getPathToFixture('ContractInstancePublishedEventData.hex');
     return Buffer.from(readFileSync(path).toString(), 'hex');

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.1-commit.993d52e",
+  "version": "0.0.1-commit.9a89641",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -73,14 +73,15 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.993d52e",
-    "@aztec/foundation": "0.0.1-commit.993d52e",
-    "@aztec/stdlib": "0.0.1-commit.993d52e",
+    "@aztec/constants": "0.0.1-commit.9a89641",
+    "@aztec/foundation": "0.0.1-commit.9a89641",
+    "@aztec/stdlib": "0.0.1-commit.9a89641",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
+    "@aztec/protocol-contracts-artifacts": "6.0.0-nightly.20260807",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.chunk": "^4.2.9",

package/src/class-registry/contract_class_published_event.ts

@@ -4,7 +4,7 @@ import { FieldReader } from '@aztec/foundation/serialize';
 import { bufferFromFields } from '@aztec/stdlib/abi';
 import {
   type ContractClassPublic,
-  computeContractClassId,
+  type ContractClassPublicWithCommitment,
   computePublicBytecodeCommitment,
 } from '@aztec/stdlib/contract';
 import type { ContractClassLog } from '@aztec/stdlib/logs';
@@ -29,14 +29,19 @@ export class ContractClassPublishedEvent {
   }
 
   static fromLog(log: ContractClassLog) {
-    // See how the log is serialized in `noir-projects/noir-contracts/contracts/protocol/contract_class_registry_contract/src/events/class_published.nr`.
+    // See how the log is serialized in `noir-projects/fnd/noir-contracts/contracts/protocol/contract_class_registry_contract/src/events/class_published.nr`.
     const fieldsWithoutTag = log.fields.fields.slice(1);
     const reader = new FieldReader(fieldsWithoutTag);
     const contractClassId = reader.readField();
     const version = reader.readField().toNumber();
     const artifactHash = reader.readField();
     const privateFunctionsRoot = reader.readField();
-    const packedPublicBytecode = bufferFromFields(reader.readFieldArray(fieldsWithoutTag.length - reader.cursor));
+    const bytecodeFields = reader.readFieldArray(fieldsWithoutTag.length - reader.cursor);
+    // The fixed-size class log can hold at most this many packed-bytecode bytes (every payload field
+    // carries 31 bytes). Bound the declared length to it so a malformed log can't declare a multi-MiB
+    // length backed by a tiny payload and force a large allocation during early (pre-proof) validation.
+    const maxByteLength = (bytecodeFields.length - 1) * (Fr.SIZE_IN_BYTES - 1);
+    const packedPublicBytecode = bufferFromFields(bytecodeFields, maxByteLength);
 
     return new ContractClassPublishedEvent(
       contractClassId,
@@ -47,34 +52,23 @@ export class ContractClassPublishedEvent {
     );
   }
 
-  async toContractClassPublic(): Promise<ContractClassPublic> {
-    const computedClassId = await computeContractClassId({
-      artifactHash: this.artifactHash,
-      privateFunctionsRoot: this.privateFunctionsRoot,
-      publicBytecodeCommitment: await computePublicBytecodeCommitment(this.packedPublicBytecode),
-    });
-
-    if (!computedClassId.equals(this.contractClassId)) {
-      throw new Error(
-        `Invalid contract class id: computed ${computedClassId.toString()} but event broadcasted ${this.contractClassId.toString()}`,
-      );
-    }
-
-    if (this.version !== 1) {
-      throw new Error(`Unexpected contract class version ${this.version}`);
-    }
-
+  /** Converts the event to a contract class, without computing or validating the bytecode commitment. */
+  toContractClassPublic(): ContractClassPublic {
     return {
       id: this.contractClassId,
       artifactHash: this.artifactHash,
       packedBytecode: this.packedPublicBytecode,
       privateFunctionsRoot: this.privateFunctionsRoot,
-      version: this.version,
-      privateFunctions: [],
-      utilityFunctions: [],
+      version: this.version as 1,
     };
   }
 
+  /** Converts the event to a contract class with its bytecode commitment (expensive). */
+  async toContractClassPublicWithBytecodeCommitment(): Promise<ContractClassPublicWithCommitment> {
+    const publicBytecodeCommitment = await computePublicBytecodeCommitment(this.packedPublicBytecode);
+    return { ...this.toContractClassPublic(), publicBytecodeCommitment };
+  }
+
   public static extractContractClassEvents(logs: ContractClassLog[]): ContractClassPublishedEvent[] {
     return logs
       .filter((log: ContractClassLog) => ContractClassPublishedEvent.isContractClassPublishedEvent(log))

package/src/class-registry/index.ts

@@ -6,8 +6,6 @@ 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';
 
 export const ContractClassRegistryArtifact = loadContractArtifact(ContractClassRegistryJson as NoirCompiledContract);
 

package/src/class-registry/lazy.ts

@@ -4,8 +4,6 @@ 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;
@@ -14,7 +12,7 @@ export async function getContractClassRegistryArtifact(): Promise<ContractArtifa
   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
+    // Even if now supported by all 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');

package/src/fee-juice/lazy.ts

@@ -10,7 +10,7 @@ export async function getFeeJuiceArtifact(): 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
+    // Even if now supported by all 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');

package/src/instance-registry/contract_instance_published_event.ts

@@ -15,6 +15,7 @@ export class ContractInstancePublishedEvent {
     public readonly salt: Fr,
     public readonly contractClassId: Fr,
     public readonly initializationHash: Fr,
+    public readonly immutablesHash: Fr,
     public readonly publicKeys: PublicKeys,
     public readonly deployer: AztecAddress,
   ) {}
@@ -31,6 +32,7 @@ export class ContractInstancePublishedEvent {
     const salt = reader.readObject(Fr);
     const contractClassId = reader.readObject(Fr);
     const initializationHash = reader.readObject(Fr);
+    const immutablesHash = reader.readObject(Fr);
     const publicKeys = reader.readObject(PublicKeys);
     const deployer = reader.readObject(AztecAddress);
 
@@ -40,13 +42,14 @@ export class ContractInstancePublishedEvent {
       salt,
       contractClassId,
       initializationHash,
+      immutablesHash,
       publicKeys,
       deployer,
     );
   }
 
   toContractInstance(): ContractInstanceWithAddress {
-    if (this.version !== 1) {
+    if (this.version !== 2) {
       throw new Error(`Unexpected contract instance version ${this.version}`);
     }
 
@@ -56,6 +59,7 @@ export class ContractInstancePublishedEvent {
       currentContractClassId: this.contractClassId,
       originalContractClassId: this.contractClassId,
       initializationHash: this.initializationHash,
+      immutablesHash: this.immutablesHash,
       publicKeys: this.publicKeys,
       salt: this.salt,
       deployer: this.deployer,

package/src/instance-registry/lazy.ts

@@ -13,7 +13,7 @@ export async function getContractInstanceRegistryArtifact(): Promise<ContractArt
   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
+    // Even if now supported by all major browsers, the MIME type is replaced with
     // "text/javascript"
     // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
     const { default: contractInstanceRegistryJson } = await import('../../artifacts/ContractInstanceRegistry.json');

package/src/make_protocol_contract.ts

@@ -1,3 +1,4 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
@@ -34,10 +35,11 @@ export function makeProtocolContract(name: ProtocolContractName, artifact: Contr
   };
 
   const instance = {
-    version: 1 as const,
+    version: 2 as const,
     currentContractClassId: classId,
     originalContractClassId: classId,
     initializationHash,
+    immutablesHash: Fr.ZERO, // Protocol Contracts Have No Immutables
     publicKeys: PublicKeys.default(),
     salt,
     deployer: address,

package/src/protocol_contract.ts

@@ -1,8 +1,9 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 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';
+import { ProtocolContractAddress, ProtocolContractClassId } from './protocol_contract_data.js';
 
 /** Represents a canonical contract in the protocol. */
 export interface ProtocolContract {
@@ -20,4 +21,11 @@ export function isProtocolContract(address: AztecAddress) {
   return Object.values(ProtocolContractAddress).some(a => a.equals(address));
 }
 
+const protocolContractClassIds = new Set(Object.values(ProtocolContractClassId).map(id => id.toString()));
+
+/** Returns whether the given contract class id belongs to a bundled protocol contract. */
+export function isProtocolContractClass(classId: Fr): boolean {
+  return protocolContractClassIds.has(classId.toString());
+}
+
 export { type ProtocolContractsProvider } from './provider/protocol_contracts_provider.js';

package/src/protocol_contract_data.ts

@@ -7,12 +7,9 @@
 
     
     export const protocolContractNames = [
-      'AuthRegistry',
-'ContractInstanceRegistry',
+      'ContractInstanceRegistry',
 'ContractClassRegistry',
-'MultiCallEntrypoint',
-'FeeJuice',
-'PublicChecks'
+'FeeJuice'
     ] as const;
 
     export type ProtocolContractName = typeof protocolContractNames[number];
@@ -20,115 +17,82 @@
 
     
     export const ProtocolContractSalt: Record<ProtocolContractName, Fr> = {
-      AuthRegistry: new Fr(1),
-ContractInstanceRegistry: new Fr(1),
+      ContractInstanceRegistry: new Fr(1),
 ContractClassRegistry: new Fr(1),
-MultiCallEntrypoint: new Fr(1),
-FeeJuice: new Fr(1),
-PublicChecks: new Fr(1)
+FeeJuice: new Fr(1)
     };
   
 
     
     export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress> = {
-      AuthRegistry: AztecAddress.fromBigInt(1n),
-ContractInstanceRegistry: AztecAddress.fromBigInt(2n),
-ContractClassRegistry: AztecAddress.fromBigInt(3n),
-MultiCallEntrypoint: AztecAddress.fromBigInt(4n),
-FeeJuice: AztecAddress.fromBigInt(5n),
-PublicChecks: AztecAddress.fromBigInt(6n)
+      ContractInstanceRegistry: AztecAddress.fromBigIntUnsafe(2n),
+ContractClassRegistry: AztecAddress.fromBigIntUnsafe(1n),
+FeeJuice: AztecAddress.fromBigIntUnsafe(3n)
     };
   
 
     
     export const ProtocolContractDerivedAddress = {
-      AuthRegistry: AztecAddress.fromString('0x139f8eb6d6e7e7a7c0322c3b7558687a7e24201f11bf2c4cb2fe56c18d363695'),
-ContractInstanceRegistry: AztecAddress.fromString('0x1254246c88aca5a66fa66f3aa78c408a698ebca3b713120497c7555dfc718592'),
-ContractClassRegistry: AztecAddress.fromString('0x14d670efa326a07b99777b01fb706427ca776095246569150f2a3f17a7d4dc66'),
-MultiCallEntrypoint: AztecAddress.fromString('0x230d0b47ba6d5ed99afb89d584f32ff33438b64f51000f252a140cf995781628'),
-FeeJuice: AztecAddress.fromString('0x204913186c0dd70015d05bf9100a12e31ccb7cc2527aacdfae0c19ad6439fcf4'),
-PublicChecks: AztecAddress.fromString('0x1198142fd84a58c0ab22d5fde371ce527042db49487e05206a326ad154952ac8')
+      ContractInstanceRegistry: AztecAddress.fromStringUnsafe('0x2ce1dfe11c45332d557e8302d624b011eb471f0dfa40d2fae64d9fb21590321b'),
+ContractClassRegistry: AztecAddress.fromStringUnsafe('0x1bbb52d2b4ac8c634f4b5026f2228580627c918895c369495f71caae13d996fe'),
+FeeJuice: AztecAddress.fromStringUnsafe('0x258a4892dd83d064f6f250601711a82a7b2aaa20f39dbab216237af3ae0c63f2')
     };
   
 
     
     export const ProtocolContractClassId: Record<ProtocolContractName, Fr> = {
-      AuthRegistry: Fr.fromString('0x17ad10e1b5dba2877b9a973449c03d5227f2c719c0eb1989427c10c1d83867a5'),
-ContractInstanceRegistry: Fr.fromString('0x187c710b0d69b2da7a6f0663c15093a5d595c04e77762c249aa9b654bc12158c'),
-ContractClassRegistry: Fr.fromString('0x013466b8a65dea98ad80c119cf236a0acf53acfede687769410cfd57876b8242'),
-MultiCallEntrypoint: Fr.fromString('0x1acd7ab8bf186c16eafc9c4fe9049f35df27e172bb2d8319a2a22ddd0006966d'),
-FeeJuice: Fr.fromString('0x16b2d5ef5044c11126a16ccdb3778082eb423375977da9458d493fdf84505e81'),
-PublicChecks: Fr.fromString('0x03f2ebaef8d692422185e35d8fe35d0bb7289702cf023b525c022d77fc6b5ed5')
+      ContractInstanceRegistry: Fr.fromString('0x265816820ef83a476c1725199f5b25fefffcf30d564b31ae95fa8eeee579aa30'),
+ContractClassRegistry: Fr.fromString('0x0026d0944a8b8204b840c37cf238b145bdd6b1af9daf59eeb5e689022a708e5e'),
+FeeJuice: Fr.fromString('0x2a58e1588a3ee6ef0d4c951051959789ec8a3680c551f74148f4b4dab7a3df9d')
     };
 
     export const ProtocolContractClassIdPreimage: Record<ProtocolContractName, { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }> = {
-      AuthRegistry: {
-        artifactHash: Fr.fromString('0x029f3b5582e9e2f9cddb4f887fa67c06d8dbe9aef604aa7de91a6f5328bf477c'),
-        privateFunctionsRoot: Fr.fromString('0x0826df9bf86cf460935b2bd024edcb5a58532fcf0392abbdb33f5f2150753756'),
-        publicBytecodeCommitment: Fr.fromString('0x22db1f0a70bfefaf90371c7728e558cf60507b718e99ed276ed3143bec615f6f'),
-      },
-ContractInstanceRegistry: {
-        artifactHash: Fr.fromString('0x18601566bacdca7a5a40528f221b04ee7b74f382e6cd34fbdf69d31c50d5ee88'),
-        privateFunctionsRoot: Fr.fromString('0x136a6705c7ad1d47f65cb881a56909d4c78d3fa8944f5b103734cd91e654ed63'),
-        publicBytecodeCommitment: Fr.fromString('0x01c573f470ba9a17d362c7dd5a28931c39432f9ce527555049c71432f895ad6c'),
+      ContractInstanceRegistry: {
+        artifactHash: Fr.fromString('0x19835337f0aee2e9042f3a0ae0d334bdb39ecb22794b40d2670d26b2ca72b98f'),
+        privateFunctionsRoot: Fr.fromString('0x05bb912d9d2871492d76c610472544d8219df70aa874768f9667e99861d7971f'),
+        publicBytecodeCommitment: Fr.fromString('0x1a226919cd754b17c3c32ad430ecb2ce41117aa6bab5d52f070d3ab4c103c45f'),
       },
 ContractClassRegistry: {
-        artifactHash: Fr.fromString('0x232d868db8a4d1e0f013efa4bfe5c39d96e11f16a62e3e73abbbafc3028fc410'),
-        privateFunctionsRoot: Fr.fromString('0x2ac3bf890a7d534a768079aa86889caa1a86373c8e6fc2db48215b11bbb79106'),
-        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
-      },
-MultiCallEntrypoint: {
-        artifactHash: Fr.fromString('0x0d30526b6b786cf887d7e44ba59d2e9561d5791b0e3c78c681d0499ae45b225a'),
-        privateFunctionsRoot: Fr.fromString('0x266505ecb7c02ce6e227227c0b6bdb44713c8ecd43164ee7bb00b8fb340e8b03'),
+        artifactHash: Fr.fromString('0x0d0ef0a61d9c829c306eee702aa7914299d58e7d3fc9f11d5aebd38c838fa1d0'),
+        privateFunctionsRoot: Fr.fromString('0x119c77be6d76c221642b63a337d94bf7b6ed8f872927ef3645c7e6b5002baa34'),
         publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e'),
       },
 FeeJuice: {
-        artifactHash: Fr.fromString('0x2eb476f12cce5207be118047fb7f603378b78aa619d6539a4d9eec4700ea2507'),
-        privateFunctionsRoot: Fr.fromString('0x0abef3cfc6ae314886c841b42dc33d3eed255ad3dee7773daabf05b229573759'),
-        publicBytecodeCommitment: Fr.fromString('0x2a144b28b36efa21b7488467aba7e06b33e016d00bfe083a7bfa06ad6ff5aa2f'),
-      },
-PublicChecks: {
-        artifactHash: Fr.fromString('0x228ea8af66ff150f40a4b01b64115d12777b2f7fd3a4bfc0d97d38a91f139ef6'),
-        privateFunctionsRoot: Fr.fromString('0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1'),
-        publicBytecodeCommitment: Fr.fromString('0x2d0834fc9468fd2092091852543a2fbd7b6b313c7e5e4defe8730c8065366a03'),
+        artifactHash: Fr.fromString('0x2686d931d674aa3a340ad779b9464901ea46b645570f62ddf6beeafcab989e5b'),
+        privateFunctionsRoot: Fr.fromString('0x1c4bf54a4a33e3b9eae6f816dfc81e128d76d2646807a5443598c8adbd47f81f'),
+        publicBytecodeCommitment: Fr.fromString('0x1d4b1a8f71b8250d4fb65f8e16a4604e9165648279f47d80e024ce2684c4bdfb'),
       }
     };
 
     export const ProtocolContractInitializationHash: Record<ProtocolContractName, Fr> = {
-      AuthRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-ContractInstanceRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+      ContractInstanceRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
 ContractClassRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-MultiCallEntrypoint: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-FeeJuice: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-PublicChecks: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+FeeJuice: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
     };
 
     export const ProtocolContractPrivateFunctions: Record<ProtocolContractName, { selector: FunctionSelector; vkHash: Fr }[]> = {
-      AuthRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000079a3d418')), vkHash: Fr.fromString('0x019c553854290b9b547841e45bf45e344d4a2d4f6702fee430ec5897ce7d3b78') }],
-ContractInstanceRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000016ec12aa')), vkHash: Fr.fromString('0x262f7a90ecf055779001b67dad01a3add1e549f6c27931f0e71e463ce2142b57') }],
-ContractClassRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x000000000000000000000000000000000000000000000000000000006934ed0d')), vkHash: Fr.fromString('0x1163f31e191528254c877fce0c7f62dd738f5552bbd2dda97512fe4777377f5b') }],
-MultiCallEntrypoint: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000f04908a9')), vkHash: Fr.fromString('0x21732ab3cecf633e4c31a030df62c93e35a005b89941fdab568d2818c1355192') }],
-FeeJuice: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000cbe67243')), vkHash: Fr.fromString('0x2ad6083b4595f8076c014e5152191013167ab1b5a31ad0cbb06490054c7c59ae') }, { selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000e8d374b6')), vkHash: Fr.fromString('0x05aaffffdf797625ff24575d939339303775c5db77fb6bdcecbf955f726fd071') }],
-PublicChecks: []
+      ContractInstanceRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000077cff62f')), vkHash: Fr.fromString('0x19172c0acecd517dd8995c2e36178ca2aa16cbe001c3606d8cd848776ab80d23') }],
+ContractClassRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x000000000000000000000000000000000000000000000000000000006934ed0d')), vkHash: Fr.fromString('0x1241fdbf61631c59b977bb6a520cafe3169604036705b8680dea59f05fb71251') }],
+FeeJuice: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000cbe67243')), vkHash: Fr.fromString('0x0bdf2e5c4467f295f8defb436546a7f2e642e7fe75786d0d54aef497b76527a1') }, { selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000e8d374b6')), vkHash: Fr.fromString('0x2616a94d2d2981737c31ed7d74b9fd32ddc8376bf436dd60fb2507662b47c6dd') }]
     };
   
 
     
     export const ProtocolContractsList = new ProtocolContracts([
-      AztecAddress.fromString('0x139f8eb6d6e7e7a7c0322c3b7558687a7e24201f11bf2c4cb2fe56c18d363695'),
-AztecAddress.fromString('0x1254246c88aca5a66fa66f3aa78c408a698ebca3b713120497c7555dfc718592'),
-AztecAddress.fromString('0x14d670efa326a07b99777b01fb706427ca776095246569150f2a3f17a7d4dc66'),
-AztecAddress.fromString('0x230d0b47ba6d5ed99afb89d584f32ff33438b64f51000f252a140cf995781628'),
-AztecAddress.fromString('0x204913186c0dd70015d05bf9100a12e31ccb7cc2527aacdfae0c19ad6439fcf4'),
-AztecAddress.fromString('0x1198142fd84a58c0ab22d5fde371ce527042db49487e05206a326ad154952ac8'),
-AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+      AztecAddress.fromStringUnsafe('0x1bbb52d2b4ac8c634f4b5026f2228580627c918895c369495f71caae13d996fe'),
+AztecAddress.fromStringUnsafe('0x2ce1dfe11c45332d557e8302d624b011eb471f0dfa40d2fae64d9fb21590321b'),
+AztecAddress.fromStringUnsafe('0x258a4892dd83d064f6f250601711a82a7b2aaa20f39dbab216237af3ae0c63f2'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
+AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000')
     ]);
 
-    export const protocolContractsHash = Fr.fromString('0x2672340d9a0107a7b81e6d10d25b854debe613f3272e8738e8df0ca2ff297141');
+    export const protocolContractsHash = Fr.fromString('0x08d0026a4983c49638d0910859942c6648d5ea0a3a152c8a376e4983d0a003d9');
   
 
     

package/src/provider/bundle.ts

@@ -1,23 +1,17 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 
-import { AuthRegistryArtifact } from '../auth-registry/index.js';
 import { ContractClassRegistryArtifact } from '../class-registry/index.js';
 import { FeeJuiceArtifact } from '../fee-juice/index.js';
 import { ContractInstanceRegistryArtifact } from '../instance-registry/index.js';
 import { makeProtocolContract } from '../make_protocol_contract.js';
-import { MultiCallEntrypointArtifact } from '../multi-call-entrypoint/index.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 import type { ProtocolContractName } from '../protocol_contract_data.js';
-import { PublicChecksArtifact } from '../public-checks/index.js';
 import type { ProtocolContractsProvider } from './protocol_contracts_provider.js';
 
 export const ProtocolContractArtifact: Record<ProtocolContractName, ContractArtifact> = {
-  AuthRegistry: AuthRegistryArtifact,
   ContractInstanceRegistry: ContractInstanceRegistryArtifact,
   ContractClassRegistry: ContractClassRegistryArtifact,
-  MultiCallEntrypoint: MultiCallEntrypointArtifact,
   FeeJuice: FeeJuiceArtifact,
-  PublicChecks: PublicChecksArtifact,
 };
 
 export class BundledProtocolContractsProvider implements ProtocolContractsProvider {

package/src/provider/lazy.ts

@@ -1,28 +1,19 @@
-import { getCanonicalAuthRegistry } from '../auth-registry/lazy.js';
 import { getCanonicalClassRegistry } from '../class-registry/lazy.js';
 import { getCanonicalFeeJuice } from '../fee-juice/lazy.js';
 import { getCanonicalInstanceRegistry } from '../instance-registry/lazy.js';
-import { getCanonicalMultiCallEntrypoint } from '../multi-call-entrypoint/lazy.js';
 import type { ProtocolContract } from '../protocol_contract.js';
 import type { ProtocolContractName } from '../protocol_contract_data.js';
-import { getCanonicalPublicChecks } from '../public-checks/lazy.js';
 import type { ProtocolContractsProvider } from './protocol_contracts_provider.js';
 
 export class LazyProtocolContractsProvider implements ProtocolContractsProvider {
   getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract> {
     switch (name) {
-      case 'AuthRegistry':
-        return getCanonicalAuthRegistry();
       case 'ContractInstanceRegistry':
         return getCanonicalInstanceRegistry();
       case 'ContractClassRegistry':
         return getCanonicalClassRegistry();
-      case 'MultiCallEntrypoint':
-        return getCanonicalMultiCallEntrypoint();
       case 'FeeJuice':
         return getCanonicalFeeJuice();
-      case 'PublicChecks':
-        return getCanonicalPublicChecks();
       default:
         throw new Error(`Unknown protocol contract name: ${name}`);
     }