@aztec/protocol-contracts 0.0.0-test.0

package/dest/scripts/cleanup_artifacts.js

@@ -0,0 +1,16 @@
+import { fileURLToPath } from '@aztec/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());
+        fileData.file_map = {};
+        fileData.debug_symbols = {};
+        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,173 @@
+import { CANONICAL_AUTH_REGISTRY_ADDRESS, DEPLOYER_CONTRACT_ADDRESS, DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE, DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, FEE_JUICE_ADDRESS, MULTI_CALL_ENTRYPOINT_ADDRESS, REGISTERER_CONTRACT_ADDRESS, REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE, REGISTERER_PRIVATE_FUNCTION_BROADCASTED_MAGIC_VALUE, REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_MAGIC_VALUE, ROUTER_ADDRESS } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { createConsoleLogger } from '@aztec/foundation/log';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { buildProtocolContractTree } from '../build_protocol_contract_tree.js';
+const log = createConsoleLogger('autogenerate');
+const noirContractsRoot = '../../noir-projects/noir-contracts';
+const srcPath = path.join(noirContractsRoot, './target');
+const destArtifactsDir = './artifacts';
+const outputFilePath = './src/protocol_contract_data.ts';
+const salt = new Fr(1);
+const contractAddressMapping = {
+    AuthRegistry: CANONICAL_AUTH_REGISTRY_ADDRESS,
+    ContractInstanceDeployer: DEPLOYER_CONTRACT_ADDRESS,
+    ContractClassRegisterer: REGISTERER_CONTRACT_ADDRESS,
+    MultiCallEntrypoint: MULTI_CALL_ENTRYPOINT_ADDRESS,
+    FeeJuice: FEE_JUICE_ADDRESS,
+    Router: ROUTER_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;
+}
+async function computeContractLeaf(artifact) {
+    const instance = await getContractInstanceFromDeployParams(loadContractArtifact(artifact), {
+        salt
+    });
+    return instance.address;
+}
+async function computeRoot(names, leaves) {
+    const data = names.map((name, i)=>({
+            address: new AztecAddress(new Fr(contractAddressMapping[name])),
+            leaf: leaves[i]
+        }));
+    const tree = await buildProtocolContractTree(data);
+    return Fr.fromBuffer(tree.root);
+}
+async function generateDeclarationFile(destName) {
+    const content = `
+    import type { NoirCompiledContract } from '@aztec/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.fromBigInt(${contractAddressMapping[name]}n)`).join(',\n');
+    return `
+    export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress> = {
+      ${addresses}
+    };
+  `;
+}
+function generateContractLeaves(names, leaves) {
+    return `
+    export const ProtocolContractLeaves = {
+      ${leaves.map((leaf, i)=>`${names[i]}: Fr.fromHexString('${leaf.toString()}')`).join(',\n')}
+    };
+  `;
+}
+async function generateRoot(names, leaves) {
+    const root = await computeRoot(names, leaves);
+    return `
+    export const protocolContractTreeRoot = Fr.fromHexString('${root.toString()}');
+  `;
+}
+async function generateLogTags() {
+    // See silo_contract_class_log for all registerer tags
+    return `
+  export const REGISTERER_CONTRACT_CLASS_REGISTERED_TAG = Fr.fromHexString('${await poseidon2Hash([
+        REGISTERER_CONTRACT_ADDRESS,
+        REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE
+    ])}');
+  export const REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG = Fr.fromHexString('${await poseidon2Hash([
+        REGISTERER_CONTRACT_ADDRESS,
+        REGISTERER_PRIVATE_FUNCTION_BROADCASTED_MAGIC_VALUE
+    ])}');
+  export const REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG = Fr.fromHexString('${await poseidon2Hash([
+        REGISTERER_CONTRACT_ADDRESS,
+        REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_MAGIC_VALUE
+    ])}');
+  export const DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG = Fr.fromHexString('${await poseidon2Hash([
+        DEPLOYER_CONTRACT_ADDRESS,
+        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE
+    ])}');
+   export const DEPLOYER_CONTRACT_INSTANCE_UPDATED_TAG = new Fr(${DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE}n);
+  `;
+}
+async function generateOutputFile(names, leaves) {
+    const content = `
+    // GENERATED FILE - DO NOT EDIT. RUN \`yarn generate\` or \`yarn generate:data\`
+    import { Fr } from '@aztec/foundation/fields';
+    import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+    ${generateNames(names)}
+
+    ${generateSalts(names)}
+
+    ${generateContractAddresses(names)}
+
+    ${generateContractLeaves(names, leaves)}
+
+    ${await generateRoot(names, leaves)}
+
+    ${await generateLogTags()}
+  `;
+    await fs.writeFile(outputFilePath, content);
+}
+async function main() {
+    await clearDestDir();
+    const srcNames = JSON.parse(await fs.readFile(path.join(noirContractsRoot, 'protocol_contracts.json'), 'utf8'));
+    const leaves = [];
+    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);
+        const contractLeaf = await computeContractLeaf(artifact);
+        leaves.push(contractLeaf.toField());
+    }
+    await generateOutputFile(destNames, leaves);
+}
+try {
+    await main();
+} catch (err) {
+    log(`Error copying protocol contract artifacts: ${err}`);
+    process.exit(1);
+}

package/dest/tests/fixtures.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+export declare function getSampleContractClassRegisteredEventPayload(): Buffer;
+export declare function getSamplePrivateFunctionBroadcastedEventPayload(): Buffer;
+export declare function getSampleUnconstrainedFunctionBroadcastedEventPayload(): Buffer;
+export declare function getSampleContractInstanceDeployedEventPayload(): Buffer;
+export declare function getPathToFixture(name: string): string;
+//# sourceMappingURL=fixtures.d.ts.map

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,4CAA4C,IAAI,MAAM,CAGrE;AAGD,wBAAgB,+CAA+C,IAAI,MAAM,CAGxE;AAGD,wBAAgB,qDAAqD,IAAI,MAAM,CAG9E;AAGD,wBAAgB,6CAA6C,IAAI,MAAM,CAGtE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,UAE5C"}

package/dest/tests/fixtures.js

@@ -0,0 +1,26 @@
+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
+export function getSampleContractClassRegisteredEventPayload() {
+    const path = getPathToFixture('ContractClassRegisteredEventData.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 getSampleUnconstrainedFunctionBroadcastedEventPayload() {
+    const path = getPathToFixture('UnconstrainedFunctionBroadcastedEventData.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 getSampleContractInstanceDeployedEventPayload() {
+    const path = getPathToFixture('ContractInstanceDeployedEventData.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,103 @@
+{
+  "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.0-test.0",
+  "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-registerer/index.ts",
+      "./src/instance-deployer/index.ts"
+    ],
+    "name": "Protocol Contracts",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn generate && yarn generate:cleanup-artifacts && tsc -b",
+    "build:keep-debug-symbols": "yarn clean && yarn generate && tsc -b",
+    "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": "tsc -b --watch",
+    "build:ts": "tsc -b",
+    "clean": "rm -rf ./dest .tsbuildinfo ./artifacts",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "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"
+    ]
+  },
+  "dependencies": {
+    "@aztec/constants": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "lodash.chunk": "^4.2.0",
+    "lodash.omit": "^4.5.0",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/lodash.chunk": "^4.2.9",
+    "@types/lodash.omit": "^4.5.9",
+    "@types/node": "^18.7.23",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "ts-loader": "^9.4.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*",
+    "artifacts",
+    "!src/scripts/*"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/auth-registry/index.ts

@@ -0,0 +1,18 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import AuthRegistryJson from '../../artifacts/AuthRegistry.json' assert { type: 'json' };
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+let protocolContract: ProtocolContract;
+
+export const AuthRegistryArtifact = loadContractArtifact(AuthRegistryJson as NoirCompiledContract);
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalAuthRegistry(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    protocolContract = await makeProtocolContract('AuthRegistry', AuthRegistryArtifact);
+  }
+  return protocolContract;
+}

package/src/auth-registry/lazy.ts

@@ -0,0 +1,29 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+let protocolContract: ProtocolContract;
+let protocolContractArtifact: ContractArtifact;
+
+export async function getAuthRegistryArtifact(): Promise<ContractArtifact> {
+  if (!protocolContractArtifact) {
+    // Cannot assert this import as it's incompatible with browsers
+    // https://caniuse.com/mdn-javascript_statements_import_import_assertions_type_json
+    // Use the new "with" syntax once supported by firefox
+    // https://caniuse.com/mdn-javascript_statements_import_import_attributes_type_json
+    // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+    const { default: authRegistryJson } = await import('../../artifacts/AuthRegistry.json');
+    protocolContractArtifact = loadContractArtifact(authRegistryJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalAuthRegistry(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const authRegistryArtifact = await getAuthRegistryArtifact();
+    protocolContract = await makeProtocolContract('AuthRegistry', authRegistryArtifact);
+  }
+  return protocolContract;
+}

package/src/build_protocol_contract_tree.ts

@@ -0,0 +1,29 @@
+import { MAX_PROTOCOL_CONTRACTS, PROTOCOL_CONTRACT_TREE_HEIGHT } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import { type IndexedMerkleTree, IndexedMerkleTreeCalculator } from '@aztec/foundation/trees';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ProtocolContractLeafPreimage } from '@aztec/stdlib/trees';
+
+export async function buildProtocolContractTree(
+  contracts: { address: AztecAddress; leaf: Fr }[],
+): Promise<IndexedMerkleTree<ProtocolContractLeafPreimage, typeof PROTOCOL_CONTRACT_TREE_HEIGHT>> {
+  const hasher = {
+    hash: async (l: Buffer, r: Buffer) => (await poseidon2Hash([l, r])).toBuffer(),
+    hashInputs: async (i: Buffer[]) => (await poseidon2Hash(i)).toBuffer(),
+  };
+  const calculator = await IndexedMerkleTreeCalculator.create(
+    PROTOCOL_CONTRACT_TREE_HEIGHT,
+    hasher,
+    ProtocolContractLeafPreimage,
+  );
+
+  const leaves = new Array(MAX_PROTOCOL_CONTRACTS).fill(Buffer.alloc(32));
+
+  for (const contract of contracts) {
+    const index = contract.address.toField().toNumber();
+    leaves[index] = contract.leaf.toBuffer();
+  }
+
+  return calculator.computeTree(leaves);
+}

package/src/class-registerer/contract_class_registered_event.ts

@@ -0,0 +1,83 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
+import {
+  type ContractClassPublic,
+  type PublicFunction,
+  computeContractClassId,
+  computePublicBytecodeCommitment,
+} from '@aztec/stdlib/contract';
+import type { ContractClassLog } from '@aztec/stdlib/logs';
+
+import { REGISTERER_CONTRACT_CLASS_REGISTERED_TAG } from '../protocol_contract_data.js';
+
+/** Event emitted from the ContractClassRegisterer. */
+export class ContractClassRegisteredEvent {
+  constructor(
+    public readonly contractClassId: Fr,
+    public readonly version: number,
+    public readonly artifactHash: Fr,
+    public readonly privateFunctionsRoot: Fr,
+    public readonly packedPublicBytecode: Buffer,
+  ) {}
+
+  static isContractClassRegisteredEvent(log: ContractClassLog) {
+    return log.fields[0].equals(REGISTERER_CONTRACT_CLASS_REGISTERED_TAG);
+  }
+
+  static fromLog(log: ContractClassLog) {
+    const reader = new FieldReader(log.fields.slice(1));
+    const contractClassId = reader.readField();
+    const version = reader.readField().toNumber();
+    const artifactHash = reader.readField();
+    const privateFunctionsRoot = reader.readField();
+    const packedPublicBytecode = bufferFromFields(reader.readFieldArray(log.fields.slice(1).length - reader.cursor));
+
+    return new ContractClassRegisteredEvent(
+      contractClassId,
+      version,
+      artifactHash,
+      privateFunctionsRoot,
+      packedPublicBytecode,
+    );
+  }
+
+  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}`);
+    }
+
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
+    const publicFunctions: PublicFunction[] = [];
+    if (this.packedPublicBytecode.length > 0) {
+      publicFunctions.push({
+        selector: FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+        bytecode: this.packedPublicBytecode,
+      });
+    }
+
+    return {
+      id: this.contractClassId,
+      artifactHash: this.artifactHash,
+      packedBytecode: this.packedPublicBytecode,
+      privateFunctionsRoot: this.privateFunctionsRoot,
+      publicFunctions: publicFunctions,
+      version: this.version,
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    };
+  }
+}

package/src/class-registerer/index.ts

@@ -0,0 +1,25 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import ContractClassRegistererJson from '../../artifacts/ContractClassRegisterer.json' assert { type: 'json' };
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+export * from './contract_class_registered_event.js';
+export * from './private_function_broadcasted_event.js';
+export * from './unconstrained_function_broadcasted_event.js';
+
+export const ContractClassRegistererArtifact = loadContractArtifact(
+  ContractClassRegistererJson as NoirCompiledContract,
+);
+
+let protocolContract: ProtocolContract;
+
+/** Returns the canonical deployment of the contract. */
+export async function getCanonicalClassRegisterer(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const artifact = ContractClassRegistererArtifact;
+    protocolContract = await makeProtocolContract('ContractClassRegisterer', artifact);
+  }
+  return protocolContract;
+}

package/src/class-registerer/lazy.ts

@@ -0,0 +1,33 @@
+import { type ContractArtifact, loadContractArtifact } from '@aztec/stdlib/abi';
+
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+export * from './contract_class_registered_event.js';
+export * from './private_function_broadcasted_event.js';
+export * from './unconstrained_function_broadcasted_event.js';
+
+let protocolContract: ProtocolContract;
+let protocolContractArtifact: ContractArtifact;
+
+export async function getContractClassRegistererArtifact(): Promise<ContractArtifact> {
+  if (!protocolContractArtifact) {
+    // Cannot assert this import as it's incompatible with browsers
+    // https://caniuse.com/mdn-javascript_statements_import_import_assertions_type_json
+    // Use the new "with" syntax once supported by firefox
+    // https://caniuse.com/mdn-javascript_statements_import_import_attributes_type_json
+    // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+    const { default: contractClassRegistererJson } = await import('../../artifacts/ContractClassRegisterer.json');
+    protocolContractArtifact = loadContractArtifact(contractClassRegistererJson);
+  }
+  return protocolContractArtifact;
+}
+
+/** Returns the canonical deployment of the auth registry. */
+export async function getCanonicalClassRegisterer(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    const contractClassRegistererArtifact = await getContractClassRegistererArtifact();
+    protocolContract = await makeProtocolContract('ContractClassRegisterer', contractClassRegistererArtifact);
+  }
+  return protocolContract;
+}

package/src/class-registerer/private_function_broadcasted_event.ts

@@ -0,0 +1,105 @@
+import {
+  ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
+  FUNCTION_TREE_HEIGHT,
+  MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { FunctionSelector, bufferFromFields } from '@aztec/stdlib/abi';
+import type { ExecutablePrivateFunctionWithMembershipProof, PrivateFunction } from '@aztec/stdlib/contract';
+import type { ContractClassLog } from '@aztec/stdlib/logs';
+
+import { REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
+
+/** Event emitted from the ContractClassRegisterer. */
+export class PrivateFunctionBroadcastedEvent {
+  constructor(
+    public readonly contractClassId: Fr,
+    public readonly artifactMetadataHash: Fr,
+    public readonly unconstrainedFunctionsArtifactTreeRoot: Fr,
+    public readonly privateFunctionTreeSiblingPath: Tuple<Fr, typeof FUNCTION_TREE_HEIGHT>,
+    public readonly privateFunctionTreeLeafIndex: number,
+    public readonly artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>,
+    public readonly artifactFunctionTreeLeafIndex: number,
+    public readonly privateFunction: BroadcastedPrivateFunction,
+  ) {}
+
+  static isPrivateFunctionBroadcastedEvent(log: ContractClassLog) {
+    return log.fields[0].equals(REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG);
+  }
+
+  static fromLog(log: ContractClassLog) {
+    const reader = new FieldReader(log.fields.slice(1));
+    const event = PrivateFunctionBroadcastedEvent.fromFields(reader);
+    while (!reader.isFinished()) {
+      const field = reader.readField();
+      if (!field.isZero()) {
+        throw new Error(`Unexpected data after parsing PrivateFunctionBroadcastedEvent: ${field.toString()}`);
+      }
+    }
+
+    return event;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const contractClassId = reader.readField();
+    const artifactMetadataHash = reader.readField();
+    const unconstrainedFunctionsArtifactTreeRoot = reader.readField();
+    const privateFunctionTreeSiblingPath = reader.readFieldArray(FUNCTION_TREE_HEIGHT);
+    const privateFunctionTreeLeafIndex = reader.readField().toNumber();
+    const artifactFunctionTreeSiblingPath = reader.readFieldArray(ARTIFACT_FUNCTION_TREE_MAX_HEIGHT);
+    const artifactFunctionTreeLeafIndex = reader.readField().toNumber();
+    const privateFunction = BroadcastedPrivateFunction.fromFields(reader);
+
+    return new PrivateFunctionBroadcastedEvent(
+      contractClassId,
+      artifactMetadataHash,
+      unconstrainedFunctionsArtifactTreeRoot,
+      privateFunctionTreeSiblingPath,
+      privateFunctionTreeLeafIndex,
+      artifactFunctionTreeSiblingPath,
+      artifactFunctionTreeLeafIndex,
+      privateFunction,
+    );
+  }
+
+  toFunctionWithMembershipProof(): ExecutablePrivateFunctionWithMembershipProof {
+    return {
+      ...this.privateFunction,
+      bytecode: this.privateFunction.bytecode,
+      functionMetadataHash: this.privateFunction.metadataHash,
+      artifactMetadataHash: this.artifactMetadataHash,
+      unconstrainedFunctionsArtifactTreeRoot: this.unconstrainedFunctionsArtifactTreeRoot,
+      privateFunctionTreeSiblingPath: this.privateFunctionTreeSiblingPath,
+      privateFunctionTreeLeafIndex: this.privateFunctionTreeLeafIndex,
+      artifactTreeSiblingPath: this.artifactFunctionTreeSiblingPath.filter(fr => !fr.isZero()),
+      artifactTreeLeafIndex: this.artifactFunctionTreeLeafIndex,
+    };
+  }
+}
+
+export class BroadcastedPrivateFunction implements PrivateFunction {
+  constructor(
+    /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
+    public readonly selector: FunctionSelector,
+    /** Artifact metadata hash */
+    public readonly metadataHash: Fr,
+    /** Hash of the verification key associated to this private function. */
+    public readonly vkHash: Fr,
+    /** ACIR and Brillig bytecode */
+    public readonly bytecode: Buffer,
+  ) {}
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const selector = FunctionSelector.fromField(reader.readField());
+    const metadataHash = reader.readField();
+    const vkHash = reader.readField();
+    // The '* 1' removes the 'Type instantiation is excessively deep and possibly infinite. ts(2589)' err
+    const encodedBytecode = reader.readFieldArray(MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS * 1);
+    const bytecode = bufferFromFields(encodedBytecode);
+    return new BroadcastedPrivateFunction(selector, metadataHash, vkHash, bytecode);
+  }
+}