@aztec/protocol-contracts 0.0.1-commit.a072138 → 0.0.1-commit.a4600f49

package/dest/protocol_contract_data.js

@@ -1,51 +1,91 @@
 // GENERATED FILE - DO NOT EDIT. RUN `yarn generate` or `yarn generate:data`
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { ProtocolContracts } from '@aztec/stdlib/tx';
 export const protocolContractNames = [
-    'AuthRegistry',
     'ContractInstanceRegistry',
     'ContractClassRegistry',
-    'MultiCallEntrypoint',
-    'FeeJuice',
-    'PublicChecks'
+    'FeeJuice'
 ];
 export const ProtocolContractSalt = {
-    AuthRegistry: 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 = {
-    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('0x074c384d4f465b02d655e0b5d1119c09ad02ffdbd85e1174868be44b6fa7f8e7'),
-    ContractInstanceRegistry: AztecAddress.fromString('0x05b5dd93ea27555718ec16888041897fc34e6029e76668bf8cc21480c7086525'),
-    ContractClassRegistry: AztecAddress.fromString('0x123f0f7a7d9b64be4841cc18f95de572cd93b3ab1dcd9b4c980a62b300e0ddb2'),
-    MultiCallEntrypoint: AztecAddress.fromString('0x2a8fc1cc2eeb9fcc6ff9afdb931f8145675f6bd9e0ec1ea07aab3281b1f42ed6'),
-    FeeJuice: AztecAddress.fromString('0x2f3092f023435793470f241cadf26ba66e422e6cebd9208482ea3a7f4b1bcffe'),
-    PublicChecks: AztecAddress.fromString('0x09234f39c502e335237149623d721d16cb5616ade2a2de33f57afe16921724d4')
+    ContractInstanceRegistry: AztecAddress.fromStringUnsafe('0x262381bdb818ed44505e217b6b02ecc37a1046edc6785b3caef6a86513d71058'),
+    ContractClassRegistry: AztecAddress.fromStringUnsafe('0x0f75f6277a8850d5f77139ea643de697009a1ab4666673553b908b247d514f0f'),
+    FeeJuice: AztecAddress.fromStringUnsafe('0x0aee027cb94b86007afb04f4378f4a2c1649e4642c72056896ba54819fbf5430')
+};
+export const ProtocolContractClassId = {
+    ContractInstanceRegistry: Fr.fromString('0x06900ee6077e08bc0bcf1be064f3dad67b58d46ca59a00c99e1ad1db425525c7'),
+    ContractClassRegistry: Fr.fromString('0x2cce985fc14d6fff65d3eed0435e037ed27039a6a86d3aab6a5bd2569b83ec70'),
+    FeeJuice: Fr.fromString('0x17c33630396638ccf890042352185bedae92c69d7db3ec4aece71b70bcb8a7a4')
+};
+export const ProtocolContractClassIdPreimage = {
+    ContractInstanceRegistry: {
+        artifactHash: Fr.fromString('0x1a45ee8878136dff02e310c2c62b875be7480494673f5dc2d4f963746b0dbd8d'),
+        privateFunctionsRoot: Fr.fromString('0x05bb912d9d2871492d76c610472544d8219df70aa874768f9667e99861d7971f'),
+        publicBytecodeCommitment: Fr.fromString('0x232a10bc23611d07c57c32110e6ad7accd088e861c4e167a17bd7433fec2f020')
+    },
+    ContractClassRegistry: {
+        artifactHash: Fr.fromString('0x2cbc206eed84dbb5fc5b5d34e223c8c26def6bf0eb4ef93a54936ef1d6be6bbb'),
+        privateFunctionsRoot: Fr.fromString('0x1226036210d1d3d19245a2fe913bd14c7d3922be9e551aa481189d9561ca23a2'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e')
+    },
+    FeeJuice: {
+        artifactHash: Fr.fromString('0x1a57ff2a8e653094229bd15c028683e08b2086dfeadecac4c6b950c383b3ae1d'),
+        privateFunctionsRoot: Fr.fromString('0x1c4bf54a4a33e3b9eae6f816dfc81e128d76d2646807a5443598c8adbd47f81f'),
+        publicBytecodeCommitment: Fr.fromString('0x1d4b1a8f71b8250d4fb65f8e16a4604e9165648279f47d80e024ce2684c4bdfb')
+    }
+};
+export const ProtocolContractInitializationHash = {
+    ContractInstanceRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+    ContractClassRegistry: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
+    FeeJuice: Fr.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+};
+export const ProtocolContractPrivateFunctions = {
+    ContractInstanceRegistry: [
+        {
+            selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000077cff62f')),
+            vkHash: Fr.fromString('0x19172c0acecd517dd8995c2e36178ca2aa16cbe001c3606d8cd848776ab80d23')
+        }
+    ],
+    ContractClassRegistry: [
+        {
+            selector: FunctionSelector.fromField(Fr.fromString('0x000000000000000000000000000000000000000000000000000000006934ed0d')),
+            vkHash: Fr.fromString('0x0609c8195389d9ff372c9788d314c1387c31a9a4b73dacad95b01f5e03956056')
+        }
+    ],
+    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('0x074c384d4f465b02d655e0b5d1119c09ad02ffdbd85e1174868be44b6fa7f8e7'),
-    AztecAddress.fromString('0x05b5dd93ea27555718ec16888041897fc34e6029e76668bf8cc21480c7086525'),
-    AztecAddress.fromString('0x123f0f7a7d9b64be4841cc18f95de572cd93b3ab1dcd9b4c980a62b300e0ddb2'),
-    AztecAddress.fromString('0x2a8fc1cc2eeb9fcc6ff9afdb931f8145675f6bd9e0ec1ea07aab3281b1f42ed6'),
-    AztecAddress.fromString('0x2f3092f023435793470f241cadf26ba66e422e6cebd9208482ea3a7f4b1bcffe'),
-    AztecAddress.fromString('0x09234f39c502e335237149623d721d16cb5616ade2a2de33f57afe16921724d4'),
-    AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-    AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-    AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-    AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000'),
-    AztecAddress.fromString('0x0000000000000000000000000000000000000000000000000000000000000000')
+    AztecAddress.fromStringUnsafe('0x0f75f6277a8850d5f77139ea643de697009a1ab4666673553b908b247d514f0f'),
+    AztecAddress.fromStringUnsafe('0x262381bdb818ed44505e217b6b02ecc37a1046edc6785b3caef6a86513d71058'),
+    AztecAddress.fromStringUnsafe('0x0aee027cb94b86007afb04f4378f4a2c1649e4642c72056896ba54819fbf5430'),
+    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('0x216f2a744c0a5c1cbb2b8f67a4f81050dbf7ace228ae1611ddc929340ea1009f');
-export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x1fac4c16bff9365b079923d46d85c86b4fcbb5c67c5c65febe8596599412b0ee');
+export const protocolContractsHash = Fr.fromString('0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b');
+export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x1a7e1badb79abdd38c684b3c8306ffe7ecb33c69e3380d9855730aaaa83a21a8');

package/dest/provider/bundle.d.ts

@@ -6,4 +6,4 @@ export declare const ProtocolContractArtifact: Record<ProtocolContractName, Cont
 export declare class BundledProtocolContractsProvider implements ProtocolContractsProvider {
     getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVuZGxlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXIvYnVuZGxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFRMUQsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRXpFLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFbEYsZUFBTyxNQUFNLHdCQUF3QixFQUFFLE1BQU0sQ0FBQyxvQkFBb0IsRUFBRSxnQkFBZ0IsQ0FPbkYsQ0FBQztBQUVGLHFCQUFhLGdDQUFpQyxZQUFXLHlCQUF5QjtJQUNoRiwyQkFBMkIsQ0FBQyxJQUFJLEVBQUUsb0JBQW9CLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBRWpGO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVuZGxlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXIvYnVuZGxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFNMUQsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3pFLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFbEYsZUFBTyxNQUFNLHdCQUF3QixFQUFFLE1BQU0sQ0FBQyxvQkFBb0IsRUFBRSxnQkFBZ0IsQ0FJbkYsQ0FBQztBQUVGLHFCQUFhLGdDQUFpQyxZQUFXLHlCQUF5QjtJQUNoRiwyQkFBMkIsQ0FBQyxJQUFJLEVBQUUsb0JBQW9CLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBRWpGO0NBQ0YifQ==

package/dest/provider/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/provider/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAQ1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAElF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,oBAAoB,EAAE,gBAAgB,CAOnF,CAAC;AAEF,qBAAa,gCAAiC,YAAW,yBAAyB;IAChF,2BAA2B,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAEjF;CACF"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/provider/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAM1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAElF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,oBAAoB,EAAE,gBAAgB,CAInF,CAAC;AAEF,qBAAa,gCAAiC,YAAW,yBAAyB;IAChF,2BAA2B,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAEjF;CACF"}

package/dest/provider/bundle.js

@@ -1,20 +1,14 @@
-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 { PublicChecksArtifact } from '../public-checks/index.js';
 export const ProtocolContractArtifact = {
-    AuthRegistry: AuthRegistryArtifact,
     ContractInstanceRegistry: ContractInstanceRegistryArtifact,
     ContractClassRegistry: ContractClassRegistryArtifact,
-    MultiCallEntrypoint: MultiCallEntrypointArtifact,
-    FeeJuice: FeeJuiceArtifact,
-    PublicChecks: PublicChecksArtifact
+    FeeJuice: FeeJuiceArtifact
 };
 export class BundledProtocolContractsProvider {
     getProtocolContractArtifact(name) {
-        return makeProtocolContract(name, ProtocolContractArtifact[name]);
+        return Promise.resolve(makeProtocolContract(name, ProtocolContractArtifact[name]));
     }
 }

package/dest/provider/lazy.d.ts

@@ -4,4 +4,4 @@ import type { ProtocolContractsProvider } from './protocol_contracts_provider.js
 export declare class LazyProtocolContractsProvider implements ProtocolContractsProvider {
     getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF6eS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3ZpZGVyL2xhenkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRXpFLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFbEYscUJBQWEsNkJBQThCLFlBQVcseUJBQXlCO0lBQzdFLDJCQUEyQixDQUFDLElBQUksRUFBRSxvQkFBb0IsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FpQmpGO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF6eS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3ZpZGVyL2xhenkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3pFLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFbEYscUJBQWEsNkJBQThCLFlBQVcseUJBQXlCO0lBQzdFLDJCQUEyQixDQUFDLElBQUksRUFBRSxvQkFBb0IsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FXakY7Q0FDRiJ9

package/dest/provider/lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/provider/lazy.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAElF,qBAAa,6BAA8B,YAAW,yBAAyB;IAC7E,2BAA2B,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAiBjF;CACF"}
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/provider/lazy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAElF,qBAAa,6BAA8B,YAAW,yBAAyB;IAC7E,2BAA2B,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAWjF;CACF"}

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

@@ -1,11 +1,16 @@
-import { CANONICAL_AUTH_REGISTRY_ADDRESS, CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, FEE_JUICE_ADDRESS, GeneratorIndex, MAX_PROTOCOL_CONTRACTS, MULTI_CALL_ENTRYPOINT_ADDRESS, PUBLIC_CHECKS_ADDRESS } from '@aztec/constants';
+// Reads compiled Noir artifacts for each protocol contract and derives their addresses, class IDs,
+// 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 { 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 { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createConsoleLogger } from '@aztec/foundation/log';
 import { loadContractArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import { computeContractAddressFromInstance, computeInitializationHash, getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { computeSiloedPrivateLogFirstField } from '@aztec/stdlib/hash';
+import { PublicKeys } from '@aztec/stdlib/keys';
 import { ProtocolContracts } from '@aztec/stdlib/tx';
 import { promises as fs } from 'fs';
 import path from 'path';
@@ -16,12 +21,9 @@ 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 {
@@ -50,11 +52,33 @@ async function copyArtifact(srcName, destName) {
     await fs.copyFile(src, dest);
     return artifact;
 }
-async function computeAddress(artifact) {
-    const instance = await getContractInstanceFromInstantiationParams(loadContractArtifact(artifact), {
-        salt
-    });
-    return instance.address;
+// Precompute all the expensive contract data that can be obtained from the artifact, to avoid redundant computations in clients.
+// Protocol contracts come from a trusted source, so no class verifications are needed.
+async function computeContractData(artifact, deployer) {
+    const loaded = loadContractArtifact(artifact);
+    const contractClass = await getContractClassFromArtifact(loaded);
+    const constructorArtifact = loaded.functions.find((f)=>f.name === 'constructor');
+    const initializationHash = await computeInitializationHash(constructorArtifact, []);
+    const instance = {
+        version: 2,
+        currentContractClassId: contractClass.id,
+        originalContractClassId: contractClass.id,
+        initializationHash,
+        immutablesHash: Fr.ZERO,
+        publicKeys: PublicKeys.default(),
+        salt,
+        deployer
+    };
+    const address = await computeContractAddressFromInstance(instance);
+    return {
+        address,
+        classId: contractClass.id,
+        artifactHash: contractClass.artifactHash,
+        privateFunctionsRoot: contractClass.privateFunctionsRoot,
+        publicBytecodeCommitment: contractClass.publicBytecodeCommitment,
+        initializationHash,
+        privateFunctions: contractClass.privateFunctions
+    };
 }
 async function generateDeclarationFile(destName) {
     const content = `
@@ -81,21 +105,44 @@ 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}
     };
   `;
 }
-function generateDerivedAddresses(names, derivedAddresses) {
+function generateDerivedAddresses(names, contractData) {
     return `
     export const ProtocolContractDerivedAddress = {
-      ${derivedAddresses.map((address, i)=>`${names[i]}: AztecAddress.fromString('${address.toString()}')`).join(',\n')}
+      ${contractData.map((d, i)=>`${names[i]}: AztecAddress.fromStringUnsafe('${d.address.toString()}')`).join(',\n')}
+    };
+  `;
+}
+function generateClassIdPreimages(names, contractData) {
+    return `
+    export const ProtocolContractClassId: Record<ProtocolContractName, Fr> = {
+      ${contractData.map((d, i)=>`${names[i]}: Fr.fromString('${d.classId.toString()}')`).join(',\n')}
+    };
+
+    export const ProtocolContractClassIdPreimage: Record<ProtocolContractName, { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }> = {
+      ${contractData.map((d, i)=>`${names[i]}: {
+        artifactHash: Fr.fromString('${d.artifactHash.toString()}'),
+        privateFunctionsRoot: Fr.fromString('${d.privateFunctionsRoot.toString()}'),
+        publicBytecodeCommitment: Fr.fromString('${d.publicBytecodeCommitment.toString()}'),
+      }`).join(',\n')}
+    };
+
+    export const ProtocolContractInitializationHash: Record<ProtocolContractName, Fr> = {
+      ${contractData.map((d, i)=>`${names[i]}: Fr.fromString('${d.initializationHash.toString()}')`).join(',\n')}
+    };
+
+    export const ProtocolContractPrivateFunctions: Record<ProtocolContractName, { selector: FunctionSelector; vkHash: Fr }[]> = {
+      ${contractData.map((d, i)=>`${names[i]}: [${d.privateFunctions.map((fn)=>`{ selector: FunctionSelector.fromField(Fr.fromString('${fn.selector.toField().toString()}')), vkHash: Fr.fromString('${fn.vkHash.toString()}') }`).join(', ')}]`).join(',\n')}
     };
   `;
 }
-async function generateProtocolContractsList(names, derivedAddresses) {
+async function generateProtocolContractsList(names, contractData) {
     const list = makeTuple(MAX_PROTOCOL_CONTRACTS, ()=>AztecAddress.zero());
     for(let i = 0; i < names.length; i++){
         const name = names[i];
@@ -104,11 +151,11 @@ async function generateProtocolContractsList(names, derivedAddresses) {
         if (!list[derivedAddressIndex].equals(AztecAddress.zero())) {
             throw new Error(`Duplicate protocol contract address: ${address.toString()}`);
         }
-        list[derivedAddressIndex] = derivedAddresses[i];
+        list[derivedAddressIndex] = contractData[i].address;
     }
     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()}');
@@ -117,16 +164,14 @@ async function generateProtocolContractsList(names, derivedAddresses) {
 // Generate the siloed log tags for events emitted via private logs.
 async function generateLogTags() {
     return `
-  export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('${await poseidon2HashWithSeparator([
-        CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE
-    ], GeneratorIndex.PRIVATE_LOG_FIRST_FIELD)}');
+  export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('${await computeSiloedPrivateLogFirstField(new AztecAddress(new Fr(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS)), new Fr(CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE))}');
   `;
 }
-async function generateOutputFile(names, derivedAddresses) {
+async function generateOutputFile(names, contractData) {
     const content = `
     // GENERATED FILE - DO NOT EDIT. RUN \`yarn generate\` or \`yarn generate:data\`
     import { Fr } from '@aztec/foundation/curves/bn254';
+    import { FunctionSelector } from '@aztec/stdlib/abi';
     import { AztecAddress } from '@aztec/stdlib/aztec-address';
     import { ProtocolContracts } from '@aztec/stdlib/tx';
 
@@ -136,9 +181,11 @@ async function generateOutputFile(names, derivedAddresses) {
 
     ${generateContractAddresses(names)}
 
-    ${generateDerivedAddresses(names, derivedAddresses)}
+    ${generateDerivedAddresses(names, contractData)}
+
+    ${generateClassIdPreimages(names, contractData)}
 
-    ${await generateProtocolContractsList(names, derivedAddresses)}
+    ${await generateProtocolContractsList(names, contractData)}
 
     ${await generateLogTags()}
   `;
@@ -147,16 +194,16 @@ async function generateOutputFile(names, derivedAddresses) {
 async function main() {
     await clearDestDir();
     const srcNames = JSON.parse(await fs.readFile(path.join(noirContractsRoot, 'protocol_contracts.json'), 'utf8'));
-    const derivedAddresses = [];
+    const contractDataList = [];
     const destNames = srcNames.map((n)=>n.split('-')[1]);
     for(let i = 0; i < srcNames.length; i++){
         const srcName = srcNames[i];
         const destName = destNames[i];
         const artifact = await copyArtifact(srcName, destName);
         await generateDeclarationFile(destName);
-        derivedAddresses.push(await computeAddress(artifact));
+        contractDataList.push(await computeContractData(artifact, AztecAddress.fromBigIntUnsafe(BigInt(contractAddressMapping[destName]))));
     }
-    await generateOutputFile(destNames, derivedAddresses);
+    await generateOutputFile(destNames, contractDataList);
 }
 try {
     await main();

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.a072138",
+  "version": "0.0.1-commit.a4600f49",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -73,9 +73,9 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.a072138",
-    "@aztec/foundation": "0.0.1-commit.a072138",
-    "@aztec/stdlib": "0.0.1-commit.a072138",
+    "@aztec/constants": "0.0.1-commit.a4600f49",
+    "@aztec/foundation": "0.0.1-commit.a4600f49",
+    "@aztec/stdlib": "0.0.1-commit.a4600f49",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"

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';
@@ -36,7 +36,12 @@ export class ContractClassPublishedEvent {
     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,18 +6,16 @@ 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);
 
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalClassRegistry(): Promise<ProtocolContract> {
+export function getCanonicalClassRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const artifact = ContractClassRegistryArtifact;
-    protocolContract = await makeProtocolContract('ContractClassRegistry', artifact);
+    protocolContract = makeProtocolContract('ContractClassRegistry', artifact);
   }
-  return protocolContract;
+  return Promise.resolve(protocolContract);
 }

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');
@@ -27,7 +25,7 @@ export async function getContractClassRegistryArtifact(): Promise<ContractArtifa
 export async function getCanonicalClassRegistry(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const contractClassRegistryArtifact = await getContractClassRegistryArtifact();
-    protocolContract = await makeProtocolContract('ContractClassRegistry', contractClassRegistryArtifact);
+    protocolContract = makeProtocolContract('ContractClassRegistry', contractClassRegistryArtifact);
   }
   return protocolContract;
 }

package/src/fee-juice/index.ts

@@ -14,11 +14,11 @@ export const FeeJuiceArtifact = loadContractArtifact(FeeJuiceJson as NoirCompile
 let protocolContract: ProtocolContract;
 
 /** Returns the canonical deployment of the contract. */
-export async function getCanonicalFeeJuice(): Promise<ProtocolContract> {
+export function getCanonicalFeeJuice(): Promise<ProtocolContract> {
   if (!protocolContract) {
-    protocolContract = await makeProtocolContract('FeeJuice', FeeJuiceArtifact);
+    protocolContract = makeProtocolContract('FeeJuice', FeeJuiceArtifact);
   }
-  return protocolContract;
+  return Promise.resolve(protocolContract);
 }
 
 /**

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');
@@ -23,7 +23,7 @@ export async function getFeeJuiceArtifact(): Promise<ContractArtifact> {
 export async function getCanonicalFeeJuice(): Promise<ProtocolContract> {
   if (!protocolContract) {
     const feeJuiceArtifact = await getFeeJuiceArtifact();
-    protocolContract = await makeProtocolContract('FeeJuice', feeJuiceArtifact);
+    protocolContract = makeProtocolContract('FeeJuice', feeJuiceArtifact);
   }
   return protocolContract;
 }