@aztec-labs/protocol-contracts 6.0.0-nightly.20260829

package/dest/protocol_contract_data.js

@@ -0,0 +1,91 @@
+// GENERATED FILE - DO NOT EDIT. RUN `yarn generate` or `yarn generate:data`
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FunctionSelector } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { ProtocolContracts } from '@aztec-labs/stdlib/tx';
+export const protocolContractNames = [
+    'ContractInstanceRegistry',
+    'ContractClassRegistry',
+    'FeeJuice'
+];
+export const ProtocolContractSalt = {
+    ContractInstanceRegistry: new Fr(1),
+    ContractClassRegistry: new Fr(1),
+    FeeJuice: new Fr(1)
+};
+export const ProtocolContractAddress = {
+    ContractInstanceRegistry: AztecAddress.fromBigIntUnsafe(2n),
+    ContractClassRegistry: AztecAddress.fromBigIntUnsafe(1n),
+    FeeJuice: AztecAddress.fromBigIntUnsafe(3n)
+};
+export const ProtocolContractDerivedAddress = {
+    ContractInstanceRegistry: AztecAddress.fromStringUnsafe('0x2d822c19c286cf1b249431a6c5ffb1864f627b469a6386574da83f44800d6c17'),
+    ContractClassRegistry: AztecAddress.fromStringUnsafe('0x1bbb52d2b4ac8c634f4b5026f2228580627c918895c369495f71caae13d996fe'),
+    FeeJuice: AztecAddress.fromStringUnsafe('0x1df1b0934b368c073f61d3cdb2de064766cd44ea4429f7920959f4a7758ef208')
+};
+export const ProtocolContractClassId = {
+    ContractInstanceRegistry: Fr.fromString('0x28d8b9fff43315ce084cbd127532c8a1bb562fe1f147aee518c2c8ca822dcd4a'),
+    ContractClassRegistry: Fr.fromString('0x0026d0944a8b8204b840c37cf238b145bdd6b1af9daf59eeb5e689022a708e5e'),
+    FeeJuice: Fr.fromString('0x013e4ae6015db998dabfe78684c8b9e2fe413d316b36395091f53b9ea40f15ed')
+};
+export const ProtocolContractClassIdPreimage = {
+    ContractInstanceRegistry: {
+        artifactHash: Fr.fromString('0x19835337f0aee2e9042f3a0ae0d334bdb39ecb22794b40d2670d26b2ca72b98f'),
+        privateFunctionsRoot: Fr.fromString('0x05bb912d9d2871492d76c610472544d8219df70aa874768f9667e99861d7971f'),
+        publicBytecodeCommitment: Fr.fromString('0x1fd8380bb220e7d13db681da7e62c93b03add6754895a84c51d13fcde03e8d25')
+    },
+    ContractClassRegistry: {
+        artifactHash: Fr.fromString('0x0d0ef0a61d9c829c306eee702aa7914299d58e7d3fc9f11d5aebd38c838fa1d0'),
+        privateFunctionsRoot: Fr.fromString('0x119c77be6d76c221642b63a337d94bf7b6ed8f872927ef3645c7e6b5002baa34'),
+        publicBytecodeCommitment: Fr.fromString('0x0ce4c618c3ed7f3a20410e618c06bb701e150af7fe28a3e92f68e7733809f33e')
+    },
+    FeeJuice: {
+        artifactHash: Fr.fromString('0x100f61126a468cb2c4b5bad99a769256f7944830ea7b396225975a8628bd37a6'),
+        privateFunctionsRoot: Fr.fromString('0x1c4bf54a4a33e3b9eae6f816dfc81e128d76d2646807a5443598c8adbd47f81f'),
+        publicBytecodeCommitment: Fr.fromString('0x2968eb109f722c701d59d171c32d32b79199841f0044d6bbd77dc43bd513a770')
+    }
+};
+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('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.fromStringUnsafe('0x1bbb52d2b4ac8c634f4b5026f2228580627c918895c369495f71caae13d996fe'),
+    AztecAddress.fromStringUnsafe('0x2d822c19c286cf1b249431a6c5ffb1864f627b469a6386574da83f44800d6c17'),
+    AztecAddress.fromStringUnsafe('0x1df1b0934b368c073f61d3cdb2de064766cd44ea4429f7920959f4a7758ef208'),
+    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('0x14cec0ae6f31e913c3be04691c6d49c3ec07b3f2d024c9558693ea62fc530bbf');
+export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x1a7e1badb79abdd38c684b3c8306ffe7ecb33c69e3380d9855730aaaa83a21a8');

package/dest/provider/bundle.d.ts

@@ -0,0 +1,9 @@
+import type { ContractArtifact } from '@aztec-labs/stdlib/abi';
+import type { ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContractName } from '../protocol_contract_data.js';
+import type { ProtocolContractsProvider } from './protocol_contracts_provider.js';
+export declare const ProtocolContractArtifact: Record<ProtocolContractName, ContractArtifact>;
+export declare class BundledProtocolContractsProvider implements ProtocolContractsProvider {
+    getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVuZGxlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXIvYnVuZGxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFNL0QsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3pFLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFbEYsZUFBTyxNQUFNLHdCQUF3QixFQUFFLE1BQU0sQ0FBQyxvQkFBb0IsRUFBRSxnQkFBZ0IsQ0FJbkYsQ0FBQztBQUVGLHFCQUFhLGdDQUFpQyxZQUFXLHlCQUF5QjtJQUNoRiwyQkFBMkIsQ0FBQyxJQUFJLEVBQUUsb0JBQW9CLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBRWpGO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/provider/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAM/D,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

@@ -0,0 +1,14 @@
+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';
+export const ProtocolContractArtifact = {
+    ContractInstanceRegistry: ContractInstanceRegistryArtifact,
+    ContractClassRegistry: ContractClassRegistryArtifact,
+    FeeJuice: FeeJuiceArtifact
+};
+export class BundledProtocolContractsProvider {
+    getProtocolContractArtifact(name) {
+        return Promise.resolve(makeProtocolContract(name, ProtocolContractArtifact[name]));
+    }
+}

package/dest/provider/lazy.d.ts

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,17 @@
+import { getCanonicalClassRegistry } from '../class-registry/lazy.js';
+import { getCanonicalFeeJuice } from '../fee-juice/lazy.js';
+import { getCanonicalInstanceRegistry } from '../instance-registry/lazy.js';
+export class LazyProtocolContractsProvider {
+    getProtocolContractArtifact(name) {
+        switch(name){
+            case 'ContractInstanceRegistry':
+                return getCanonicalInstanceRegistry();
+            case 'ContractClassRegistry':
+                return getCanonicalClassRegistry();
+            case 'FeeJuice':
+                return getCanonicalFeeJuice();
+            default:
+                throw new Error(`Unknown protocol contract name: ${name}`);
+        }
+    }
+}

package/dest/provider/protocol_contracts_provider.d.ts

@@ -0,0 +1,7 @@
+import type { ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContractName } from '../protocol_contract_data.js';
+/** Returns the canonical deployment of a given artifact. */
+export interface ProtocolContractsProvider {
+    getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdG9jb2xfY29udHJhY3RzX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXIvcHJvdG9jb2xfY29udHJhY3RzX3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUV6RSw0REFBNEQ7QUFDNUQsTUFBTSxXQUFXLHlCQUF5QjtJQUN4QywyQkFBMkIsQ0FBQyxJQUFJLEVBQUUsb0JBQW9CLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBQUM7Q0FDcEYifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocol_contracts_provider.d.ts","sourceRoot":"","sources":["../../src/provider/protocol_contracts_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,4DAA4D;AAC5D,MAAM,WAAW,yBAAyB;IACxC,2BAA2B,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACpF"}

package/dest/provider/protocol_contracts_provider.js

@@ -0,0 +1 @@
+/** Returns the canonical deployment of a given artifact. */ export { };

package/dest/scripts/cleanup_artifacts.js

@@ -0,0 +1,16 @@
+import { fileURLToPath } from '@aztec-labs/foundation/url';
+import { readFile, readdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+async function cleanupArtifacts(target) {
+    const files = await readdir(target);
+    for (const file of files){
+        if (!file.endsWith('.json')) {
+            continue;
+        }
+        const fileData = JSON.parse((await readFile(join(target, file), 'utf8')).toString());
+        /* eslint-disable camelcase */ fileData.file_map = {};
+        fileData.debug_symbols = {};
+        /* eslint-enable camelcase */ await writeFile(join(target, file), JSON.stringify(fileData));
+    }
+}
+await cleanupArtifacts(fileURLToPath(new URL('../../artifacts', import.meta.url).href));

package/dest/scripts/generate_data.js

@@ -0,0 +1,214 @@
+// 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-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createConsoleLogger } from '@aztec-labs/foundation/log';
+import { fileURLToPath } from '@aztec-labs/foundation/url';
+import { loadContractArtifact } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { computeContractAddressFromInstance, computeInitializationHash, getContractClassFromArtifact } from '@aztec-labs/stdlib/contract';
+import { computeSiloedPrivateLogFirstField } from '@aztec-labs/stdlib/hash';
+import { PublicKeys } from '@aztec-labs/stdlib/keys';
+import { ProtocolContracts } from '@aztec-labs/stdlib/tx';
+import { promises as fs } from 'fs';
+import path from 'path';
+const log = createConsoleLogger('autogenerate');
+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 = {
+    ContractInstanceRegistry: CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
+    ContractClassRegistry: CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
+    FeeJuice: FEE_JUICE_ADDRESS
+};
+async function clearDestDir() {
+    try {
+        await fs.access(destArtifactsDir);
+        // If the directory exists, remove it recursively.
+        await fs.rm(destArtifactsDir, {
+            recursive: true,
+            force: true,
+            maxRetries: 3
+        });
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+        // If the directory does not exist, do nothing.
+        } else {
+            log(`Error removing dest directory: ${err}`);
+        }
+    }
+    await fs.mkdir(destArtifactsDir, {
+        recursive: true
+    });
+}
+async function copyArtifact(srcName, destName) {
+    const src = path.join(srcPath, `${srcName}.json`);
+    const artifact = JSON.parse(await fs.readFile(src, 'utf8'));
+    const dest = path.join(destArtifactsDir, `${destName}.json`);
+    await fs.copyFile(src, dest);
+    return artifact;
+}
+// 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 = `
+    import type { NoirCompiledContract } from '@aztec-labs/stdlib/noir';
+    const circuit: NoirCompiledContract;
+    export = circuit;
+  `;
+    await fs.writeFile(path.join(destArtifactsDir, `${destName}.d.json.ts`), content);
+}
+function generateNames(names) {
+    return `
+    export const protocolContractNames = [
+      ${names.map((name)=>`'${name}'`).join(',\n')}
+    ] as const;
+
+    export type ProtocolContractName = typeof protocolContractNames[number];
+  `;
+}
+function generateSalts(names) {
+    return `
+    export const ProtocolContractSalt: Record<ProtocolContractName, Fr> = {
+      ${names.map((name)=>`${name}: new Fr(${salt.toNumber()})`).join(',\n')}
+    };
+  `;
+}
+function generateContractAddresses(names) {
+    const addresses = names.map((name)=>`${name}: AztecAddress.fromBigIntUnsafe(${contractAddressMapping[name]}n)`).join(',\n');
+    return `
+    export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress> = {
+      ${addresses}
+    };
+  `;
+}
+function generateDerivedAddresses(names, contractData) {
+    return `
+    export const ProtocolContractDerivedAddress = {
+      ${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, contractData) {
+    const list = makeTuple(MAX_PROTOCOL_CONTRACTS, ()=>AztecAddress.zero());
+    for(let i = 0; i < names.length; i++){
+        const name = names[i];
+        const address = contractAddressMapping[name];
+        const derivedAddressIndex = address - 1;
+        if (!list[derivedAddressIndex].equals(AztecAddress.zero())) {
+            throw new Error(`Duplicate protocol contract address: ${address.toString()}`);
+        }
+        list[derivedAddressIndex] = contractData[i].address;
+    }
+    return `
+    export const ProtocolContractsList = new ProtocolContracts([
+      ${list.map((address)=>`AztecAddress.fromStringUnsafe('${address.toString()}')`).join(',\n')}
+    ]);
+
+    export const protocolContractsHash = Fr.fromString('${(await new ProtocolContracts(list).hash()).toString()}');
+  `;
+}
+// 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 computeSiloedPrivateLogFirstField(new AztecAddress(new Fr(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS)), new Fr(CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE))}');
+  `;
+}
+async function generateOutputFile(names, contractData) {
+    const content = `
+    // GENERATED FILE - DO NOT EDIT. RUN \`yarn generate\` or \`yarn generate:data\`
+    import { Fr } from '@aztec-labs/foundation/curves/bn254';
+    import { FunctionSelector } from '@aztec-labs/stdlib/abi';
+    import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+    import { ProtocolContracts } from '@aztec-labs/stdlib/tx';
+
+    ${generateNames(names)}
+
+    ${generateSalts(names)}
+
+    ${generateContractAddresses(names)}
+
+    ${generateDerivedAddresses(names, contractData)}
+
+    ${generateClassIdPreimages(names, contractData)}
+
+    ${await generateProtocolContractsList(names, contractData)}
+
+    ${await generateLogTags()}
+  `;
+    await fs.writeFile(outputFilePath, content);
+}
+async function main() {
+    await clearDestDir();
+    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++){
+        const srcName = srcNames[i];
+        const destName = destNames[i];
+        const artifact = await copyArtifact(srcName, destName);
+        await generateDeclarationFile(destName);
+        contractDataList.push(await computeContractData(artifact, AztecAddress.fromBigIntUnsafe(BigInt(contractAddressMapping[destName]))));
+    }
+    await generateOutputFile(destNames, contractDataList);
+}
+try {
+    await main();
+} catch (err) {
+    log(`Error copying protocol contract artifacts: ${err}`);
+    process.exit(1);
+}

package/dest/tests/fixtures.d.ts

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,16 @@
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+// 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/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');
+}
+export function getPathToFixture(name) {
+    return resolve(dirname(fileURLToPath(import.meta.url)), `../../fixtures/${name}`);
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@aztec-labs/protocol-contracts",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/protocol-contracts",
+  "description": "Canonical Noir contracts for the Aztec Network",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./providers/bundle": "./dest/provider/bundle.js",
+    "./providers/lazy": "./dest/provider/lazy.js",
+    "./*": "./dest/*/index.js",
+    "./*/lazy": "./dest/*/lazy.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts",
+      "./src/class-registry/index.ts",
+      "./src/instance-registry/index.ts"
+    ],
+    "name": "Protocol Contracts",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn generate && yarn generate:cleanup-artifacts && ../scripts/tsc.sh",
+    "build:keep-debug-symbols": "yarn clean && yarn generate && ../scripts/tsc.sh",
+    "generate": "yarn generate:data",
+    "generate:cleanup-artifacts": "node --no-warnings --loader @swc-node/register/esm src/scripts/cleanup_artifacts.ts",
+    "generate:data": "node --no-warnings --loader @swc-node/register/esm src/scripts/generate_data.ts",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "build:ts": "../scripts/tsc.sh",
+    "clean": "rm -rf ./dest .tsbuildinfo ./artifacts",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json",
+    "./package.local.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/constants": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "lodash.chunk": "^4.2.0",
+    "lodash.omit": "^4.5.0",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@aztec/protocol-contracts-artifacts": "6.0.0-nightly.20260826",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/lodash.chunk": "^4.2.9",
+    "@types/lodash.omit": "^4.5.9",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*",
+    "artifacts",
+    "!src/scripts/*"
+  ],
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/class-registry/__snapshots__/README.md

@@ -0,0 +1,9 @@
+# How to update these snapshots
+
+(You probably need to have done a `./bootstrap.sh` at some point)
+
+From the root:
+
+`cd yarn-project/protocol-contracts`
+
+`yarn test -u`

package/src/class-registry/contract_class_published_event.ts

@@ -0,0 +1,77 @@
+import { CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FieldReader } from '@aztec-labs/foundation/serialize';
+import { bufferFromFields } from '@aztec-labs/stdlib/abi';
+import {
+  type ContractClassPublic,
+  type ContractClassPublicWithCommitment,
+  computePublicBytecodeCommitment,
+} from '@aztec-labs/stdlib/contract';
+import type { ContractClassLog } from '@aztec-labs/stdlib/logs';
+
+import { ProtocolContractAddress } from '../protocol_contract_data.js';
+
+/** Event emitted from the ContractClassRegistry. */
+export class ContractClassPublishedEvent {
+  constructor(
+    public readonly contractClassId: Fr,
+    public readonly version: number,
+    public readonly artifactHash: Fr,
+    public readonly privateFunctionsRoot: Fr,
+    public readonly packedPublicBytecode: Buffer,
+  ) {}
+
+  static isContractClassPublishedEvent(log: ContractClassLog) {
+    return (
+      log.contractAddress.equals(ProtocolContractAddress.ContractClassRegistry) &&
+      log.fields.fields[0].toBigInt() === CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE
+    );
+  }
+
+  static fromLog(log: ContractClassLog) {
+    // 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 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,
+      version,
+      artifactHash,
+      privateFunctionsRoot,
+      packedPublicBytecode,
+    );
+  }
+
+  /** 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 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))
+      .map((log: ContractClassLog) => ContractClassPublishedEvent.fromLog(log));
+  }
+}

package/src/class-registry/index.ts

@@ -0,0 +1,21 @@
+import { loadContractArtifact } from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec-labs/stdlib/noir';
+
+import ContractClassRegistryJson from '../../artifacts/ContractClassRegistry.json' with { type: 'json' };
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+export * from './contract_class_published_event.js';
+
+export const ContractClassRegistryArtifact = loadContractArtifact(ContractClassRegistryJson as NoirCompiledContract);
+
+let protocolContract: ProtocolContract;
+
+/** Returns the canonical deployment of the contract. */
+export function getCanonicalClassRegistry(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const artifact = ContractClassRegistryArtifact;
+    protocolContract = makeProtocolContract('ContractClassRegistry', artifact);
+  }
+  return Promise.resolve(protocolContract);
+}