@aztec/aztec.js 0.0.1-commit.2ed92850 → 0.0.1-commit.3469e52

package/src/contract/sent_tx.ts

@@ -0,0 +1,129 @@
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { retryUntil } from '@aztec/foundation/retry';
+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 = {
+  /** 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 time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
+  interval?: number;
+  /** 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: 300,
+  interval: 1,
+};
+
+/**
+ * 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 {
+  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.
+   * 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 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!);
+  }
+
+  /**
+   * 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.walletOrNode.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<TxReceipt> {
+    const receipt = await this.waitForReceipt(opts);
+    if (receipt.status !== TxStatus.SUCCESS && !opts?.dontThrowOnRevert) {
+      throw new Error(
+        `Transaction ${(await this.getTxHash()).toString()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
+      );
+    }
+    return receipt;
+  }
+
+  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.walletOrNode.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,
+    );
+  }
+}

package/src/contract/wait_for_proven.ts

@@ -2,7 +2,7 @@ import { retryUntil } from '@aztec/foundation/retry';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { TxReceipt } from '@aztec/stdlib/tx';
 
-import { DefaultWaitOpts } from './wait_opts.js';
+import { DefaultWaitOpts } from './sent_tx.js';
 
 /**
  * Options for waiting for a transaction to be proven.

package/src/utils/authwit.ts

@@ -5,18 +5,16 @@ import { type ABIParameterVisibility, type FunctionAbi, type FunctionCall, Funct
 import { AuthWitness, computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeVarArgsHash } from '@aztec/stdlib/hash';
-import type { TxHash, TxProfileResult, TxReceipt } from '@aztec/stdlib/tx';
+import type { TxProfileResult } from '@aztec/stdlib/tx';
 
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 import type {
-  InteractionWaitOptions,
   ProfileInteractionOptions,
   SendInteractionOptions,
-  SendInteractionOptionsWithoutWait,
-  SendReturn,
   SimulateInteractionOptions,
   SimulationReturn,
 } from '../contract/interaction_options.js';
+import type { SentTx } from '../contract/sent_tx.js';
 import type { Wallet } from '../wallet/index.js';
 
 /** Intent with an inner hash */
@@ -288,19 +286,9 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
    * Overrides the send method, adding the sender of the authwit (authorizer) as from
    * and preventing misuse
    * @param options - An optional object containing 'fee' options information
-   * @returns A TxReceipt (if wait is true/undefined) or TxHash (if wait is false)
+   * @returns A SentTx instance for tracking the transaction status and information.
    */
-  // Overload for when wait is not specified at all - returns TxReceipt
-  public override send(options?: Omit<SendInteractionOptionsWithoutWait, 'from'>): Promise<TxReceipt>;
-  // Generic overload for explicit wait values
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  public override send<W extends InteractionWaitOptions>(
-    options?: Omit<SendInteractionOptions<W>, 'from'>,
-  ): Promise<SendReturn<W>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  public override send(
-    options?: Omit<SendInteractionOptions<InteractionWaitOptions>, 'from'>,
-  ): Promise<TxReceipt | TxHash> {
+  public override send(options: Omit<SendInteractionOptions, 'from'> = {}): SentTx {
     return super.send({ ...options, from: this.from });
   }
 

package/src/utils/node.ts

@@ -1,10 +1,6 @@
 import type { Logger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
-import { SortedTxStatuses, TxStatus } from '@aztec/stdlib/tx';
-
-import { DefaultWaitOpts, type WaitOpts } from '../contract/wait_opts.js';
 
 export const waitForNode = async (node: AztecNode, logger?: Logger) => {
   await retryUntil(async () => {
@@ -20,62 +16,4 @@ export const waitForNode = async (node: AztecNode, logger?: Logger) => {
   }, 'RPC Get Node Info');
 };
 
-/** Returns true if the receipt status is at least the desired status level. */
-function hasReachedStatus(receipt: TxReceipt, desiredStatus: TxStatus): boolean {
-  return SortedTxStatuses.indexOf(receipt.status) >= SortedTxStatuses.indexOf(desiredStatus);
-}
-
-/**
- * Waits for a transaction to be mined and returns its receipt.
- * @param node - The Aztec node to query for transaction status
- * @param txHash - The hash of the transaction to wait for
- * @param opts - Optional configuration for waiting behavior
- * @returns The transaction receipt
- * @throws If the transaction fails and dontThrowOnRevert is not set
- */
-export async function waitForTx(node: AztecNode, txHash: TxHash, opts?: WaitOpts): Promise<TxReceipt> {
-  const startTime = Date.now();
-  const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
-  const waitForStatus = opts?.waitForStatus ?? TxStatus.CHECKPOINTED;
-
-  const receipt = await retryUntil(
-    async () => {
-      const txReceipt = await node.getTxReceipt(txHash);
-      // If receipt is not yet available, try again
-      if (txReceipt.isPending()) {
-        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.isDropped()) {
-        const elapsedSeconds = (Date.now() - startTime) / 1000;
-        if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
-          return txReceipt;
-        }
-        return undefined;
-      }
-      // Check if the receipt has reached the desired status level
-      if (!hasReachedStatus(txReceipt, waitForStatus)) {
-        return undefined;
-      }
-      return txReceipt;
-    },
-    'isMined',
-    opts?.timeout ?? DefaultWaitOpts.timeout,
-    opts?.interval ?? DefaultWaitOpts.interval,
-  );
-
-  if (!receipt.isMined()) {
-    throw new Error(`Transaction ${txHash.toString()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`);
-  }
-  if (!receipt.hasExecutionSucceeded() && !opts?.dontThrowOnRevert) {
-    throw new Error(
-      `Transaction ${txHash.toString()} reverted: ${receipt.executionResult}. Reason: ${receipt.error ?? 'unknown'}`,
-    );
-  }
-
-  return receipt;
-}
-
 export { createAztecNodeClient, type AztecNode } from '@aztec/stdlib/interfaces/client';

package/src/wallet/deploy_account_method.ts

@@ -10,11 +10,11 @@ import type { Contract } from '../contract/contract.js';
 import type { ContractBase } from '../contract/contract_base.js';
 import {
   DeployMethod,
-  type DeployOptionsWithoutWait,
+  type DeployOptions,
   type RequestDeployOptions,
   type SimulateDeployOptions,
 } from '../contract/deploy_method.js';
-import type { FeePaymentMethodOption, InteractionWaitOptions } from '../contract/interaction_options.js';
+import type { FeePaymentMethodOption } from '../contract/interaction_options.js';
 import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
 import { AccountEntrypointMetaPaymentMethod } from './account_entrypoint_meta_payment_method.js';
 import type { Wallet } from './index.js';
@@ -36,27 +36,12 @@ export type RequestDeployAccountOptions = Omit<RequestDeployOptions, 'contractAd
   fee?: DeployAccountFeePaymentMethodOption;
 };
 
-/**
- * Base configuration options for the send/prove methods without wait parameter. Omits:
- * - The contractAddressSalt, since for account contracts that is fixed in the constructor.
- * - UniversalDeployment flag, since account contracts are always deployed with it set to true
- */
-export type DeployAccountOptionsWithoutWait = Omit<DeployOptionsWithoutWait, 'contractAddressSalt' | 'universalDeploy'>;
-
 /**
  * The configuration options for the send/prove methods. Omits:
  * - The contractAddressSalt, since for account contracts that is fixed in the constructor.
  * - UniversalDeployment flag, since account contracts are always deployed with it set to true
  */
-export type DeployAccountOptions<W extends InteractionWaitOptions = undefined> = DeployAccountOptionsWithoutWait & {
-  /**
-   * Whether to wait for the transaction to be mined.
-   * - undefined (default): wait with default options and return TxReceipt
-   * - WaitOpts object: wait with custom options and return TxReceipt
-   * - false: return txHash immediately without waiting
-   */
-  wait?: W;
-};
+export type DeployAccountOptions = Omit<DeployOptions, 'contractAddressSalt' | 'universalDeploy'>;
 
 /**
  * The configuration options for the simulate method. Omits the contractAddressSalt, since
@@ -137,7 +122,7 @@ export class DeployAccountMethod<TContract extends ContractBase = Contract> exte
     return mergeExecutionPayloads(executionPayloads);
   }
 
-  override convertDeployOptionsToRequestOptions(options: DeployAccountOptionsWithoutWait): RequestDeployOptions {
+  override convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions {
     return {
       ...options,
       // Deployer is handled in the request method and forcibly set to undefined,

package/src/wallet/wallet.ts

@@ -29,15 +29,12 @@ import type { ExecutionPayload, InTx } from '@aztec/stdlib/tx';
 
 import { z } from 'zod';
 
-import {
-  type FeeEstimationOptions,
-  type GasSettingsOption,
-  type InteractionWaitOptions,
-  NO_WAIT,
-  type ProfileInteractionOptions,
-  type SendInteractionOptionsWithoutWait,
-  type SendReturn,
-  type SimulateInteractionOptions,
+import type {
+  FeeEstimationOptions,
+  GasSettingsOption,
+  ProfileInteractionOptions,
+  SendInteractionOptions,
+  SimulateInteractionOptions,
 } from '../contract/interaction_options.js';
 import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
 
@@ -80,14 +77,9 @@ export type ProfileOptions = Omit<ProfileInteractionOptions, 'fee'> & {
  * a simplified version that only hints at the wallet whether the interaction contains a
  * fee payment method or not
  */
-export type SendOptions<W extends InteractionWaitOptions = undefined> = Omit<
-  SendInteractionOptionsWithoutWait,
-  'fee'
-> & {
+export type SendOptions = Omit<SendInteractionOptions, 'fee'> & {
   /** The fee options */
   fee?: GasSettingsOption;
-  /** Whether to wait for the transaction to be mined */
-  wait?: W;
 };
 
 /**
@@ -205,6 +197,7 @@ export type Wallet = {
     eventFilter: PrivateEventFilter,
   ): Promise<PrivateEvent<T>[]>;
   getChainInfo(): Promise<ChainInfo>;
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
   getContractMetadata(address: AztecAddress): Promise<ContractMetadata>;
   getContractClassMetadata(id: Fr): Promise<ContractClassMetadata>;
   registerSender(address: AztecAddress, alias?: string): Promise<AztecAddress>;
@@ -218,10 +211,7 @@ export type Wallet = {
   simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult>;
   simulateUtility(call: FunctionCall, authwits?: AuthWitness[]): Promise<UtilitySimulationResult>;
   profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult>;
-  sendTx<W extends InteractionWaitOptions = undefined>(
-    exec: ExecutionPayload,
-    opts: SendOptions<W>,
-  ): Promise<SendReturn<W>>;
+  sendTx(exec: ExecutionPayload, opts: SendOptions): Promise<TxHash>;
   createAuthWit(from: AztecAddress, messageHashOrIntent: IntentInnerHash | CallIntent): Promise<AuthWitness>;
   batch<const T extends readonly BatchedMethod[]>(methods: T): Promise<BatchResults<T>>;
 };
@@ -261,19 +251,11 @@ export const WalletSimulationFeeOptionSchema = GasSettingsOptionSchema.extend({
   estimateGas: optional(z.boolean()),
 });
 
-export const WaitOptsSchema = z.object({
-  ignoreDroppedReceiptsFor: optional(z.number()),
-  timeout: optional(z.number()),
-  interval: optional(z.number()),
-  dontThrowOnRevert: optional(z.boolean()),
-});
-
 export const SendOptionsSchema = z.object({
   from: schemas.AztecAddress,
   authWitnesses: optional(z.array(AuthWitness.schema)),
   capsules: optional(z.array(Capsule.schema)),
   fee: optional(GasSettingsOptionSchema),
-  wait: optional(z.union([z.literal(NO_WAIT), WaitOptsSchema])),
 });
 
 export const SimulateOptionsSchema = z.object({
@@ -342,6 +324,7 @@ const WalletMethodSchemas = {
     .function()
     .args()
     .returns(z.object({ chainId: schemas.Fr, version: schemas.Fr })),
+  getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
   getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
   getContractClassMetadata: z.function().args(schemas.Fr).returns(ContractClassMetadataSchema),
   getPrivateEvents: z
@@ -367,10 +350,7 @@ const WalletMethodSchemas = {
     .args(FunctionCallSchema, optional(z.array(AuthWitness.schema)))
     .returns(UtilitySimulationResult.schema),
   profileTx: z.function().args(ExecutionPayloadSchema, ProfileOptionsSchema).returns(TxProfileResult.schema),
-  sendTx: z
-    .function()
-    .args(ExecutionPayloadSchema, SendOptionsSchema)
-    .returns(z.union([TxHash.schema, TxReceipt.schema])),
+  sendTx: z.function().args(ExecutionPayloadSchema, SendOptionsSchema).returns(TxHash.schema),
   createAuthWit: z.function().args(schemas.AztecAddress, MessageHashOrIntentSchema).returns(AuthWitness.schema),
 };
 

package/dest/contract/wait_opts.d.ts

@@ -1,16 +0,0 @@
-import type { 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 time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
-    interval?: number;
-    /** 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;
-    /** The minimum inclusion status to wait for. If set, waits until the receipt reaches this status or higher. Defaults to CHECKPOINTED. */
-    waitForStatus?: TxStatus;
-};
-export declare const DefaultWaitOpts: WaitOpts;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FpdF9vcHRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3Qvd2FpdF9vcHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpELDJDQUEyQztBQUMzQyxNQUFNLE1BQU0sUUFBUSxHQUFHO0lBQ3JCLGdLQUFnSztJQUNoSyx3QkFBd0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNsQyw2RkFBNkY7SUFDN0YsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLHNHQUFzRztJQUN0RyxRQUFRLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbEIsMEhBQTBIO0lBQzFILGlCQUFpQixDQUFDLEVBQUUsT0FBTyxDQUFDO0lBQzVCLHlJQUF5STtJQUN6SSxhQUFhLENBQUMsRUFBRSxRQUFRLENBQUM7Q0FDMUIsQ0FBQztBQUVGLGVBQU8sTUFBTSxlQUFlLEVBQUUsUUFJN0IsQ0FBQyJ9

package/dest/contract/wait_opts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wait_opts.d.ts","sourceRoot":"","sources":["../../src/contract/wait_opts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,2CAA2C;AAC3C,MAAM,MAAM,QAAQ,GAAG;IACrB,gKAAgK;IAChK,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sGAAsG;IACtG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0HAA0H;IAC1H,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,yIAAyI;IACzI,aAAa,CAAC,EAAE,QAAQ,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAI7B,CAAC"}

package/dest/contract/wait_opts.js

@@ -1,5 +0,0 @@
-export const DefaultWaitOpts = {
-    ignoreDroppedReceiptsFor: 5,
-    timeout: 300,
-    interval: 1
-};

package/src/contract/wait_opts.ts

@@ -1,21 +0,0 @@
-import type { 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 time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
-  interval?: number;
-  /** 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;
-  /** The minimum inclusion status to wait for. If set, waits until the receipt reaches this status or higher. Defaults to CHECKPOINTED. */
-  waitForStatus?: TxStatus;
-};
-
-export const DefaultWaitOpts: WaitOpts = {
-  ignoreDroppedReceiptsFor: 5,
-  timeout: 300,
-  interval: 1,
-};