@aztec/aztec.js 0.0.1-commit.b655e406 → 0.0.1-commit.c31f2472

package/src/utils/authwit.ts

@@ -1,20 +1,22 @@
 import type { ChainInfo } from '@aztec/entrypoints/interfaces';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { type ABIParameterVisibility, type FunctionAbi, type FunctionCall, FunctionType } from '@aztec/stdlib/abi';
 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 */
@@ -22,7 +24,7 @@ export type IntentInnerHash = {
   /** The consumer   */
   consumer: AztecAddress;
   /** The action to approve */
-  innerHash: Buffer<ArrayBuffer> | Fr;
+  innerHash: Fr;
 };
 
 /** Intent with a call */
@@ -42,8 +44,8 @@ export type ContractFunctionInteractionCallIntent = {
 };
 
 /** Identifies ContractFunctionInteractionCallIntents */
-function isContractFunctionIntractionCallIntent(
-  messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+export function isContractFunctionInteractionCallIntent(
+  messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
 ): messageHashOrIntent is ContractFunctionInteractionCallIntent {
   return (
     'caller' in messageHashOrIntent &&
@@ -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,
@@ -102,14 +104,12 @@ export const computeAuthWitMessageHash = async (
  * @returns The message hash for the intent
  */
 export async function getMessageHashFromIntent(
-  messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+  messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
   chainInfo: ChainInfo,
 ) {
   let messageHash: Fr;
   const { chainId, version } = chainInfo;
-  if (Buffer.isBuffer(messageHashOrIntent)) {
-    messageHash = Fr.fromBuffer(messageHashOrIntent);
-  } else if (messageHashOrIntent instanceof Fr) {
+  if (messageHashOrIntent instanceof Fr) {
     messageHash = messageHashOrIntent;
   } else {
     messageHash = await computeAuthWitMessageHash(messageHashOrIntent, { chainId, version });
@@ -156,12 +156,9 @@ 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 if (Buffer.isBuffer(intent.innerHash)) {
-    innerHash = Fr.fromBuffer(intent.innerHash);
-    consumer = intent.consumer;
   } else {
     ({ innerHash, consumer } = intent);
   }
@@ -174,9 +171,20 @@ export async function lookupValidity(
     name: 'lookup_validity',
     isInitializer: false,
     functionType: FunctionType.UTILITY,
-    isInternal: false,
+    isOnlySelf: false,
     isStatic: false,
-    parameters: [{ name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility }],
+    parameters: [
+      {
+        name: 'consumer',
+        type: {
+          fields: [{ name: 'inner', type: { kind: 'field' } }],
+          kind: 'struct',
+          path: 'aztec::protocol_types::address::aztec_address::AztecAddress',
+        },
+        visibility: 'private' as ABIParameterVisibility,
+      },
+      { name: 'inner_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility },
+    ],
     returnTypes: [{ kind: 'boolean' }],
     errorTypes: {},
   } as FunctionAbi;
@@ -194,7 +202,7 @@ export async function lookupValidity(
     name: 'utility_is_consumable',
     isInitializer: false,
     functionType: FunctionType.UTILITY,
-    isInternal: false,
+    isOnlySelf: false,
     isStatic: false,
     parameters: [
       {
@@ -240,7 +248,7 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
   static async create(
     wallet: Wallet,
     from: AztecAddress,
-    messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+    messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
     authorized: boolean,
   ) {
     const chainInfo = await wallet.getChainInfo();
@@ -280,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 });
   }
 
@@ -291,7 +309,7 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
       name: 'set_authorized',
       isInitializer: false,
       functionType: FunctionType.PUBLIC,
-      isInternal: true,
+      isOnlySelf: true,
       isStatic: false,
       parameters: [
         {

package/src/utils/cross_chain.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { retryUntil } from '@aztec/foundation/retry';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 

package/src/utils/fee_juice.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
@@ -6,7 +6,7 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 /**
  * Returns the owner's fee juice balance.
- * Note: This is used only e2e_sandbox_example test. TODO: Consider nuking.
+ * Note: This is used only e2e_local_network_example test. TODO: Consider nuking.
  */
 export async function getFeeJuiceBalance(owner: AztecAddress, node: AztecNode): Promise<bigint> {
   const slot = await deriveStorageSlotInMap(new Fr(1), owner);

package/src/utils/field_compressed_string.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 /**
  * The representation of a FieldCompressedString in aztec.nr

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';

package/src/utils/pub_key.ts

@@ -1,5 +1,5 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import type { GrumpkinScalar } from '@aztec/foundation/fields';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import type { PublicKey } from '@aztec/stdlib/keys';
 
 /**

package/src/wallet/account_entrypoint_meta_payment_method.ts

@@ -1,20 +1,11 @@
 import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
-import { EncodedAppEntrypointCalls } from '@aztec/entrypoints/encoding';
-import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import {
-  type ContractArtifact,
-  type FunctionArtifact,
-  FunctionCall,
-  FunctionSelector,
-  encodeArguments,
-  getFunctionArtifactByName,
-} from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
 
+import type { Account } from '../account/account.js';
 import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
-import type { Wallet } from './index.js';
 
 /**
  * Fee payment method that allows an account contract to pay for its own deployment
@@ -33,11 +24,9 @@ import type { Wallet } from './index.js';
  */
 export class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
   constructor(
-    private wallet: Wallet,
-    private artifact: ContractArtifact,
-    private feePaymentNameOrArtifact: string | FunctionArtifact,
-    private accountAddress: AztecAddress,
+    private account: Account,
     private paymentMethod?: FeePaymentMethod,
+    private feeEntrypointOptions?: any,
   ) {}
 
   getAsset(): Promise<AztecAddress> {
@@ -45,58 +34,38 @@ export class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
   }
 
   async getExecutionPayload(): Promise<ExecutionPayload> {
-    // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
-    // It can be empty because the account might attempt to pay for the tx fee using its own
-    // FeeJuice balance
-    const { calls: feeCalls, authWitnesses: feeAuthwitnesses } =
-      (await this.paymentMethod?.getExecutionPayload()) ?? ExecutionPayload.empty();
-    // Encode the calls for the fee
-    const feePayer = (await this.paymentMethod?.getFeePayer()) ?? this.accountAddress;
-    const isFeePayer = feePayer.equals(this.accountAddress);
-    let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
-    if (isFeePayer) {
-      // If the account is the fee payer, and the incoming fee payload has calls
-      // it can only be FeeJuicePaymentMethodWithClaim
-      // If the payload has no calls, it's paying using
-      // its own fee juice balance
-      accountFeePaymentMethodOptions =
-        feeCalls.length === 0
-          ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE
-          : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
-    }
-    const feeEncodedCalls = await EncodedAppEntrypointCalls.create(feeCalls);
+    // Get the execution payload for the fee
+    const innerPayload = (await this.paymentMethod?.getExecutionPayload()) ?? ExecutionPayload.empty();
 
-    // Get the entrypoint args
-    const args = [feeEncodedCalls, accountFeePaymentMethodOptions, false];
-    const feePaymentArtifact =
-      typeof this.feePaymentNameOrArtifact === 'string'
-        ? getFunctionArtifactByName(this.artifact, this.feePaymentNameOrArtifact)
-        : this.feePaymentNameOrArtifact;
+    // If no fee entrypoint options were provided, compute them based on the wrapped payment method
+    // This mimics how the actual account contract works when invoked directly:
+    // - If we are the fee payer, are there calls in the inner payload? In that case, those calls can
+    //   only be claiming fee juice, so we use FEE_JUICE_WITH_CLAIM
+    // - If we are the fee payer, but there are no calls, then we assume the account already has
+    //   fee juice and can pay directly with PREEXISTING_FEE_JUICE
+    // - If we are not the fee payer, then EXTERNAL is used
+    let options = this.feeEntrypointOptions;
+    if (!options) {
+      const feePayer = (await this.paymentMethod?.getFeePayer()) ?? this.account.getAddress();
+      const isFeePayer = feePayer.equals(this.account.getAddress());
 
-    const entrypointCall = new FunctionCall(
-      feePaymentArtifact.name,
-      this.accountAddress,
-      await FunctionSelector.fromNameAndParameters(feePaymentArtifact.name, feePaymentArtifact.parameters),
-      feePaymentArtifact.functionType,
-      false /** hideMsgSender -- set to `false`, because it's not applicable for an entrypoint function (only for enqueued public calls) */,
-      feePaymentArtifact.isStatic,
-      encodeArguments(feePaymentArtifact, args),
-      feePaymentArtifact.returnTypes,
-    );
+      let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
+      if (isFeePayer) {
+        accountFeePaymentMethodOptions =
+          innerPayload.calls.length === 0
+            ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE
+            : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+      }
 
-    // Compute the authwitness required to verify the combined payload
-    const payloadAuthWitness = await this.wallet.createAuthWit(this.accountAddress, await feeEncodedCalls.hash());
+      options = { feePaymentMethodOptions: accountFeePaymentMethodOptions };
+    }
 
-    return new ExecutionPayload(
-      [entrypointCall],
-      [payloadAuthWitness, ...feeAuthwitnesses],
-      [],
-      feeEncodedCalls.hashedArguments,
-    );
+    // Use the generic wrapping mechanism from the account interface
+    return this.account.wrapExecutionPayload(innerPayload, options);
   }
 
   getFeePayer(): Promise<AztecAddress> {
-    return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.accountAddress);
+    return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.account.getAddress());
   }
 
   getGasSettings(): GasSettings | undefined {

package/src/wallet/account_manager.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   CompleteAddress,
   type ContractInstanceWithAddress,
@@ -9,7 +9,6 @@ import { deriveKeys } from '@aztec/stdlib/keys';
 import type { AccountContract } from '../account/account_contract.js';
 import { AccountWithSecretKey } from '../account/account_with_secret_key.js';
 import type { Salt } from '../account/index.js';
-import type { AccountInterface } from '../account/interface.js';
 import { Contract } from '../contract/contract.js';
 import { DeployAccountMethod } from './deploy_account_method.js';
 import type { Wallet } from './wallet.js';
@@ -58,16 +57,6 @@ export class AccountManager {
     return this.getPublicKeys().hash();
   }
 
-  /**
-   * Returns the entrypoint for this account as defined by its account contract.
-   * @returns An entrypoint.
-   */
-  public async getAccountInterface(): Promise<AccountInterface> {
-    const chainInfo = await this.wallet.getChainInfo();
-    const completeAddress = await this.getCompleteAddress();
-    return this.accountContract.getInterface(completeAddress, chainInfo);
-  }
-
   /**
    * Gets the calculated complete address associated with this account.
    * Does not require the account to have been published for public execution.
@@ -103,8 +92,9 @@ export class AccountManager {
    * @returns A Wallet instance.
    */
   public async getAccount(): Promise<AccountWithSecretKey> {
-    const accountInterface = await this.getAccountInterface();
-    return new AccountWithSecretKey(accountInterface, this.secretKey, this.salt);
+    const completeAddress = await this.getCompleteAddress();
+    const account = this.accountContract.getAccount(completeAddress);
+    return new AccountWithSecretKey(account, this.secretKey, this.salt);
   }
 
   /**
@@ -134,12 +124,14 @@ export class AccountManager {
       constructorArgs: undefined,
     };
 
+    const account = await this.getAccount();
     return new DeployAccountMethod(
       this.getPublicKeys(),
       this.wallet,
       artifact,
-      address => Contract.at(address, artifact, this.wallet),
+      instance => Contract.at(instance.address, artifact, this.wallet),
       new Fr(this.salt),
+      account,
       constructorArgs,
       constructorName,
     );

package/src/wallet/deploy_account_method.ts

@@ -1,33 +1,62 @@
-import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ContractArtifact, FunctionArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { PublicKeys } from '@aztec/stdlib/keys';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
+import type { Account } from '../account/account.js';
 import type { Contract } from '../contract/contract.js';
 import type { ContractBase } from '../contract/contract_base.js';
 import {
   DeployMethod,
-  type DeployOptions,
+  type DeployOptionsWithoutWait,
   type RequestDeployOptions,
   type SimulateDeployOptions,
 } from '../contract/deploy_method.js';
+import type { FeePaymentMethodOption, InteractionWaitOptions } 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';
 
+/**
+ * Extended fee payment method option for account deployments that includes entrypoint wrapping options
+ */
+export type DeployAccountFeePaymentMethodOption = FeePaymentMethodOption & {
+  /** Optional entrypoint-specific options for wrapping execution payloads */
+  feeEntrypointOptions?: unknown;
+};
+
 /**
  * The configuration options for the request method. Omits the contractAddressSalt, since
  * for account contracts that is fixed in the constructor
  */
-export type RequestDeployAccountOptions = Omit<RequestDeployOptions, 'contractAddressSalt'>;
+export type RequestDeployAccountOptions = Omit<RequestDeployOptions, 'contractAddressSalt' | 'fee'> & {
+  /** Fee options specific to account deployment */
+  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 = Omit<DeployOptions, 'contractAddressSalt' | 'universalDeploy'>;
+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;
+};
 
 /**
  * The configuration options for the simulate method. Omits the contractAddressSalt, since
@@ -44,8 +73,9 @@ export class DeployAccountMethod<TContract extends ContractBase = Contract> exte
     publicKeys: PublicKeys,
     wallet: Wallet,
     artifact: ContractArtifact,
-    postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    postDeployCtor: (instance: ContractInstanceWithAddress, wallet: Wallet) => TContract,
     private salt: Fr,
+    private account: Account,
     args: any[] = [],
     constructorNameOrArtifact?: string | FunctionArtifact,
   ) {
@@ -60,19 +90,14 @@ export class DeployAccountMethod<TContract extends ContractBase = Contract> exte
    * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
    *
    * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
+   * @param feeEntrypointOptions - Optional entrypoint-specific options for wrapping. If not provided, will be auto-computed based on the payment method.
    * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
    */
-  private getSelfFeePaymentMethod(originalPaymentMethod?: FeePaymentMethod) {
+  private getSelfFeePaymentMethod(originalPaymentMethod?: FeePaymentMethod, feeEntrypointOptions?: any) {
     if (!this.address) {
       throw new Error('Instance is not yet constructed. This is a bug!');
     }
-    return new AccountEntrypointMetaPaymentMethod(
-      this.wallet,
-      this.artifact,
-      'entrypoint',
-      this.address,
-      originalPaymentMethod,
-    );
+    return new AccountEntrypointMetaPaymentMethod(this.account, originalPaymentMethod, feeEntrypointOptions);
   }
 
   /**
@@ -96,7 +121,7 @@ export class DeployAccountMethod<TContract extends ContractBase = Contract> exte
     const executionPayloads = [deploymentExecutionPayload];
     // If this is a self-deployment, manage the fee accordingly
     if (opts?.deployer?.equals(AztecAddress.ZERO)) {
-      const feePaymentMethod = this.getSelfFeePaymentMethod(opts?.fee?.paymentMethod);
+      const feePaymentMethod = this.getSelfFeePaymentMethod(opts?.fee?.paymentMethod, opts?.fee?.feeEntrypointOptions);
       const feeExecutionPayload = await feePaymentMethod.getExecutionPayload();
       // Notice they are reversed (fee payment usually goes first):
       // this is because we need to construct the contract BEFORE it can pay for its own fee
@@ -112,7 +137,7 @@ export class DeployAccountMethod<TContract extends ContractBase = Contract> exte
     return mergeExecutionPayloads(executionPayloads);
   }
 
-  override convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions {
+  override convertDeployOptionsToRequestOptions(options: DeployAccountOptionsWithoutWait): RequestDeployOptions {
     return {
       ...options,
       // Deployer is handled in the request method and forcibly set to undefined,

package/src/wallet/index.ts

@@ -1,3 +1,2 @@
 export * from './wallet.js';
-export * from './base_wallet.js';
 export * from './account_manager.js';