@aztec/aztec.js 0.23.0 → 0.24.0

package/src/contract/deploy_method.ts

@@ -0,0 +1,151 @@
+import { PXE, PackedArguments, PublicKey, Tx, TxExecutionRequest } from '@aztec/circuit-types';
+import {
+  AztecAddress,
+  ContractDeploymentData,
+  FunctionData,
+  TxContext,
+  computePartialAddress,
+  getContractInstanceFromDeployParams,
+} from '@aztec/circuits.js';
+import { ContractArtifact, FunctionArtifact, encodeArguments } from '@aztec/foundation/abi';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { Wallet } from '../account/index.js';
+import { BaseContractInteraction, SendMethodOptions } from './base_contract_interaction.js';
+import { type Contract } from './contract.js';
+import { ContractBase } from './contract_base.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;
+} & SendMethodOptions;
+
+/**
+ * Creates a TxRequest from a contract ABI, for contract deployment.
+ * Extends the ContractFunctionInteraction class.
+ */
+export class DeployMethod<TContract extends ContractBase = Contract> extends BaseContractInteraction {
+  /** The contract instance to be deployed. */
+  public instance?: ContractInstanceWithAddress = undefined;
+
+  /** Constructor function to call. */
+  private constructorArtifact: FunctionArtifact;
+
+  constructor(
+    private publicKey: PublicKey,
+    protected pxe: PXE,
+    private artifact: ContractArtifact,
+    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    private args: any[] = [],
+  ) {
+    super(pxe);
+    const constructorArtifact = artifact.functions.find(f => f.name === 'constructor');
+    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 = {}) {
+    const portalContract = options.portalContract ?? EthAddress.ZERO;
+    const contractAddressSalt = options.contractAddressSalt ?? Fr.random();
+
+    const { chainId, protocolVersion } = await this.pxe.getNodeInfo();
+
+    const deployParams = [this.artifact, this.args, contractAddressSalt, this.publicKey, portalContract] as const;
+    const instance = getContractInstanceFromDeployParams(...deployParams);
+    const address = instance.address;
+
+    const contractDeploymentData = new ContractDeploymentData(
+      this.publicKey,
+      instance.initializationHash,
+      instance.contractClassId,
+      contractAddressSalt,
+      portalContract,
+    );
+
+    const txContext = new TxContext(
+      false,
+      false,
+      true,
+      contractDeploymentData,
+      new Fr(chainId),
+      new Fr(protocolVersion),
+    );
+    const args = encodeArguments(this.constructorArtifact, this.args);
+    const functionData = FunctionData.fromAbi(this.constructorArtifact);
+    const execution = { args, functionData, to: address };
+    const packedArguments = PackedArguments.fromArgs(execution.args);
+
+    const txRequest = TxExecutionRequest.from({
+      origin: execution.to,
+      functionData: execution.functionData,
+      argsHash: packedArguments.hash,
+      txContext,
+      packedArguments: [packedArguments],
+      authWitnesses: [],
+    });
+
+    this.txRequest = txRequest;
+    this.instance = instance;
+
+    // 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 }]);
+
+    return this.txRequest;
+  }
+
+  /**
+   * 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.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,69 @@
+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, receipt.contractAddress);
+    return { ...receipt, contract };
+  }
+
+  protected getContractObject(wallet?: Wallet, address?: AztecAddress): 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`);
+    }
+    if (!address) {
+      throw new Error(`Contract address is missing from transaction receipt`);
+    }
+    return this.postDeployCtor(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 async getTxHash() {
+    return await 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.getTx(txHash))!;
+      const visibleNotes = await this.pxe.getNotes({ txHash });
+      receipt.debugInfo = {
+        newCommitments: tx.newCommitments,
+        newNullifiers: tx.newNullifiers,
+        newPublicDataWrites: tx.newPublicDataWrites,
+        newL2ToL1Msgs: tx.newL2ToL1Msgs,
+        newContracts: tx.newContracts,
+        newContractData: tx.newContractData,
+        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 },
+  );
+}

package/src/deployment/contract_deployer.ts

@@ -0,0 +1,30 @@
+import { PXE, PublicKey } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Point } from '@aztec/foundation/fields';
+
+import { Wallet } from '../account/wallet.js';
+import { DeployMethod } from '../contract/deploy_method.js';
+import { Contract } from '../contract/index.js';
+
+/**
+ * A class for deploying contract.
+ * @remarks Keeping this around even though we have Aztec.nr contract types because it can be useful for non-TS users.
+ */
+export class ContractDeployer {
+  constructor(private artifact: ContractArtifact, private pxe: PXE, private publicKey?: PublicKey) {}
+
+  /**
+   * Deploy a contract using the provided ABI and constructor arguments.
+   * This function creates a new DeployMethod instance that can be used to send deployment transactions
+   * and query deployment status. The method accepts any number of constructor arguments, which will
+   * be passed to the contract's constructor during deployment.
+   *
+   * @param args - The constructor arguments for the contract being deployed.
+   * @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);
+    return new DeployMethod(this.publicKey ?? Point.ZERO, this.pxe, this.artifact, postDeployCtor, args);
+  }
+}

package/src/deployment/deploy_instance.ts

@@ -0,0 +1,28 @@
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { Wallet } from '../wallet/index.js';
+import { getDeployerContract } from './protocol_contracts.js';
+
+/**
+ * Sets up a call to the canonical deployer contract to publicly deploy a contract instance.
+ * @param wallet - The wallet to use for the deployment.
+ * @param instance - The instance to deploy.
+ * @param opts - Additional options.
+ */
+export function deployInstance(
+  wallet: Wallet,
+  instance: ContractInstanceWithAddress,
+  opts: { /** Set to true to *not* mix in the deployer into the address. */ universalDeploy?: boolean } = {},
+): ContractFunctionInteraction {
+  const deployer = getDeployerContract(wallet);
+  const { salt, contractClassId, portalContractAddress, publicKeysHash } = instance;
+  return deployer.methods.deploy(
+    salt,
+    contractClassId,
+    instance.initializationHash,
+    portalContractAddress,
+    publicKeysHash,
+    !!opts.universalDeploy,
+  );
+}

package/src/deployment/index.ts

@@ -0,0 +1 @@
+export * from './contract_deployer.js';

package/src/deployment/protocol_contracts.ts

@@ -0,0 +1,17 @@
+import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
+import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
+
+import { UnsafeContract } from '../contract/unsafe_contract.js';
+import { Wallet } from '../wallet/index.js';
+
+/** Returns a Contract wrapper for the class registerer. */
+export function getRegistererContract(wallet: Wallet) {
+  const { artifact, instance } = getCanonicalClassRegisterer();
+  return new UnsafeContract(instance, artifact, wallet);
+}
+
+/** Returns a Contract wrapper for the instance deployer. */
+export function getDeployerContract(wallet: Wallet) {
+  const { artifact, instance } = getCanonicalInstanceDeployer();
+  return new UnsafeContract(instance, artifact, wallet);
+}

package/src/deployment/register_class.ts

@@ -0,0 +1,15 @@
+import { MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, getContractClassFromArtifact } from '@aztec/circuits.js';
+import { ContractArtifact, bufferAsFields } from '@aztec/foundation/abi';
+
+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 register a contract class given its artifact. */
+export function registerContractClass(wallet: Wallet, artifact: ContractArtifact): ContractFunctionInteraction {
+  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
+    getContractClassFromArtifact(artifact);
+  const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
+  const registerer = getRegistererContract(wallet);
+  return registerer.methods.register(artifactHash, privateFunctionsRoot, publicBytecodeCommitment, encodedBytecode);
+}

package/src/fee/fee_payment_method.ts

@@ -0,0 +1,30 @@
+import { FunctionCall } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export interface FeePaymentMethod {
+  /**
+   * The asset used to pay the fee.
+   */
+  getAsset(): AztecAddress;
+  /**
+   * Address which will hold the fee payment.
+   */
+  getPaymentContract(): AztecAddress;
+
+  /**
+   * Whether the fee payment is private or not
+   */
+  isPrivateFeePayment(): boolean;
+
+  /**
+   * Creates a function call to pay the fee in the given asset.
+   * TODO(fees) replace maxFee with gas limits
+   * @param maxFee - The maximum fee to be paid in the given asset.
+   * @returns The function call to pay the fee.
+   */
+  getFunctionCalls(maxFee: Fr): FunctionCall[];
+}