@aztec/aztec.js 0.0.0-test.0

package/src/contract/deploy_method.ts

@@ -0,0 +1,271 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { type ContractArtifact, type FunctionArtifact, type FunctionCall, getInitializer } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractInstanceWithAddress,
+  computePartialAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromDeployParams,
+} from '@aztec/stdlib/contract';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { PublicKeys } from '@aztec/stdlib/keys';
+import type { Capsule, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../account/index.js';
+import { deployInstance } from '../deployment/deploy_instance.js';
+import { registerContractClass } from '../deployment/register_class.js';
+import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
+import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
+import type { Contract } from './contract.js';
+import type { ContractBase } from './contract_base.js';
+import { ContractFunctionInteraction } from './contract_function_interaction.js';
+import { DeployProvenTx } from './deploy_proven_tx.js';
+import { DeploySentTx } from './deploy_sent_tx.js';
+
+/**
+ * Options for deploying a contract on the Aztec network.
+ * Allows specifying a contract address salt, and additional send method options.
+ */
+// docs:start:deploy_options
+export type DeployOptions = {
+  /** 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, instead just privately initialize the contract. */
+  skipPublicDeployment?: boolean;
+  /** Skip contract initialization. */
+  skipInitialization?: boolean;
+} & SendMethodOptions;
+// docs:end:deploy_options
+// 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 | undefined;
+
+  constructor(
+    private publicKeys: PublicKeys,
+    wallet: Wallet,
+    private artifact: ContractArtifact,
+    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    private args: any[] = [],
+    constructorNameOrArtifact?: string | FunctionArtifact,
+  ) {
+    super(wallet);
+    this.constructorArtifact = getInitializer(artifact, constructorNameOrArtifact);
+  }
+
+  /**
+   * 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, 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> {
+    return this.wallet.createTxExecutionRequest(await this.request(options));
+  }
+
+  // REFACTOR: Having a `request` method with different semantics than the ones in the other
+  // derived ContractInteractions is confusing. We should unify the flow of all ContractInteractions.
+
+  /**
+   * 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<ExecutionRequestInit> {
+    const deployment = await this.getDeploymentFunctionCalls(options);
+
+    // NOTE: MEGA HACK. Remove with #10007
+    // register the contract after generating deployment function calls in order to publicly register the class and (optioanlly) emit its bytecode
+    //
+    // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
+    // Note that we need to run this registerContract here so it's available when computeFeeOptionsFromEstimatedGas
+    // runs, since it needs the contract to have been registered in order to estimate gas for its initialization,
+    // in case the initializer is public. This hints at the need of having "transient" contracts scoped to a
+    // simulation, so we can run the simulation with a set of contracts, but only "commit" them to the wallet
+    // once this tx has gone through.
+    await this.wallet.registerContract({ artifact: this.artifact, instance: await this.getInstance(options) });
+
+    const bootstrap = await this.getInitializeFunctionCalls(options);
+
+    if (deployment.calls.length + bootstrap.calls.length === 0) {
+      throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
+    }
+
+    const calls = [...deployment.calls, ...bootstrap.calls];
+    const authWitnesses = [...(deployment.authWitnesses ?? []), ...(bootstrap.authWitnesses ?? [])];
+    const hashedArguments = [...(deployment.hashedArguments ?? []), ...(bootstrap.hashedArguments ?? [])];
+    const capsules = [...(deployment.capsules ?? []), ...(bootstrap.capsules ?? [])];
+    const { cancellable, nonce, fee: userFee } = options;
+
+    const request = { calls, authWitnesses, hashedArguments, capsules, cancellable, fee: userFee, nonce };
+
+    const fee = await this.getFeeOptions(request);
+    return { ...request, fee };
+  }
+
+  /**
+   * Register this contract in the PXE and returns the Contract object.
+   * @param options - Deployment options.
+   */
+  public async register(options: DeployOptions = {}): Promise<TContract> {
+    const instance = await this.getInstance(options);
+    await this.wallet.registerContract({ artifact: this.artifact, instance });
+    return this.postDeployCtor(instance.address, this.wallet);
+  }
+
+  /**
+   * 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<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>> {
+    const calls: FunctionCall[] = [];
+    const capsules: Capsule[] = [];
+
+    // Set contract instance object so it's available for populating the DeploySendTx object
+    const instance = await 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 = await getContractClassFromArtifact(this.artifact);
+    if (!instance.currentContractClassId.equals(contractClass.id)) {
+      throw new Error(
+        `Contract class mismatch when deploying contract: got ${instance.currentContractClassId.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.wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+        this.log.debug(
+          `Skipping registration of already registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
+        );
+      } else {
+        this.log.info(
+          `Creating request for registering contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`,
+        );
+        const registerContractClassInteraction = await registerContractClass(this.wallet, this.artifact);
+        calls.push(await registerContractClassInteraction.request());
+        capsules.push(...registerContractClassInteraction.getCapsules());
+      }
+    }
+
+    // Deploy the contract via the instance deployer.
+    if (!options.skipPublicDeployment) {
+      const deploymentInteraction = await deployInstance(this.wallet, instance);
+      calls.push(await deploymentInteraction.request());
+      capsules.push(...deploymentInteraction.getCapsules());
+    }
+
+    return { calls, capsules };
+  }
+
+  /**
+   * Returns the calls necessary to initialize the contract.
+   * @param options - Deployment options.
+   * @returns - An array of function calls.
+   */
+  protected async getInitializeFunctionCalls(
+    options: DeployOptions,
+  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>> {
+    const { address } = await this.getInstance(options);
+    const calls: FunctionCall[] = [];
+    const capsules: Capsule[] = [];
+    if (this.constructorArtifact && !options.skipInitialization) {
+      const constructorCall = new ContractFunctionInteraction(
+        this.wallet,
+        address,
+        this.constructorArtifact,
+        this.args,
+      );
+      calls.push(await constructorCall.request());
+      capsules.push(...constructorCall.getCapsules());
+    }
+    return { calls, capsules };
+  }
+
+  /**
+   * 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 contractAddressSalt and from.
+   * @returns A SentTx object that returns the receipt and the deployed contract instance.
+   */
+  public override send(options: DeployOptions = {}): DeploySentTx<TContract> {
+    const txHashPromise = super.send(options).getTxHash();
+    this.log.debug(`Sent deployment tx of ${this.artifact.name} contract`);
+    return new DeploySentTx(this.wallet, 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 async getInstance(options: DeployOptions = {}): Promise<ContractInstanceWithAddress> {
+    if (!this.instance) {
+      this.instance = await getContractInstanceFromDeployParams(this.artifact, {
+        constructorArgs: this.args,
+        salt: options.contractAddressSalt,
+        publicKeys: this.publicKeys,
+        constructorArtifact: this.constructorArtifact,
+        deployer: options.universalDeploy ? AztecAddress.ZERO : this.wallet.getAddress(),
+      });
+    }
+    return this.instance;
+  }
+
+  /**
+   * Prove the request.
+   * @param options - Deployment options.
+   * @returns The proven tx.
+   */
+  public override async prove(options: DeployOptions): Promise<DeployProvenTx<TContract>> {
+    const txProvingResult = await this.proveInternal(options);
+    return new DeployProvenTx(this.wallet, txProvingResult.toTx(), this.postDeployCtor, () =>
+      this.getInstance(options),
+    );
+  }
+
+  /**
+   * Estimates gas cost for this deployment operation.
+   * @param options - Options.
+   */
+  public override estimateGas(
+    options?: Omit<DeployOptions, 'estimateGas' | 'skipPublicSimulation'>,
+  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
+    return super.estimateGas(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_proven_tx.ts

@@ -0,0 +1,34 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { Tx } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../account/index.js';
+import type { Contract } from './contract.js';
+import { DeploySentTx } from './deploy_sent_tx.js';
+import { ProvenTx } from './proven_tx.js';
+
+/**
+ * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract deployment.
+ */
+export class DeployProvenTx<TContract extends Contract = Contract> extends ProvenTx {
+  constructor(
+    wallet: PXE | Wallet,
+    tx: Tx,
+    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    private instanceGetter: () => Promise<ContractInstanceWithAddress>,
+  ) {
+    super(wallet, tx);
+  }
+
+  /**
+   * Sends the transaction to the network via the provided wallet.
+   */
+  public override send(): DeploySentTx<TContract> {
+    const promise = (() => {
+      return this.wallet.sendTx(this.getPlainDataTx());
+    })();
+
+    return new DeploySentTx(this.wallet, promise, this.postDeployCtor, this.instanceGetter);
+  }
+}

package/src/contract/deploy_sent_tx.ts

@@ -0,0 +1,74 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../account/index.js';
+import type { Contract } from './contract.js';
+import type { ContractBase } from './contract_base.js';
+import { SentTx, type 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 {
+  private log = createLogger('aztecjs:deploy_sent_tx');
+
+  constructor(
+    pxeOrWallet: PXE | Wallet,
+    txHashPromise: Promise<TxHash>,
+    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    /** A getter for the deployed contract instance */
+    public instanceGetter: () => Promise<ContractInstanceWithAddress>,
+  ) {
+    super(pxeOrWallet, 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);
+    const instance = await this.instanceGetter();
+    this.log.info(`Contract ${instance.address.toString()} successfully deployed.`);
+    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 override async wait(opts?: DeployedWaitOpts): Promise<DeployTxReceipt<TContract>> {
+    const receipt = await super.wait(opts);
+    const contract = await this.getContractObject(opts?.wallet);
+    return { ...receipt, contract };
+  }
+
+  protected async getContractObject(wallet?: Wallet): Promise<TContract> {
+    const isWallet = (pxeOrWallet: PXE | Wallet | AztecNode): pxeOrWallet is Wallet =>
+      !!(pxeOrWallet as Wallet).createTxExecutionRequest;
+    const contractWallet = wallet ?? (isWallet(this.pxeOrNode) && this.pxeOrNode);
+    if (!contractWallet) {
+      throw new Error(`A wallet is required for creating a contract instance`);
+    }
+    const instance = await this.instanceGetter();
+    return this.postDeployCtor(instance.address, contractWallet) as Promise<TContract>;
+  }
+}

package/src/contract/get_gas_limits.ts

@@ -0,0 +1,26 @@
+import type { Gas } from '@aztec/stdlib/gas';
+import type { TxSimulationResult } from '@aztec/stdlib/tx';
+
+/**
+ * Returns suggested total and teardown gas limits for a simulated tx.
+ * Note that public gas usage is only accounted for if the publicOutput is present.
+ * @param pad - Percentage to pad the suggested gas limits by, (as decimal, e.g., 0.10 for 10%).
+ */
+export function getGasLimits(
+  simulationResult: TxSimulationResult,
+  pad = 0.1,
+): {
+  /**
+   * Total gas used across private and public
+   */
+  totalGas: Gas;
+  /**
+   * Teardown gas used
+   */
+  teardownGas: Gas;
+} {
+  return {
+    totalGas: simulationResult.gasUsed.totalGas.mul(1 + pad),
+    teardownGas: simulationResult.gasUsed.teardownGas.mul(1 + pad),
+  };
+}

package/src/contract/index.ts

@@ -0,0 +1,48 @@
+/**
+ * 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/guides/smart_contracts/how_to_compile_contract | 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 simulate methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `simulate()`.
+ *
+ * ```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().simulate()}`);
+ * ```
+ *
+ * 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/guides/smart_contracts/how_to_compile_contract#typescript-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */
+export { Contract } from './contract.js';
+export {
+  ContractFunctionInteraction,
+  type ProfileResult,
+  type SendMethodOptions,
+} from './contract_function_interaction.js';
+export { DefaultWaitOpts, SentTx, type WaitOpts } from './sent_tx.js';
+export { ContractBase, type ContractMethod, type ContractNotes, type ContractStorageLayout } from './contract_base.js';
+export { BatchCall } from './batch_call.js';
+export { type DeployOptions, DeployMethod } from './deploy_method.js';
+export { DeploySentTx } from './deploy_sent_tx.js';

package/src/contract/protocol_contracts.ts

@@ -0,0 +1,35 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+
+import type { Wallet } from '../wallet/index.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);
+  if (!contractInstance) {
+    throw new Error("ContractClassRegisterer 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);
+  if (!contractInstance) {
+    throw new Error("ContractInstanceDeployer 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 */
+export async function getFeeJuice(wallet: Wallet) {
+  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.FeeJuice);
+  if (!contractInstance) {
+    throw new Error("FeeJuice is not registered in this wallet's instance");
+  }
+  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
+  return new UnsafeContract(contractInstance!, artifact!, wallet);
+}

package/src/contract/proven_tx.ts

@@ -0,0 +1,42 @@
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { Tx } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../account/index.js';
+import { SentTx } from './sent_tx.js';
+
+/**
+ * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract interaction.
+ */
+export class ProvenTx extends Tx {
+  constructor(protected wallet: PXE | Wallet, tx: Tx) {
+    super(
+      tx.data,
+      tx.clientIvcProof,
+      tx.contractClassLogs,
+      tx.enqueuedPublicFunctionCalls,
+      tx.publicTeardownFunctionCall,
+    );
+  }
+
+  // Clone the TX data to get a serializable object.
+  protected getPlainDataTx(): Tx {
+    return new Tx(
+      this.data,
+      this.clientIvcProof,
+      this.contractClassLogs,
+      this.enqueuedPublicFunctionCalls,
+      this.publicTeardownFunctionCall,
+    );
+  }
+
+  /**
+   * Sends the transaction to the network via the provided wallet.
+   */
+  public send(): SentTx {
+    const promise = (() => {
+      return this.wallet.sendTx(this.getPlainDataTx());
+    })();
+
+    return new SentTx(this.wallet, promise);
+  }
+}

package/src/contract/sent_tx.ts

@@ -0,0 +1,141 @@
+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';
+
+/** Options related to waiting for a tx. */
+export type WaitOpts = {
+  /** The amount of time to ignore TxStatus.DROPPED receipts (in seconds) due to the presumption that it is being propagated by the p2p network. Defaults to 5. */
+  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,
+  interval: 1,
+  debug: false,
+};
+
+/**
+ * The SentTx class represents a sent transaction through the PXE (or directly to a node) providing methods to fetch
+ * its hash, receipt, and mining status.
+ */
+export class SentTx {
+  constructor(protected pxeOrNode: PXE | AztecNode, 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.
+   * TODO(#7717): Don't throw here.
+   */
+  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.pxeOrNode.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>> {
+    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'}`,
+      );
+    }
+    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();
+    const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
+
+    return await retryUntil(
+      async () => {
+        const txReceipt = await this.pxeOrNode.getTxReceipt(txHash);
+        // If receipt is not yet available, try again
+        if (txReceipt.status === TxStatus.PENDING) {
+          return undefined;
+        }
+        // If the tx was "dropped", either return it or ignore based on timing.
+        // We can ignore it at first because the transaction may have been sent to node 1, and now we're asking node 2 for the receipt.
+        // If we don't allow a short grace period, we could incorrectly return a TxReceipt with status DROPPED.
+        if (txReceipt.status === TxStatus.DROPPED) {
+          const elapsedSeconds = (Date.now() - startTime) / 1000;
+          if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
+            return txReceipt;
+          }
+          return undefined;
+        }
+        return txReceipt;
+      },
+      'isMined',
+      opts?.timeout ?? DefaultWaitOpts.timeout,
+      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,
+    );
+  }
+}