@aztec/protocol-contracts 0.0.0-test.0

package/src/class-registerer/unconstrained_function_broadcasted_event.ts

@@ -0,0 +1,99 @@
+import {
+  ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
+  MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS,
+} from '@aztec/constants';
+import { removeArrayPaddingEnd } from '@aztec/foundation/collection';
+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 { UnconstrainedFunction, UnconstrainedFunctionWithMembershipProof } from '@aztec/stdlib/contract';
+import type { ContractClassLog } from '@aztec/stdlib/logs';
+
+import { REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG } from '../protocol_contract_data.js';
+
+/** Event emitted from the ContractClassRegisterer. */
+export class UnconstrainedFunctionBroadcastedEvent {
+  constructor(
+    public readonly contractClassId: Fr,
+    public readonly artifactMetadataHash: Fr,
+    public readonly privateFunctionsArtifactTreeRoot: Fr,
+    public readonly artifactFunctionTreeSiblingPath: Tuple<Fr, typeof ARTIFACT_FUNCTION_TREE_MAX_HEIGHT>,
+    public readonly artifactFunctionTreeLeafIndex: number,
+    public readonly unconstrainedFunction: BroadcastedUnconstrainedFunction,
+  ) {}
+
+  static isUnconstrainedFunctionBroadcastedEvent(log: ContractClassLog) {
+    return log.fields[0].equals(REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG);
+  }
+
+  static fromLog(log: ContractClassLog) {
+    const reader = new FieldReader(log.fields.slice(1));
+    const event = UnconstrainedFunctionBroadcastedEvent.fromFields(reader);
+    while (!reader.isFinished()) {
+      const field = reader.readField();
+      if (!field.isZero()) {
+        throw new Error(`Unexpected data after parsing UnconstrainedFunctionBroadcastedEvent: ${field.toString()}`);
+      }
+    }
+
+    return event;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const contractClassId = reader.readField();
+    const artifactMetadataHash = reader.readField();
+    const privateFunctionsArtifactTreeRoot = reader.readField();
+    const artifactFunctionTreeSiblingPath = reader.readFieldArray(ARTIFACT_FUNCTION_TREE_MAX_HEIGHT);
+    const artifactFunctionTreeLeafIndex = reader.readField().toNumber();
+    const unconstrainedFunction = BroadcastedUnconstrainedFunction.fromFields(reader);
+
+    return new UnconstrainedFunctionBroadcastedEvent(
+      contractClassId,
+      artifactMetadataHash,
+      privateFunctionsArtifactTreeRoot,
+      artifactFunctionTreeSiblingPath,
+      artifactFunctionTreeLeafIndex,
+      unconstrainedFunction,
+    );
+  }
+
+  toFunctionWithMembershipProof(): UnconstrainedFunctionWithMembershipProof {
+    // We should be able to safely remove the zero elements that pad the variable-length sibling path,
+    // since a sibling with value zero can only occur on the tree leaves, so the sibling path will never end
+    // in a zero. The only exception is a tree with depth 2 with one non-zero leaf, where the sibling path would
+    // be a single zero element, but in that case the artifact tree should be just the single leaf.
+    const artifactTreeSiblingPath = removeArrayPaddingEnd(this.artifactFunctionTreeSiblingPath, Fr.isZero);
+    return {
+      ...this.unconstrainedFunction,
+      bytecode: this.unconstrainedFunction.bytecode,
+      functionMetadataHash: this.unconstrainedFunction.metadataHash,
+      artifactMetadataHash: this.artifactMetadataHash,
+      privateFunctionsArtifactTreeRoot: this.privateFunctionsArtifactTreeRoot,
+      artifactTreeSiblingPath,
+      artifactTreeLeafIndex: this.artifactFunctionTreeLeafIndex,
+    };
+  }
+}
+
+export class BroadcastedUnconstrainedFunction implements UnconstrainedFunction {
+  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,
+    /** 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();
+    // The '* 1' removes the 'Type instantiation is excessively deep and possibly infinite. ts(2589)' err
+    const encodedBytecode = reader.readFieldArray(MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS * 1);
+    const bytecode = bufferFromFields(encodedBytecode);
+    return new BroadcastedUnconstrainedFunction(selector, metadataHash, bytecode);
+  }
+}

package/src/fee-juice/index.ts

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

package/src/fee-juice/lazy.ts

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

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './protocol_contract.js';
+export * from './protocol_contract_data.js';
+export * from './protocol_contract_tree.js';

package/src/instance-deployer/contract_instance_deployed_event.ts

@@ -0,0 +1,64 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import type { PrivateLog } from '@aztec/stdlib/logs';
+
+import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '../protocol_contract_data.js';
+
+/** Event emitted from the ContractInstanceDeployer. */
+export class ContractInstanceDeployedEvent {
+  constructor(
+    public readonly address: AztecAddress,
+    public readonly version: number,
+    public readonly salt: Fr,
+    public readonly contractClassId: Fr,
+    public readonly initializationHash: Fr,
+    public readonly publicKeys: PublicKeys,
+    public readonly deployer: AztecAddress,
+  ) {}
+
+  static isContractInstanceDeployedEvent(log: PrivateLog) {
+    return log.fields[0].equals(DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG);
+  }
+
+  static fromLog(log: PrivateLog) {
+    const bufferWithoutTag = log.toBuffer().subarray(32);
+    const reader = new BufferReader(bufferWithoutTag);
+    const address = reader.readObject(AztecAddress);
+    const version = reader.readObject(Fr).toNumber();
+    const salt = reader.readObject(Fr);
+    const contractClassId = reader.readObject(Fr);
+    const initializationHash = reader.readObject(Fr);
+    const publicKeys = reader.readObject(PublicKeys);
+    const deployer = reader.readObject(AztecAddress);
+
+    return new ContractInstanceDeployedEvent(
+      address,
+      version,
+      salt,
+      contractClassId,
+      initializationHash,
+      publicKeys,
+      deployer,
+    );
+  }
+
+  toContractInstance(): ContractInstanceWithAddress {
+    if (this.version !== 1) {
+      throw new Error(`Unexpected contract instance version ${this.version}`);
+    }
+
+    return {
+      address: this.address,
+      version: this.version,
+      currentContractClassId: this.contractClassId,
+      originalContractClassId: this.contractClassId,
+      initializationHash: this.initializationHash,
+      publicKeys: this.publicKeys,
+      salt: this.salt,
+      deployer: this.deployer,
+    };
+  }
+}

package/src/instance-deployer/contract_instance_updated_event.ts

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

package/src/instance-deployer/index.ts

@@ -0,0 +1,23 @@
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import ContractInstanceDeployerJson from '../../artifacts/ContractInstanceDeployer.json' assert { type: 'json' };
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+
+export * from './contract_instance_deployed_event.js';
+export * from './contract_instance_updated_event.js';
+
+export const ContractInstanceDeployerArtifact = loadContractArtifact(
+  ContractInstanceDeployerJson as NoirCompiledContract,
+);
+
+let protocolContract: ProtocolContract;
+
+/** Returns the canonical deployment of the contract. */
+export async function getCanonicalInstanceDeployer(): Promise<ProtocolContract> {
+  if (!protocolContract) {
+    protocolContract = await makeProtocolContract('ContractInstanceDeployer', ContractInstanceDeployerArtifact);
+  }
+  return protocolContract;
+}

package/src/instance-deployer/lazy.ts

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

package/src/make_protocol_contract.ts

@@ -0,0 +1,26 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { getContractClassFromArtifact, getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
+
+import type { ProtocolContract } from './protocol_contract.js';
+import { ProtocolContractAddress, type ProtocolContractName, ProtocolContractSalt } from './protocol_contract_data.js';
+
+/**
+ * Returns the canonical deployment given its name and artifact.
+ * To be used internally within the protocol-contracts package.
+ */
+export async function makeProtocolContract(
+  name: ProtocolContractName,
+  artifact: ContractArtifact,
+): Promise<ProtocolContract> {
+  const address = ProtocolContractAddress[name];
+  const salt = ProtocolContractSalt[name];
+  // TODO(@spalladino): This computes the contract class from the artifact twice.
+  const contractClass = await getContractClassFromArtifact(artifact);
+  const instance = await getContractInstanceFromDeployParams(artifact, { salt });
+  return {
+    instance: { ...instance, address },
+    contractClass,
+    artifact,
+    address,
+  };
+}

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

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

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

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

package/src/protocol_contract.ts

@@ -0,0 +1,23 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassIdPreimage, ContractClassWithId, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import { ProtocolContractAddress } from './protocol_contract_data.js';
+
+/** Represents a canonical contract in the protocol. */
+export interface ProtocolContract {
+  /** Canonical deployed instance. */
+  instance: ContractInstanceWithAddress;
+  /** Contract class of this contract. */
+  contractClass: ContractClassWithId & ContractClassIdPreimage;
+  /** Complete contract artifact. */
+  artifact: ContractArtifact;
+  /** Deployment address for the canonical instance.  */
+  address: AztecAddress;
+}
+
+export function isProtocolContract(address: AztecAddress) {
+  return Object.values(ProtocolContractAddress).some(a => a.equals(address));
+}
+
+export { type ProtocolContractsProvider } from './provider/protocol_contracts_provider.js';

package/src/protocol_contract_data.ts

@@ -0,0 +1,63 @@
+
+    // 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';
+
+    
+    export const protocolContractNames = [
+      'AuthRegistry',
+'ContractInstanceDeployer',
+'ContractClassRegisterer',
+'MultiCallEntrypoint',
+'FeeJuice',
+'Router'
+    ] as const;
+
+    export type ProtocolContractName = typeof protocolContractNames[number];
+  
+
+    
+    export const ProtocolContractSalt: Record<ProtocolContractName, Fr> = {
+      AuthRegistry: new Fr(1),
+ContractInstanceDeployer: new Fr(1),
+ContractClassRegisterer: new Fr(1),
+MultiCallEntrypoint: new Fr(1),
+FeeJuice: new Fr(1),
+Router: new Fr(1)
+    };
+  
+
+    
+    export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress> = {
+      AuthRegistry: AztecAddress.fromBigInt(1n),
+ContractInstanceDeployer: AztecAddress.fromBigInt(2n),
+ContractClassRegisterer: AztecAddress.fromBigInt(3n),
+MultiCallEntrypoint: AztecAddress.fromBigInt(4n),
+FeeJuice: AztecAddress.fromBigInt(5n),
+Router: AztecAddress.fromBigInt(6n)
+    };
+  
+
+    
+    export const ProtocolContractLeaves = {
+      AuthRegistry: Fr.fromHexString('0x1dc70bdab08ce08aef9f6ddcc8fd54fb91fdb72a6433c2dd6b69b33cf1fb87a2'),
+ContractInstanceDeployer: Fr.fromHexString('0x005d6d6addbbda03dcad6fc9a3c3b7de457c30990ec2acaaf74f139a3a506e06'),
+ContractClassRegisterer: Fr.fromHexString('0x110ef3d93e27fd61a5a56e479a9f9cbdb099d2d968cdcc16c01d2bdfd6cb0ddd'),
+MultiCallEntrypoint: Fr.fromHexString('0x121f834b03a64d38463ae18ddebceeb4dce8192cc289052e175ad754a883a7fe'),
+FeeJuice: Fr.fromHexString('0x141a566ade0bef915526762c2c2fb19b2a756ad7c82e83fde6dbf86848ecc131'),
+Router: Fr.fromHexString('0x2c20bd328fbd33c01fbcda9e6299c31da5d5b29ea30e9c7b9d631618b839bca9')
+    };
+  
+
+    
+    export const protocolContractTreeRoot = Fr.fromHexString('0x093cc9324e5a7b44883f515ac490e7294ef8cb1e6d2d8c503255b1b3a9409262');
+  
+
+    
+  export const REGISTERER_CONTRACT_CLASS_REGISTERED_TAG = Fr.fromHexString('0x20cd27645f65c15a38720ca984aef936592f3938a705db706d068ad13fc58ae9');
+  export const REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG = Fr.fromHexString('0x0abf338154e355442d9916d630da0491036d5a7b23c42b477c1395ba3bf9b42d');
+  export const REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG = Fr.fromHexString('0x27774539896271d6dbe0c1de45ddc44709d1e8d9a9fb686ca3c105d87c417bb8');
+  export const DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG = Fr.fromHexString('0x2ec28b91a5f838506d6042915005ff55cf7a0a5f889a83b11faed33a31b486f2');
+   export const DEPLOYER_CONTRACT_INSTANCE_UPDATED_TAG = new Fr(1534834688047131268740281708431107902615560100979874281215533519862n);
+  
+  

package/src/protocol_contract_tree.ts

@@ -0,0 +1,44 @@
+import type { PROTOCOL_CONTRACT_TREE_HEIGHT } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import type { IndexedMerkleTree } from '@aztec/foundation/trees';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ProtocolContractLeafPreimage } from '@aztec/stdlib/trees';
+
+import { buildProtocolContractTree } from './build_protocol_contract_tree.js';
+import { isProtocolContract } from './protocol_contract.js';
+import { ProtocolContractAddress, ProtocolContractLeaves, protocolContractNames } from './protocol_contract_data.js';
+
+let protocolContractTree:
+  | IndexedMerkleTree<ProtocolContractLeafPreimage, typeof PROTOCOL_CONTRACT_TREE_HEIGHT>
+  | undefined;
+
+async function getTree() {
+  if (!protocolContractTree) {
+    const leaves = protocolContractNames.map(name => ({
+      address: ProtocolContractAddress[name],
+      leaf: ProtocolContractLeaves[name],
+    }));
+    protocolContractTree = await buildProtocolContractTree(leaves);
+  }
+  return protocolContractTree;
+}
+
+// Computed address can be different from contract address due to upgrades
+export async function getProtocolContractLeafAndMembershipWitness(
+  contractAddress: AztecAddress,
+  computedAddress: AztecAddress,
+) {
+  const tree = await getTree();
+  let lowLeaf;
+  let witness;
+  if (isProtocolContract(contractAddress)) {
+    const index = contractAddress.toField().toNumber();
+    lowLeaf = tree.leafPreimages[index];
+    witness = tree.getMembershipWitness(index);
+  } else {
+    lowLeaf = tree.getLowLeaf(computedAddress.toBigInt());
+    const hashed = (await poseidon2Hash(lowLeaf.toHashInputs())).toBuffer();
+    witness = tree.getMembershipWitness(hashed);
+  }
+  return { lowLeaf, witness };
+}

package/src/provider/bundle.ts

@@ -0,0 +1,27 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+
+import { AuthRegistryArtifact } from '../auth-registry/index.js';
+import { ContractClassRegistererArtifact } from '../class-registerer/index.js';
+import { FeeJuiceArtifact } from '../fee-juice/index.js';
+import { ContractInstanceDeployerArtifact } from '../instance-deployer/index.js';
+import { makeProtocolContract } from '../make_protocol_contract.js';
+import { MultiCallEntrypointArtifact } from '../multi-call-entrypoint/index.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContractName } from '../protocol_contract_data.js';
+import { RouterArtifact } from '../router/index.js';
+import type { ProtocolContractsProvider } from './protocol_contracts_provider.js';
+
+export const ProtocolContractArtifact: Record<ProtocolContractName, ContractArtifact> = {
+  AuthRegistry: AuthRegistryArtifact,
+  ContractInstanceDeployer: ContractInstanceDeployerArtifact,
+  ContractClassRegisterer: ContractClassRegistererArtifact,
+  MultiCallEntrypoint: MultiCallEntrypointArtifact,
+  FeeJuice: FeeJuiceArtifact,
+  Router: RouterArtifact,
+};
+
+export class BundledProtocolContractsProvider implements ProtocolContractsProvider {
+  getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract> {
+    return makeProtocolContract(name, ProtocolContractArtifact[name]);
+  }
+}

package/src/provider/lazy.ts

@@ -0,0 +1,30 @@
+import { getCanonicalAuthRegistry } from '../auth-registry/lazy.js';
+import { getCanonicalClassRegisterer } from '../class-registerer/lazy.js';
+import { getCanonicalFeeJuice } from '../fee-juice/lazy.js';
+import { getCanonicalInstanceDeployer } from '../instance-deployer/lazy.js';
+import { getCanonicalMultiCallEntrypoint } from '../multi-call-entrypoint/lazy.js';
+import type { ProtocolContract } from '../protocol_contract.js';
+import type { ProtocolContractName } from '../protocol_contract_data.js';
+import { getCanonicalRouter } from '../router/lazy.js';
+import type { ProtocolContractsProvider } from './protocol_contracts_provider.js';
+
+export class LazyProtocolContractsProvider implements ProtocolContractsProvider {
+  getProtocolContractArtifact(name: ProtocolContractName): Promise<ProtocolContract> {
+    switch (name) {
+      case 'AuthRegistry':
+        return getCanonicalAuthRegistry();
+      case 'ContractInstanceDeployer':
+        return getCanonicalInstanceDeployer();
+      case 'ContractClassRegisterer':
+        return getCanonicalClassRegisterer();
+      case 'MultiCallEntrypoint':
+        return getCanonicalMultiCallEntrypoint();
+      case 'FeeJuice':
+        return getCanonicalFeeJuice();
+      case 'Router':
+        return getCanonicalRouter();
+      default:
+        throw new Error(`Unknown protocol contract name: ${name}`);
+    }
+  }
+}

package/src/provider/protocol_contracts_provider.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>;
+}

package/src/router/index.ts

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