@aztec/aztec.js 0.80.0 → 0.82.0

package/src/account/{contract.ts → account_contract.ts}

@@ -1,10 +1,11 @@
+import type { AuthWitnessProvider } from '@aztec/entrypoints/interfaces';
 import { Fr } from '@aztec/foundation/fields';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { CompleteAddress, NodeInfo } from '@aztec/stdlib/contract';
 import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
 import { deriveKeys } from '@aztec/stdlib/keys';
 
-import type { AccountInterface, AuthWitnessProvider } from './interface.js';
+import type { AccountInterface } from './interface.js';
 
 // docs:start:account-contract-interface
 /**
@@ -18,9 +19,17 @@ export interface AccountContract {
   getContractArtifact(): Promise<ContractArtifact>;
 
   /**
-   * Returns the deployment arguments for this instance, or undefined if this contract does not require deployment.
+   * Returns the deployment function name and arguments for this instance, or undefined if this contract does not require deployment.
    */
-  getDeploymentArgs(): Promise<any[] | undefined>;
+  getDeploymentFunctionAndArgs(): Promise<
+    | {
+        /** The name of the function used to deploy the contract */
+        constructorName: string;
+        /** The args to the function used to deploy the contract */
+        constructorArgs: any[];
+      }
+    | undefined
+  >;
 
   /**
    * Returns the account interface for this account contract given a deployment at the provided address.
@@ -45,9 +54,13 @@ export interface AccountContract {
  */
 export async function getAccountContractAddress(accountContract: AccountContract, secret: Fr, salt: Fr) {
   const { publicKeys } = await deriveKeys(secret);
-  const constructorArgs = await accountContract.getDeploymentArgs();
+  const { constructorName, constructorArgs } = (await accountContract.getDeploymentFunctionAndArgs()) ?? {
+    constructorName: undefined,
+    constructorArgs: undefined,
+  };
   const artifact = await accountContract.getContractArtifact();
   const instance = await getContractInstanceFromDeployParams(artifact, {
+    constructorArtifact: constructorName,
     constructorArgs,
     salt,
     publicKeys,

package/src/account/index.ts

@@ -8,9 +8,8 @@
  */
 import type { Fr } from '@aztec/foundation/fields';
 
-export { type AccountContract, getAccountContractAddress } from './contract.js';
-export { type AccountInterface, type AuthWitnessProvider } from './interface.js';
-export * from './wallet.js';
+export { type AccountContract, getAccountContractAddress } from './account_contract.js';
+export { type AccountInterface } from './interface.js';
 
 /** A contract deployment salt. */
 export type Salt = Fr | number | bigint;

package/src/account/interface.ts

@@ -1,20 +1,9 @@
+import type { AuthWitnessProvider, EntrypointInterface } from '@aztec/entrypoints/interfaces';
 import type { Fr } from '@aztec/foundation/fields';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress } from '@aztec/stdlib/contract';
 
-import type { EntrypointInterface } from '../entrypoint/entrypoint.js';
-
 // docs:start:account-interface
-/** Creates authorization witnesses. */
-export interface AuthWitnessProvider {
-  /**
-   * Computes an authentication witness from either a message hash
-   * @param messageHash - The message hash to approve
-   * @returns The authentication witness
-   */
-  createAuthWit(messageHash: Fr | Buffer): Promise<AuthWitness>;
-}
 
 /**
  * Handler for interfacing with an account. Knows how to create transaction execution

package/src/account_manager/account_manager.ts

@@ -0,0 +1,235 @@
+import { Fr } from '@aztec/foundation/fields';
+import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { deriveKeys } from '@aztec/stdlib/keys';
+
+import type { AccountContract } from '../account/account_contract.js';
+import type { Salt } from '../account/index.js';
+import type { AccountInterface } from '../account/interface.js';
+import { Contract } from '../contract/contract.js';
+import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
+import { DefaultWaitOpts, type WaitOpts } from '../contract/sent_tx.js';
+import { DefaultMultiCallEntrypoint } from '../entrypoint/default_multi_call_entrypoint.js';
+import { AccountWalletWithSecretKey, SignerlessWallet, type Wallet } from '../wallet/index.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
+
+/**
+ * Options to deploy an account contract.
+ */
+export type DeployAccountOptions = Pick<
+  DeployOptions,
+  'fee' | 'skipClassRegistration' | 'skipPublicDeployment' | 'skipInitialization'
+> & {
+  /**
+   * Wallet used for deploying the account contract. Must be funded in order to pay for the fee.
+   */
+  deployWallet?: Wallet;
+};
+
+/**
+ * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
+ * and creating and registering the user wallet in the PXE Service.
+ */
+export class AccountManager {
+  private constructor(
+    private pxe: PXE,
+    private secretKey: Fr,
+    private accountContract: AccountContract,
+    private instance: ContractInstanceWithAddress,
+    /**
+     * Deployment salt for the account contract
+     */
+    public readonly salt: Salt,
+  ) {}
+
+  static async create(pxe: PXE, secretKey: Fr, accountContract: AccountContract, salt?: Salt) {
+    const { publicKeys } = await deriveKeys(secretKey);
+    salt = salt !== undefined ? new Fr(salt) : Fr.random();
+
+    const { constructorName, constructorArgs } = (await accountContract.getDeploymentFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    const artifact = await accountContract.getContractArtifact();
+    const instance = await getContractInstanceFromDeployParams(artifact, {
+      constructorArtifact: constructorName,
+      constructorArgs,
+      salt: salt,
+      publicKeys,
+    });
+
+    return new AccountManager(pxe, secretKey, accountContract, instance, salt);
+  }
+
+  protected getPublicKeys() {
+    return this.instance.publicKeys;
+  }
+
+  protected getPublicKeysHash() {
+    return this.getPublicKeys().hash();
+  }
+
+  /**
+   * Returns the entrypoint for this account as defined by its account contract.
+   * @returns An entrypoint.
+   */
+  public async getAccount(): Promise<AccountInterface> {
+    const nodeInfo = await this.pxe.getNodeInfo();
+    const completeAddress = await this.getCompleteAddress();
+    return this.accountContract.getInterface(completeAddress, nodeInfo);
+  }
+
+  /**
+   * Gets the calculated complete address associated with this account.
+   * Does not require the account to be deployed or registered.
+   * @returns The address, partial address, and encryption public key.
+   */
+  public getCompleteAddress(): Promise<CompleteAddress> {
+    return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
+  }
+
+  /**
+   * Gets the address for this given account.
+   * Does not require the account to be deployed or registered.
+   * @returns The address.
+   */
+  public getAddress() {
+    return this.instance.address;
+  }
+
+  /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to be deployed or registered.
+   * @returns ContractInstance instance.
+   */
+  public getInstance(): ContractInstanceWithAddress {
+    return this.instance;
+  }
+
+  /**
+   * Returns a Wallet instance associated with this account. Use it to create Contract
+   * instances to be interacted with from this account.
+   * @returns A Wallet instance.
+   */
+  public async getWallet(): Promise<AccountWalletWithSecretKey> {
+    const entrypoint = await this.getAccount();
+    return new AccountWalletWithSecretKey(this.pxe, entrypoint, this.secretKey, this.salt);
+  }
+
+  /**
+   * Registers this account in the PXE Service and returns the associated wallet. Registering
+   * the account on the PXE Service is required for managing private state associated with it.
+   * Use the returned wallet to create Contract instances to be interacted with from this account.
+   * @param opts - Options to wait for the account to be synched.
+   * @returns A Wallet instance.
+   */
+  public async register(): Promise<AccountWalletWithSecretKey> {
+    await this.pxe.registerContract({
+      artifact: await this.accountContract.getContractArtifact(),
+      instance: this.getInstance(),
+    });
+
+    await this.pxe.registerAccount(this.secretKey, (await this.getCompleteAddress()).partialAddress);
+
+    return this.getWallet();
+  }
+
+  /**
+   * Returns the pre-populated deployment method to deploy the account contract that backs this account.
+   * Typically you will not need this method and can call `deploy` directly. Use this for having finer
+   * grained control on when to create, simulate, and send the deployment tx.
+   * @param deployWallet - Wallet used for deploying the account contract.
+   * @returns A DeployMethod instance that deploys this account contract.
+   */
+  public async getDeployMethod(deployWallet?: Wallet) {
+    const artifact = await this.accountContract.getContractArtifact();
+
+    if (!(await this.isDeployable())) {
+      throw new Error(`Account contract ${artifact.name} does not require deployment.`);
+    }
+
+    const completeAddress = await this.getCompleteAddress();
+
+    await this.pxe.registerAccount(this.secretKey, completeAddress.partialAddress);
+
+    const { constructorName, constructorArgs } = (await this.accountContract.getDeploymentFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    if (deployWallet) {
+      // If deploying using an existing wallet/account, treat it like regular contract deployment.
+      const thisWallet = await this.getWallet();
+      return new DeployMethod(
+        this.getPublicKeys(),
+        deployWallet,
+        artifact,
+        address => Contract.at(address, artifact, thisWallet),
+        constructorArgs,
+        constructorName,
+      );
+    }
+
+    const { l1ChainId: chainId, protocolVersion } = await this.pxe.getNodeInfo();
+    // We use a signerless wallet with the multi call entrypoint in order to make multiple calls in one go.
+    // If we used getWallet, the deployment would get routed via the account contract entrypoint
+    // and it can't be used unless the contract is initialized.
+    const wallet = new SignerlessWallet(this.pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion));
+
+    return new DeployAccountMethod(
+      this.accountContract.getAuthWitnessProvider(completeAddress),
+      this.getPublicKeys(),
+      wallet,
+      artifact,
+      constructorArgs,
+      constructorName,
+      'entrypoint',
+    );
+  }
+
+  /**
+   * Deploys the account contract that backs this account.
+   * Does not register the associated class nor publicly deploy the instance by default.
+   * Uses the salt provided in the constructor or a randomly generated one.
+   * Registers the account in the PXE Service before deploying the contract.
+   * @param opts - Fee options to be used for the deployment.
+   * @returns A SentTx object that can be waited to get the associated Wallet.
+   */
+  public deploy(opts?: DeployAccountOptions): DeployAccountSentTx {
+    const sentTx = this.getDeployMethod(opts?.deployWallet)
+      .then(deployMethod =>
+        deployMethod.send({
+          contractAddressSalt: new Fr(this.salt),
+          skipClassRegistration: opts?.skipClassRegistration ?? true,
+          skipPublicDeployment: opts?.skipPublicDeployment ?? true,
+          skipInitialization: opts?.skipInitialization ?? false,
+          universalDeploy: true,
+          fee: opts?.fee,
+        }),
+      )
+      .then(tx => tx.getTxHash());
+    return new DeployAccountSentTx(this.pxe, sentTx, this.getWallet());
+  }
+
+  /**
+   * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
+   * Uses the salt provided in the constructor or a randomly generated one. If no initialization
+   * is required it skips the transaction, and only registers the account in the PXE Service.
+   * @param opts - Options to wait for the tx to be mined.
+   * @returns A Wallet instance.
+   */
+  public async waitSetup(opts: DeployAccountOptions & WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithSecretKey> {
+    await ((await this.isDeployable()) ? this.deploy(opts).wait(opts) : this.register());
+    return this.getWallet();
+  }
+
+  /**
+   * Returns whether this account contract has a constructor and needs deployment.
+   */
+  public async isDeployable() {
+    return (await this.accountContract.getDeploymentFunctionAndArgs()) !== undefined;
+  }
+}

package/src/account_manager/deploy_account_method.ts

@@ -1,12 +1,17 @@
+import {
+  EncodedAppEntrypointCalls,
+  EncodedCallsForEntrypoint,
+  computeCombinedPayloadHash,
+} from '@aztec/entrypoints/encoding';
+import type { AuthWitnessProvider } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
 import { type ContractArtifact, type FunctionArtifact, getFunctionArtifactByName } from '@aztec/stdlib/abi';
 import type { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { AuthWitnessProvider } from '../account/interface.js';
-import type { Wallet } from '../account/wallet.js';
 import { Contract } from '../contract/contract.js';
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { EntrypointPayload, computeCombinedPayloadHash } from '../entrypoint/payload.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /**
  * Contract interaction for deploying an account contract. Handles fee preparation and contract initialization.
@@ -40,28 +45,43 @@ export class DeployAccountMethod extends DeployMethod {
         : feePaymentNameOrArtifact;
   }
 
-  protected override async getInitializeFunctionCalls(options: DeployOptions): Promise<ContractFunctionInteraction[]> {
-    const calls = await super.getInitializeFunctionCalls(options);
+  protected override async getInitializeExecutionPayload(options: DeployOptions): Promise<ExecutionPayload> {
+    let exec = await super.getInitializeExecutionPayload(options);
 
     if (options.fee && this.#feePaymentArtifact) {
       const { address } = await this.getInstance();
-      const emptyAppPayload = await EntrypointPayload.fromAppExecution([]);
+      const emptyAppCalls = await EncodedAppEntrypointCalls.fromAppExecution([]);
       const fee = await this.getDefaultFeeOptions(options.fee);
-      const feePayload = await EntrypointPayload.fromFeeOptions(address, fee);
-      const args = [emptyAppPayload, feePayload, false];
+      // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
+      const { calls: feeCalls, authWitnesses: feeAuthwitnesses } = await fee.paymentMethod.getExecutionPayload(
+        fee.gasSettings,
+      );
+      // Encode the calls for the fee
+      const feePayer = await fee.paymentMethod.getFeePayer(fee.gasSettings);
+      const isFeePayer = feePayer.equals(address);
+      const feeEncodedCalls = await EncodedCallsForEntrypoint.fromFeeCalls(feeCalls, isFeePayer);
 
-      const call = new ContractFunctionInteraction(this.wallet, address, this.#feePaymentArtifact, args);
+      // Get the entrypoint args
+      const args = [emptyAppCalls, feeEncodedCalls, false];
 
-      call.addAuthWitness(
-        await this.#authWitnessProvider.createAuthWit(await computeCombinedPayloadHash(emptyAppPayload, feePayload)),
+      // Compute the authwitness required to verify the combined payload
+      const combinedPayloadAuthWitness = await this.#authWitnessProvider.createAuthWit(
+        await computeCombinedPayloadHash(emptyAppCalls, feeEncodedCalls),
       );
 
-      call.addHashedArguments(emptyAppPayload.hashedArguments);
-      call.addHashedArguments(feePayload.hashedArguments);
+      const call = new ContractFunctionInteraction(
+        this.wallet,
+        address,
+        this.#feePaymentArtifact,
+        args,
+        [combinedPayloadAuthWitness, ...feeAuthwitnesses],
+        [],
+        [...emptyAppCalls.hashedArguments, ...feeEncodedCalls.hashedArguments],
+      );
 
-      calls.push(call);
+      exec = mergeExecutionPayloads([exec, await call.request()]);
     }
 
-    return calls;
+    return exec;
   }
 }

package/src/account_manager/deploy_account_sent_tx.ts

@@ -1,9 +1,9 @@
 import type { FieldsOf } from '@aztec/foundation/types';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+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 { DefaultWaitOpts, SentTx, type WaitOpts } from '../contract/sent_tx.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /** Extends a transaction receipt with a wallet instance for the newly deployed contract. */
 export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
@@ -15,8 +15,8 @@ export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
  * A deployment transaction for an account contract sent to the network, extending SentTx with methods to get the resulting wallet.
  */
 export class DeployAccountSentTx extends SentTx {
-  constructor(pxe: PXE, txHashPromise: Promise<TxHash>, private getWalletPromise: Promise<Wallet>) {
-    super(pxe, txHashPromise);
+  constructor(pxeOrNode: AztecNode | PXE, txHashPromise: Promise<TxHash>, private getWalletPromise: Promise<Wallet>) {
+    super(pxeOrNode, txHashPromise);
   }
 
   /**

package/src/account_manager/index.ts

@@ -1,229 +1,3 @@
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import { deriveKeys } from '@aztec/stdlib/keys';
-
-import type { AccountContract } from '../account/contract.js';
-import type { Salt, Wallet } from '../account/index.js';
-import type { AccountInterface } from '../account/interface.js';
-import { Contract } from '../contract/contract.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { DefaultWaitOpts, type WaitOpts } from '../contract/sent_tx.js';
-import { DefaultMultiCallEntrypoint } from '../entrypoint/default_multi_call_entrypoint.js';
-import { AccountWalletWithSecretKey, SignerlessWallet } from '../wallet/index.js';
-import { DeployAccountMethod } from './deploy_account_method.js';
-import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-
-/**
- * Options to deploy an account contract.
- */
-export type DeployAccountOptions = Pick<
-  DeployOptions,
-  'fee' | 'skipClassRegistration' | 'skipPublicDeployment' | 'skipInitialization'
-> & {
-  /**
-   * Wallet used for deploying the account contract. Must be funded in order to pay for the fee.
-   */
-  deployWallet?: Wallet;
-};
-
-/**
- * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
- * and creating and registering the user wallet in the PXE Service.
- */
-export class AccountManager {
-  private constructor(
-    private pxe: PXE,
-    private secretKey: Fr,
-    private accountContract: AccountContract,
-    private instance: ContractInstanceWithAddress,
-    /**
-     * Deployment salt for the account contract
-     */
-    public readonly salt: Salt,
-  ) {}
-
-  static async create(pxe: PXE, secretKey: Fr, accountContract: AccountContract, salt?: Salt) {
-    const { publicKeys } = await deriveKeys(secretKey);
-    salt = salt !== undefined ? new Fr(salt) : Fr.random();
-
-    const artifact = await accountContract.getContractArtifact();
-    const instance = await getContractInstanceFromDeployParams(artifact, {
-      constructorArgs: await accountContract.getDeploymentArgs(),
-      salt: salt,
-      publicKeys,
-    });
-
-    return new AccountManager(pxe, secretKey, accountContract, instance, salt);
-  }
-
-  protected getPublicKeys() {
-    return this.instance.publicKeys;
-  }
-
-  protected getPublicKeysHash() {
-    return this.getPublicKeys().hash();
-  }
-
-  /**
-   * Returns the entrypoint for this account as defined by its account contract.
-   * @returns An entrypoint.
-   */
-  public async getAccount(): Promise<AccountInterface> {
-    const nodeInfo = await this.pxe.getNodeInfo();
-    const completeAddress = await this.getCompleteAddress();
-    return this.accountContract.getInterface(completeAddress, nodeInfo);
-  }
-
-  /**
-   * Gets the calculated complete address associated with this account.
-   * Does not require the account to be deployed or registered.
-   * @returns The address, partial address, and encryption public key.
-   */
-  public getCompleteAddress(): Promise<CompleteAddress> {
-    return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
-  }
-
-  /**
-   * Gets the address for this given account.
-   * Does not require the account to be deployed or registered.
-   * @returns The address.
-   */
-  public getAddress() {
-    return this.instance.address;
-  }
-
-  /**
-   * Returns the contract instance definition associated with this account.
-   * Does not require the account to be deployed or registered.
-   * @returns ContractInstance instance.
-   */
-  public getInstance(): ContractInstanceWithAddress {
-    return this.instance;
-  }
-
-  /**
-   * Returns a Wallet instance associated with this account. Use it to create Contract
-   * instances to be interacted with from this account.
-   * @returns A Wallet instance.
-   */
-  public async getWallet(): Promise<AccountWalletWithSecretKey> {
-    const entrypoint = await this.getAccount();
-    return new AccountWalletWithSecretKey(this.pxe, entrypoint, this.secretKey, this.salt);
-  }
-
-  /**
-   * Registers this account in the PXE Service and returns the associated wallet. Registering
-   * the account on the PXE Service is required for managing private state associated with it.
-   * Use the returned wallet to create Contract instances to be interacted with from this account.
-   * @param opts - Options to wait for the account to be synched.
-   * @returns A Wallet instance.
-   */
-  public async register(): Promise<AccountWalletWithSecretKey> {
-    await this.pxe.registerContract({
-      artifact: await this.accountContract.getContractArtifact(),
-      instance: this.getInstance(),
-    });
-
-    await this.pxe.registerAccount(this.secretKey, (await this.getCompleteAddress()).partialAddress);
-
-    return this.getWallet();
-  }
-
-  /**
-   * Returns the pre-populated deployment method to deploy the account contract that backs this account.
-   * Typically you will not need this method and can call `deploy` directly. Use this for having finer
-   * grained control on when to create, simulate, and send the deployment tx.
-   * @param deployWallet - Wallet used for deploying the account contract.
-   * @returns A DeployMethod instance that deploys this account contract.
-   */
-  public async getDeployMethod(deployWallet?: Wallet) {
-    const artifact = await this.accountContract.getContractArtifact();
-
-    if (!(await this.isDeployable())) {
-      throw new Error(`Account contract ${artifact.name} does not require deployment.`);
-    }
-
-    const completeAddress = await this.getCompleteAddress();
-
-    await this.pxe.registerAccount(this.secretKey, completeAddress.partialAddress);
-
-    const args = (await this.accountContract.getDeploymentArgs()) ?? [];
-
-    if (deployWallet) {
-      // If deploying using an existing wallet/account, treat it like regular contract deployment.
-      const thisWallet = await this.getWallet();
-      return new DeployMethod(
-        this.getPublicKeys(),
-        deployWallet,
-        artifact,
-        address => Contract.at(address, artifact, thisWallet),
-        args,
-        'constructor',
-      );
-    }
-
-    const { l1ChainId: chainId, protocolVersion } = await this.pxe.getNodeInfo();
-    // We use a signerless wallet with the multi call entrypoint in order to make multiple calls in one go.
-    // If we used getWallet, the deployment would get routed via the account contract entrypoint
-    // and it can't be used unless the contract is initialized.
-    const wallet = new SignerlessWallet(this.pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion));
-
-    return new DeployAccountMethod(
-      this.accountContract.getAuthWitnessProvider(completeAddress),
-      this.getPublicKeys(),
-      wallet,
-      artifact,
-      args,
-      'constructor',
-      'entrypoint',
-    );
-  }
-
-  /**
-   * Deploys the account contract that backs this account.
-   * Does not register the associated class nor publicly deploy the instance by default.
-   * Uses the salt provided in the constructor or a randomly generated one.
-   * Registers the account in the PXE Service before deploying the contract.
-   * @param opts - Fee options to be used for the deployment.
-   * @returns A SentTx object that can be waited to get the associated Wallet.
-   */
-  public deploy(opts?: DeployAccountOptions): DeployAccountSentTx {
-    const sentTx = this.getDeployMethod(opts?.deployWallet)
-      .then(deployMethod =>
-        deployMethod.send({
-          contractAddressSalt: new Fr(this.salt),
-          skipClassRegistration: opts?.skipClassRegistration ?? true,
-          skipPublicDeployment: opts?.skipPublicDeployment ?? true,
-          skipInitialization: opts?.skipInitialization ?? false,
-          universalDeploy: true,
-          fee: opts?.fee,
-        }),
-      )
-      .then(tx => tx.getTxHash());
-    return new DeployAccountSentTx(this.pxe, sentTx, this.getWallet());
-  }
-
-  /**
-   * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
-   * Uses the salt provided in the constructor or a randomly generated one. If no initialization
-   * is required it skips the transaction, and only registers the account in the PXE Service.
-   * @param opts - Options to wait for the tx to be mined.
-   * @returns A Wallet instance.
-   */
-  public async waitSetup(opts: DeployAccountOptions & WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithSecretKey> {
-    await ((await this.isDeployable()) ? this.deploy(opts).wait(opts) : this.register());
-    return this.getWallet();
-  }
-
-  /**
-   * Returns whether this account contract has a constructor and needs deployment.
-   */
-  public async isDeployable() {
-    return (await this.accountContract.getDeploymentArgs()) !== undefined;
-  }
-}
-
+export { AccountManager, type DeployAccountOptions } from './account_manager.js';
 export { DeployAccountMethod } from './deploy_account_method.js';
 export { type DeployAccountTxReceipt, DeployAccountSentTx } from './deploy_account_sent_tx.js';

package/src/api/account.ts

@@ -1,10 +1,4 @@
-export {
-  type AccountContract,
-  type AccountInterface,
-  type AuthWitnessProvider,
-  type Salt,
-  type Wallet,
-  getAccountContractAddress,
-} from '../account/index.js';
+export { type AccountContract, type AccountInterface, type Salt, getAccountContractAddress } from '../account/index.js';
+export type { AuthWitnessProvider } from '@aztec/entrypoints/interfaces';
 
 export { AccountManager, type DeployAccountOptions } from '../account_manager/index.js';