@aztec/aztec.js 0.0.1-commit.8afd444 → 0.0.1-commit.8f9871590

package/src/wallet/wallet.ts

@@ -7,8 +7,7 @@ import {
   type ContractArtifact,
   ContractArtifactSchema,
   type EventMetadataDefinition,
-  type FunctionCall,
-  FunctionType,
+  FunctionCall,
 } from '@aztec/stdlib/abi';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -140,37 +139,66 @@ export type BatchResults<T extends readonly BatchedMethod[]> = {
 };
 
 /**
- * Filter options when querying private events.
+ * Base filter options for event queries.
  */
-export type PrivateEventFilter = {
-  /** The address of the contract that emitted the events. */
-  contractAddress: AztecAddress;
-  /** Addresses of accounts that are in scope for this filter. */
-  scopes: AztecAddress[];
+export type EventFilterBase = {
   /** Transaction in which the events were emitted. */
   txHash?: TxHash;
   /** The block number from which to start fetching events (inclusive).
    * Optional. If provided, it must be greater or equal than 1.
    * Defaults to the initial L2 block number (INITIAL_L2_BLOCK_NUM).
-   * */
+   */
   fromBlock?: BlockNumber;
   /** The block number until which to fetch logs (not inclusive).
    * Optional. If provided, it must be greater than fromBlock.
-   * Defaults to the latest known block to PXE + 1.
    */
   toBlock?: BlockNumber;
 };
 
 /**
- * An ABI decoded private event with associated metadata.
+ * Filter options when querying private events.
  */
-export type PrivateEvent<T> = {
+export type PrivateEventFilter = EventFilterBase & {
+  /** The address of the contract that emitted the events. */
+  contractAddress: AztecAddress;
+  /** Addresses of accounts that are in scope for this filter. */
+  scopes: AztecAddress[];
+};
+
+/**
+ * Filter options when querying public events.
+ */
+export type PublicEventFilter = EventFilterBase & {
+  /** The address of the contract that emitted the events. */
+  contractAddress?: AztecAddress;
+};
+
+/**
+ * An ABI decoded event with associated metadata.
+ * @typeParam T - The decoded event type
+ * @typeParam M - Additional metadata fields (empty by default)
+ */
+export type Event<T, M extends object = object> = {
   /** The ABI decoded event */
   event: T;
   /** Metadata describing event context information such as tx and block */
-  metadata: InTx;
+  metadata: InTx & M;
 };
 
+/** An ABI decoded private event with associated metadata. */
+export type PrivateEvent<T> = Event<T>;
+
+/** An ABI decoded public event with associated metadata (includes contract address). */
+export type PublicEvent<T> = Event<
+  T,
+  {
+    /**
+     * Address of the contract that emitted this event
+     */
+    contractAddress: AztecAddress;
+  }
+>;
+
 /**
  * Contract metadata including deployment and registration status.
  */
@@ -197,6 +225,16 @@ export type ContractClassMetadata = {
   isContractClassPubliclyRegistered: boolean;
 };
 
+/**
+ * Options for simulating a utility function call.
+ */
+export type SimulateUtilityOptions = {
+  /** The scope for the utility simulation (determines which notes and keys are visible). */
+  scope: AztecAddress;
+  /** Optional auth witnesses to use during execution. */
+  authWitnesses?: AuthWitness[];
+};
+
 /**
  * The wallet interface.
  */
@@ -217,7 +255,7 @@ export type Wallet = {
     secretKey?: Fr,
   ): Promise<ContractInstanceWithAddress>;
   simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult>;
-  simulateUtility(call: FunctionCall, authwits?: AuthWitness[]): Promise<UtilitySimulationResult>;
+  simulateUtility(call: FunctionCall, opts: SimulateUtilityOptions): Promise<UtilitySimulationResult>;
   profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult>;
   sendTx<W extends InteractionWaitOptions = undefined>(
     exec: ExecutionPayload,
@@ -228,19 +266,8 @@ export type Wallet = {
   batch<const T extends readonly BatchedMethod[]>(methods: T): Promise<BatchResults<T>>;
 };
 
-export const FunctionCallSchema = z.object({
-  name: z.string(),
-  to: schemas.AztecAddress,
-  selector: schemas.FunctionSelector,
-  type: z.nativeEnum(FunctionType),
-  isStatic: z.boolean(),
-  hideMsgSender: z.boolean(),
-  args: z.array(schemas.Fr),
-  returnTypes: z.array(AbiTypeSchema),
-});
-
 export const ExecutionPayloadSchema = z.object({
-  calls: z.array(FunctionCallSchema),
+  calls: z.array(FunctionCall.schema),
   authWitnesses: z.array(AuthWitness.schema),
   capsules: z.array(Capsule.schema),
   extraHashedArgs: z.array(HashedValues.schema),
@@ -297,7 +324,7 @@ export const MessageHashOrIntentSchema = z.union([
   z.object({ consumer: schemas.AztecAddress, innerHash: schemas.Fr }),
   z.object({
     caller: schemas.AztecAddress,
-    call: FunctionCallSchema,
+    call: FunctionCall.schema,
   }),
 ]);
 
@@ -307,6 +334,21 @@ export const EventMetadataDefinitionSchema = z.object({
   fieldNames: z.array(z.string()),
 });
 
+const EventFilterBaseSchema = z.object({
+  txHash: optional(TxHash.schema),
+  fromBlock: optional(BlockNumberPositiveSchema),
+  toBlock: optional(BlockNumberPositiveSchema),
+});
+
+export const PrivateEventFilterSchema = EventFilterBaseSchema.extend({
+  contractAddress: schemas.AztecAddress,
+  scopes: z.array(schemas.AztecAddress),
+});
+
+export const PublicEventFilterSchema = EventFilterBaseSchema.extend({
+  contractAddress: optional(schemas.AztecAddress),
+});
+
 export const PrivateEventSchema: z.ZodType<any> = zodFor<PrivateEvent<AbiDecoded>>()(
   z.object({
     event: AbiDecodedSchema,
@@ -314,13 +356,12 @@ export const PrivateEventSchema: z.ZodType<any> = zodFor<PrivateEvent<AbiDecoded
   }),
 );
 
-export const PrivateEventFilterSchema = z.object({
-  contractAddress: schemas.AztecAddress,
-  scopes: z.array(schemas.AztecAddress),
-  txHash: optional(TxHash.schema),
-  fromBlock: optional(BlockNumberPositiveSchema),
-  toBlock: optional(BlockNumberPositiveSchema),
-});
+export const PublicEventSchema = zodFor<PublicEvent<AbiDecoded>>()(
+  z.object({
+    event: AbiDecodedSchema,
+    metadata: z.intersection(inTxSchema(), z.object({ contractAddress: schemas.AztecAddress })),
+  }),
+);
 
 export const ContractMetadataSchema = z.object({
   instance: optional(ContractInstanceWithAddressSchema),
@@ -479,7 +520,13 @@ const WalletMethodSchemas = {
   simulateTx: z.function().args(ExecutionPayloadSchema, SimulateOptionsSchema).returns(TxSimulationResult.schema),
   simulateUtility: z
     .function()
-    .args(FunctionCallSchema, optional(z.array(AuthWitness.schema)))
+    .args(
+      FunctionCall.schema,
+      z.object({
+        scope: schemas.AztecAddress,
+        authWitnesses: optional(z.array(AuthWitness.schema)),
+      }),
+    )
     .returns(UtilitySimulationResult.schema),
   profileTx: z.function().args(ExecutionPayloadSchema, ProfileOptionsSchema).returns(TxProfileResult.schema),
   sendTx: z

package/dest/deployment/broadcast_function.d.ts

@@ -1,24 +0,0 @@
-import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
-import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import type { Wallet } from '../wallet/index.js';
-/**
- * Sets up a call to broadcast a private function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */
-export declare function broadcastPrivateFunction(wallet: Wallet, artifact: ContractArtifact, selector: FunctionSelector): Promise<ContractFunctionInteraction>;
-/**
- * Sets up a call to broadcast a utility function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */
-export declare function broadcastUtilityFunction(wallet: Wallet, artifact: ContractArtifact, selector: FunctionSelector): Promise<ContractFunctionInteraction>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvYWRjYXN0X2Z1bmN0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVwbG95bWVudC9icm9hZGNhc3RfZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQWdDLE1BQU0sbUJBQW1CLENBQUM7QUFTMUcsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUVoRyxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVqRDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQix3QkFBd0IsQ0FDNUMsTUFBTSxFQUFFLE1BQU0sRUFDZCxRQUFRLEVBQUUsZ0JBQWdCLEVBQzFCLFFBQVEsRUFBRSxnQkFBZ0IsR0FDekIsT0FBTyxDQUFDLDJCQUEyQixDQUFDLENBb0R0QztBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxNQUFNLEVBQUUsTUFBTSxFQUNkLFFBQVEsRUFBRSxnQkFBZ0IsRUFDMUIsUUFBUSxFQUFFLGdCQUFnQixHQUN6QixPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0E4Q3RDIn0=

package/dest/deployment/broadcast_function.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast_function.d.ts","sourceRoot":"","sources":["../../src/deployment/broadcast_function.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgC,MAAM,mBAAmB,CAAC;AAS1G,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAEhG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,2BAA2B,CAAC,CAoDtC;AAED;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,2BAA2B,CAAC,CA8CtC"}

package/dest/deployment/broadcast_function.js

@@ -1,74 +0,0 @@
-import { ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { FunctionSelector, FunctionType, bufferAsFields } from '@aztec/stdlib/abi';
-import { computeVerificationKeyHash, createPrivateFunctionMembershipProof, createUtilityFunctionMembershipProof, getContractClassFromArtifact } from '@aztec/stdlib/contract';
-import { Capsule } from '@aztec/stdlib/tx';
-import { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
-/**
- * Sets up a call to broadcast a private function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */ export async function broadcastPrivateFunction(wallet, artifact, selector) {
-    const contractClass = await getContractClassFromArtifact(artifact);
-    const privateFunctions = artifact.functions.filter((fn)=>fn.functionType === FunctionType.PRIVATE);
-    const functionsAndSelectors = await Promise.all(privateFunctions.map(async (fn)=>({
-            f: fn,
-            selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)
-        })));
-    const privateFunctionArtifact = functionsAndSelectors.find((fn)=>selector.equals(fn.selector))?.f;
-    if (!privateFunctionArtifact) {
-        throw new Error(`Private function with selector ${selector.toString()} not found`);
-    }
-    const { artifactTreeSiblingPath, artifactTreeLeafIndex, artifactMetadataHash, functionMetadataHash, utilityFunctionsTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex } = await createPrivateFunctionMembershipProof(selector, artifact);
-    const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
-    const classRegistry = ContractClassRegistryContract.at(wallet);
-    const bytecode = bufferAsFields(privateFunctionArtifact.bytecode, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS);
-    return classRegistry.methods.broadcast_private_function(contractClass.id, artifactMetadataHash, utilityFunctionsTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex, padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT), artifactTreeLeafIndex, // eslint-disable-next-line camelcase
-    {
-        selector,
-        metadata_hash: functionMetadataHash,
-        vk_hash: vkHash
-    }).with({
-        capsules: [
-            new Capsule(ProtocolContractAddress.ContractClassRegistry, new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT), bytecode)
-        ]
-    });
-}
-/**
- * Sets up a call to broadcast a utility function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */ export async function broadcastUtilityFunction(wallet, artifact, selector) {
-    const contractClass = await getContractClassFromArtifact(artifact);
-    const utilityFunctions = artifact.functions.filter((fn)=>fn.functionType === FunctionType.UTILITY);
-    const utilityFunctionsAndSelectors = await Promise.all(utilityFunctions.map(async (fn)=>({
-            f: fn,
-            selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)
-        })));
-    const utilityFunctionArtifact = utilityFunctionsAndSelectors.find((fn)=>selector.equals(fn.selector))?.f;
-    if (!utilityFunctionArtifact) {
-        throw new Error(`Utility function with selector ${selector.toString()} not found`);
-    }
-    const { artifactMetadataHash, artifactTreeLeafIndex, artifactTreeSiblingPath, functionMetadataHash, privateFunctionsArtifactTreeRoot } = await createUtilityFunctionMembershipProof(selector, artifact);
-    const classRegistry = ContractClassRegistryContract.at(wallet);
-    const bytecode = bufferAsFields(utilityFunctionArtifact.bytecode, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS);
-    return classRegistry.methods.broadcast_utility_function(contractClass.id, artifactMetadataHash, privateFunctionsArtifactTreeRoot, padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT), artifactTreeLeafIndex, // eslint-disable-next-line camelcase
-    {
-        selector,
-        metadata_hash: functionMetadataHash
-    }).with({
-        capsules: [
-            new Capsule(ProtocolContractAddress.ContractClassRegistry, new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT), bytecode)
-        ]
-    });
-}

package/src/deployment/broadcast_function.ts

@@ -1,148 +0,0 @@
-import {
-  ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
-  CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT,
-  MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-} from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type ContractArtifact, FunctionSelector, FunctionType, bufferAsFields } from '@aztec/stdlib/abi';
-import {
-  computeVerificationKeyHash,
-  createPrivateFunctionMembershipProof,
-  createUtilityFunctionMembershipProof,
-  getContractClassFromArtifact,
-} from '@aztec/stdlib/contract';
-import { Capsule } from '@aztec/stdlib/tx';
-
-import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
-import type { Wallet } from '../wallet/index.js';
-
-/**
- * Sets up a call to broadcast a private function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */
-export async function broadcastPrivateFunction(
-  wallet: Wallet,
-  artifact: ContractArtifact,
-  selector: FunctionSelector,
-): Promise<ContractFunctionInteraction> {
-  const contractClass = await getContractClassFromArtifact(artifact);
-  const privateFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.PRIVATE);
-  const functionsAndSelectors = await Promise.all(
-    privateFunctions.map(async fn => ({
-      f: fn,
-      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
-    })),
-  );
-  const privateFunctionArtifact = functionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
-  if (!privateFunctionArtifact) {
-    throw new Error(`Private function with selector ${selector.toString()} not found`);
-  }
-
-  const {
-    artifactTreeSiblingPath,
-    artifactTreeLeafIndex,
-    artifactMetadataHash,
-    functionMetadataHash,
-    utilityFunctionsTreeRoot,
-    privateFunctionTreeSiblingPath,
-    privateFunctionTreeLeafIndex,
-  } = await createPrivateFunctionMembershipProof(selector, artifact);
-
-  const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
-
-  const classRegistry = ContractClassRegistryContract.at(wallet);
-  const bytecode = bufferAsFields(
-    privateFunctionArtifact.bytecode,
-    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  );
-  return classRegistry.methods
-    .broadcast_private_function(
-      contractClass.id,
-      artifactMetadataHash,
-      utilityFunctionsTreeRoot,
-      privateFunctionTreeSiblingPath,
-      privateFunctionTreeLeafIndex,
-      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-      artifactTreeLeafIndex,
-      // eslint-disable-next-line camelcase
-      { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
-    )
-    .with({
-      capsules: [
-        new Capsule(
-          ProtocolContractAddress.ContractClassRegistry,
-          new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
-          bytecode,
-        ),
-      ],
-    });
-}
-
-/**
- * Sets up a call to broadcast a utility function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */
-export async function broadcastUtilityFunction(
-  wallet: Wallet,
-  artifact: ContractArtifact,
-  selector: FunctionSelector,
-): Promise<ContractFunctionInteraction> {
-  const contractClass = await getContractClassFromArtifact(artifact);
-  const utilityFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UTILITY);
-  const utilityFunctionsAndSelectors = await Promise.all(
-    utilityFunctions.map(async fn => ({
-      f: fn,
-      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
-    })),
-  );
-  const utilityFunctionArtifact = utilityFunctionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
-  if (!utilityFunctionArtifact) {
-    throw new Error(`Utility function with selector ${selector.toString()} not found`);
-  }
-
-  const {
-    artifactMetadataHash,
-    artifactTreeLeafIndex,
-    artifactTreeSiblingPath,
-    functionMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-  } = await createUtilityFunctionMembershipProof(selector, artifact);
-
-  const classRegistry = ContractClassRegistryContract.at(wallet);
-  const bytecode = bufferAsFields(
-    utilityFunctionArtifact.bytecode,
-    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  );
-  return classRegistry.methods
-    .broadcast_utility_function(
-      contractClass.id,
-      artifactMetadataHash,
-      privateFunctionsArtifactTreeRoot,
-      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-      artifactTreeLeafIndex,
-      // eslint-disable-next-line camelcase
-      { selector, metadata_hash: functionMetadataHash },
-    )
-    .with({
-      capsules: [
-        new Capsule(
-          ProtocolContractAddress.ContractClassRegistry,
-          new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
-          bytecode,
-        ),
-      ],
-    });
-}