@aztec/aztec.js 3.0.3 → 4.0.0-devnet.1-patch.0

package/src/deployment/publish_class.ts

@@ -9,7 +9,7 @@ import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { Capsule } from '@aztec/stdlib/tx';
 
 import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getClassRegistryContract } from '../contract/protocol_contracts.js';
+import { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
 import type { Wallet } from '../wallet/index.js';
 
 /** Sets up a call to publish a contract class given its artifact. */
@@ -19,7 +19,7 @@ export async function publishContractClass(
 ): Promise<ContractFunctionInteraction> {
   const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
     await getContractClassFromArtifact(artifact);
-  const classRegistry = await getClassRegistryContract(wallet);
+  const classRegistry = ContractClassRegistryContract.at(wallet);
 
   const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
   return classRegistry.methods.publish(artifactHash, privateFunctionsRoot, publicBytecodeCommitment).with({

package/src/deployment/publish_instance.ts

@@ -1,7 +1,7 @@
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getInstanceRegistryContract } from '../contract/protocol_contracts.js';
+import { ContractInstanceRegistryContract } from '../contract/protocol_contracts/contract-instance-registry.js';
 import type { Wallet } from '../wallet/wallet.js';
 
 /**
@@ -9,11 +9,8 @@ import type { Wallet } from '../wallet/wallet.js';
  * @param wallet - The wallet to use for the publication (setup) tx.
  * @param instance - The instance to publish.
  */
-export async function publishInstance(
-  wallet: Wallet,
-  instance: ContractInstanceWithAddress,
-): Promise<ContractFunctionInteraction> {
-  const contractInstanceRegistry = await getInstanceRegistryContract(wallet);
+export function publishInstance(wallet: Wallet, instance: ContractInstanceWithAddress): ContractFunctionInteraction {
+  const contractInstanceRegistry = ContractInstanceRegistryContract.at(wallet);
   const { salt, currentContractClassId: contractClassId, publicKeys, deployer: instanceDeployer } = instance;
   const isUniversalDeploy = instanceDeployer.isZero();
   return contractInstanceRegistry.methods.publish_for_public_execution(

package/src/ethereum/portal_manager.ts

@@ -1,5 +1,6 @@
 import type { ExtendedViemWalletClient, ViemContract } from '@aztec/ethereum/types';
 import { extractEvent } from '@aztec/ethereum/utils';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
 import { sha256ToField } from '@aztec/foundation/crypto/sha256';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -132,7 +133,7 @@ export class L1FeeJuicePortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
-    handlerAddress: EthAddress,
+    handlerAddress: EthAddress | undefined,
     private readonly extendedClient: ExtendedViemWalletClient,
     private readonly logger: Logger,
   ) {
@@ -157,9 +158,9 @@ export class L1FeeJuicePortalManager {
    */
   public async bridgeTokensPublic(to: AztecAddress, amount: bigint | undefined, mint = false): Promise<L2AmountClaim> {
     const [claimSecret, claimSecretHash] = await generateClaimSecret();
-    const mintableAmount = await this.tokenManager.getMintAmount();
-    const amountToBridge = amount ?? mintableAmount;
+    const amountToBridge = amount ?? (await this.tokenManager.getMintAmount());
     if (mint) {
+      const mintableAmount = await this.tokenManager.getMintAmount();
       if (amountToBridge !== mintableAmount) {
         throw new Error(`Minting amount must be ${mintableAmount}`);
       }
@@ -233,17 +234,12 @@ export class L1FeeJuicePortalManager {
     if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
       throw new Error('Portal or token not deployed on L1');
     }
-    if (!feeAssetHandlerAddress || feeAssetHandlerAddress.isZero()) {
-      throw new Error('Handler not deployed on L1, or handler address is zero');
-    }
 
-    return new L1FeeJuicePortalManager(
-      feeJuicePortalAddress,
-      feeJuiceAddress,
-      feeAssetHandlerAddress,
-      extendedClient,
-      logger,
-    );
+    // Handler is optional - it's only needed for minting tokens during testing
+    const handlerAddress =
+      feeAssetHandlerAddress && !feeAssetHandlerAddress.isZero() ? feeAssetHandlerAddress : undefined;
+
+    return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, handlerAddress, extendedClient, logger);
   }
 }
 
@@ -413,26 +409,26 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
    * Withdraws funds from the portal by consuming an L2 to L1 message. Returns once the tx is mined on L1.
    * @param amount - Amount to withdraw.
    * @param recipient - Who will receive the funds.
-   * @param blockNumber - L2 block number of the message.
+   * @param epochNumber - Epoch number of the message.
    * @param messageIndex - Index of the message.
    * @param siblingPath - Sibling path of the message.
    */
   public async withdrawFunds(
     amount: bigint,
     recipient: EthAddress,
-    blockNumber: bigint,
+    epochNumber: EpochNumber,
     messageIndex: bigint,
     siblingPath: SiblingPath<number>,
   ) {
     this.logger.info(
-      `Sending L1 tx to consume message at block ${blockNumber} index ${messageIndex} to withdraw ${amount}`,
+      `Sending L1 tx to consume message at epoch ${epochNumber} index ${messageIndex} to withdraw ${amount}`,
     );
 
     const messageLeafId = getL2ToL1MessageLeafId({ leafIndex: messageIndex, siblingPath });
-    const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtCheckpoint([blockNumber, messageLeafId]);
+    const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtEpoch([BigInt(epochNumber), messageLeafId]);
     if (isConsumedBefore) {
       throw new Error(
-        `L1 to L2 message at block ${blockNumber} index ${messageIndex} height ${siblingPath.pathSize} has already been consumed`,
+        `L2 to L1 message at epoch ${epochNumber} index ${messageIndex} height ${siblingPath.pathSize} has already been consumed`,
       );
     }
 
@@ -441,7 +437,7 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
       recipient.toString(),
       amount,
       false,
-      BigInt(blockNumber),
+      BigInt(epochNumber),
       messageIndex,
       siblingPath.toBufferArray().map((buf: Buffer): Hex => `0x${buf.toString('hex')}`),
     ]);
@@ -450,10 +446,10 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
       hash: await this.extendedClient.writeContract(withdrawRequest),
     });
 
-    const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtCheckpoint([blockNumber, messageLeafId]);
+    const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtEpoch([BigInt(epochNumber), messageLeafId]);
     if (!isConsumedAfter) {
       throw new Error(
-        `L1 to L2 message at block ${blockNumber} index ${messageIndex} height ${siblingPath.pathSize} not consumed after withdrawal`,
+        `L2 to L1 message at epoch ${epochNumber} index ${messageIndex} height ${siblingPath.pathSize} not consumed after withdrawal`,
       );
     }
   }

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -1,6 +1,6 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -27,10 +27,11 @@ export class FeeJuicePaymentMethodWithClaim implements FeePaymentMethod {
 
     return new ExecutionPayload(
       [
-        {
-          to: ProtocolContractAddress.FeeJuice,
+        FunctionCall.from({
           name: 'claim_and_end_setup',
+          to: ProtocolContractAddress.FeeJuice,
           selector,
+          type: FunctionType.PRIVATE,
           hideMsgSender: false,
           isStatic: false,
           args: [
@@ -40,8 +41,7 @@ export class FeeJuicePaymentMethodWithClaim implements FeePaymentMethod {
             new Fr(this.claim.messageLeafIndex),
           ],
           returnTypes: [],
-          type: FunctionType.PRIVATE,
-        },
+        }),
       ],
       [],
       [],

package/src/fee/private_fee_payment_method.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { type FunctionAbi, FunctionCall, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -102,21 +102,21 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
 
     const witness = await this.wallet.createAuthWit(this.sender, {
       caller: this.paymentContract,
-      call: {
+      call: FunctionCall.from({
         name: 'transfer_to_public',
-        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
+        to: await this.getAsset(),
         selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),u128,Field)'),
         type: FunctionType.PRIVATE,
         hideMsgSender: false,
         isStatic: false,
-        to: await this.getAsset(),
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
         returnTypes: [],
-      },
+      }),
     });
 
     return new ExecutionPayload(
       [
-        {
+        FunctionCall.from({
           name: 'fee_entrypoint_private',
           to: this.paymentContract,
           selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
@@ -125,7 +125,7 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
           isStatic: false,
           args: [maxFee, txNonce],
           returnTypes: [],
-        },
+        }),
       ],
       [witness],
       [],

package/src/fee/public_fee_payment_method.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { type FunctionAbi, FunctionCall, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -94,16 +94,16 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
 
     const intent = {
       caller: this.paymentContract,
-      call: {
+      call: FunctionCall.from({
         name: 'transfer_in_public',
-        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
+        to: await this.getAsset(),
         selector: await FunctionSelector.fromSignature('transfer_in_public((Field),(Field),u128,Field)'),
         type: FunctionType.PUBLIC,
-        isStatic: false,
         hideMsgSender: false /** The target function performs an authwit check, so msg_sender is needed */,
-        to: await this.getAsset(),
+        isStatic: false,
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
         returnTypes: [],
-      },
+      }),
     };
 
     const setPublicAuthWitInteraction = await SetPublicAuthwitContractInteraction.create(
@@ -116,7 +116,7 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
     return new ExecutionPayload(
       [
         ...(await setPublicAuthWitInteraction.request()).calls,
-        {
+        FunctionCall.from({
           name: 'fee_entrypoint_public',
           to: this.paymentContract,
           selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
@@ -125,7 +125,7 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
           isStatic: false,
           args: [maxFee, txNonce],
           returnTypes: [],
-        },
+        }),
       ],
       [],
       [],

package/src/fee/sponsored_fee_payment.ts

@@ -1,5 +1,5 @@
 import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
-import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -22,7 +22,7 @@ export class SponsoredFeePaymentMethod implements FeePaymentMethod {
   async getExecutionPayload(): Promise<ExecutionPayload> {
     return new ExecutionPayload(
       [
-        {
+        FunctionCall.from({
           name: 'sponsor_unconditionally',
           to: this.paymentContract,
           selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'),
@@ -31,7 +31,7 @@ export class SponsoredFeePaymentMethod implements FeePaymentMethod {
           isStatic: false,
           args: [],
           returnTypes: [],
-        },
+        }),
       ],
       [],
       [],

package/src/scripts/generate_protocol_contract_types.ts

@@ -0,0 +1,150 @@
+/**
+ * Generates type-safe contract wrappers for protocol contracts.
+ * These wrappers use a minimal artifact (without bytecode) since PXE already has the full artifacts registered.
+ */
+import { generateTypescriptContractInterface } from '@aztec/builder/codegen';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  FunctionType,
+  getAllFunctionAbis,
+  loadContractArtifact,
+} from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const log = console.log;
+
+const noirContractsRoot = path.join(import.meta.dirname, '../../../../noir-projects/noir-contracts');
+const srcPath = path.join(noirContractsRoot, 'target');
+const outputDir = path.join(import.meta.dirname, '../contract/protocol_contracts');
+
+function toKebabCase(str: string): string {
+  return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+function functionTypeToEnum(type: FunctionType): string {
+  switch (type) {
+    case FunctionType.PRIVATE:
+      return 'FunctionType.PRIVATE';
+    case FunctionType.PUBLIC:
+      return 'FunctionType.PUBLIC';
+    case FunctionType.UTILITY:
+      return 'FunctionType.UTILITY';
+  }
+}
+
+function generateFunctionAbiJson(abi: FunctionAbi): string {
+  const baseObj = {
+    name: abi.name,
+    isOnlySelf: abi.isOnlySelf,
+    isStatic: abi.isStatic,
+    isInitializer: abi.isInitializer,
+    parameters: abi.parameters,
+    returnTypes: abi.returnTypes,
+    errorTypes: abi.errorTypes,
+  };
+  const jsonStr = JSON.stringify(baseObj);
+  return jsonStr.replace('{', `{ functionType: ${functionTypeToEnum(abi.functionType)},`);
+}
+
+function generateProtocolContractArtifact(input: ContractArtifact): string {
+  const allAbis = getAllFunctionAbis(input);
+  const functionAbis = input.functions.map(f => allAbis.find(abi => abi.name === f.name)!);
+  const nonDispatchAbis = input.nonDispatchPublicFunctions;
+
+  const functionsArray = functionAbis
+    .map(abi => `{ ...${generateFunctionAbiJson(abi)}, bytecode: Buffer.from([]), debugSymbols: '' }`)
+    .join(',\n    ');
+
+  const nonDispatchArray = nonDispatchAbis.map(abi => generateFunctionAbiJson(abi)).join(',\n    ');
+
+  return `{
+  name: '${input.name}',
+  functions: [
+    ${functionsArray}
+  ],
+  nonDispatchPublicFunctions: [
+    ${nonDispatchArray}
+  ],
+  outputs: { structs: {}, globals: {} },
+  storageLayout: {},
+  fileMap: {},
+}`;
+}
+
+async function generateProtocolContractInterface(
+  input: ContractArtifact,
+  protocolContractName: string,
+): Promise<string> {
+  const baseInterface = await generateTypescriptContractInterface(input);
+
+  // Match everything between "public declare methods: {" and the closing "};"
+  const methodsMatch = baseInterface.match(/public declare methods: \{([\s\S]*?)\n  \};/);
+  if (!methodsMatch) {
+    throw new Error('Could not extract methods from generated interface');
+  }
+
+  const artifactCode = generateProtocolContractArtifact(input);
+  const contractName = `${input.name}Contract`;
+
+  return `
+/* Autogenerated file, do not edit! */
+
+/* eslint-disable */
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionType } from '@aztec/stdlib/abi';
+
+import type { ContractArtifact } from '../../api/abi.js';
+import { PublicKeys } from '../../api/keys.js';
+import type { AztecAddressLike, EthAddressLike, FieldLike, FunctionSelectorLike, WrappedFieldLike } from '../../utils/abi_types.js';
+import { ContractBase, type ContractMethod } from '../contract_base.js';
+import { ContractFunctionInteraction } from '../contract_function_interaction.js';
+import type { Wallet } from '../../wallet/wallet.js';
+
+const ${contractName}Artifact: ContractArtifact = ${artifactCode};
+
+export class ${contractName} extends ContractBase {
+  private constructor(wallet: Wallet) {
+    super(ProtocolContractAddress.${protocolContractName}, ${contractName}Artifact, wallet);
+  }
+
+  public static at(wallet: Wallet): ${contractName} {
+    return new ${contractName}(wallet);
+  }
+
+  public declare methods: {${methodsMatch[1]}
+  };
+}
+`;
+}
+
+async function main() {
+  await fs.rm(outputDir, { recursive: true, force: true });
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const srcNames = JSON.parse(
+    await fs.readFile(path.join(noirContractsRoot, 'protocol_contracts.json'), 'utf8'),
+  ) as string[];
+
+  for (const srcName of srcNames) {
+    // srcName is like "auth_registry_contract-AuthRegistry", split to get the contract name
+    const name = srcName.split('-')[1];
+    const artifactPath = path.join(srcPath, `${srcName}.json`);
+    const json = JSON.parse(await fs.readFile(artifactPath, 'utf8')) as NoirCompiledContract;
+    const contractArtifact = loadContractArtifact(json);
+
+    const content = await generateProtocolContractInterface(contractArtifact, name);
+    const fileName = `${toKebabCase(name)}.ts`;
+    await fs.writeFile(path.join(outputDir, fileName), content);
+
+    log(`Generated ${fileName}`);
+  }
+}
+
+main().catch(err => {
+  console.error('Error generating protocol contract types:', err);
+  process.exit(1);
+});

package/src/utils/authwit.ts

@@ -5,16 +5,18 @@ 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 { TxProfileResult } from '@aztec/stdlib/tx';
+import type { TxHash, TxProfileResult, TxReceipt } 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 */
@@ -42,7 +44,7 @@ export type ContractFunctionInteractionCallIntent = {
 };
 
 /** Identifies ContractFunctionInteractionCallIntents */
-function isContractFunctionIntractionCallIntent(
+export function isContractFunctionInteractionCallIntent(
   messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
 ): messageHashOrIntent is ContractFunctionInteractionCallIntent {
   return (
@@ -81,7 +83,7 @@ export const computeAuthWitMessageHash = async (
   const version = metadata.version;
 
   if ('caller' in intent) {
-    const call = isContractFunctionIntractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+    const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
     return computeOuterAuthWitHash(
       call.to,
       chainId,
@@ -154,7 +156,7 @@ export async function lookupValidity(
 }> {
   let innerHash, consumer;
   if ('caller' in intent) {
-    const call = isContractFunctionIntractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+    const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
     innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
     consumer = call.to;
   } else {
@@ -286,9 +288,19 @@ 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 SentTx instance for tracking the transaction status and information.
+   * @returns A TxReceipt (if wait is true/undefined) or TxHash (if wait is false)
    */
-  public override send(options: Omit<SendInteractionOptions, 'from'> = {}): SentTx {
+  // 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> {
     return super.send({ ...options, from: this.from });
   }
 

package/src/utils/node.ts

@@ -1,6 +1,10 @@
 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 () => {
@@ -16,4 +20,62 @@ 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';