@aztec/aztec.js 0.0.1-commit.c80b6263 → 0.0.1-commit.cf93bcc56

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';
@@ -40,6 +39,7 @@ import {
   type SimulateInteractionOptions,
 } from '../contract/interaction_options.js';
 import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+import type { AppCapabilities, WalletCapabilities } from './capabilities.js';
 
 /**
  * A wrapper type that allows any item to be associated with an alias.
@@ -139,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.
  */
@@ -196,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.
  */
@@ -216,29 +255,19 @@ 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,
     opts: SendOptions<W>,
   ): Promise<SendReturn<W>>;
   createAuthWit(from: AztecAddress, messageHashOrIntent: IntentInnerHash | CallIntent): Promise<AuthWitness>;
+  requestCapabilities(manifest: AppCapabilities): Promise<WalletCapabilities>;
   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),
@@ -295,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,
   }),
 ]);
 
@@ -305,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,
@@ -312,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),
@@ -333,6 +376,119 @@ export const ContractClassMetadataSchema = z.object({
   isContractClassPubliclyRegistered: z.boolean(),
 });
 
+export const ContractFunctionPatternSchema = z.object({
+  contract: z.union([schemas.AztecAddress, z.literal('*')]),
+  function: z.union([z.string(), z.literal('*')]),
+});
+
+export const AccountsCapabilitySchema = z.object({
+  type: z.literal('accounts'),
+  canGet: optional(z.boolean()),
+  canCreateAuthWit: optional(z.boolean()),
+});
+
+export const GrantedAccountsCapabilitySchema = AccountsCapabilitySchema.extend({
+  accounts: z.array(z.object({ alias: z.string(), item: schemas.AztecAddress })),
+});
+
+export const ContractsCapabilitySchema = z.object({
+  type: z.literal('contracts'),
+  contracts: z.union([z.literal('*'), z.array(schemas.AztecAddress)]),
+  canRegister: optional(z.boolean()),
+  canGetMetadata: optional(z.boolean()),
+});
+
+export const GrantedContractsCapabilitySchema = ContractsCapabilitySchema;
+
+export const ContractClassesCapabilitySchema = z.object({
+  type: z.literal('contractClasses'),
+  classes: z.union([z.literal('*'), z.array(schemas.Fr)]),
+  canGetMetadata: z.boolean(),
+});
+
+export const GrantedContractClassesCapabilitySchema = ContractClassesCapabilitySchema;
+
+export const SimulationCapabilitySchema = z.object({
+  type: z.literal('simulation'),
+  transactions: optional(
+    z.object({
+      scope: z.union([z.literal('*'), z.array(ContractFunctionPatternSchema)]),
+    }),
+  ),
+  utilities: optional(
+    z.object({
+      scope: z.union([z.literal('*'), z.array(ContractFunctionPatternSchema)]),
+    }),
+  ),
+});
+
+export const GrantedSimulationCapabilitySchema = SimulationCapabilitySchema;
+
+export const TransactionCapabilitySchema = z.object({
+  type: z.literal('transaction'),
+  scope: z.union([z.literal('*'), z.array(ContractFunctionPatternSchema)]),
+});
+
+export const GrantedTransactionCapabilitySchema = TransactionCapabilitySchema;
+
+export const DataCapabilitySchema = z.object({
+  type: z.literal('data'),
+  addressBook: optional(z.boolean()),
+  privateEvents: optional(
+    z.object({
+      contracts: z.union([z.literal('*'), z.array(schemas.AztecAddress)]),
+    }),
+  ),
+});
+
+export const GrantedDataCapabilitySchema = DataCapabilitySchema;
+
+export const CapabilitySchema = z.discriminatedUnion('type', [
+  AccountsCapabilitySchema,
+  ContractsCapabilitySchema,
+  ContractClassesCapabilitySchema,
+  SimulationCapabilitySchema,
+  TransactionCapabilitySchema,
+  DataCapabilitySchema,
+]);
+
+export const GrantedCapabilitySchema = z.discriminatedUnion('type', [
+  GrantedAccountsCapabilitySchema,
+  GrantedContractsCapabilitySchema,
+  GrantedContractClassesCapabilitySchema,
+  GrantedSimulationCapabilitySchema,
+  GrantedTransactionCapabilitySchema,
+  GrantedDataCapabilitySchema,
+]);
+
+export const AppCapabilitiesSchema = z.object({
+  version: z.literal('1.0'),
+  metadata: z.object({
+    name: z.string(),
+    version: z.string(),
+    description: optional(z.string()),
+    url: optional(z.string()),
+    icon: optional(z.string()),
+  }),
+  capabilities: z.array(CapabilitySchema),
+  behavior: optional(
+    z.object({
+      mode: optional(z.enum(['strict', 'permissive'])),
+      expiration: optional(z.number()),
+    }),
+  ),
+});
+
+export const WalletCapabilitiesSchema = z.object({
+  version: z.literal('1.0'),
+  granted: z.array(GrantedCapabilitySchema),
+  wallet: z.object({
+    name: z.string(),
+    version: z.string(),
+  }),
+  expiresAt: optional(z.number()),
+});
+
 /**
  * Record of all wallet method schemas (excluding batch).
  * This is the single source of truth for method schemas - batch schemas are derived from this.
@@ -364,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
@@ -372,6 +534,7 @@ const WalletMethodSchemas = {
     .args(ExecutionPayloadSchema, SendOptionsSchema)
     .returns(z.union([TxHash.schema, TxReceipt.schema])),
   createAuthWit: z.function().args(schemas.AztecAddress, MessageHashOrIntentSchema).returns(AuthWitness.schema),
+  requestCapabilities: z.function().args(AppCapabilitiesSchema).returns(WalletCapabilitiesSchema),
 };
 
 /**

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,
-        ),
-      ],
-    });
-}