@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/contract/interaction_options.ts

@@ -0,0 +1,163 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { Capsule, OffchainEffect, SimulationStats } from '@aztec/stdlib/tx';
+
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import type { ProfileOptions, SendOptions, SimulateOptions } from '../wallet/index.js';
+
+/**
+ * Options used to tweak the simulation and add gas estimation capabilities
+ */
+export type FeeEstimationOptions = {
+  /** Whether to modify the fee settings of the simulation with high gas limit to figure out actual gas settings. */
+  estimateGas?: boolean;
+  /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
+  estimatedGasPadding?: number;
+};
+
+/**
+ * Interactions allow configuring a custom fee payment method that gets bundled with the transaction before
+ * sending it to the wallet
+ */
+export type FeePaymentMethodOption = {
+  /** Fee payment method to embed in the interaction */
+  paymentMethod?: FeePaymentMethod;
+};
+
+/**
+ * User-defined partial gas settings for the interaction. This type is completely optional since
+ * the wallet will fill in the missing options
+ */
+export type GasSettingsOption = {
+  /** The gas settings */
+  gasSettings?: Partial<FieldsOf<GasSettings>>;
+};
+
+/** Fee options as set by a user. */
+export type InteractionFeeOptions = GasSettingsOption & FeePaymentMethodOption;
+
+/**  Fee options that can be set for simulation *only* */
+export type SimulationInteractionFeeOptions = InteractionFeeOptions & FeeEstimationOptions;
+
+/**
+ * Represents the options to configure a request from a contract interaction.
+ * Allows specifying additional auth witnesses and capsules to use during execution
+ */
+export type RequestInteractionOptions = {
+  /** Extra authwits to use during execution */
+  authWitnesses?: AuthWitness[];
+  /** Extra capsules to use during execution */
+  capsules?: Capsule[];
+  /** Fee payment method to embed in the interaction request */
+  fee?: FeePaymentMethodOption;
+};
+
+/**
+ * Represents options for calling a (constrained) function in a contract.
+ */
+export type SendInteractionOptions = RequestInteractionOptions & {
+  /** The sender's Aztec address. */
+  from: AztecAddress;
+  /** The fee options for the transaction. */
+  fee?: InteractionFeeOptions;
+};
+
+/**
+ * Represents the options for simulating a contract function interaction.
+ * Allows specifying the address from which the method should be called.
+ * Disregarded for simulation of public functions
+ */
+export type SimulateInteractionOptions = Omit<SendInteractionOptions, 'fee'> & {
+  /** The fee options for the transaction. */
+  fee?: SimulationInteractionFeeOptions;
+  /** Simulate without checking for the validity of the resulting transaction, e.g. whether it emits any existing nullifiers. */
+  skipTxValidation?: boolean;
+  /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
+  skipFeeEnforcement?: boolean;
+  /** Whether to include metadata such as offchain effects and performance statistics (e.g. timing information of the different circuits and oracles) in
+   * the simulation result, instead of just the return value of the function */
+  includeMetadata?: boolean;
+};
+
+/**
+ * Represents the options for profiling an interaction.
+ */
+export type ProfileInteractionOptions = SimulateInteractionOptions & {
+  /** Whether to return gates information or the bytecode/witnesses. */
+  profileMode: 'gates' | 'execution-steps' | 'full';
+  /** Whether to generate a Chonk proof or not */
+  skipProofGeneration?: boolean;
+};
+
+/**
+ * Represents the result type of a simulation.
+ * By default, it will just be the return value of the simulated function
+ * If `includeMetadata` is set to true in `SimulateInteractionOptions` on the input of `simulate(...)`,
+ * it will provide extra information.
+ */
+export type SimulationReturn<T extends boolean | undefined> = T extends true
+  ? {
+      /** Additional stats about the simulation */
+      stats: SimulationStats;
+      /** Offchain effects generated during the simulation */
+      offchainEffects: OffchainEffect[];
+      /**  Return value of the function */
+      result: any;
+      /** Gas estimation results */
+      estimatedGas: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>;
+    }
+  : any;
+
+/**
+ * Transforms and cleans up the higher level SendInteractionOptions defined by the interaction into
+ * SendOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export function toSendOptions(options: SendInteractionOptions): SendOptions {
+  return {
+    ...options,
+    fee: {
+      // If a payment method that includes gas settings was used,
+      // try to reuse as much as possible while still allowing
+      // manual override. CAREFUL: this can cause mismatches during proving
+      gasSettings: {
+        ...options.fee?.paymentMethod?.getGasSettings(),
+        ...options.fee?.gasSettings,
+      },
+    },
+  };
+}
+
+/**
+ * Transforms and cleans up the higher level SimulateInteractionOptions defined by the interaction into
+ * SimulateOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export function toSimulateOptions(options: SimulateInteractionOptions): SimulateOptions {
+  return {
+    ...options,
+    fee: {
+      // If a payment method that includes gas settings was used,
+      // try to reuse as much as possible while still allowing
+      // manual override. CAREFUL: this can cause mismatches during proving
+      gasSettings: {
+        ...options.fee?.paymentMethod?.getGasSettings(),
+        ...options.fee?.gasSettings,
+      },
+      estimateGas: options.fee?.estimateGas,
+      estimatedGasPadding: options.fee?.estimatedGasPadding,
+    },
+  };
+}
+
+/**
+ * Transforms and cleans up the higher level ProfileInteractionOptions defined by the interaction into
+ * ProfileOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export function toProfileOptions(options: ProfileInteractionOptions): ProfileOptions {
+  return {
+    ...toSimulateOptions(options),
+    profileMode: options.profileMode,
+    skipProofGeneration: options.skipProofGeneration,
+  };
+}

package/src/contract/protocol_contracts.ts

@@ -1,30 +1,30 @@
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 
-import type { Wallet } from '../wallet/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { UnsafeContract } from './unsafe_contract.js';
 
-/** Returns a Contract wrapper for the class registerer. */
-export async function getRegistererContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractClassRegisterer);
+/** Returns a Contract wrapper for the contract class registry. */
+export async function getClassRegistryContract(wallet: Wallet) {
+  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractClassRegistry);
   if (!contractInstance) {
-    throw new Error("ContractClassRegisterer is not registered in this wallet's instance");
+    throw new Error("ContractClassRegistry is not registered in this wallet's instance");
   }
   const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
 
   return new UnsafeContract(contractInstance!, artifact!, wallet);
 }
 
-/** Returns a Contract wrapper for the instance deployer. */
-export async function getDeployerContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractInstanceDeployer);
+/** Returns a Contract wrapper for the contract instance registry. */
+export async function getInstanceRegistryContract(wallet: Wallet) {
+  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractInstanceRegistry);
   if (!contractInstance) {
-    throw new Error("ContractInstanceDeployer is not registered in this wallet's instance");
+    throw new Error("ContractInstanceRegistry is not registered in this wallet's instance");
   }
   const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
   return new UnsafeContract(contractInstance!, artifact!, wallet);
 }
 
-/** Returns a Contract wrapper for the fee juice */
+/** Returns a Contract wrapper for the fee juice contract */
 export async function getFeeJuice(wallet: Wallet) {
   const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.FeeJuice);
   if (!contractInstance) {

package/src/contract/sent_tx.ts

@@ -1,7 +1,10 @@
+import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { retryUntil } from '@aztec/foundation/retry';
 import type { FieldsOf } from '@aztec/foundation/types';
-import type { AztecNode, GetPublicLogsResponse, PXE } from '@aztec/stdlib/interfaces/client';
-import { type TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../wallet/wallet.js';
 
 /** Options related to waiting for a tx. */
 export type WaitOpts = {
@@ -9,24 +12,16 @@ export type WaitOpts = {
   ignoreDroppedReceiptsFor?: number;
   /** The maximum time (in seconds) to wait for the transaction to be mined. Defaults to 60. */
   timeout?: number;
-  /** The maximum time (in seconds) to wait for the transaction to be proven. Defaults to 600. */
-  provenTimeout?: number;
   /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
   interval?: number;
-  /** Whether to wait for the tx to be proven. */
-  proven?: boolean;
-  /** Whether to include information useful for debugging/testing in the receipt. */
-  debug?: boolean;
   /** Whether to accept a revert as a status code for the tx when waiting for it. If false, will throw if the tx reverts. */
   dontThrowOnRevert?: boolean;
 };
 
 export const DefaultWaitOpts: WaitOpts = {
   ignoreDroppedReceiptsFor: 5,
-  timeout: 60,
-  provenTimeout: 600,
+  timeout: 300,
   interval: 1,
-  debug: false,
 };
 
 /**
@@ -34,7 +29,27 @@ export const DefaultWaitOpts: WaitOpts = {
  * its hash, receipt, and mining status.
  */
 export class SentTx {
-  constructor(protected pxeOrNode: PXE | AztecNode, protected txHashPromise: Promise<TxHash>) {}
+  protected sendTxPromise: Promise<void>;
+  protected sendTxError?: Error;
+  protected txHash?: TxHash;
+
+  constructor(
+    protected walletOrNode: Wallet | AztecNode,
+    sendTx: () => Promise<TxHash>,
+  ) {
+    const { promise, resolve } = promiseWithResolvers<void>();
+    this.sendTxPromise = promise;
+    sendTx()
+      .then(txHash => {
+        this.txHash = txHash;
+        resolve();
+      })
+      .catch(err => {
+        this.sendTxError = err;
+        // Calling resolve instead of reject here because we want to throw the error when getTxHash is called.
+        resolve();
+      });
+  }
 
   /**
    * Retrieves the transaction hash of the SentTx instance.
@@ -43,8 +58,17 @@ export class SentTx {
    * @returns A promise that resolves to the transaction hash of the SentTx instance.
    * TODO(#7717): Don't throw here.
    */
-  public getTxHash(): Promise<TxHash> {
-    return this.txHashPromise;
+  public async getTxHash(): Promise<TxHash> {
+    // Make sure sendTx has been resolved, which can be triggered when it returns a txHash or when it throws an error.
+    await this.sendTxPromise;
+
+    // If sendTx threw an error, throw it.
+    if (this.sendTxError) {
+      throw this.sendTxError;
+    }
+
+    // sendTx returned a txHash if it's been resolved and no error was set.
+    return Promise.resolve(this.txHash!);
   }
 
   /**
@@ -56,7 +80,7 @@ export class SentTx {
    */
   public async getReceipt(): Promise<TxReceipt> {
     const txHash = await this.getTxHash();
-    return await this.pxeOrNode.getTxReceipt(txHash);
+    return await this.walletOrNode.getTxReceipt(txHash);
   }
 
   /**
@@ -68,35 +92,12 @@ export class SentTx {
     const receipt = await this.waitForReceipt(opts);
     if (receipt.status !== TxStatus.SUCCESS && !opts?.dontThrowOnRevert) {
       throw new Error(
-        `Transaction ${await this.getTxHash()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
+        `Transaction ${(await this.getTxHash()).toString()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
       );
     }
-    if (opts?.proven && receipt.blockNumber !== undefined) {
-      await this.waitForProven(receipt.blockNumber, opts);
-    }
-    if (opts?.debug) {
-      const txHash = await this.getTxHash();
-      const { data: tx } = (await this.pxeOrNode.getTxEffect(txHash))!;
-      receipt.debugInfo = {
-        noteHashes: tx.noteHashes,
-        nullifiers: tx.nullifiers,
-        publicDataWrites: tx.publicDataWrites,
-        l2ToL1Msgs: tx.l2ToL1Msgs,
-      };
-    }
     return receipt;
   }
 
-  /**
-   * Gets public logs emitted by this tx.
-   * @remarks This function will wait for the tx to be mined if it hasn't been already.
-   * @returns The requested logs.
-   */
-  public async getPublicLogs(): Promise<GetPublicLogsResponse> {
-    await this.wait();
-    return this.pxeOrNode.getPublicLogs({ txHash: await this.getTxHash() });
-  }
-
   protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {
     const txHash = await this.getTxHash();
     const startTime = Date.now();
@@ -104,7 +105,7 @@ export class SentTx {
 
     return await retryUntil(
       async () => {
-        const txReceipt = await this.pxeOrNode.getTxReceipt(txHash);
+        const txReceipt = await this.walletOrNode.getTxReceipt(txHash);
         // If receipt is not yet available, try again
         if (txReceipt.status === TxStatus.PENDING) {
           return undefined;
@@ -126,16 +127,4 @@ export class SentTx {
       opts?.interval ?? DefaultWaitOpts.interval,
     );
   }
-
-  protected async waitForProven(minedBlock: number, opts?: WaitOpts) {
-    return await retryUntil(
-      async () => {
-        const provenBlock = await this.pxeOrNode.getProvenBlockNumber();
-        return provenBlock >= minedBlock ? provenBlock : undefined;
-      },
-      'isProven',
-      opts?.provenTimeout ?? DefaultWaitOpts.provenTimeout,
-      opts?.interval ?? DefaultWaitOpts.interval,
-    );
-  }
 }

package/src/contract/unsafe_contract.ts

@@ -1,7 +1,7 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
-import type { Wallet } from '../wallet/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractBase } from './contract_base.js';
 
 /** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */
@@ -14,6 +14,6 @@ export class UnsafeContract extends ContractBase {
     /** The wallet used for interacting with this contract. */
     wallet: Wallet,
   ) {
-    super(instance, artifact, wallet);
+    super(instance.address, artifact, wallet);
   }
 }

package/src/contract/wait_for_proven.ts

@@ -0,0 +1,38 @@
+import { retryUntil } from '@aztec/foundation/retry';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { TxReceipt } from '@aztec/stdlib/tx';
+
+import { DefaultWaitOpts } from './sent_tx.js';
+
+/**
+ * Options for waiting for a transaction to be proven.
+ */
+export type WaitForProvenOpts = {
+  /** Time to wait for the tx to be proven before timing out */
+  provenTimeout?: number;
+  /** Elapsed time between polls to the node */
+  interval?: number;
+};
+
+export const DefaultWaitForProvenOpts: WaitForProvenOpts = {
+  provenTimeout: 600,
+  interval: DefaultWaitOpts.interval,
+};
+
+/**
+ * Wait for a transaction to be proven by polling the node
+ */
+export async function waitForProven(node: AztecNode, receipt: TxReceipt, opts?: WaitForProvenOpts) {
+  if (!receipt.blockNumber) {
+    throw new Error(`Cannot wait for proven: receipt of tx ${receipt.txHash} does not have a block number`);
+  }
+  return await retryUntil(
+    async () => {
+      const provenBlock = await node.getProvenBlockNumber();
+      return provenBlock >= receipt.blockNumber! ? provenBlock : undefined;
+    },
+    'isProven',
+    opts?.provenTimeout ?? DefaultWaitForProvenOpts.provenTimeout,
+    opts?.interval ?? DefaultWaitForProvenOpts.interval,
+  );
+}

package/src/deployment/broadcast_function.ts

@@ -1,7 +1,7 @@
 import {
   ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
+  CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT,
   MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
@@ -10,17 +10,17 @@ import { type ContractArtifact, FunctionSelector, FunctionType, bufferAsFields }
 import {
   computeVerificationKeyHash,
   createPrivateFunctionMembershipProof,
-  createUnconstrainedFunctionMembershipProof,
+  createUtilityFunctionMembershipProof,
   getContractClassFromArtifact,
 } from '@aztec/stdlib/contract';
 import { Capsule } from '@aztec/stdlib/tx';
 
 import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getRegistererContract } from '../contract/protocol_contracts.js';
+import { getClassRegistryContract } from '../contract/protocol_contracts.js';
 import type { Wallet } from '../wallet/index.js';
 
 /**
- * Sets up a call to broadcast a private function's bytecode via the ClassRegisterer contract.
+ * 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.
@@ -51,43 +51,43 @@ export async function broadcastPrivateFunction(
     artifactTreeLeafIndex,
     artifactMetadataHash,
     functionMetadataHash,
-    unconstrainedFunctionsArtifactTreeRoot,
+    utilityFunctionsTreeRoot,
     privateFunctionTreeSiblingPath,
     privateFunctionTreeLeafIndex,
   } = await createPrivateFunctionMembershipProof(selector, artifact);
 
   const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
 
-  const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_private_function(
-    contractClass.id,
-    artifactMetadataHash,
-    unconstrainedFunctionsArtifactTreeRoot,
-    privateFunctionTreeSiblingPath,
-    privateFunctionTreeLeafIndex,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
-  );
-
+  const classRegistry = await getClassRegistryContract(wallet);
   const bytecode = bufferAsFields(
     privateFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  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 an unconstrained function's bytecode via the ClassRegisterer contract.
+ * 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.
@@ -95,22 +95,22 @@ export async function broadcastPrivateFunction(
  * @param selector - Selector of the function to be broadcast.
  * @returns A ContractFunctionInteraction object that can be used to send the transaction.
  */
-export async function broadcastUnconstrainedFunction(
+export async function broadcastUtilityFunction(
   wallet: Wallet,
   artifact: ContractArtifact,
   selector: FunctionSelector,
 ): Promise<ContractFunctionInteraction> {
   const contractClass = await getContractClassFromArtifact(artifact);
-  const unconstrainedFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UNCONSTRAINED);
-  const unconstrainedFunctionsAndSelectors = await Promise.all(
-    unconstrainedFunctions.map(async fn => ({
+  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 unconstrainedFunctionArtifact = unconstrainedFunctionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
-  if (!unconstrainedFunctionArtifact) {
-    throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
+  const utilityFunctionArtifact = utilityFunctionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
+  if (!utilityFunctionArtifact) {
+    throw new Error(`Utility function with selector ${selector.toString()} not found`);
   }
 
   const {
@@ -119,30 +119,30 @@ export async function broadcastUnconstrainedFunction(
     artifactTreeSiblingPath,
     functionMetadataHash,
     privateFunctionsArtifactTreeRoot,
-  } = await createUnconstrainedFunctionMembershipProof(selector, artifact);
-
-  const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_unconstrained_function(
-    contractClass.id,
-    artifactMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash },
-  );
+  } = await createUtilityFunctionMembershipProof(selector, artifact);
 
+  const classRegistry = await getClassRegistryContract(wallet);
   const bytecode = bufferAsFields(
-    unconstrainedFunctionArtifact.bytecode,
+    utilityFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  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/contract_deployer.ts

@@ -1,10 +1,10 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { Wallet } from '../account/wallet.js';
 import { Contract } from '../contract/contract.js';
 import { DeployMethod } from '../contract/deploy_method.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /**
  * A class for deploying contract.
@@ -28,7 +28,8 @@ export class ContractDeployer {
    * @returns A DeployMethod instance configured with the ABI, PXE, and constructor arguments.
    */
   public deploy(...args: any[]) {
-    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, this.artifact, wallet);
+    const postDeployCtor = (instance: ContractInstanceWithAddress, wallet: Wallet) =>
+      Contract.at(instance.address, this.artifact, wallet);
     return new DeployMethod(
       this.publicKeys ?? PublicKeys.default(),
       this.wallet,

package/src/deployment/publish_class.ts

@@ -0,0 +1,34 @@
+import {
+  CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT,
+  MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { type ContractArtifact, bufferAsFields } from '@aztec/stdlib/abi';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { Capsule } from '@aztec/stdlib/tx';
+
+import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { getClassRegistryContract } from '../contract/protocol_contracts.js';
+import type { Wallet } from '../wallet/index.js';
+
+/** Sets up a call to publish a contract class given its artifact. */
+export async function publishContractClass(
+  wallet: Wallet,
+  artifact: ContractArtifact,
+): Promise<ContractFunctionInteraction> {
+  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
+    await getContractClassFromArtifact(artifact);
+  const classRegistry = await getClassRegistryContract(wallet);
+
+  const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
+  return classRegistry.methods.publish(artifactHash, privateFunctionsRoot, publicBytecodeCommitment).with({
+    capsules: [
+      new Capsule(
+        ProtocolContractAddress.ContractClassRegistry,
+        new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
+        encodedBytecode,
+      ),
+    ],
+  });
+}