@aztec/aztec.js 0.23.0 → 0.26.1

package/src/contract/contract_function_interaction.ts

@@ -0,0 +1,80 @@
+import { FunctionCall, TxExecutionRequest } from '@aztec/circuit-types';
+import { AztecAddress, FunctionData } from '@aztec/circuits.js';
+import { FunctionAbi, FunctionType, encodeArguments } from '@aztec/foundation/abi';
+
+import { Wallet } from '../account/wallet.js';
+import { BaseContractInteraction, SendMethodOptions } from './base_contract_interaction.js';
+
+export { SendMethodOptions };
+
+/**
+ * Represents the options for a view method in a contract function interaction.
+ * Allows specifying the address from which the view method should be called.
+ */
+export type ViewMethodOptions = {
+  /**
+   * The sender's Aztec address.
+   */
+  from?: AztecAddress;
+};
+
+/**
+ * This is the class that is returned when calling e.g. `contract.methods.myMethod(arg0, arg1)`.
+ * It contains available interactions one can call on a method, including view.
+ */
+export class ContractFunctionInteraction extends BaseContractInteraction {
+  constructor(
+    protected wallet: Wallet,
+    protected contractAddress: AztecAddress,
+    protected functionDao: FunctionAbi,
+    protected args: any[],
+  ) {
+    super(wallet);
+    if (args.some(arg => arg === undefined || arg === null)) {
+      throw new Error('All function interaction arguments must be defined and not null. Received: ' + args);
+    }
+  }
+
+  /**
+   * Create a transaction execution request that represents this call, encoded and authenticated by the
+   * user's wallet, ready to be simulated.
+   * @param opts - An optional object containing additional configuration for the transaction.
+   * @returns A Promise that resolves to a transaction instance.
+   */
+  public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
+    if (this.functionDao.functionType === FunctionType.UNCONSTRAINED) {
+      throw new Error("Can't call `create` on an unconstrained function.");
+    }
+    if (!this.txRequest) {
+      this.txRequest = await this.wallet.createTxExecutionRequest([this.request()], opts?.fee);
+    }
+    return this.txRequest;
+  }
+
+  /**
+   * Returns an execution request that represents this operation. Useful as a building
+   * block for constructing batch requests.
+   * @returns An execution request wrapped in promise.
+   */
+  public request(): FunctionCall {
+    const args = encodeArguments(this.functionDao, this.args);
+    const functionData = FunctionData.fromAbi(this.functionDao);
+    return { args, functionData, to: this.contractAddress };
+  }
+
+  /**
+   * Execute a view (read-only) transaction on an unconstrained function.
+   * This method is used to call functions that do not modify the contract state and only return data.
+   * Throws an error if called on a non-unconstrained function.
+   * @param options - An optional object containing additional configuration for the transaction.
+   * @returns The result of the view transaction as returned by the contract function.
+   */
+  public view(options: ViewMethodOptions = {}) {
+    if (this.functionDao.functionType !== FunctionType.UNCONSTRAINED) {
+      throw new Error('Can only call `view` on an unconstrained function.');
+    }
+
+    const { from } = options;
+    return this.wallet.viewTx(this.functionDao.name, this.args, this.contractAddress, from);
+  }
+}

package/src/contract/deploy_method.ts

@@ -0,0 +1,192 @@
+import { FunctionCall, PublicKey, Tx, TxExecutionRequest } from '@aztec/circuit-types';
+import {
+  AztecAddress,
+  computePartialAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromDeployParams,
+} from '@aztec/circuits.js';
+import { ContractArtifact, FunctionArtifact } from '@aztec/foundation/abi';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { Wallet } from '../account/index.js';
+import { deployInstance } from '../deployment/deploy_instance.js';
+import { registerContractClass } from '../deployment/register_class.js';
+import { BaseContractInteraction, SendMethodOptions } from './base_contract_interaction.js';
+import { type Contract } from './contract.js';
+import { ContractBase } from './contract_base.js';
+import { ContractFunctionInteraction } from './contract_function_interaction.js';
+import { DeploySentTx } from './deploy_sent_tx.js';
+
+/**
+ * Options for deploying a contract on the Aztec network.
+ * Allows specifying a portal contract, contract address salt, and additional send method options.
+ */
+export type DeployOptions = {
+  /** The Ethereum address of the Portal contract. */
+  portalContract?: EthAddress;
+  /** An optional salt value used to deterministically calculate the contract address. */
+  contractAddressSalt?: Fr;
+  /** Set to true to *not* include the sender in the address computation. */
+  universalDeploy?: boolean;
+  /** Skip contract class registration. */
+  skipClassRegistration?: boolean;
+  /** Skip public deployment and only initialize the contract. */
+  skipPublicDeployment?: boolean;
+} & SendMethodOptions;
+
+// TODO(@spalladino): Add unit tests for this class!
+
+/**
+ * Contract interaction for deployment. Handles class registration, public instance deployment,
+ * and initialization of the contract. Extends the BaseContractInteraction class.
+ */
+export class DeployMethod<TContract extends ContractBase = Contract> extends BaseContractInteraction {
+  /** The contract instance to be deployed. */
+  private instance?: ContractInstanceWithAddress = undefined;
+
+  /** Constructor function to call. */
+  private constructorArtifact: FunctionArtifact;
+
+  private log = createDebugLogger('aztec:js:deploy_method');
+
+  constructor(
+    private publicKey: PublicKey,
+    protected wallet: Wallet,
+    private artifact: ContractArtifact,
+    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    private args: any[] = [],
+    constructorName: string = 'constructor',
+  ) {
+    super(wallet);
+    const constructorArtifact = artifact.functions.find(f => f.name === constructorName);
+    if (!constructorArtifact) {
+      throw new Error('Cannot find constructor in the artifact.');
+    }
+    this.constructorArtifact = constructorArtifact;
+  }
+
+  /**
+   * Create a contract deployment transaction, given the deployment options.
+   * This function internally calls `request()` and `sign()` methods to prepare
+   * the transaction for deployment. The resulting signed transaction can be
+   * later sent using the `send()` method.
+   *
+   * @param options - An object containing optional deployment settings, including portalContract, contractAddressSalt, and from.
+   * @returns A Promise resolving to an object containing the signed transaction data and other relevant information.
+   */
+  public async create(options: DeployOptions = {}): Promise<TxExecutionRequest> {
+    if (!this.txRequest) {
+      this.txRequest = await this.wallet.createTxExecutionRequest(await this.request(options));
+      // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
+      await this.pxe.addContracts([{ artifact: this.artifact, instance: this.instance! }]);
+    }
+    return this.txRequest;
+  }
+
+  /**
+   * Returns an array of function calls that represent this operation. Useful as a building
+   * block for constructing batch requests.
+   * @param options - Deployment options.
+   * @returns An array of function calls.
+   * @remarks This method does not have the same return type as the `request` in the ContractInteraction object,
+   * it returns a promise for an array instead of a function call directly.
+   */
+  public async request(options: DeployOptions = {}): Promise<FunctionCall[]> {
+    const { address } = this.getInstance(options);
+    const constructorCall = new ContractFunctionInteraction(this.wallet, address, this.constructorArtifact, this.args);
+    return [...(await this.getDeploymentFunctionCalls(options)), constructorCall.request()];
+  }
+
+  /**
+   * Returns calls for registration of the class and deployment of the instance, depending on the provided options.
+   * @param options - Deployment options.
+   * @returns A function call array with potentially requests to the class registerer and instance deployer.
+   */
+  protected async getDeploymentFunctionCalls(options: DeployOptions = {}): Promise<FunctionCall[]> {
+    const calls: FunctionCall[] = [];
+
+    // Set contract instance object so it's available for populating the DeploySendTx object
+    const instance = this.getInstance(options);
+
+    // Obtain contract class from artifact and check it matches the reported one by the instance.
+    // TODO(@spalladino): We're unnecessarily calculating the contract class multiple times here.
+    const contractClass = getContractClassFromArtifact(this.artifact);
+    if (!instance.contractClassId.equals(contractClass.id)) {
+      throw new Error(
+        `Contract class mismatch when deploying contract: got ${instance.contractClassId.toString()} from instance and ${contractClass.id.toString()} from artifact`,
+      );
+    }
+
+    // Register the contract class if it hasn't been published already.
+    if (!options.skipClassRegistration) {
+      if (await this.pxe.isContractClassPubliclyRegistered(contractClass.id)) {
+        this.log(
+          `Skipping registration of already registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
+        );
+      } else {
+        this.log(
+          `Creating request for registering contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`,
+        );
+        calls.push((await registerContractClass(this.wallet, this.artifact)).request());
+      }
+    }
+
+    // Deploy the contract via the instance deployer.
+    if (!options.skipPublicDeployment) {
+      calls.push(deployInstance(this.wallet, instance, { universalDeploy: options.universalDeploy }).request());
+    }
+
+    return calls;
+  }
+
+  /**
+   * Send the contract deployment transaction using the provided options.
+   * This function extends the 'send' method from the ContractFunctionInteraction class,
+   * allowing us to send a transaction specifically for contract deployment.
+   *
+   * @param options - An object containing various deployment options such as portalContract, contractAddressSalt, and from.
+   * @returns A SentTx object that returns the receipt and the deployed contract instance.
+   */
+  public send(options: DeployOptions = {}): DeploySentTx<TContract> {
+    const txHashPromise = super.send(options).getTxHash();
+    return new DeploySentTx(this.pxe, txHashPromise, this.postDeployCtor, this.getInstance(options));
+  }
+
+  /**
+   * Builds the contract instance to be deployed and returns it.
+   *
+   * @param options - An object containing various deployment options.
+   * @returns An instance object.
+   */
+  public getInstance(options: DeployOptions = {}): ContractInstanceWithAddress {
+    if (!this.instance) {
+      const portalContract = options.portalContract ?? EthAddress.ZERO;
+      const contractAddressSalt = options.contractAddressSalt ?? Fr.random();
+      const deployParams = [this.artifact, this.args, contractAddressSalt, this.publicKey, portalContract] as const;
+      this.instance = getContractInstanceFromDeployParams(...deployParams);
+    }
+    return this.instance;
+  }
+
+  /**
+   * Simulate the request.
+   * @param options - Deployment options.
+   * @returns The simulated tx.
+   */
+  public simulate(options: DeployOptions): Promise<Tx> {
+    return super.simulate(options);
+  }
+
+  /** Return this deployment address. */
+  public get address() {
+    return this.instance?.address;
+  }
+
+  /** Returns the partial address for this deployment. */
+  public get partialAddress() {
+    return this.instance && computePartialAddress(this.instance);
+  }
+}

package/src/contract/deploy_sent_tx.ts

@@ -0,0 +1,66 @@
+import { PXE, TxHash, TxReceipt } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+import { FieldsOf } from '@aztec/foundation/types';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { Wallet } from '../account/index.js';
+import { type Contract } from './contract.js';
+import { ContractBase } from './contract_base.js';
+import { SentTx, WaitOpts } from './sent_tx.js';
+
+/** Options related to waiting for a deployment tx. */
+export type DeployedWaitOpts = WaitOpts & {
+  /** Wallet to use for creating a contract instance. Uses the one set in the deployer constructor if not set. */
+  wallet?: Wallet;
+};
+
+/** Extends a transaction receipt with a contract instance that represents the newly deployed contract. */
+export type DeployTxReceipt<TContract extends ContractBase = Contract> = FieldsOf<TxReceipt> & {
+  /** Instance of the newly deployed contract. */
+  contract: TContract;
+};
+
+/**
+ * A contract deployment transaction sent to the network, extending SentTx with methods to create a contract instance.
+ */
+export class DeploySentTx<TContract extends Contract = Contract> extends SentTx {
+  constructor(
+    wallet: PXE | Wallet,
+    txHashPromise: Promise<TxHash>,
+    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    /** The deployed contract instance */
+    public instance: ContractInstanceWithAddress,
+  ) {
+    super(wallet, txHashPromise);
+  }
+
+  /**
+   * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
+   * @param opts - Options for configuring the waiting for the tx to be mined.
+   * @returns The deployed contract instance.
+   */
+  public async deployed(opts?: DeployedWaitOpts): Promise<TContract> {
+    const receipt = await this.wait(opts);
+    return receipt.contract;
+  }
+
+  /**
+   * Awaits for the tx to be mined and returns the receipt along with a contract instance. Throws if tx is not mined.
+   * @param opts - Options for configuring the waiting for the tx to be mined.
+   * @returns The transaction receipt with the deployed contract instance.
+   */
+  public async wait(opts?: DeployedWaitOpts): Promise<DeployTxReceipt<TContract>> {
+    const receipt = await super.wait(opts);
+    const contract = await this.getContractObject(opts?.wallet);
+    return { ...receipt, contract };
+  }
+
+  protected getContractObject(wallet?: Wallet): Promise<TContract> {
+    const isWallet = (pxe: PXE | Wallet): pxe is Wallet => !!(pxe as Wallet).createTxExecutionRequest;
+    const contractWallet = wallet ?? (isWallet(this.pxe) && this.pxe);
+    if (!contractWallet) {
+      throw new Error(`A wallet is required for creating a contract instance`);
+    }
+    return this.postDeployCtor(this.instance.address, contractWallet) as Promise<TContract>;
+  }
+}

package/src/contract/index.ts

@@ -0,0 +1,44 @@
+/**
+ * The `contract` module provides utilities for deploying and interacting with contracts, based on a
+ * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
+ * `Wallet` instance, and to the {@link https://docs.aztec.network/developers/contracts/compiling | Compiling contracts}
+ * section of the documentation for how to generate an artifact out of your Noir source code.
+ *
+ * The {@link Contract} class is the main class in this module, and provides static methods for deploying
+ * a contract or interacting with an already deployed one. The `methods` property of the contract instance
+ * provides access to private, public, and view methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `view()`.
+ *
+ * ```ts
+ * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send().deployed();
+ * console.log(`Contract deployed at ${contract.address}`);
+ * ```
+ *
+ * ```ts
+ * const contract = await Contract.at(address, MyContractArtifact, wallet);
+ * await contract.methods.mint(1000, owner).send().wait();
+ * console.log(`Total supply is now ${await contract.methods.totalSupply().view()}`);
+ * ```
+ *
+ * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
+ * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
+ * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
+ * or obtaining the `request` for aggregating into a {@link BatchCall}.
+ *
+ * The result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
+ * transaction hash, or simply `wait` until the transaction is mined and the local PXE Service
+ * has synchronized its changes.
+ *
+ * @remarks If you are using typescript, consider using the
+ * {@link https://docs.aztec.network/developers/contracts/compiling#typescript-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */
+export * from './contract.js';
+export * from './contract_function_interaction.js';
+export * from './sent_tx.js';
+export * from './contract_base.js';
+export * from './batch_call.js';
+export * from './deploy_method.js';
+export * from './deploy_sent_tx.js';

package/src/contract/sent_tx.ts

@@ -0,0 +1,135 @@
+import { ExtendedNote, GetUnencryptedLogsResponse, PXE, TxHash, TxReceipt, TxStatus } from '@aztec/circuit-types';
+import { retryUntil } from '@aztec/foundation/retry';
+import { FieldsOf } from '@aztec/foundation/types';
+
+/** Options related to waiting for a tx. */
+export type WaitOpts = {
+  /** The maximum time (in seconds) to wait for the transaction to be mined. Defaults to 60. */
+  timeout?: number;
+  /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
+  interval?: number;
+  /**
+   * Whether to wait for the PXE Service to sync all notes up to the block in which this tx was mined.
+   * If false, then any queries that depend on state set by this transaction may return stale data. Defaults to true.
+   **/
+  waitForNotesSync?: boolean;
+  /** Whether to include information useful for debugging/testing in the receipt. */
+  debug?: boolean;
+};
+
+export const DefaultWaitOpts: WaitOpts = {
+  timeout: 60,
+  interval: 1,
+  waitForNotesSync: true,
+  debug: false,
+};
+
+/**
+ * The SentTx class represents a sent transaction through the PXE, providing methods to fetch
+ * its hash, receipt, and mining status.
+ */
+export class SentTx {
+  constructor(protected pxe: PXE, protected txHashPromise: Promise<TxHash>) {}
+
+  /**
+   * Retrieves the transaction hash of the SentTx instance.
+   * The function internally awaits for the 'txHashPromise' to resolve, and then returns the resolved transaction hash.
+   *
+   * @returns A promise that resolves to the transaction hash of the SentTx instance.
+   */
+  public getTxHash(): Promise<TxHash> {
+    return this.txHashPromise;
+  }
+
+  /**
+   * Retrieve the transaction receipt associated with the current SentTx instance.
+   * The function fetches the transaction hash using 'getTxHash' and then queries
+   * the PXE to get the corresponding transaction receipt.
+   *
+   * @returns A promise that resolves to a TxReceipt object representing the fetched transaction receipt.
+   */
+  public async getReceipt(): Promise<TxReceipt> {
+    const txHash = await this.getTxHash();
+    return await this.pxe.getTxReceipt(txHash);
+  }
+
+  /**
+   * Awaits for a tx to be mined and returns the receipt. Throws if tx is not mined.
+   * @param opts - Options for configuring the waiting for the tx to be mined.
+   * @returns The transaction receipt.
+   */
+  public async wait(opts?: WaitOpts): Promise<FieldsOf<TxReceipt>> {
+    if (opts?.debug && opts.waitForNotesSync === false) {
+      throw new Error('Cannot set getNotes to true if waitForNotesSync is false');
+    }
+    const receipt = await this.waitForReceipt(opts);
+    if (receipt.status !== TxStatus.MINED) {
+      throw new Error(`Transaction ${await this.getTxHash()} was ${receipt.status}`);
+    }
+    if (opts?.debug) {
+      const txHash = await this.getTxHash();
+      const tx = (await this.pxe.getTxEffect(txHash))!;
+      const visibleNotes = await this.pxe.getNotes({ txHash });
+      receipt.debugInfo = {
+        noteHashes: tx.noteHashes.filter(n => !n.isZero()),
+        nullifiers: tx.nullifiers.filter(n => !n.isZero()),
+        publicDataWrites: tx.publicDataWrites.filter(p => !p.isEmpty()),
+        l2ToL1Msgs: tx.l2ToL1Msgs.filter(l => !l.isZero()),
+        contractsLeaves: tx.contractLeaves.filter(c => !c.isZero()),
+        contractData: tx.contractData.filter(c => !c.isEmpty()),
+        visibleNotes,
+      };
+    }
+    return receipt;
+  }
+
+  /**
+   * Gets unencrypted 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 getUnencryptedLogs(): Promise<GetUnencryptedLogsResponse> {
+    await this.wait();
+    return this.pxe.getUnencryptedLogs({ txHash: await this.getTxHash() });
+  }
+
+  /**
+   * Get notes of accounts registered in the provided PXE/Wallet created in this tx.
+   * @remarks This function will wait for the tx to be mined if it hasn't been already.
+   * @returns The requested notes.
+   */
+  public async getVisibleNotes(): Promise<ExtendedNote[]> {
+    await this.wait();
+    return this.pxe.getNotes({ txHash: await this.getTxHash() });
+  }
+
+  protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {
+    const txHash = await this.getTxHash();
+    return await retryUntil(
+      async () => {
+        const txReceipt = await this.pxe.getTxReceipt(txHash);
+        // If receipt is not yet available, try again
+        if (txReceipt.status === TxStatus.PENDING) {
+          return undefined;
+        }
+        // If the tx was dropped, return it
+        if (txReceipt.status === TxStatus.DROPPED) {
+          return txReceipt;
+        }
+        // If we don't care about waiting for notes to be synced, return the receipt
+        const waitForNotesSync = opts?.waitForNotesSync ?? DefaultWaitOpts.waitForNotesSync;
+        if (!waitForNotesSync) {
+          return txReceipt;
+        }
+        // Check if all sync blocks on the PXE Service are greater or equal than the block in which the tx was mined
+        const { blocks, notes } = await this.pxe.getSyncStatus();
+        const targetBlock = txReceipt.blockNumber!;
+        const areNotesSynced = blocks >= targetBlock && Object.values(notes).every(block => block >= targetBlock);
+        return areNotesSynced ? txReceipt : undefined;
+      },
+      'isMined',
+      opts?.timeout ?? DefaultWaitOpts.timeout,
+      opts?.interval ?? DefaultWaitOpts.interval,
+    );
+  }
+}

package/src/contract/unsafe_contract.ts

@@ -0,0 +1,19 @@
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { Wallet } from '../wallet/index.js';
+import { ContractBase } from './contract_base.js';
+
+/** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */
+export class UnsafeContract extends ContractBase {
+  constructor(
+    /** The deployed contract instance definition. */
+    instance: ContractInstanceWithAddress,
+    /** The Application Binary Interface for the contract. */
+    artifact: ContractArtifact,
+    /** The wallet used for interacting with this contract. */
+    wallet: Wallet,
+  ) {
+    super(instance, artifact, wallet);
+  }
+}

package/src/deployment/broadcast_function.ts

@@ -0,0 +1,118 @@
+import {
+  ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
+  MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
+  computeArtifactFunctionTree,
+  computeArtifactFunctionTreeRoot,
+  computeArtifactMetadataHash,
+  computeFunctionArtifactHash,
+  computePrivateFunctionsTree,
+  getContractClassFromArtifact,
+} from '@aztec/circuits.js';
+import { ContractArtifact, FunctionSelector, FunctionType, bufferAsFields } from '@aztec/foundation/abi';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { Wallet } from '../wallet/index.js';
+import { getRegistererContract } from './protocol_contracts.js';
+
+/**
+ * Sets up a call to broadcast a private function's bytecode via the ClassRegisterer 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 function broadcastPrivateFunction(
+  wallet: Wallet,
+  artifact: ContractArtifact,
+  selector: FunctionSelector,
+): ContractFunctionInteraction {
+  const contractClass = getContractClassFromArtifact(artifact);
+  const privateFunction = contractClass.privateFunctions.find(fn => fn.selector.equals(selector));
+  if (!privateFunction) {
+    throw new Error(`Private function with selector ${selector.toString()} not found`);
+  }
+  const privateFunctionArtifact = artifact.functions.find(fn =>
+    FunctionSelector.fromNameAndParameters(fn).equals(selector),
+  )!;
+
+  // TODO(@spalladino): The following is computing the unconstrained root hash twice.
+  // Feels like we need a nicer API for returning a hash along with all its preimages,
+  // since it's common to provide all hash preimages to a function that verifies them.
+  const artifactMetadataHash = computeArtifactMetadataHash(artifact);
+  const unconstrainedArtifactFunctionTreeRoot = computeArtifactFunctionTreeRoot(artifact, FunctionType.OPEN);
+
+  // We need two sibling paths because private function information is split across two trees:
+  // The "private function tree" captures the selectors and verification keys, and is used in the kernel circuit for verifying the proof generated by the app circuit.
+  // The "artifact tree" captures function bytecode and metadata, and is used by the pxe to check that its executing the code it's supposed to be executing, but it never goes into circuits.
+  const privateFunctionTreePath = computePrivateFunctionsTree(contractClass.privateFunctions).getSiblingPath(0);
+  const artifactFunctionTreePath = computeArtifactFunctionTree(artifact, FunctionType.SECRET)!.getSiblingPath(0);
+
+  const vkHash = privateFunction.vkHash;
+  const metadataHash = computeFunctionArtifactHash(privateFunctionArtifact);
+  const bytecode = bufferAsFields(
+    Buffer.from(privateFunctionArtifact.bytecode, 'hex'),
+    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
+  );
+
+  const registerer = getRegistererContract(wallet);
+  return registerer.methods.broadcast_private_function(
+    contractClass.id,
+    Fr.fromBufferReduce(artifactMetadataHash),
+    Fr.fromBufferReduce(unconstrainedArtifactFunctionTreeRoot),
+    privateFunctionTreePath.map(Fr.fromBufferReduce),
+    padArrayEnd(artifactFunctionTreePath.map(Fr.fromBufferReduce), Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+    // eslint-disable-next-line camelcase
+    { selector, metadata_hash: Fr.fromBufferReduce(metadataHash), bytecode, vk_hash: vkHash },
+  );
+}
+
+/**
+ * Sets up a call to broadcast an unconstrained function's bytecode via the ClassRegisterer 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 function broadcastUnconstrainedFunction(
+  wallet: Wallet,
+  artifact: ContractArtifact,
+  selector: FunctionSelector,
+): ContractFunctionInteraction {
+  const functionArtifactIndex = artifact.functions.findIndex(
+    fn => fn.functionType === FunctionType.UNCONSTRAINED && FunctionSelector.fromNameAndParameters(fn).equals(selector),
+  );
+  if (functionArtifactIndex < 0) {
+    throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
+  }
+  const functionArtifact = artifact.functions[functionArtifactIndex];
+
+  // TODO(@spalladino): Same comment as above on computing duplicated hashes.
+  const artifactMetadataHash = computeArtifactMetadataHash(artifact);
+  const privateArtifactFunctionTreeRoot = computeArtifactFunctionTreeRoot(artifact, FunctionType.SECRET);
+  const functionTreePath = computeArtifactFunctionTree(artifact, FunctionType.UNCONSTRAINED)!.getSiblingPath(
+    functionArtifactIndex,
+  );
+
+  const contractClassId = getContractClassFromArtifact(artifact).id;
+  const metadataHash = computeFunctionArtifactHash(functionArtifact);
+  const bytecode = bufferAsFields(
+    Buffer.from(functionArtifact.bytecode, 'hex'),
+    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
+  );
+
+  const registerer = getRegistererContract(wallet);
+  return registerer.methods.broadcast_unconstrained_function(
+    contractClassId,
+    Fr.fromBufferReduce(artifactMetadataHash),
+    Fr.fromBufferReduce(privateArtifactFunctionTreeRoot),
+    padArrayEnd(functionTreePath.map(Fr.fromBufferReduce), Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+    // eslint-disable-next-line camelcase
+    { selector, metadata_hash: Fr.fromBufferReduce(metadataHash), bytecode },
+  );
+}